@optave/codegraph 3.12.0 → 3.13.0

package/dist/domain/graph/builder/stages/build-edges.js

@@ -16,10 +16,8 @@ import { buildPointsToMap, resolveViaPointsTo } from '../../resolver/points-to.j
 import { enrichTypeMapWithTsc } from '../../resolver/ts-resolver.js';
 import { findCaller, isModuleScopedLanguage, resolveCallTargets, resolveReceiverEdge, } from '../call-resolver.js';
 import { buildChaContext, resolveChaTargets, resolveThisDispatch } from '../cha.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';
-/** Phase 8.5: confidence penalty applied to CHA-dispatch edges. */
-export const CHA_DISPATCH_PENALTY = 0.1;
 // ── Node lookup setup ───────────────────────────────────────────────────
 function makeGetNodeIdStmt(db) {
     return {
@@ -337,17 +335,35 @@ function buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native)
         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,
         });
     }
     const nativeEdges = native.buildCallEdges(nativeFiles, allNodes, [
@@ -364,282 +380,6 @@ function buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native)
         ]);
     }
 }
-/**
- * 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, getNodeIdStmt, allEdgeRows, sharedLookup) {
-    // 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();
-    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 = 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);
-            if (targets.length > 0)
-                continue;
-            for (const alias of resolveViaPointsTo(scopedKey, ptsMap)) {
-                const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(lookup, { name: alias }, relPath, importedNames, typeMap);
-                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, getNodeIdStmt, allEdgeRows, sharedLookup) {
-    // 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();
-    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 = 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);
-            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);
-                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, getNodeIdStmt, allEdgeRows, sharedLookup) {
-    const filesWithBindings = [...ctx.fileSymbols].filter(([, symbols]) => symbols.thisCallBindings && symbols.thisCallBindings.length > 0);
-    if (filesWithBindings.length === 0)
-        return;
-    const seenByPair = new Set();
-    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 = 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);
-                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, getNodeIdStmt, allEdgeRows, sharedLookup) {
-    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();
-    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 = 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();
-        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();
-        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, 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.
  *
@@ -715,11 +455,11 @@ function buildDefinePropertyPostPass(ctx, getNodeIdStmt, allEdgeRows, sharedLook
  *
  * 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, getNodeIdStmt, allEdgeRows, chaCtx) {
     // Fast-exit when the CHA context is empty (no class hierarchy in the project)
@@ -748,8 +488,9 @@ function buildChaPostPass(ctx, getNodeIdStmt, allEdgeRows, chaCtx) {
                 continue;
             const caller = findCaller(lookup, call, symbols.definitions, relPath, fileNodeRow);
             let chaTargets = [];
+            let isTypedReceiverDispatch = false;
             if (call.receiver === 'this' || call.receiver === 'self' || call.receiver === 'super') {
-                chaTargets = resolveThisDispatch(call.name, caller.callerName, call.receiver, chaCtx, lookup);
+                chaTargets = resolveThisDispatch(call.name, caller.callerName, call.receiver, chaCtx, lookup, relPath);
             }
             else {
                 const typeEntry = typeMap.get(call.receiver);
@@ -760,15 +501,25 @@ function buildChaPostPass(ctx, getNodeIdStmt, allEdgeRows, chaCtx) {
                     : 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]);
                     }
                 }
             }
@@ -1054,6 +805,15 @@ function buildFileCallEdges(relPath, symbols, fileNodeRow, importedNames, seenCa
                 }
             }
         }
+        // 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) {
@@ -1126,7 +886,11 @@ function buildFileCallEdges(relPath, symbols, fileNodeRow, importedNames, seenCa
                 // and line are not relevant for alias resolution (we are looking up the
                 // aliased function by name, not dispatching a method call).
                 const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(lookup, { name: alias }, relPath, importedNames, typeMap);
-                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 = computeConfidence(relPath, t.file, aliasFrom ?? null) - PROPAGATION_HOP_PENALTY;
@@ -1152,7 +916,11 @@ function buildFileCallEdges(relPath, symbols, fileNodeRow, importedNames, seenCa
             if (ptsMap.has(receiverKey)) {
                 for (const alias of resolveViaPointsTo(receiverKey, ptsMap)) {
                     const { targets: aliasTargets, importedFrom: aliasFrom } = resolveCallTargets(lookup, { name: alias }, relPath, importedNames, typeMap);
-                    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 = computeConfidence(relPath, t.file, aliasFrom ?? null) - PROPAGATION_HOP_PENALTY;
@@ -1170,7 +938,7 @@ function buildFileCallEdges(relPath, symbols, fileNodeRow, importedNames, seenCa
             call.receiver !== 'this' &&
             call.receiver !== 'self' &&
             call.receiver !== 'super') {
-            const recv = resolveReceiverEdge(lookup, { name: call.name, receiver: call.receiver }, caller, relPath, typeMap, seenCallEdges);
+            const recv = resolveReceiverEdge(lookup, { name: call.name, receiver: call.receiver }, caller, relPath, typeMap, seenCallEdges, importedNames);
             if (recv) {
                 allEdgeRows.push([recv.callerId, recv.receiverId, 'receiver', recv.confidence, 0, null]);
             }
@@ -1181,8 +949,9 @@ function buildFileCallEdges(relPath, symbols, fileNodeRow, importedNames, seenCa
         // For typed receiver calls: expand to all instantiated concrete implementations.
         if (chaCtx && call.receiver) {
             let chaTargets = [];
+            let isTypedReceiverDispatch = false;
             if (call.receiver === 'this' || call.receiver === 'self' || call.receiver === 'super') {
-                chaTargets = resolveThisDispatch(call.name, caller.callerName, call.receiver, chaCtx, lookup);
+                chaTargets = resolveThisDispatch(call.name, caller.callerName, call.receiver, chaCtx, lookup, relPath);
             }
             else if (!BUILTIN_RECEIVERS.has(call.receiver)) {
                 const typeEntry = typeMap.get(call.receiver);
@@ -1193,12 +962,19 @@ function buildFileCallEdges(relPath, symbols, fileNodeRow, importedNames, seenCa
                     : 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']);
@@ -1330,7 +1106,7 @@ function reconnectReverseDepEdges(ctx) {
  * 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) {
     const { db, fileSymbols, isFullBuild, batchResolved } = ctx;
     const nodeKindFilter = NODE_KIND_FILTER_SQL;
@@ -1399,7 +1175,15 @@ export async function buildEdges(ctx) {
     // 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);
     }
     const native = engineName === 'native' ? loadNative() : null;
@@ -1454,26 +1238,12 @@ export async function buildEdges(ctx) {
             (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);