fix: add native orchestrator post-pass for prototype method resolution

The Rust engine does not recognise Foo.prototype.bar = function(){} as a
method definition, so prototype-based method nodes were absent from the DB
when the native orchestrator ran. This causes the integration tests to fail
on all platforms where the native addon is available.

Fix two issues:
1. Remove duplicate extractPrototypeMethodsWalk call in extractSymbolsQuery
   that was inflating the definitions array (identified by Greptile)
2. Add runPostNativePrototypeMethods post-pass to native-orchestrator.ts:
   - Re-parses JS/TS files via WASM after native build
   - Inserts any method nodes missing from the DB (prototype patterns)
   - Resolves and inserts call edges to those new nodes using the WASM
     typeMap and the call-resolver

Author: carlos-alm

src/domain/graph/builder/stages/native-orchestrator.ts

@@ -42,6 +42,8 @@ import {
   parseFilesWasmForBackfill,
 } from '../../../parser.js';
 import { computeConfidence } from '../../resolve.js';
+import type { CallNodeLookup } from '../call-resolver.js';
+import { findCaller, resolveByMethodOrGlobal } from '../call-resolver.js';
 import type { PipelineContext } from '../context.js';
 import {
   batchInsertEdges,
@@ -558,6 +560,183 @@ function runPostNativeCha(db: BetterSqlite3Database): Set<number> {
   return newTargetIds;
 }
 
+/**
+ * Post-pass: backfill prototype-based method definitions and their call edges.
+ *
+ * The Rust engine does not recognise `Foo.prototype.bar = function(){}` as a
+ * method definition, so those nodes are absent from the DB after the native
+ * orchestrator completes. This pass:
+ *   1. Re-parses JS/TS files via WASM to obtain the full ExtractorOutput
+ *      (including definitions emitted by extractPrototypeMethodsWalk).
+ *   2. Inserts any method nodes that are missing from the DB.
+ *   3. Resolves call edges to those newly-inserted nodes using the WASM typeMap
+ *      and the existing DB node table as a lookup.
+ */
+async function runPostNativePrototypeMethods(
+  db: BetterSqlite3Database,
+  rootDir: string,
+): Promise<void> {
+  // Collect JS/TS file paths from the DB — only extensions where prototype
+  // patterns can appear.
+  const jsExts = new Set(['.js', '.mjs', '.cjs', '.ts', '.tsx']);
+  const fileRows = db
+    .prepare(
+      `SELECT DISTINCT file FROM nodes WHERE kind = 'file' AND file IS NOT NULL ORDER BY file`,
+    )
+    .all() as Array<{ file: string }>;
+
+  const jsFiles = fileRows
+    .map((r) => r.file)
+    .filter((f) => jsExts.has(path.extname(f).toLowerCase()));
+
+  if (jsFiles.length === 0) return;
+
+  // WASM-parse all JS/TS files to get full ExtractorOutput including
+  // prototype method definitions and typeMap entries.
+  const absPaths = jsFiles.map((f) => path.join(rootDir, f));
+  let wasmResults: Map<string, ExtractorOutput>;
+  try {
+    wasmResults = await parseFilesWasmForBackfill(absPaths, rootDir);
+  } catch (e) {
+    debug(`runPostNativePrototypeMethods: WASM parse failed: ${toErrorMessage(e)}`);
+    return;
+  }
+
+  if (wasmResults.size === 0) return;
+
+  // Check which nodes already exist — INSERT OR IGNORE handles races but
+  // we need the IDs of newly inserted rows, so we check first.
+  const existsStmt = db.prepare(
+    `SELECT id FROM nodes WHERE name = ? AND kind = 'method' AND file = ?`,
+  );
+
+  // Insert rows: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
+  const newNodeRows: unknown[][] = [];
+  // Track which file+definition combos are new so we can insert edges for them.
+  const newDefs: Array<{ name: string; file: string; line: number }> = [];
+
+  for (const [relPath, symbols] of wasmResults) {
+    for (const def of symbols.definitions ?? []) {
+      if (def.kind !== 'method') continue;
+      const dotIdx = def.name.indexOf('.');
+      if (dotIdx === -1) continue; // skip bare method names (shouldn't happen, but guard)
+
+      // Only insert if the node is not already in the DB.
+      const existing = existsStmt.get(def.name, relPath) as { id: number } | undefined;
+      if (existing) continue;
+
+      const scope = def.name.slice(0, dotIdx);
+      newNodeRows.push([
+        def.name,
+        'method',
+        relPath,
+        def.line,
+        def.endLine ?? null,
+        null,
+        def.name,
+        scope,
+        null,
+      ]);
+      newDefs.push({ name: def.name, file: relPath, line: def.line });
+    }
+  }
+
+  if (newNodeRows.length === 0) return;
+
+  db.transaction(() => batchInsertNodes(db, newNodeRows))();
+
+  // Build a name → node lookup from all DB nodes (including newly inserted ones).
+  type NodeEntry = { id: number; file: string; kind: string };
+  const byNameMap = new Map<string, NodeEntry[]>();
+  const byNameFileMap = new Map<string, NodeEntry[]>();
+  const byIdKey = new Map<string, { id: number }>();
+
+  const allNodes = db
+    .prepare(`SELECT id, name, kind, file, line FROM nodes WHERE kind != 'file'`)
+    .all() as Array<{ id: number; name: string; kind: string; file: string; line: number }>;
+
+  for (const n of allNodes) {
+    const list = byNameMap.get(n.name);
+    if (list) list.push(n);
+    else byNameMap.set(n.name, [n]);
+
+    const fk = `${n.name}::${n.file}`;
+    const flist = byNameFileMap.get(fk);
+    if (flist) flist.push(n);
+    else byNameFileMap.set(fk, [n]);
+
+    byIdKey.set(`${n.name}|${n.kind}|${n.file}|${n.line}`, { id: n.id });
+  }
+
+  const lookup: CallNodeLookup = {
+    byName: (name) => byNameMap.get(name) ?? [],
+    byNameAndFile: (name, file) => byNameFileMap.get(`${name}::${file}`) ?? [],
+    isBarrel: () => false,
+    resolveBarrel: () => null,
+    nodeId: (name, kind, file, line) => byIdKey.get(`${name}|${kind}|${file}|${line}`),
+  };
+
+  // Build a fast set of newly-inserted node IDs so we only emit edges to
+  // prototype nodes that the Rust engine missed (avoids duplicating existing edges).
+  const newNodeIds = new Set<number>(
+    newDefs.flatMap((d) => {
+      const nodes = byNameFileMap.get(`${d.name}::${d.file}`);
+      return nodes ? nodes.map((n) => n.id) : [];
+    }),
+  );
+
+  // Seed seenByPair from existing call edges to avoid duplicates.
+  const existingPairs = db
+    .prepare(`SELECT source_id, target_id FROM edges WHERE kind = 'calls'`)
+    .all() as Array<{ source_id: number; target_id: number }>;
+  const seenByPair = new Set<string>(existingPairs.map((e) => `${e.source_id}|${e.target_id}`));
+
+  // For each file that produced new prototype nodes, resolve call edges.
+  const newEdgeRows: unknown[][] = [];
+  const newDefFiles = new Set(newDefs.map((d) => d.file));
+
+  for (const [relPath, symbols] of wasmResults) {
+    if (!newDefFiles.has(relPath)) continue;
+
+    const fileNodeRow = db
+      .prepare(`SELECT id FROM nodes WHERE kind = 'file' AND file = ?`)
+      .get(relPath) as { id: number } | undefined;
+    if (!fileNodeRow) continue;
+
+    const typeMap = symbols.typeMap instanceof Map ? symbols.typeMap : new Map();
+
+    for (const call of symbols.calls ?? []) {
+      if (!call.receiver) continue; // prototype resolution only applies to receiver calls
+
+      const caller = findCaller(lookup, call, symbols.definitions ?? [], relPath, fileNodeRow);
+
+      const targets = resolveByMethodOrGlobal(
+        lookup,
+        call,
+        relPath,
+        typeMap as Map<string, unknown>,
+        caller.callerName,
+      );
+
+      for (const t of targets) {
+        // Only emit edges to newly-inserted prototype nodes to avoid
+        // duplicating edges the Rust engine already built.
+        if (!newNodeIds.has(t.id)) continue;
+        const key = `${caller.id}|${t.id}`;
+        if (seenByPair.has(key)) continue;
+        seenByPair.add(key);
+        const conf = computeConfidence(relPath, t.file, null);
+        if (conf <= 0) continue;
+        newEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'receiver-typed']);
+      }
+    }
+  }
+
+  if (newEdgeRows.length > 0) {
+    db.transaction(() => batchInsertEdges(db, newEdgeRows))();
+  }
+}
+
 /** Format timing result from native orchestrator phases + JS post-processing. */
 function formatNativeTimingResult(
   p: Record<string, number>,
@@ -1195,6 +1374,15 @@ export async function tryNativeOrchestrator(
     }
   }
 
+  // Prototype method post-pass: the Rust engine does not recognise pre-ES6
+  // `Foo.prototype.bar = function(){}` patterns. Re-parse JS/TS files via
+  // WASM to insert missing method nodes and their call edges.
+  try {
+    await runPostNativePrototypeMethods(ctx.db as unknown as BetterSqlite3Database, ctx.rootDir);
+  } catch (err) {
+    debug(`Prototype methods post-pass failed: ${toErrorMessage(err)}`);
+  }
+
   // Backfill the `technique` column on `calls` edges written by the Rust
   // orchestrator, which does not write the column. Runs after all edge-writing
   // phases (including the WASM dropped-language backfill and CHA post-pass) so

src/domain/graph/resolver/points-to.ts

@@ -19,7 +19,14 @@
  * that build-edges.ts already builds per file is the cross-module link — if
  * a variable aliases an imported name, resolveCallTargets follows it).
  */
-import type { ArrayCallbackBinding, ArrayElemBinding, FnRefBinding, ForOfBinding, ParamBinding, SpreadArgBinding } from '../../../types.js';
+import type {
+  ArrayCallbackBinding,
+  ArrayElemBinding,
+  FnRefBinding,
+  ForOfBinding,
+  ParamBinding,
+  SpreadArgBinding,
+} from '../../../types.js';
 
 export type PointsToMap = Map<string, Set<string>>;
 
@@ -127,7 +134,7 @@ export function buildPointsToMap(
   if (spreadArgBindings && spreadArgBindings.length > 0 && definitionParams) {
     // Build a per-array index count from arrayElemBindings for precise per-index constraints.
     const arrayMaxIndex = new Map<string, number>();
-    for (const { arrayName, index } of (arrayElemBindings ?? [])) {
+    for (const { arrayName, index } of arrayElemBindings ?? []) {
       const cur = arrayMaxIndex.get(arrayName) ?? -1;
       if (index > cur) arrayMaxIndex.set(arrayName, index);
     }

src/extractors/javascript.ts

@@ -372,9 +372,6 @@ function extractSymbolsQuery(tree: TreeSitterTree, query: TreeSitterQuery): Extr
   // Extract definitions from destructured bindings (query patterns don't match object_pattern)
   extractDestructuredBindingsWalk(tree.rootNode, definitions);
 
-  // Pre-ES6 prototype methods: `Foo.prototype.bar = fn` and `Foo.prototype = { bar: fn }`
-  extractPrototypeMethodsWalk(tree.rootNode, definitions, typeMap);
-
   // Phase 8.5: collect all `new X()` constructor names for RTA instantiation tracking
   const newExpressions: string[] = [];
   extractNewExpressionsWalk(tree.rootNode, newExpressions);
@@ -1715,10 +1712,7 @@ function extractSpreadForOfWalk(
     if (depth >= MAX_WALK_DEPTH) return;
 
     let pushedFunc = false;
-    if (
-      node.type === 'function_declaration' ||
-      node.type === 'generator_function_declaration'
-    ) {
+    if (node.type === 'function_declaration' || node.type === 'generator_function_declaration') {
       const nameNode = node.childForFieldName('name');
       if (nameNode?.type === 'identifier') {
         funcStack.push(nameNode.text);
@@ -1745,8 +1739,7 @@ function extractSpreadForOfWalk(
           if (child.type === ',' || child.type === '(' || child.type === ')') continue;
           if (child.type === 'spread_element') {
             const spreadTarget =
-              child.childForFieldName('argument') ??
-              (child.childCount > 1 ? child.child(1) : null);
+              child.childForFieldName('argument') ?? (child.childCount > 1 ? child.child(1) : null);
             if (spreadTarget?.type === 'identifier' && !BUILTIN_GLOBALS.has(spreadTarget.text)) {
               spreadArgBindings.push({
                 callee: fn.text,