Fixes

xPaw · xPaw · commit 4db3310d6e85 · 2026-03-20T18:48:11.000+02:00
diff --git a/scripts/generate-lastmod.ts b/scripts/generate-lastmod.ts
@@ -27,6 +27,7 @@ function extractLastModified(repoDir: string): Promise<Record<string, string>> {
     });
 
     let currentDate = "";
+    let exitCode: number | null = null;
     const rl = createInterface({ input: proc.stdout });
 
     rl.on("line", (line) => {
@@ -38,10 +39,13 @@ function extractLastModified(repoDir: string): Promise<Record<string, string>> {
       }
     });
 
-    rl.on("close", () => resolve(map));
     proc.on("error", reject);
     proc.on("close", (code) => {
-      if (code !== 0) reject(new Error(`git log exited ${code}`));
+      exitCode = code;
+    });
+    rl.on("close", () => {
+      if (exitCode !== 0) reject(new Error(`git log exited ${exitCode}`));
+      else resolve(map);
     });
   });
 }
diff --git a/src/components/Link.tsx b/src/components/Link.tsx
@@ -2,9 +2,9 @@ import { forwardRef, type ComponentProps } from "react";
 import { Link as RouterLink, NavLink as RouterNavLink } from "react-router";
 
 export const Link = forwardRef<HTMLAnchorElement, ComponentProps<typeof RouterLink>>(
-  (props, ref) => <RouterLink discover="none" {...props} ref={ref} />,
+  (props, ref) => <RouterLink {...props} discover="none" ref={ref} />,
 );
 
 export const NavLink = forwardRef<HTMLAnchorElement, ComponentProps<typeof RouterNavLink>>(
-  (props, ref) => <RouterNavLink discover="none" {...props} ref={ref} />,
+  (props, ref) => <RouterNavLink {...props} discover="none" ref={ref} />,
 );
diff --git a/src/components/Lists.tsx b/src/components/Lists.tsx
@@ -8,19 +8,19 @@ interface Props<T> {
 
 export function LazyList<T>({ data, render }: Props<T>) {
   const parentRef = useRef<HTMLDivElement>(null);
-  const parentOffsetRef = useRef(0);
+  const [parentOffset, setParentOffset] = React.useState(0);
 
   const virtualizer = useWindowVirtualizer({
     count: data.length,
     estimateSize: () => 80,
     overscan: 2,
-    scrollMargin: parentOffsetRef.current,
+    scrollMargin: parentOffset,
   });
 
   // Capture offset once on mount
   React.useLayoutEffect(() => {
     if (parentRef.current) {
-      parentOffsetRef.current = parentRef.current.getBoundingClientRect().top + window.scrollY;
+      setParentOffset(parentRef.current.getBoundingClientRect().top + window.scrollY);
     }
   }, []);
 
@@ -46,7 +46,7 @@ export function LazyList<T>({ data, render }: Props<T>) {
               top: 0,
               left: 0,
               width: "100%",
-              transform: `translateY(${virtualRow.start - parentOffsetRef.current}px)`,
+              transform: `translateY(${virtualRow.start - parentOffset}px)`,
             }}
           >
             {render(data[virtualRow.index])}
diff --git a/src/components/kind-icon/metadataIconMap.ts b/src/components/kind-icon/metadataIconMap.ts
@@ -1,6 +1,6 @@
 import type { IconKind } from "./KindIcon";
 
-export const metadataIconMap: Record<string, IconKind> = {
+export const metadataIconMap: Partial<Record<string, IconKind>> = {
   MPropertyFriendlyName: "meta-tag",
   MPropertyDescription: "meta-note",
   MNetworkEnable: "meta-broadcast",
diff --git a/src/components/layout/NavBar.tsx b/src/components/layout/NavBar.tsx
@@ -75,7 +75,7 @@ export function GameSwitcher({ currentGame }: { currentGame: GameId }) {
         onClick={() => setOpen(!open)}
         title={currentGameInfo?.name}
         aria-expanded={open}
-        aria-haspopup="menu"
+        aria-haspopup="listbox"
       >
         <SwitcherChevron
           viewBox="0 0 24 24"
@@ -98,11 +98,12 @@ export function GameSwitcher({ currentGame }: { currentGame: GameId }) {
         </SwitcherIcon>
       </SwitcherToggle>
       {open && (
-        <SwitcherDropdown role="menu" aria-label="Select game">
+        <SwitcherDropdown role="listbox" aria-label="Select game">
           {GAME_LIST.map((g) => (
             <SwitcherOption
               key={g.id}
-              role="menuitem"
+              role="option"
+              aria-selected={g.id === currentGame}
               onClick={() => switchTo(g.id)}
               data-active={g.id === currentGame || undefined}
             >
@@ -277,7 +278,7 @@ const ToggleThumb = styled.span`
     background-color 0.2s;
 
   [data-theme="dark"] & {
-    left: 22px;
+    left: 24px;
     background-color: #7a7f88;
   }
 `;
diff --git a/src/components/layout/Sidebar.tsx b/src/components/layout/Sidebar.tsx
@@ -44,7 +44,7 @@ const SidebarLink = styled(NavLink)`
   }
 `;
 
-export const SidebarElement: React.FC<{
+const SidebarElement: React.FC<{
   to: string;
   icon: IconKind;
   text: string;
@@ -94,7 +94,7 @@ export const SidebarGroupHeader = styled.button`
   gap: 4px;
   overflow: hidden;
   white-space: nowrap;
-  text-overflow: ellipsis;
+  min-width: 0;
   transition: color 0.1s;
 
   &:hover {
diff --git a/src/components/schema/ColoredSyntax.tsx b/src/components/schema/ColoredSyntax.tsx
@@ -1,6 +1,6 @@
 import React from "react";
 
-export type ColoredSyntaxKind = "literal" | "interface" | "container" | "atomic";
+type ColoredSyntaxKind = "literal" | "interface" | "container" | "atomic";
 
 const syntaxStyles: Record<ColoredSyntaxKind, React.CSSProperties> = {
   literal: { color: "var(--syntax-literal)" },
diff --git a/src/components/schema/CrossGameRefs.tsx b/src/components/schema/CrossGameRefs.tsx
@@ -16,11 +16,11 @@ type DiffStatus = "identical" | "offsets_only" | "differs";
 
 const GameLink = styled(SectionLink)`
   &[data-status="offsets_only"] {
-    border-color: #5b8ab5;
+    border-color: var(--cross-game-offsets);
   }
 
   &[data-status="differs"] {
-    border-color: #c97a1e;
+    border-color: var(--cross-game-differs);
   }
 `;
 
@@ -81,6 +81,7 @@ function compareClasses(a: SchemaClass, b: SchemaClass): DiffStatus {
     if (a.fields[i].name !== b.fields[i].name) return "differs";
     if (!typesEqual(a.fields[i].type, b.fields[i].type)) return "differs";
     if (!metadataEqual(a.fields[i].metadata, b.fields[i].metadata)) return "differs";
+    if (a.fields[i].defaultValue !== b.fields[i].defaultValue) return "differs";
     if (a.fields[i].offset !== b.fields[i].offset) offsetsDiffer = true;
   }
   if (!metadataEqual(a.metadata, b.metadata)) return "differs";
diff --git a/src/components/schema/DeclarationsContext.ts b/src/components/schema/DeclarationsContext.ts
@@ -3,8 +3,8 @@ import { href } from "react-router";
 import { Declaration, SchemaClass } from "../../data/types";
 import { SchemaMetadata } from "../../data/schemas";
 import { DEFAULT_GAME, GameId } from "../../games-list";
+export { declarationKey } from "../../data/derived";
 import type { ReferenceEntry } from "../../data/derived";
-export { declarationKey, type ReferenceEntry } from "../../data/derived";
 
 export function schemaPath(game: string, module?: string, scope?: string): string {
   return href("/:game?/:module?/:scope?", { game, module, scope });
diff --git a/src/components/schema/SchemaClass.tsx b/src/components/schema/SchemaClass.tsx
@@ -310,7 +310,7 @@ const BitRange = styled.span`
   font-variant-numeric: tabular-nums;
 `;
 
-const BitfieldPadding = styled.div`
+const BitfieldPadding = styled.li`
   padding: 3px 10px;
   font-size: 13px;
   color: var(--text-dim);
diff --git a/src/components/schema/SchemaType.tsx b/src/components/schema/SchemaType.tsx
@@ -61,6 +61,8 @@ export function SchemaTypeView({ type }: { type: SchemaFieldType }) {
       return <ColoredSyntax kind="atomic">{type.name}</ColoredSyntax>;
     case "bitfield":
       return <ColoredSyntax kind="literal">bitfield:{type.count}</ColoredSyntax>;
+    default:
+      return <span>{(type as { category: string }).category}</span>;
   }
 }
 
diff --git a/src/components/search/SearchBox.tsx b/src/components/search/SearchBox.tsx
@@ -437,7 +437,7 @@ export function SearchBox({ className }: { className?: string }) {
 
   return (
     <SearchBoxWrapper className={className}>
-      <SearchIcon width="16" height="16">
+      <SearchIcon width="16" height="16" aria-hidden="true">
         <use href={`${ICONS_URL}#search`} />
       </SearchIcon>
       {!inputValue && !isFocused && (
@@ -456,7 +456,7 @@ export function SearchBox({ className }: { className?: string }) {
         onKeyDown={onKeyDown}
         role="combobox"
         aria-label="Search"
-        aria-controls="search-listbox"
+        aria-controls={showPopup ? "search-listbox" : undefined}
         aria-autocomplete="list"
         aria-expanded={showPopup}
         spellCheck={false}
diff --git a/src/data/derived.ts b/src/data/derived.ts
@@ -73,7 +73,7 @@ function buildReferences(declarations: Declaration[]): Map<string, ReferenceEntr
   return refs;
 }
 
-export type DerivedGameData = {
+type DerivedGameData = {
   classesByKey: Map<string, SchemaClass>;
   references: Map<string, ReferenceEntry[]>;
   otherGamesLookup: Map<GameId, Map<string, Declaration>>;
@@ -93,13 +93,21 @@ export function getDerivedGameData(gameId: GameId): DerivedGameData {
     if (d.kind === "class") classesByKey.set(declarationKey(d.module, d.name), d);
   }
 
+  const modules = new Set(declarations.map((d) => d.module));
+
   const otherGamesLookup = new Map<GameId, Map<string, Declaration>>();
   for (const g of GAME_LIST) {
     if (g.id === gameId) continue;
     const other = preloadedData.get(g.id);
     if (other) {
       const map = new Map<string, Declaration>();
-      for (const d of other.declarations) map.set(d.name, d);
+      for (const d of other.declarations) {
+        // On duplicate names, prefer the one whose module also exists in the current game
+        const existing = map.get(d.name);
+        if (!existing || (modules.has(d.module) && !modules.has(existing.module))) {
+          map.set(d.name, d);
+        }
+      }
       otherGamesLookup.set(g.id, map);
     }
   }
diff --git a/src/data/preload.ts b/src/data/preload.ts
@@ -1,7 +1,7 @@
 import type { Declaration } from "./types";
 import type { SchemaMetadata } from "./schemas";
 
-export type PreloadedSchema = { declarations: Declaration[]; metadata: SchemaMetadata };
+type PreloadedSchema = { declarations: Declaration[]; metadata: SchemaMetadata };
 
 export const preloadedData = new Map<string, PreloadedSchema>();
 export const preloadErrors = new Map<string, string>();
diff --git a/src/data/schemas.test.ts b/src/data/schemas.test.ts
@@ -181,6 +181,13 @@ describe("resolveLeafType", () => {
     expect(resolveLeafType(type)).toBe(type);
   });
 
+  it("prefers inner2 over inner for atomic types (map value type)", () => {
+    const key = { category: "builtin" as const, name: "uint64" };
+    const value = { category: "declared_class" as const, name: "Bar", module: "m" };
+    const type = { category: "atomic" as const, name: "CUtlHashMap", inner: key, inner2: value };
+    expect(resolveLeafType(type)).toBe(value);
+  });
+
   it("returns declared_enum as-is", () => {
     const type = { category: "declared_enum" as const, name: "MyEnum", module: "m" };
     expect(resolveLeafType(type)).toBe(type);
@@ -339,6 +346,27 @@ describe("assignDefaults via parseSchemas", () => {
     const cls = getClass("TestBrokenDefaults");
     expect(cls.metadata.some((m) => m.name === "MGetKV3ClassDefaults")).toBe(true);
   });
+
+  it("assigns correct defaults when same-name class exists in different modules", () => {
+    const result = parseSchemas(testData as SchemasJson);
+    const classA = result.declarations.find(
+      (d) => d.name === "TestSameNameClass" && d.kind === "class" && d.module === "modA",
+    ) as SchemaClass;
+    const classB = result.declarations.find(
+      (d) => d.name === "TestSameNameClass" && d.kind === "class" && d.module === "modB",
+    ) as SchemaClass;
+    expect(classA).toBeDefined();
+    expect(classB).toBeDefined();
+    expect(getField(classA, "m_flVal").defaultValue).toBe("100");
+    expect(getField(classB, "m_flVal").defaultValue).toBe("200");
+  });
+
+  it("diffs nested object using inner2 (map value type) for target defaults", () => {
+    const cls = getClass("TestMapInner2");
+    // TestBaseClass defaults: m_flA=10, m_flB=20. Embedded: m_flA=10, m_flB=77
+    // inner2 resolves to TestBaseClass, diff should be {"m_flB":77}
+    expect(getField(cls, "m_map").defaultValue).toBe('{"m_flB":77}');
+  });
 });
 
 // ==================== parseSchemas basics ====================
diff --git a/src/data/schemas.ts b/src/data/schemas.ts
@@ -42,6 +42,7 @@ export function diffObject(
 
 /** @internal Exported for testing */
 export function resolveLeafType(type: SchemaFieldType): SchemaFieldType {
+  if ("inner2" in type && type.inner2) return resolveLeafType(type.inner2);
   if ("inner" in type && type.inner) return resolveLeafType(type.inner);
   return type;
 }
@@ -57,30 +58,31 @@ function stringifyDefault(value: unknown): string {
 
 function assignDefaults(classes: SchemaClass[]) {
   const classMap = new Map<string, SchemaClass>();
-  for (const cls of classes) classMap.set(cls.name, cls);
+  for (const cls of classes) classMap.set(`${cls.module}/${cls.name}`, cls);
 
-  // Parse and cache defaults per class name
+  // Parse and cache defaults per class key
   const defaultsCache = new Map<string, Record<string, unknown> | null>();
-  function getDefaults(name: string): Record<string, unknown> | null {
-    if (defaultsCache.has(name)) return defaultsCache.get(name)!;
-    const cls = classMap.get(name);
+  function getDefaults(module: string, name: string): Record<string, unknown> | null {
+    const key = `${module}/${name}`;
+    if (defaultsCache.has(key)) return defaultsCache.get(key)!;
+    const cls = classMap.get(key);
     const meta = cls?.metadata.find((m) => m.name === "MGetKV3ClassDefaults" && m.value);
     const parsed = meta ? parseKV3Defaults(meta.value!) : null;
-    defaultsCache.set(name, parsed);
+    defaultsCache.set(key, parsed);
     return parsed;
   }
 
   // Collect all fields including from parent chain
   function collectFields(cls: SchemaClass, out: Map<string, SchemaField>) {
     for (const p of cls.parents) {
-      const parent = classMap.get(p.name);
+      const parent = classMap.get(`${p.module}/${p.name}`);
       if (parent) collectFields(parent, out);
     }
     for (const f of cls.fields) out.set(f.name, f);
   }
 
   for (const cls of classes) {
-    const defaults = getDefaults(cls.name);
+    const defaults = getDefaults(cls.module, cls.name);
     if (!defaults) continue;
 
     // Only assign defaults to the class's own fields, not inherited ones
@@ -106,7 +108,7 @@ function assignDefaults(classes: SchemaClass[]) {
         // Inherited field — put into unconsumed if child overrides the parent's default
         let parentDefault: unknown;
         for (const p of cls.parents) {
-          const pd = getDefaults(p.name);
+          const pd = getDefaults(p.module, p.name);
           if (pd && key in pd) {
             parentDefault = pd[key];
             break;
@@ -134,7 +136,8 @@ function assignDefaults(classes: SchemaClass[]) {
       } else {
         // For declared_class fields, diff against target's own defaults to avoid redundancy
         const leaf = resolveLeafType(field.type);
-        const targetDefaults = leaf.category === "declared_class" ? getDefaults(leaf.name) : null;
+        const targetDefaults =
+          leaf.category === "declared_class" ? getDefaults(leaf.module, leaf.name) : null;
         const obj = targetDefaults
           ? diffObject(value as Record<string, unknown>, targetDefaults)
           : (value as Record<string, unknown>);
@@ -153,7 +156,7 @@ function assignDefaults(classes: SchemaClass[]) {
   }
 }
 
-export interface RawSchemaClass {
+interface RawSchemaClass {
   name: string;
   module: string;
   parents?: { name: string; module: string }[];
@@ -166,7 +169,7 @@ export interface RawSchemaClass {
   metadata?: SchemaMetadataEntry[];
 }
 
-export interface RawSchemaEnum {
+interface RawSchemaEnum {
   name: string;
   module: string;
   alignment: string;
diff --git a/src/entry.server.tsx b/src/entry.server.tsx
@@ -2,7 +2,7 @@ import type { EntryContext } from "react-router";
 import { ServerRouter } from "react-router";
 import { renderToPipeableStream } from "react-dom/server";
 import { PassThrough } from "node:stream";
-import { resolve } from "node:path";
+import { resolve as pathResolve } from "node:path";
 import { preloadedData } from "./data/preload";
 import { parseSchemas, type SchemasJson } from "./data/schemas";
 import { GAME_LIST } from "./games-list";
@@ -16,7 +16,7 @@ export default async function handleRequest(
 ) {
   for (const game of GAME_LIST) {
     if (!preloadedData.has(game.id)) {
-      const data = await readGzippedJson<SchemasJson>(resolve("schemas", `${game.id}.json.gz`));
+      const data = await readGzippedJson<SchemasJson>(pathResolve("schemas", `${game.id}.json.gz`));
       preloadedData.set(game.id, parseSchemas(data));
     }
   }
diff --git a/src/games-list.ts b/src/games-list.ts
@@ -4,7 +4,7 @@ export const GAME_LIST = [
   { id: "deadlock", name: "Deadlock", repo: "SteamTracking/GameTracking-Deadlock" },
 ] as const;
 
-export type GameDef = (typeof GAME_LIST)[number];
+type GameDef = (typeof GAME_LIST)[number];
 export type GameId = GameDef["id"];
 export const DEFAULT_GAME: GameId = GAME_LIST[0].id;
 
diff --git a/src/global.css b/src/global.css
diff --git a/src/utils/enum-flags.test.ts b/src/utils/enum-flags.test.ts
diff --git a/src/utils/enum-flags.ts b/src/utils/enum-flags.ts
diff --git a/src/utils/filtering.tsx b/src/utils/filtering.tsx
diff --git a/src/utils/format.test.ts b/src/utils/format.test.ts
diff --git a/src/utils/format.ts b/src/utils/format.ts
diff --git a/src/utils/test-schemas.json b/src/utils/test-schemas.json

Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,11 @@ type DiffStatus = "identical" \| "offsets_only" \| "differs";`
`16`	`16`
`17`	`17`	const GameLink = styled(SectionLink)`
`18`	`18`	`&[data-status="offsets_only"] {`
`19`		`- border-color: #5b8ab5;`
	`19`	`+ border-color: var(--cross-game-offsets);`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`&[data-status="differs"] {`
`23`		`- border-color: #c97a1e;`
	`23`	`+ border-color: var(--cross-game-differs);`
`24`	`24`	`}`
`25`	`25`	`;
`26`	`26`
`@@ -81,6 +81,7 @@ function compareClasses(a: SchemaClass, b: SchemaClass): DiffStatus {`
`81`	`81`	`if (a.fields[i].name !== b.fields[i].name) return "differs";`
`82`	`82`	`if (!typesEqual(a.fields[i].type, b.fields[i].type)) return "differs";`
`83`	`83`	`if (!metadataEqual(a.fields[i].metadata, b.fields[i].metadata)) return "differs";`
	`84`	`+ if (a.fields[i].defaultValue !== b.fields[i].defaultValue) return "differs";`
`84`	`85`	`if (a.fields[i].offset !== b.fields[i].offset) offsetsDiffer = true;`
`85`	`86`	`}`
`86`	`87`	`if (!metadataEqual(a.metadata, b.metadata)) return "differs";`