@optave/codegraph 3.12.0 → 3.13.0

package/src/domain/graph/builder/stages/resolve-imports.ts

@@ -135,7 +135,7 @@ async function reparseBarrelFiles(
   // which only runs on the original (changed + reverse-dep) fileSymbols. Barrel
   // candidates are merged here *after* insertNodes, so wiping those kinds
   // would permanently drop them (mirrors the Rust orchestrator's Stage 6b
-  // delete in build_pipeline.rs).
+  // delete in domain/graph/builder/pipeline.rs).
   const deleteOutgoingEdges = db.prepare(
     `DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)
      AND kind NOT IN ('contains', 'parameter_of')`,

package/src/domain/parser.ts

@@ -158,6 +158,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (generator_function) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
   '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (computed_property_name) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -221,7 +222,9 @@ async function doLoadLanguage(entry: LanguageRegistryEntry): Promise<void> {
         file: entry.grammarFile,
         cause: e as Error,
       });
-    warn(
+    const isEnoent = (e as NodeJS.ErrnoException).code === 'ENOENT';
+    const log = isEnoent ? debug : warn;
+    log(
       `${entry.id} parser failed to initialize: ${(e as Error).message}. ${entry.id} files will be skipped.`,
     );
     _cachedParsers!.set(entry.id, null);
@@ -465,7 +468,7 @@ export function getInstalledWasmExtensions(): Set<string> {
  * Lowercase file extensions covered by the native Rust addon.
  *
  * Mirrors `LanguageKind::from_extension` in
- * `crates/codegraph-core/src/parser_registry.rs`. Used to classify why the
+ * `crates/codegraph-core/src/domain/parser.rs`. Used to classify why the
  * native orchestrator dropped a file: extensions outside this set are a
  * legitimate parser limit (no Rust extractor exists), while extensions inside
  * it indicate a real native bug (parse/read/extract failure).
@@ -1181,12 +1184,25 @@ async function parseFilesWasm(
 /**
  * Files at or below this count use the inline parse path (no worker spawn).
  *
- * Sized for typical engine-parity drops: a handful of fixture files in one
- * or two languages (the recurring HCL case is 4 files). Above this, the
- * worker-pool's IPC + crash-isolation cost (#965) is amortized over enough
- * parse work to be worth paying; below it, the ~1–2s cold-start dominates.
+ * The worker pool exists for crash safety (#965): exotic (non-required) WASM
+ * grammars can trigger uncatchable V8 fatal errors that would kill the main
+ * process. Running them in a worker means only the worker dies; the pool
+ * detects the exit, skips the file, respawns, and continues.
+ *
+ * JS/TS/TSX are required-tier grammars — they have never triggered the V8
+ * fatal crash class and are safe to run inline. The primary hot caller
+ * (this/super dispatch post-pass) exclusively handles JS/TS/TSX files and
+ * measured ~55–64ms/file through the pool vs ~8–10ms/file inline (#1435);
+ * IPC overhead scales linearly with file count, not amortised.
+ *
+ * The threshold is set high enough to keep typical this-dispatch batches
+ * (≤ 18 files on the codegraph corpus) on the inline path, while still
+ * routing truly large exotic-language drops (rare; typical HCL case is 4
+ * files) through the pool for crash isolation. Exotic-language drops are
+ * almost always well under this limit anyway, so they benefit from the
+ * inline fast path too without meaningful crash risk increase.
  */
-const INLINE_BACKFILL_THRESHOLD = 16;
+const INLINE_BACKFILL_THRESHOLD = 32;
 
 /**
  * Inline WASM parse (no worker) for small file batches.
@@ -1198,11 +1214,16 @@ const INLINE_BACKFILL_THRESHOLD = 16;
  *
  * Returns symbols with `_tree` set so `runAnalyses` can run AST/CFG/dataflow
  * visitors via the unified walker (mirrors how WASM-engine results behaved
- * before the worker pool was introduced).
+ * before the worker pool was introduced), unless `symbolsOnly` is true — in
+ * that case `_tree` is not set, skipping all analysis visitor walks. Use
+ * `symbolsOnly` when only definitions/calls/typeMap are needed (e.g. the
+ * this/super dispatch post-pass) to avoid the analysis overhead on the inline
+ * path, matching the optimization already applied to the worker-pool path.
  */
 async function parseFilesWasmInline(
   filePaths: string[],
   rootDir: string,
+  symbolsOnly = false,
 ): Promise<Map<string, ExtractorOutput>> {
   const result = new Map<string, ExtractorOutput>();
   if (filePaths.length === 0) return result;
@@ -1220,7 +1241,18 @@ async function parseFilesWasmInline(
     if (!extracted) continue;
     const relPath = path.relative(rootDir, filePath).split(path.sep).join('/');
     const symbols = extracted.symbols as ExtractorOutput & { _tree?: unknown; _langId?: string };
-    symbols._tree = extracted.tree;
+    // When symbolsOnly=true, skip setting _tree so runAnalyses does not run
+    // AST/complexity/CFG/dataflow visitor walks — only definitions/calls/typeMap
+    // are needed by callers like the this/super dispatch post-pass.
+    if (!symbolsOnly) {
+      symbols._tree = extracted.tree;
+    } else if (typeof (extracted.tree as any)?.delete === 'function') {
+      // Free the WASM-backed tree immediately — web-tree-sitter trees are backed
+      // by WASM linear memory and require explicit disposal.  When symbolsOnly is
+      // true the tree is never stored anywhere, so we must delete it here to
+      // avoid leaking WASM heap on every incremental rebuild.
+      (extracted.tree as any).delete();
+    }
     symbols._langId = extracted.langId;
     result.set(relPath, symbols);
   }
@@ -1230,14 +1262,13 @@ async function parseFilesWasmInline(
 /**
  * Backfill helper: small batches use the inline (main-thread) path; larger
  * batches keep the worker-pool isolation against tree-sitter WASM crashes
- * (#965). Threshold matches typical engine-parity drop sizes (a few fixture
- * files in one or two languages).
+ * (#965). See INLINE_BACKFILL_THRESHOLD for threshold rationale.
  *
  * `opts.symbolsOnly` skips the AST/complexity/CFG/dataflow visitors in the
  * worker (and their result serialization across the thread boundary) for
  * callers that only consume definitions/calls/typeMap — the native
- * orchestrator's prototype-methods and this-dispatch post-passes. Callers
- * that ingest the files into the DB (dropped-language backfill) must keep
+ * orchestrator's this-dispatch post-pass. Callers that ingest the files into
+ * the DB (dropped-language backfill) must keep
  * the default full analysis.
  */
 export async function parseFilesWasmForBackfill(
@@ -1246,7 +1277,7 @@ export async function parseFilesWasmForBackfill(
   opts: { symbolsOnly?: boolean } = {},
 ): Promise<Map<string, ExtractorOutput>> {
   if (filePaths.length <= INLINE_BACKFILL_THRESHOLD) {
-    return parseFilesWasmInline(filePaths, rootDir);
+    return parseFilesWasmInline(filePaths, rootDir, opts.symbolsOnly);
   }
   return parseFilesWasm(filePaths, rootDir, opts.symbolsOnly ? EXTRACT_ONLY : FULL_ANALYSIS);
 }

package/src/domain/wasm-worker-entry.ts

@@ -115,6 +115,7 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(variable_declarator name: (identifier) @varfn_name value: (generator_function) @varfn_value)',
   '(method_definition name: (property_identifier) @meth_name) @meth_node',
   '(method_definition name: (private_property_identifier) @meth_name) @meth_node',
+  '(method_definition name: (computed_property_name) @meth_name) @meth_node',
   '(import_statement source: (string) @imp_source) @imp_node',
   '(export_statement) @exp_node',
   '(call_expression function: (identifier) @callfn_name) @callfn_node',
@@ -125,11 +126,17 @@ const COMMON_QUERY_PATTERNS: string[] = [
   '(expression_statement (assignment_expression left: (member_expression) @assign_left right: (_) @assign_right)) @assign_node',
 ];
 
-const JS_CLASS_PATTERN: string = '(class_declaration name: (identifier) @cls_name) @cls_node';
+const JS_CLASS_PATTERNS: string[] = [
+  '(class_declaration name: (identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }` or `const X = class Foo { ... }`
+  '(class name: (identifier) @cls_name) @cls_node',
+];
 
 const TS_EXTRA_PATTERNS: string[] = [
   '(class_declaration name: (type_identifier) @cls_name) @cls_node',
   '(abstract_class_declaration name: (type_identifier) @cls_name) @cls_node',
+  // class expressions: `return class Foo extends Bar { ... }`
+  '(class name: (type_identifier) @cls_name) @cls_node',
   '(interface_declaration name: (type_identifier) @iface_name) @iface_node',
   '(type_alias_declaration name: (type_identifier) @type_name) @type_node',
 ];
@@ -433,7 +440,7 @@ async function loadLanguageLazy(entry: LanguageRegistryEntry): Promise<Parser |
       const isTS = entry.id === 'typescript' || entry.id === 'tsx';
       const patterns = isTS
         ? [...COMMON_QUERY_PATTERNS, ...TS_EXTRA_PATTERNS]
-        : [...COMMON_QUERY_PATTERNS, JS_CLASS_PATTERN];
+        : [...COMMON_QUERY_PATTERNS, ...JS_CLASS_PATTERNS];
       _queries.set(entry.id, new Query(lang, patterns.join('\n')));
     }
     return parser;
@@ -818,6 +825,7 @@ function serializeExtractorOutput(
     ...(symbols.objectPropBindings?.length
       ? { objectPropBindings: symbols.objectPropBindings }
       : {}),
+    ...(symbols.thisCallBindings?.length ? { thisCallBindings: symbols.thisCallBindings } : {}),
     ...(symbols.newExpressions?.length ? { newExpressions: symbols.newExpressions } : {}),
     ...(symbols.definePropertyReceivers?.size
       ? { definePropertyReceivers: Array.from(symbols.definePropertyReceivers.entries()) }

package/src/domain/wasm-worker-pool.ts

@@ -115,6 +115,7 @@ function deserializeResult(ser: SerializedExtractorOutput | null): ExtractorOutp
   if (ser.objectRestParamBindings?.length)
     out.objectRestParamBindings = ser.objectRestParamBindings;
   if (ser.objectPropBindings?.length) out.objectPropBindings = ser.objectPropBindings;
+  if (ser.thisCallBindings?.length) out.thisCallBindings = ser.thisCallBindings;
   if (ser.newExpressions?.length) out.newExpressions = ser.newExpressions;
   if (ser.definePropertyReceivers?.length) {
     const m = new Map<string, string>();

package/src/domain/wasm-worker-protocol.ts

@@ -71,6 +71,7 @@ export interface SerializedExtractorOutput {
   objectRestParamBindings?: import('../types.js').ObjectRestParamBinding[];
   objectPropBindings?: import('../types.js').ObjectPropBinding[];
   paramBindings?: import('../types.js').ParamBinding[];
+  thisCallBindings?: import('../types.js').ThisCallBinding[];
   newExpressions?: readonly string[];
   /** Serialized definePropertyReceivers map (funcName → receiverVarName) as tuple array. */
   definePropertyReceivers?: Array<[string, string]>;

package/src/extractors/cpp.ts

@@ -5,7 +5,13 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import {
+  extractModifierVisibility,
+  findChild,
+  isCPrimitiveType,
+  nodeEndLine,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /**
  * Extract symbols from C++ files.
@@ -50,6 +56,9 @@ function walkCppNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCppCallExpression(node, ctx);
       break;
+    case 'declaration':
+      handleCppDeclaration(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -204,6 +213,40 @@ function handleCppInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
   });
 }
 
+/**
+ * Seed typeMap for declaration-typed locals: `UserService svc;` and
+ * `UserService svc = makeService();` both yield typeMap["svc"] = "UserService"
+ * at confidence 0.9. Mirrors `match_c_family_type_map` ("declaration" branch)
+ * in the native Rust C++ extractor.
+ */
+function handleCppDeclaration(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.text;
+  // Skip primitive types — they are never class/struct receivers
+  if (isCPrimitiveType(typeName)) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const kind = child.type;
+    let nameNode: TreeSitterNode | null = null;
+    if (kind === 'init_declarator') {
+      nameNode = child.childForFieldName('declarator') ?? null;
+    } else if (kind === 'identifier') {
+      nameNode = child;
+    }
+    // Note: pointer_declarator / reference_declarator children (e.g. `UserService *svc;`)
+    // are intentionally skipped here — they are also skipped by the native Rust
+    // match_c_family_type_map helper, which only handles 'init_declarator' and
+    // 'identifier' children. Both engines have the same scope for this case.
+    if (!nameNode) continue;
+    const varName = unwrapCppDeclaratorName(nameNode);
+    if (varName) {
+      setTypeMapEntry(ctx.typeMap, varName, typeName, 0.9);
+    }
+  }
+}
+
 function handleCppCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;

package/src/extractors/cuda.ts

@@ -5,7 +5,13 @@ import type {
   TreeSitterNode,
   TreeSitterTree,
 } from '../types.js';
-import { extractModifierVisibility, findChild, nodeEndLine } from './helpers.js';
+import {
+  extractModifierVisibility,
+  findChild,
+  isCPrimitiveType,
+  nodeEndLine,
+  setTypeMapEntry,
+} from './helpers.js';
 
 /**
  * Extract symbols from CUDA files.
@@ -63,6 +69,9 @@ function walkCudaNode(node: TreeSitterNode, ctx: ExtractorOutput): void {
     case 'call_expression':
       handleCudaCallExpression(node, ctx);
       break;
+    case 'declaration':
+      handleCudaDeclaration(node, ctx);
+      break;
   }
 
   for (let i = 0; i < node.childCount; i++) {
@@ -204,6 +213,40 @@ function handleCudaInclude(node: TreeSitterNode, ctx: ExtractorOutput): void {
   });
 }
 
+/**
+ * Seed typeMap for declaration-typed locals: `UserService svc;` and
+ * `UserService svc = make();` both yield typeMap["svc"] = "UserService"
+ * at confidence 0.9. Mirrors `match_c_family_type_map` ("declaration" branch)
+ * in the native Rust CUDA extractor.
+ */
+function handleCudaDeclaration(node: TreeSitterNode, ctx: ExtractorOutput): void {
+  const typeNode = node.childForFieldName('type');
+  if (!typeNode) return;
+  const typeName = typeNode.text;
+  // Skip primitive types — they are never class/struct receivers
+  if (isCPrimitiveType(typeName)) return;
+  for (let i = 0; i < node.childCount; i++) {
+    const child = node.child(i);
+    if (!child) continue;
+    const kind = child.type;
+    let nameNode: TreeSitterNode | null = null;
+    if (kind === 'init_declarator') {
+      nameNode = child.childForFieldName('declarator') ?? null;
+    } else if (kind === 'identifier') {
+      nameNode = child;
+    }
+    // Note: pointer_declarator / reference_declarator children (e.g. `UserService *svc;`)
+    // are intentionally skipped here — they are also skipped by the native Rust
+    // match_c_family_type_map helper, which only handles 'init_declarator' and
+    // 'identifier' children. Both engines have the same scope for this case.
+    if (!nameNode) continue;
+    const varName = extractCudaFieldName(nameNode);
+    if (varName) {
+      setTypeMapEntry(ctx.typeMap, varName, typeName, 0.9);
+    }
+  }
+}
+
 function handleCudaCallExpression(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const funcNode = node.childForFieldName('function');
   if (!funcNode) return;

package/src/extractors/helpers.ts

@@ -305,6 +305,49 @@ export function pushImport(
   ctx.imports.push(entry);
 }
 
+// ── C-family primitive types ───────────────────────────────────────────────
+
+/**
+ * Primitive C/C++/CUDA types that are never class/struct receivers. Seeding
+ * these into typeMap would produce spurious receiver edges (e.g. `int x` → `int`).
+ * Shared between the C++ and CUDA extractors to prevent divergence.
+ */
+export const C_PRIMITIVE_TYPES: ReadonlySet<string> = new Set([
+  'int',
+  'long',
+  'short',
+  'unsigned',
+  'signed',
+  'float',
+  'double',
+  'char',
+  'bool',
+  'void',
+  'wchar_t',
+  'auto',
+  'size_t',
+  'uint8_t',
+  'uint16_t',
+  'uint32_t',
+  'uint64_t',
+  'int8_t',
+  'int16_t',
+  'int32_t',
+  'int64_t',
+  'ptrdiff_t',
+  'intptr_t',
+  'uintptr_t',
+]);
+
+/**
+ * Return true when `typeName` is a primitive C/C++/CUDA type.
+ * Strips leading qualifiers (`const int` → `int`) before checking.
+ */
+export function isCPrimitiveType(typeName: string): boolean {
+  const base = typeName.split(/\s+/).pop() ?? typeName;
+  return C_PRIMITIVE_TYPES.has(base) || C_PRIMITIVE_TYPES.has(typeName);
+}
+
 // ── Parameter extraction ───────────────────────────────────────────────────
 
 /**

package/src/extractors/java.ts

@@ -16,6 +16,7 @@ import {
   nodeStartLine,
   pushCall,
   pushImport,
+  setTypeMapEntry,
 } from './helpers.js';
 
 /**
@@ -273,13 +274,13 @@ function handleJavaLocalVarDecl(node: TreeSitterNode, ctx: ExtractorOutput): voi
     const child = node.child(i);
     if (child?.type === 'variable_declarator') {
       const nameNode = child.childForFieldName('name');
-      // Use direct Map.set (last-wins) for local variable declarations.
-      // Local variable types are method-scoped and should override any
-      // prior entry (e.g. a same-named constructor parameter). Using
-      // setTypeMapEntry (first-wins on tie) would let a constructor
-      // parameter type block a local variable's more-specific concrete type.
-      if (nameNode && ctx.typeMap)
-        ctx.typeMap.set(nameNode.text, { type: typeName, confidence: 0.9 });
+      // Use setTypeMapEntry (first-wins on tie) to match Rust extractor semantics.
+      // The typeMap is flat per-file without method scoping, so a local variable
+      // in one method (e.g. `InMemoryUserRepository repo` in `createDefault()`) must
+      // not override a parameter binding set by an earlier method
+      // (e.g. `UserRepository repo` constructor param). First-wins preserves the
+      // interface/abstract type annotation that drives correct CHA dispatch.
+      if (nameNode && ctx.typeMap) setTypeMapEntry(ctx.typeMap, nameNode.text, typeName, 0.9);
     }
   }
 }

package/src/extractors/javascript.ts

@@ -169,7 +169,19 @@ function handleClassCapture(
 
 /** Handle method_definition capture. */
 function handleMethodCapture(c: Record<string, TreeSitterNode>, definitions: Definition[]): void {
-  const methName = c.meth_name!.text;
+  const methNameNode = c.meth_name!;
+  let methName: string;
+  if (methNameNode.type === 'computed_property_name') {
+    // Extract the inner string literal from `['methodName']` or `["methodName"]`.
+    // Non-string computed keys (e.g. `[Symbol.iterator]`) cannot be resolved at
+    // dot-notation call sites, so skip them entirely.
+    const inner = methNameNode.child(1); // child(0)='[', child(1)=string, child(2)=']'
+    if (!inner || (inner.type !== 'string' && inner.type !== 'string_fragment')) return;
+    methName = inner.text.replace(/^['"]|['"]$/g, '');
+    if (!methName) return;
+  } else {
+    methName = methNameNode.text;
+  }
   const parentClass = findParentClass(c.meth_node!);
   const fullName = parentClass ? `${parentClass}.${methName}` : methName;
   const methChildren = extractParameters(c.meth_node!);
@@ -507,6 +519,15 @@ function extractDestructuredBindingsWalk(node: TreeSitterNode, definitions: Defi
             nodeEndLine(declNode),
             definitions,
           );
+        } else if (nameN && nameN.type === 'array_pattern') {
+          // `const [x, y] = ...` — emit a single constant node whose name is the
+          // full array pattern text (e.g. `[x, y]`), matching native engine behaviour.
+          definitions.push({
+            name: nameN.text,
+            kind: 'constant',
+            line: nodeStartLine(declNode),
+            endLine: nodeEndLine(declNode),
+          });
         }
       }
     }
@@ -816,8 +837,20 @@ function handleClassDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
 function handleMethodDef(node: TreeSitterNode, ctx: ExtractorOutput): void {
   const nameNode = node.childForFieldName('name');
   if (nameNode) {
+    let methName: string;
+    if (nameNode.type === 'computed_property_name') {
+      // Extract the inner string literal from `['methodName']` or `["methodName"]`.
+      // Non-string computed keys (e.g. `[Symbol.iterator]`) cannot be resolved at
+      // dot-notation call sites, so skip them entirely.
+      const inner = nameNode.child(1); // child(0)='[', child(1)=string, child(2)=']'
+      if (!inner || (inner.type !== 'string' && inner.type !== 'string_fragment')) return;
+      methName = inner.text.replace(/^['"]|['"]$/g, '');
+      if (!methName) return;
+    } else {
+      methName = nameNode.text;
+    }
     const parentClass = findParentClass(node);
-    const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+    const fullName = parentClass ? `${parentClass}.${methName}` : methName;
     const methChildren = extractParameters(node);
     const methVis = extractVisibility(node);
     ctx.definitions.push({
@@ -1017,6 +1050,16 @@ function handleVariableDecl(node: TreeSitterNode, ctx: ExtractorOutput): void {
             nodeEndLine(node),
             ctx.definitions,
           );
+        } else if (isConst && nameN.type === 'array_pattern' && !hasFunctionScopeAncestor(node)) {
+          // Array destructuring: `const [x, y] = ...` — emit a single constant node
+          // whose name is the full array pattern text (e.g. `[x, y]`), matching
+          // native engine behaviour. Scope guard mirrors the object_pattern branch above.
+          ctx.definitions.push({
+            name: nameN.text,
+            kind: 'constant',
+            line: nodeStartLine(node),
+            endLine: nodeEndLine(node),
+          });
         }
       }
     }
@@ -1065,8 +1108,19 @@ function extractObjectLiteralFunctions(
     } else if (child.type === 'method_definition') {
       const nameNode = child.childForFieldName('name');
       if (nameNode) {
+        let methodName: string;
+        if (nameNode.type === 'computed_property_name') {
+          // Strip brackets+quotes from `['methodName']` to get a resolvable name.
+          // Skip non-string computed keys (e.g. [Symbol.iterator]).
+          const inner = nameNode.child(1);
+          if (!inner || (inner.type !== 'string' && inner.type !== 'string_fragment')) continue;
+          methodName = inner.text.replace(/^['"]|['"]$/g, '');
+          if (!methodName) continue;
+        } else {
+          methodName = nameNode.text;
+        }
         definitions.push({
-          name: `${varName}.${nameNode.text}`,
+          name: `${varName}.${methodName}`,
           kind: 'function',
           line: nodeStartLine(child),
           endLine: nodeEndLine(child),
@@ -1813,9 +1867,23 @@ function runContextCollectorWalk(rootNode: TreeSitterNode, out: ContextCollector
         // Qualify with the enclosing class name so the PTS key matches
         // callerName from findCaller (which uses def.name = 'ClassName.method').
         const enclosingClass = classStack.length > 0 ? classStack[classStack.length - 1] : null;
-        const qualifiedName = enclosingClass ? `${enclosingClass}.${nameNode.text}` : nameNode.text;
-        funcStack.push(qualifiedName);
-        pushedFunc = true;
+        let rawName: string;
+        if (nameNode.type === 'computed_property_name') {
+          const inner = nameNode.child(1);
+          if (!inner || (inner.type !== 'string' && inner.type !== 'string_fragment')) {
+            // Non-string computed key — skip adding to funcStack (no resolvable name).
+            rawName = '';
+          } else {
+            rawName = inner.text.replace(/^['"]|['"]$/g, '');
+          }
+        } else {
+          rawName = nameNode.text;
+        }
+        if (rawName) {
+          const qualifiedName = enclosingClass ? `${enclosingClass}.${rawName}` : rawName;
+          funcStack.push(qualifiedName);
+          pushedFunc = true;
+        }
       }
     } else if (t === 'variable_declarator') {
       // `const process = (arr) => { ... }` — arrow/expression functions assigned
@@ -1866,6 +1934,8 @@ function runContextCollectorWalk(rootNode: TreeSitterNode, out: ContextCollector
       collectCollectionWrapBinding(node, out.fnRefBindings);
     } else if (t === 'required_parameter' || t === 'optional_parameter') {
       handleParamTypeMap(node, out.typeMap);
+    } else if (t === 'public_field_definition' || t === 'field_definition') {
+      handleFieldDefTypeMap(node, out.typeMap, typeMapClass);
     } else if (t === 'assignment_expression') {
       handlePropWriteTypeMap(node, out.typeMap, typeMapClass);
     } else if (t === 'call_expression') {
@@ -2090,6 +2160,55 @@ function handleParamTypeMap(node: TreeSitterNode, typeMap: Map<string, TypeMapEn
   }
 }
 
+/**
+ * Extract type info from a class field declaration: `private repo: Repository<User>`.
+ *
+ * Seeds a class-scoped key `ClassName.field` (confidence 0.9) as the primary entry
+ * so that two classes with identically-named fields don't overwrite each other's
+ * typeMap entry (issue #1458). The resolver's `CallerClass.X` fallback (call-resolver.ts
+ * line 110) looks up exactly this key.
+ *
+ * Bare `field` and `this.field` keys are kept at lower confidence (0.6) as fallbacks
+ * for single-class files where the resolver may not have a callerClass context.
+ *
+ * Mirrors the field_definition branch of match_js_type_map in
+ * crates/codegraph-core/src/extractors/javascript.rs.
+ */
+function handleFieldDefTypeMap(
+  node: TreeSitterNode,
+  typeMap: Map<string, TypeMapEntry>,
+  currentClass: string | null,
+): void {
+  const nameNode =
+    node.childForFieldName('name') ||
+    node.childForFieldName('property') ||
+    findChild(node, 'property_identifier');
+  if (!nameNode) return;
+  const kind = nameNode.type;
+  if (
+    kind !== 'property_identifier' &&
+    kind !== 'identifier' &&
+    kind !== 'private_property_identifier'
+  )
+    return;
+  const typeAnno = findChild(node, 'type_annotation');
+  if (!typeAnno) return;
+  const typeName = extractSimpleTypeName(typeAnno);
+  if (!typeName) return;
+  if (currentClass) {
+    // Primary: class-scoped key prevents cross-class collision (issue #1458).
+    setTypeMapEntry(typeMap, `${currentClass}.${nameNode.text}`, typeName, 0.9);
+    // Fallback: bare keys at lower confidence for single-class files or when
+    // the resolver does not have a callerClass in scope.
+    setTypeMapEntry(typeMap, nameNode.text, typeName, 0.6);
+    setTypeMapEntry(typeMap, `this.${nameNode.text}`, typeName, 0.6);
+  } else {
+    // No enclosing class declaration (e.g. class expression) — use bare keys only.
+    setTypeMapEntry(typeMap, nameNode.text, typeName, 0.9);
+    setTypeMapEntry(typeMap, `this.${nameNode.text}`, typeName, 0.9);
+  }
+}
+
 /**
  * Phase 8.3d: seed the pts map from object property writes.
  *
@@ -3308,11 +3427,13 @@ function emitPrototypeMethod(
 ): void {
   const fullName = `${className}.${methodName}`;
   if (rhs.type === 'function_expression' || rhs.type === 'arrow_function') {
+    const params = extractParameters(rhs);
     definitions.push({
       name: fullName,
       kind: 'method',
       line: nodeStartLine(rhs),
       endLine: nodeEndLine(rhs),
+      children: params.length > 0 ? params : undefined,
     });
   } else if (rhs.type === 'identifier' && !BUILTIN_GLOBALS.has(rhs.text)) {
     // Prototype alias: `A.prototype.t = f` → typeMap['A.t'] = { type: 'f' }

package/src/features/structure-query.ts

@@ -324,7 +324,7 @@ export function hotspotsData(
   metric: string;
   level: string;
   limit: number;
-  hotspots: unknown[];
+  items: unknown[];
 } {
   const { db, nativeDb, close } = openReadonlyWithNative(customDbPath);
   try {
@@ -337,19 +337,19 @@ export function hotspotsData(
     // ── Native fast path: single query instead of 4 eagerly prepared ──
     if (nativeDb?.getHotspots) {
       const rows = nativeDb.getHotspots(kind, metric, noTests, limit);
-      const hotspots = rows.map(mapNativeHotspotRow);
-      const base = { metric, level, limit, hotspots };
-      return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
+      const items = rows.map(mapNativeHotspotRow);
+      const base = { metric, level, limit, items };
+      return paginateResult(base, 'items', { limit: opts.limit, offset: opts.offset });
     }
 
     // ── JS fallback ───────────────────────────────────────────────────
     const testFilter = testFilterSQL('n.name', noTests && kind === 'file');
     const stmt = db.prepare(buildHotspotQuery(metric, testFilter));
     const rows = stmt.all(kind, limit) as HotspotRow[];
-    const hotspots = rows.map(mapJsHotspotRow);
+    const items = rows.map(mapJsHotspotRow);
 
-    const base = { metric, level, limit, hotspots };
-    return paginateResult(base, 'hotspots', { limit: opts.limit, offset: opts.offset });
+    const base = { metric, level, limit, items };
+    return paginateResult(base, 'items', { limit: opts.limit, offset: opts.offset });
   } finally {
     close();
   }

package/src/index.ts

@@ -52,7 +52,11 @@ export { ownersData } from './features/owners.js';
 export { sequenceData } from './features/sequence.js';
 export { hotspotsData, moduleBoundariesData, structureData } from './features/structure.js';
 export { triageData } from './features/triage.js';
-export { loadConfig } from './infrastructure/config.js';
+export {
+  loadConfig,
+  loadConfigWithProvenance,
+  resolveUserConfigPath,
+} from './infrastructure/config.js';
 export type { ArrayCompatSet } from './shared/constants.js';
 export { EXTENSIONS, IGNORE_DIRS } from './shared/constants.js';
 export {