@optave/codegraph 3.12.0 → 3.13.0

package/src/domain/graph/builder/stages/build-edges.ts

@@ -12,15 +12,23 @@ import { PROPAGATION_HOP_PENALTY } from '../../../../extractors/javascript.js';
 import { debug } from '../../../../infrastructure/logger.js';
 import { loadNative } from '../../../../infrastructure/native.js';
 import type {
+  ArrayCallbackBinding,
+  ArrayElemBinding,
   BetterSqlite3Database,
   Call,
   ClassRelation,
   Definition,
   ExtractorOutput,
   FnRefBinding,
+  ForOfBinding,
   Import,
   NativeAddon,
   NodeRow,
+  ObjectPropBinding,
+  ObjectRestParamBinding,
+  ParamBinding,
+  SpreadArgBinding,
+  ThisCallBinding,
   TypeMapEntry,
 } from '../../../../types.js';
 import { computeConfidence } from '../../resolve.js';
@@ -37,7 +45,13 @@ import {
 import type { ChaContext } from '../cha.js';
 import { buildChaContext, resolveChaTargets, resolveThisDispatch } from '../cha.js';
 import type { PipelineContext } from '../context.js';
-import { BUILTIN_RECEIVERS, batchInsertEdges, runChaPostPass } from '../helpers.js';
+import {
+  BUILTIN_RECEIVERS,
+  batchInsertEdges,
+  CHA_DISPATCH_PENALTY,
+  CHA_TYPED_DISPATCH_CONFIDENCE,
+  runChaPostPass,
+} from '../helpers.js';
 import { getResolved, isBarrelFile, resolveBarrelExportCached } from './resolve-imports.js';
 
 // ── Local types ──────────────────────────────────────────────────────────
@@ -61,13 +75,27 @@ interface QueryNodeRow {
 interface NativeFileEntry {
   file: string;
   fileNodeId: number;
-  definitions: Array<{ name: string; kind: string; line: number; endLine: number | null }>;
+  definitions: Array<{
+    name: string;
+    kind: string;
+    line: number;
+    endLine: number | null;
+    params?: string[];
+  }>;
   calls: Call[];
   importedNames: Array<{ name: string; file: string }>;
   classes: ClassRelation[];
   typeMap: Array<{ name: string; typeName: string; confidence: number }>;
   /** Phase 8.3: function-reference bindings for pts analysis. */
   fnRefBindings?: Array<{ lhs: string; rhs: string; rhsReceiver?: string }>;
+  paramBindings?: ParamBinding[];
+  thisCallBindings?: ThisCallBinding[];
+  arrayElemBindings?: ArrayElemBinding[];
+  spreadArgBindings?: SpreadArgBinding[];
+  forOfBindings?: ForOfBinding[];
+  arrayCallbackBindings?: ArrayCallbackBinding[];
+  objectRestParamBindings?: ObjectRestParamBinding[];
+  objectPropBindings?: ObjectPropBinding[];
 }
 
 /** Shape returned by native buildCallEdges. */
@@ -79,9 +107,6 @@ interface NativeEdge {
   dynamic: number;
 }
 
-/** Phase 8.5: confidence penalty applied to CHA-dispatch edges. */
-export const CHA_DISPATCH_PENALTY = 0.1;
-
 // ── Node lookup setup ───────────────────────────────────────────────────
 
 function makeGetNodeIdStmt(db: BetterSqlite3Database): NodeIdStmt {
@@ -509,17 +534,35 @@ function buildCallEdgesNative(
     nativeFiles.push({
       file: relPath,
       fileNodeId: fileNodeRow.id,
-      definitions: symbols.definitions.map((d) => ({
-        name: d.name,
-        kind: d.kind,
-        line: d.line,
-        endLine: d.endLine ?? null,
-      })),
+      definitions: symbols.definitions.map((d) => {
+        const params = d.children?.filter((c) => c.kind === 'parameter').map((c) => c.name);
+        return {
+          name: d.name,
+          kind: d.kind,
+          line: d.line,
+          endLine: d.endLine ?? null,
+          params: params?.length ? params : undefined,
+        };
+      }),
       calls: symbols.calls,
       importedNames,
       classes: symbols.classes,
       typeMap,
       fnRefBindings: symbols.fnRefBindings?.length ? symbols.fnRefBindings : undefined,
+      paramBindings: symbols.paramBindings?.length ? symbols.paramBindings : undefined,
+      thisCallBindings: symbols.thisCallBindings?.length ? symbols.thisCallBindings : undefined,
+      arrayElemBindings: symbols.arrayElemBindings?.length ? symbols.arrayElemBindings : undefined,
+      spreadArgBindings: symbols.spreadArgBindings?.length ? symbols.spreadArgBindings : undefined,
+      forOfBindings: symbols.forOfBindings?.length ? symbols.forOfBindings : undefined,
+      arrayCallbackBindings: symbols.arrayCallbackBindings?.length
+        ? symbols.arrayCallbackBindings
+        : undefined,
+      objectRestParamBindings: symbols.objectRestParamBindings?.length
+        ? symbols.objectRestParamBindings
+        : undefined,
+      objectPropBindings: symbols.objectPropBindings?.length
+        ? symbols.objectPropBindings
+        : undefined,
     });
   }
 
@@ -538,363 +581,6 @@ function buildCallEdgesNative(
   }
 }
 
-/**
- * Phase 8.3c pts post-pass for the native call-edge path.
- *
- * The native Rust engine builds call edges without knowledge of paramBindings,
- * so `fn()` calls inside higher-order functions are not resolved to their
- * concrete targets. This JS post-pass runs after the native edge pass and adds
- * only the parameter-flow pts edges that the native engine missed.
- *
- * To avoid duplicating edges already emitted by the native engine, the current
- * allEdgeRows snapshot is used to seed a seenByPair set before processing each
- * file.
- */
-function buildParamFlowPtsPostPass(
-  ctx: PipelineContext,
-  getNodeIdStmt: NodeIdStmt,
-  allEdgeRows: EdgeRowTuple[],
-  sharedLookup?: CallNodeLookup,
-): void {
-  // Only process files that actually have paramBindings (avoid useless work).
-  const filesWithParams = [...ctx.fileSymbols].filter(
-    ([, symbols]) => symbols.paramBindings && symbols.paramBindings.length > 0,
-  );
-  if (filesWithParams.length === 0) return;
-
-  // Seed seenByPair from the existing rows so we don't duplicate native edges.
-  // This is O(|allEdgeRows|) once per post-pass, which is acceptable.
-  const seenByPair = new Set<string>();
-  for (const [srcId, tgtId] of allEdgeRows) {
-    seenByPair.add(`${srcId}|${tgtId}`);
-  }
-
-  const { barrelOnlyFiles, rootDir } = ctx;
-  const lookup = sharedLookup ?? makeContextLookup(ctx, getNodeIdStmt);
-
-  for (const [relPath, symbols] of filesWithParams) {
-    if (barrelOnlyFiles.has(relPath)) continue;
-    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-    if (!fileNodeRow) continue;
-
-    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
-    const typeMap: Map<string, TypeMapEntry | string> = symbols.typeMap || new Map();
-    const ptsMap = buildPointsToMapForFile(symbols, importedNames);
-    if (!ptsMap) continue;
-
-    for (const call of symbols.calls) {
-      if (call.receiver || call.dynamic) continue; // pts post-pass handles only param-flow (non-dynamic)
-
-      const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
-      const scopedKey = caller.callerName != null ? `${caller.callerName}::${call.name}` : null;
-      if (!scopedKey || !ptsMap.has(scopedKey)) continue;
-
-      // Only resolve calls that had no direct targets (same guard as buildFileCallEdges).
-      const { targets } = resolveCallTargets(
-        lookup,
-        call,
-        relPath,
-        importedNames,
-        typeMap as Map<string, unknown>,
-      );
-      if (targets.length > 0) continue;
-
-      for (const alias of resolveViaPointsTo(scopedKey, ptsMap)) {
-        const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(
-          lookup,
-          { name: alias },
-          relPath,
-          importedNames,
-          typeMap as Map<string, unknown>,
-        );
-        for (const t of aliasTargets) {
-          const edgeKey = `${caller.id}|${t.id}`;
-          if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
-            const conf =
-              computeConfidence(relPath, t.file, aliasFrom ?? null) - PROPAGATION_HOP_PENALTY;
-            if (conf > 0) {
-              seenByPair.add(edgeKey);
-              allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'points-to']);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-/**
- * bind/alias pts post-pass for the native call-edge path.
- *
- * The native Rust engine has no knowledge of JS-layer fnRefBindings (e.g.
- * `const f = fn.bind(ctx)`), so calls to bind-created aliases are not resolved
- * to their original function on the native path. This JS post-pass runs after
- * the native edge pass and adds only the fnRefBindings-seeded pts edges that the
- * native engine missed.
- *
- * Uses the same seenByPair dedup guard as buildParamFlowPtsPostPass to avoid
- * duplicating edges already emitted by the native engine.
- */
-function buildFnRefBindingsPtsPostPass(
-  ctx: PipelineContext,
-  getNodeIdStmt: NodeIdStmt,
-  allEdgeRows: EdgeRowTuple[],
-  sharedLookup?: CallNodeLookup,
-): void {
-  // Only process files that actually have fnRefBindings.
-  const filesWithBindings = [...ctx.fileSymbols].filter(
-    ([, symbols]) => symbols.fnRefBindings && symbols.fnRefBindings.length > 0,
-  );
-  if (filesWithBindings.length === 0) return;
-
-  // Seed seenByPair from the existing rows so we don't duplicate native edges.
-  const seenByPair = new Set<string>();
-  for (const [srcId, tgtId] of allEdgeRows) {
-    seenByPair.add(`${srcId}|${tgtId}`);
-  }
-
-  const { barrelOnlyFiles, rootDir } = ctx;
-  const lookup = sharedLookup ?? makeContextLookup(ctx, getNodeIdStmt);
-
-  for (const [relPath, symbols] of filesWithBindings) {
-    if (barrelOnlyFiles.has(relPath)) continue;
-    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-    if (!fileNodeRow) continue;
-
-    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
-    const typeMap: Map<string, TypeMapEntry | string> = symbols.typeMap || new Map();
-    const ptsMap = buildPointsToMapForFile(symbols, importedNames);
-    if (!ptsMap) continue;
-
-    // Only resolve calls whose name is an lhs in fnRefBindings — the same
-    // narrowed guard used in buildFileCallEdges case (c).
-    const fnRefBindingLhs = new Set(symbols.fnRefBindings!.map((b) => b.lhs));
-
-    for (const call of symbols.calls) {
-      if (call.receiver || call.dynamic) continue; // bind aliases are flat-keyed, never dynamic
-      if (!fnRefBindingLhs.has(call.name)) continue;
-      if (!ptsMap.has(call.name)) continue;
-
-      const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
-
-      // Only resolve calls that had no direct targets (same guard as buildFileCallEdges).
-      const { targets } = resolveCallTargets(
-        lookup,
-        call,
-        relPath,
-        importedNames,
-        typeMap as Map<string, unknown>,
-      );
-      if (targets.length > 0) continue;
-
-      for (const alias of resolveViaPointsTo(call.name, ptsMap)) {
-        const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(
-          lookup,
-          { name: alias },
-          relPath,
-          importedNames,
-          typeMap as Map<string, unknown>,
-        );
-        for (const t of aliasTargets) {
-          const edgeKey = `${caller.id}|${t.id}`;
-          if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
-            const conf =
-              computeConfidence(relPath, t.file, aliasFrom ?? null) - PROPAGATION_HOP_PENALTY;
-            if (conf > 0) {
-              seenByPair.add(edgeKey);
-              allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'points-to']);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-/**
- * this-rebinding post-pass for the native call-edge path.
- *
- * When `fn.call(namedCtx, ...)` or `fn.apply(namedCtx, ...)` is extracted by the
- * WASM layer, `thisCallBindings` records `{ callee: 'fn', thisArg: 'namedCtx' }`.
- * The native Rust engine has no knowledge of these bindings, so `this()` calls
- * inside `fn` remain unresolved. This JS post-pass adds the missing edges by
- * resolving `this()` calls inside each `fn` that has a thisCallBinding.
- */
-function buildThisCallBindingsPtsPostPass(
-  ctx: PipelineContext,
-  getNodeIdStmt: NodeIdStmt,
-  allEdgeRows: EdgeRowTuple[],
-  sharedLookup?: CallNodeLookup,
-): void {
-  const filesWithBindings = [...ctx.fileSymbols].filter(
-    ([, symbols]) => symbols.thisCallBindings && symbols.thisCallBindings.length > 0,
-  );
-  if (filesWithBindings.length === 0) return;
-
-  const seenByPair = new Set<string>();
-  for (const [srcId, tgtId] of allEdgeRows) {
-    seenByPair.add(`${srcId}|${tgtId}`);
-  }
-
-  const { barrelOnlyFiles, rootDir } = ctx;
-  const lookup = sharedLookup ?? makeContextLookup(ctx, getNodeIdStmt);
-
-  for (const [relPath, symbols] of filesWithBindings) {
-    if (barrelOnlyFiles.has(relPath)) continue;
-    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-    if (!fileNodeRow) continue;
-
-    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
-    const typeMap: Map<string, TypeMapEntry | string> = symbols.typeMap || new Map();
-    const ptsMap = buildPointsToMapForFile(symbols, importedNames);
-    if (!ptsMap) continue;
-
-    // Only process calls named 'this' (callee-not-receiver usage)
-    for (const call of symbols.calls) {
-      if (call.name !== 'this' || call.receiver) continue;
-
-      const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
-      if (caller.callerName == null) continue;
-
-      const scopedKey = `${caller.callerName}::this`;
-      if (!ptsMap.has(scopedKey)) continue;
-
-      for (const alias of resolveViaPointsTo(scopedKey, ptsMap)) {
-        const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(
-          lookup,
-          { name: alias },
-          relPath,
-          importedNames,
-          typeMap as Map<string, unknown>,
-        );
-        for (const t of aliasTargets) {
-          const edgeKey = `${caller.id}|${t.id}`;
-          if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
-            const conf =
-              computeConfidence(relPath, t.file, aliasFrom ?? null) - PROPAGATION_HOP_PENALTY;
-            if (conf > 0) {
-              seenByPair.add(edgeKey);
-              allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'points-to']);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-/**
- * Phase 8.3f post-pass for the native call-edge path.
- *
- * The native Rust engine builds call edges without knowledge of
- * objectRestParamBindings, so `rest.method()` calls inside functions with
- * object-destructuring rest parameters are not resolved via the typeMap chain.
- * The Rust engine already resolves same-file and directly-imported callees
- * (via steps 1–2 of its resolution logic), so this post-pass only adds edges
- * that require the typeMap-chain path:
- *   typeMap[restName] → argName → typeMap[argName.method] → target
- *
- * Mirrors the seeding in buildCallEdgesJS (Phase 8.3f) to ensure both engine
- * paths produce identical results for receiver-typed rest-param calls.
- */
-function buildObjectRestParamPostPass(
-  ctx: PipelineContext,
-  getNodeIdStmt: NodeIdStmt,
-  allEdgeRows: EdgeRowTuple[],
-  sharedLookup?: CallNodeLookup,
-): void {
-  const filesWithRestBindings = [...ctx.fileSymbols].filter(
-    ([, symbols]) =>
-      symbols.objectRestParamBindings &&
-      symbols.objectRestParamBindings.length > 0 &&
-      symbols.paramBindings &&
-      symbols.paramBindings.length > 0,
-  );
-  if (filesWithRestBindings.length === 0) return;
-
-  const seenByPair = new Set<string>();
-  for (const [srcId, tgtId] of allEdgeRows) {
-    seenByPair.add(`${srcId}|${tgtId}`);
-  }
-
-  const { barrelOnlyFiles, rootDir } = ctx;
-  const lookup = sharedLookup ?? makeContextLookup(ctx, getNodeIdStmt);
-
-  for (const [relPath, symbols] of filesWithRestBindings) {
-    if (barrelOnlyFiles.has(relPath)) continue;
-    const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
-    if (!fileNodeRow) continue;
-
-    const importedNames = buildImportedNamesMap(ctx, relPath, symbols, rootDir);
-    const typeMap: Map<string, TypeMapEntry | string> = new Map(
-      symbols.typeMap instanceof Map ? symbols.typeMap : [],
-    );
-
-    // Seed typeMap[callee::restName] = { type: argName } for each matching pair.
-    // Mirrors the seeding in buildCallEdgesJS Phase 8.3f. Keys are scoped by
-    // callee so two functions with the same rest-param name (e.g. `...rest`) in
-    // the same file don't collide (#1358).
-    // When only one callee uses a given rest name, also seed the unscoped key
-    // as a null-callerName fallback so edges aren't silently dropped if
-    // findCaller can't identify the enclosing function (#1358).
-    const restNameCallees = new Map<string, Set<string>>();
-    for (const orpb of symbols.objectRestParamBindings!) {
-      if (!restNameCallees.has(orpb.restName)) restNameCallees.set(orpb.restName, new Set());
-      restNameCallees.get(orpb.restName)!.add(orpb.callee);
-    }
-    const restNames = new Set<string>();
-    for (const orpb of symbols.objectRestParamBindings!) {
-      for (const pb of symbols.paramBindings!) {
-        if (pb.callee === orpb.callee && pb.argIndex === orpb.argIndex) {
-          const scopedKey = `${orpb.callee}::${orpb.restName}`;
-          if (!typeMap.has(scopedKey)) {
-            typeMap.set(scopedKey, { type: pb.argName, confidence: 0.65 });
-            if (restNameCallees.get(orpb.restName)!.size === 1 && !typeMap.has(orpb.restName)) {
-              typeMap.set(orpb.restName, { type: pb.argName, confidence: 0.65 });
-            }
-          }
-          // restNames tracks every rest-parameter name found, regardless of whether the
-          // scoped key was already in typeMap.  This ensures the post-pass (below) processes
-          // all calls whose receiver matches a known rest binding — not just those whose
-          // typeMap entry was seeded in this iteration.
-          restNames.add(orpb.restName);
-        }
-      }
-    }
-    if (restNames.size === 0) continue;
-
-    for (const call of symbols.calls) {
-      // Only process calls whose receiver is a known rest-binding name.
-      if (!call.receiver || !restNames.has(call.receiver)) continue;
-
-      const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
-
-      // Resolve with the enriched typeMap. callerName is passed so
-      // resolveByMethodOrGlobal can look up the scoped key callee::restName (#1358).
-      // seenByPair deduplicates edges the native engine already emitted.
-      const { targets, importedFrom } = resolveCallTargets(
-        lookup,
-        call,
-        relPath,
-        importedNames,
-        typeMap as Map<string, unknown>,
-        caller.callerName,
-      );
-      for (const t of targets) {
-        const edgeKey = `${caller.id}|${t.id}`;
-        if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
-          const conf =
-            computeConfidence(relPath, t.file, importedFrom ?? null) - PROPAGATION_HOP_PENALTY;
-          if (conf > 0) {
-            seenByPair.add(edgeKey);
-            allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'points-to']);
-          }
-        }
-      }
-    }
-  }
-}
-
 /**
  * Object.defineProperty accessor post-pass for the native call-edge path.
  *
@@ -988,11 +674,11 @@ function buildDefinePropertyPostPass(
  *
  * The native Rust engine has no knowledge of the CHA context, so `this.method()`
  * calls and interface method dispatches are not expanded to their concrete
- * implementations.  This JS post-pass runs after the native edges (and the pts
- * post-pass) and adds only the CHA-resolved edges that the native engine missed.
+ * implementations.  This JS post-pass runs after the native edges and adds only
+ * the CHA-resolved edges that the native engine missed.
  *
- * Like buildParamFlowPtsPostPass, it seeds seenByPair from the current allEdgeRows
- * snapshot to avoid duplicating edges the native engine already produced.
+ * Seeds seenByPair from the current allEdgeRows snapshot to avoid duplicating
+ * edges the native engine already produced.
  */
 function buildChaPostPass(
   ctx: PipelineContext,
@@ -1026,6 +712,7 @@ function buildChaPostPass(
 
       const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
       let chaTargets: ReadonlyArray<{ id: number; file: string }> = [];
+      let isTypedReceiverDispatch = false;
 
       if (call.receiver === 'this' || call.receiver === 'self' || call.receiver === 'super') {
         chaTargets = resolveThisDispatch(
@@ -1034,6 +721,7 @@ function buildChaPostPass(
           call.receiver,
           chaCtx,
           lookup,
+          relPath,
         );
       } else {
         const typeEntry = typeMap.get(call.receiver);
@@ -1044,16 +732,26 @@ function buildChaPostPass(
           : null;
         if (typeName) {
           chaTargets = resolveChaTargets(typeName, call.name, chaCtx, lookup);
+          isTypedReceiverDispatch = true;
         }
       }
 
       for (const t of chaTargets) {
         const edgeKey = `${caller.id}|${t.id}`;
         if (t.id !== caller.id && !seenByPair.has(edgeKey)) {
-          const conf = computeConfidence(relPath, t.file, null) - CHA_DISPATCH_PENALTY;
+          // Typed-receiver (interface/CHA) dispatch: use CHA_TYPED_DISPATCH_CONFIDENCE
+          // — file proximity is not meaningful for virtual dispatch confidence.
+          // this/super dispatch keeps computeConfidence-based proximity scoring to
+          // match runPostNativeThisDispatch (native-orchestrator.ts).
+          const conf = isTypedReceiverDispatch
+            ? CHA_TYPED_DISPATCH_CONFIDENCE
+            : computeConfidence(relPath, t.file, null) - CHA_DISPATCH_PENALTY;
           if (conf > 0) {
             seenByPair.add(edgeKey);
-            allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'cha']);
+            // Tag super-dispatch edges distinctly so runChaPostPass can exclude them
+            // from further CHA expansion (super calls are not virtual dispatch).
+            const technique = call.receiver === 'super' ? 'super-dispatch' : 'cha';
+            allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, technique]);
           }
         }
       }
@@ -1317,7 +1015,6 @@ function buildFileCallEdges(
   // bind/alias entries, not for every locally-defined function or import that
   // buildPointsToMap seeds with a self-pointing entry.
   const fnRefBindingLhs = new Set(symbols.fnRefBindings?.map((b) => b.lhs) ?? []);
-
   for (const call of symbols.calls) {
     if (call.receiver && BUILTIN_RECEIVERS.has(call.receiver)) continue;
 
@@ -1424,6 +1121,19 @@ function buildFileCallEdges(
       }
     }
 
+    // Sort targets by confidence descending before emitting edges.
+    // For multi-target calls with duplicate (source_id, target_id) pairs the
+    // stored confidence depends on which duplicate is processed last — sorting
+    // here guarantees the highest-confidence target wins on dedup, matching the
+    // native engine's sort_targets_by_confidence call in build_edges.rs.
+    if (targets.length > 1) {
+      targets = [...targets].sort(
+        (a, b) =>
+          computeConfidence(relPath, b.file, importedFrom ?? null) -
+          computeConfidence(relPath, a.file, importedFrom ?? null),
+      );
+    }
+
     for (const t of targets) {
       const edgeKey = `${caller.id}|${t.id}`;
       if (t.id !== caller.id) {
@@ -1505,7 +1215,15 @@ function buildFileCallEdges(
           importedNames,
           typeMap as Map<string, unknown>,
         );
-        for (const t of aliasTargets) {
+        const sortedAliasTargets =
+          aliasTargets.length > 1
+            ? [...aliasTargets].sort(
+                (a, b) =>
+                  computeConfidence(relPath, b.file, aliasFrom ?? null) -
+                  computeConfidence(relPath, a.file, aliasFrom ?? null),
+              )
+            : aliasTargets;
+        for (const t of sortedAliasTargets) {
           const edgeKey = `${caller.id}|${t.id}`;
           if (t.id !== caller.id && !seenCallEdges.has(edgeKey) && !ptsEdgeRows.has(edgeKey)) {
             const conf =
@@ -1541,7 +1259,15 @@ function buildFileCallEdges(
             importedNames,
             typeMap as Map<string, unknown>,
           );
-          for (const t of aliasTargets) {
+          const sortedAliasTargets =
+            aliasTargets.length > 1
+              ? [...aliasTargets].sort(
+                  (a, b) =>
+                    computeConfidence(relPath, b.file, aliasFrom ?? null) -
+                    computeConfidence(relPath, a.file, aliasFrom ?? null),
+                )
+              : aliasTargets;
+          for (const t of sortedAliasTargets) {
             const edgeKey = `${caller.id}|${t.id}`;
             if (t.id !== caller.id && !seenCallEdges.has(edgeKey) && !ptsEdgeRows.has(edgeKey)) {
               const conf =
@@ -1570,6 +1296,7 @@ function buildFileCallEdges(
         relPath,
         typeMap as Map<string, unknown>,
         seenCallEdges,
+        importedNames,
       );
       if (recv) {
         allEdgeRows.push([recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0, null]);
@@ -1582,6 +1309,7 @@ function buildFileCallEdges(
     // For typed receiver calls: expand to all instantiated concrete implementations.
     if (chaCtx && call.receiver) {
       let chaTargets: ReadonlyArray<{ id: number; file: string }> = [];
+      let isTypedReceiverDispatch = false;
       if (call.receiver === 'this' || call.receiver === 'self' || call.receiver === 'super') {
         chaTargets = resolveThisDispatch(
           call.name,
@@ -1589,6 +1317,7 @@ function buildFileCallEdges(
           call.receiver,
           chaCtx,
           lookup,
+          relPath,
         );
       } else if (!BUILTIN_RECEIVERS.has(call.receiver)) {
         const typeEntry = typeMap.get(call.receiver);
@@ -1599,12 +1328,19 @@ function buildFileCallEdges(
           : null;
         if (typeName) {
           chaTargets = resolveChaTargets(typeName, call.name, chaCtx, lookup);
+          isTypedReceiverDispatch = true;
         }
       }
       for (const t of chaTargets) {
         const edgeKey = `${caller.id}|${t.id}`;
         if (t.id !== caller.id && !seenCallEdges.has(edgeKey) && !ptsEdgeRows.has(edgeKey)) {
-          const conf = computeConfidence(relPath, t.file, null) - CHA_DISPATCH_PENALTY;
+          // Typed-receiver (interface/CHA) dispatch: use CHA_TYPED_DISPATCH_CONFIDENCE
+          // — file proximity is not meaningful for virtual dispatch confidence.
+          // this/super dispatch keeps computeConfidence-based proximity scoring to
+          // match runPostNativeThisDispatch (native-orchestrator.ts).
+          const conf = isTypedReceiverDispatch
+            ? CHA_TYPED_DISPATCH_CONFIDENCE
+            : computeConfidence(relPath, t.file, null) - CHA_DISPATCH_PENALTY;
           if (conf > 0) {
             seenCallEdges.add(edgeKey);
             allEdgeRows.push([caller.id, t.id, 'calls', conf, 0, 'cha']);
@@ -1775,7 +1511,7 @@ function reconnectReverseDepEdges(ctx: PipelineContext): void {
  * their import targets. Falls back to loading ALL nodes for full builds or
  * larger incremental changes.
  */
-const NODE_KIND_FILTER_SQL = `kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`;
+const NODE_KIND_FILTER_SQL = `kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant','variable')`;
 
 function loadNodes(ctx: PipelineContext): { rows: QueryNodeRow[]; scoped: boolean } {
   const { db, fileSymbols, isFullBuild, batchResolved } = ctx;
@@ -1858,7 +1594,16 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
   // Enrich typeMap for .ts/.tsx files using the TypeScript compiler API.
   // Runs before call-edge construction so the accurate types are available
   // for method-call resolution. Gated on config so users can opt out.
-  if (ctx.config.build.typescriptResolver) {
+  //
+  // Skip for small incremental builds: TypeScript program creation requires
+  // loading the entire tsconfig file list (~700ms startup on the codegraph
+  // corpus), which dominates the 1-file rebuild time. Native engine bypasses
+  // this entirely via the Rust orchestrator; WASM/JS engines need this gate
+  // to match native's effective behaviour on tiny incremental changes.
+  // Mirrors the smallFilesThreshold gates for nativeDb and native call-edges.
+  const isSmallIncremental =
+    !ctx.isFullBuild && ctx.fileSymbols.size <= ctx.config.build.smallFilesThreshold;
+  if (ctx.config.build.typescriptResolver && !isSmallIncremental) {
     await enrichTypeMapWithTsc(ctx.rootDir, ctx.fileSymbols);
   }
 
@@ -1921,26 +1666,12 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       (ctx.isFullBuild || ctx.fileSymbols.size > ctx.config.build.smallFilesThreshold);
     if (useNativeCallEdges) {
       buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodesBefore, native!);
-      // Build the shared lookup once — both pts post-passes use it, avoiding
-      // redundant construction of the same context closure.
+      // The native engine receives all pts bindings (paramBindings,
+      // fnRefBindings, thisCallBindings, objectRestParamBindings, …) through
+      // NativeFileEntry and runs the same points-to solver as the JS path, so
+      // no pts post-passes are needed here. Only capabilities that remain
+      // JS-only run as post-passes below.
       const sharedLookup = makeContextLookup(ctx, getNodeIdStmt);
-      // Phase 8.3c post-pass: augment native call edges with parameter-flow pts
-      // edges. The native Rust engine has no knowledge of paramBindings, so any
-      // `fn()` call inside a higher-order function would be missed. This JS pass
-      // runs on top of the native edges and adds only the pts-resolved edges that
-      // the native engine could not produce.
-      buildParamFlowPtsPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
-      // bind/alias post-pass: augment native call edges with fnRefBindings-seeded
-      // pts edges. The native Rust engine has no knowledge of JS fnRefBindings
-      // (e.g. `const f = fn.bind(ctx)`), so calls to bind-created aliases are
-      // not resolved to their original function on the native path.
-      buildFnRefBindingsPtsPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
-      // this-rebinding post-pass: resolve `this()` calls inside functions that
-      // were invoked via `.call(namedCtx, ...)` / `.apply(namedCtx, ...)`.
-      buildThisCallBindingsPtsPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
-      // Phase 8.3f post-pass: augment native call edges with object rest-param
-      // receiver resolution — typeMap[restName] → argName → typeMap[argName.method].
-      buildObjectRestParamPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);
       // Object.defineProperty accessor post-pass: resolve this-dispatch inside
       // getter/setter functions registered via Object.defineProperty.
       buildDefinePropertyPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLookup);