@optave/codegraph 3.11.2 → 3.12.0

package/dist/domain/graph/builder/stages/native-orchestrator.js

@@ -21,8 +21,11 @@ import { normalizePath } from '../../../../shared/constants.js';
 import { toErrorMessage } from '../../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../../shared/version.js';
 import { classifyNativeDrops, formatDropExtensionSummary, getInstalledWasmExtensions, NATIVE_SUPPORTED_EXTENSIONS, parseFilesWasmForBackfill, } from '../../../parser.js';
-import { batchInsertNodes, collectFiles as collectFilesUtil, fileHash, fileStat, readFileSafe, } from '../helpers.js';
+import { computeConfidence } from '../../resolve.js';
+import { resolveThisDispatch } from '../cha.js';
+import { batchInsertEdges, batchInsertNodes, collectFiles as collectFilesUtil, fileHash, fileStat, readFileSafe, } from '../helpers.js';
 import { NativeDbProxy } from '../native-db-proxy.js';
+import { CHA_DISPATCH_PENALTY } from './build-edges.js';
 import { closeNativeDb } from './native-db-lifecycle.js';
 // ── Native orchestrator helpers ───────────────────────────────────────
 /** Determine whether the native orchestrator should be skipped. Returns a reason string, or null if it should run. */
@@ -242,8 +245,403 @@ async function runPostNativeAnalysis(ctx, allFileSymbols, changedFiles) {
     }
     return timing;
 }
+/**
+ * Phase 8.5: CHA expansion post-pass for the native orchestrator path.
+ *
+ * The Rust build pipeline resolves typed receiver calls (e.g. `worker.doWork()`
+ * where `worker: IWorker`) to the interface method declaration only.  This
+ * post-pass reads the class hierarchy (via `implements`/`extends` edges) and
+ * instantiated types (via `calls` edges to class nodes) from the DB and expands
+ * each call to an interface/abstract method to ALL RTA-filtered concrete
+ * implementations.
+ *
+ * Note: `this`/`super` dispatch is handled separately by `runPostNativeThisDispatch`,
+ * which WASM-re-parses JS/TS files to obtain raw call site receiver info.
+ *
+ * Returns the count of newly inserted CHA edges plus the set of files containing
+ * the new edges' endpoints, so the caller can scope role re-classification to the
+ * nodes whose fan-in/out actually changed. A zero count means no edges were added
+ * and role re-classification is unnecessary.
+ */
+function runPostNativeCha(db) {
+    const affectedFiles = new Set();
+    const empty = { newEdgeCount: 0, affectedFiles };
+    // Fast guard: no hierarchy edges → no CHA work
+    const hasHierarchy = db
+        .prepare(`SELECT 1 FROM edges WHERE kind IN ('extends', 'implements') LIMIT 1`)
+        .get();
+    if (!hasHierarchy)
+        return empty;
+    // Build implementors map: parent/interface name → [child/implementing class names]
+    const hierarchyRows = db
+        .prepare(`
+      SELECT src.name AS child_name, tgt.name AS parent_name
+      FROM edges e
+      JOIN nodes src ON e.source_id = src.id
+      JOIN nodes tgt ON e.target_id = tgt.id
+      WHERE e.kind IN ('extends', 'implements')
+    `)
+        .all();
+    const implementors = new Map();
+    for (const row of hierarchyRows) {
+        let list = implementors.get(row.parent_name);
+        if (!list) {
+            list = [];
+            implementors.set(row.parent_name, list);
+        }
+        if (!list.includes(row.child_name))
+            list.push(row.child_name);
+    }
+    if (implementors.size === 0)
+        return empty;
+    // RTA: collect class names that are actually instantiated via `new X()`.
+    // Primary query targets `class`-kind nodes (the canonical schema).
+    // Fallback also matches `constructor`/`function`-kind nodes because some native
+    // engine versions record constructor calls against those kinds instead of `class`.
+    let rtaRows = db
+        .prepare(`
+      SELECT DISTINCT tgt.name
+      FROM edges e
+      JOIN nodes tgt ON e.target_id = tgt.id
+      WHERE e.kind = 'calls' AND tgt.kind = 'class'
+    `)
+        .all();
+    if (rtaRows.length === 0) {
+        // Fallback: try constructor/function-kind nodes for older native engine schemas
+        rtaRows = db
+            .prepare(`
+        SELECT DISTINCT tgt.name
+        FROM edges e
+        JOIN nodes tgt ON e.target_id = tgt.id
+        WHERE e.kind = 'calls' AND tgt.kind IN ('constructor', 'function')
+        AND INSTR(tgt.name, '.') = 0
+      `)
+            .all();
+    }
+    const instantiated = new Set(rtaRows.map((r) => r.name));
+    // noRtaEvidence: true when no constructor-call evidence exists in the DB (e.g. graph
+    // built by an older native engine that doesn't emit constructor call edges at all).
+    // In that case we skip RTA filtering so interface dispatch still produces edges —
+    // all instantiated implementors are admitted rather than silently dropping everything.
+    const noRtaEvidence = instantiated.size === 0;
+    if (noRtaEvidence) {
+        debug('runPostNativeCha: no constructor-call evidence found — proceeding without RTA filter');
+    }
+    // Find existing call edges targeting qualified methods (e.g., 'IWorker.doWork').
+    // Include the caller node's file so confidence can be computed file-pair-aware,
+    // matching the WASM path's computeConfidence(callerFile, targetFile, null) - CHA_DISPATCH_PENALTY formula.
+    const callToMethods = db
+        .prepare(`
+      SELECT e.source_id, tgt.name AS method_name, src.file AS caller_file
+      FROM edges e
+      JOIN nodes tgt ON e.target_id = tgt.id
+      JOIN nodes src ON e.source_id = src.id
+      WHERE e.kind = 'calls' AND tgt.kind = 'method'
+      AND INSTR(tgt.name, '.') > 0
+    `)
+        .all();
+    // Seed seen-pairs only from the source_ids we'll be expanding — avoids loading every
+    // call edge in the DB (which would be O(all edges)) for large codebases.
+    const seen = new Set();
+    if (callToMethods.length > 0) {
+        const sourceIds = [...new Set(callToMethods.map((r) => r.source_id))];
+        const CHUNK_SIZE = 500;
+        for (let i = 0; i < sourceIds.length; i += CHUNK_SIZE) {
+            const chunk = sourceIds.slice(i, i + CHUNK_SIZE);
+            const placeholders = chunk.map(() => '?').join(',');
+            const existingPairs = db
+                .prepare(`SELECT source_id, target_id FROM edges WHERE kind = 'calls' AND source_id IN (${placeholders})`)
+                .all(...chunk);
+            for (const e of existingPairs)
+                seen.add(`${e.source_id}|${e.target_id}`);
+        }
+    }
+    // No LIMIT: multiple files can define the same qualified name in a monorepo.
+    const findMethodStmt = db.prepare(`SELECT id, file AS method_file FROM nodes WHERE name = ? AND kind = 'method'`);
+    const newEdges = [];
+    let newEdgeCount = 0;
+    for (const { source_id, method_name, caller_file } of callToMethods) {
+        const dotIdx = method_name.indexOf('.');
+        if (dotIdx === -1)
+            continue;
+        const typeName = method_name.slice(0, dotIdx);
+        const methodSuffix = method_name.slice(dotIdx + 1);
+        // BFS over the implementors map — handles multi-level hierarchies where
+        // abstract/non-instantiated classes sit between the call-site type and
+        // the concrete leaf implementations (issue #1311).
+        const bfsQueue = [typeName];
+        const bfsVisited = new Set([typeName]);
+        while (bfsQueue.length > 0) {
+            const current = bfsQueue.shift();
+            const children = implementors.get(current);
+            if (!children?.length)
+                continue;
+            for (const cls of children) {
+                if (bfsVisited.has(cls))
+                    continue;
+                bfsVisited.add(cls);
+                if (noRtaEvidence || instantiated.has(cls)) {
+                    const qualifiedName = `${cls}.${methodSuffix}`;
+                    const methodNodes = findMethodStmt.all(qualifiedName);
+                    for (const methodNode of methodNodes) {
+                        const key = `${source_id}|${methodNode.id}`;
+                        if (seen.has(key))
+                            continue;
+                        seen.add(key);
+                        // Compute confidence file-pair-aware (mirrors WASM path: computeConfidence - CHA_DISPATCH_PENALTY)
+                        // Skip zero-confidence edges to match buildFileCallEdges / buildChaPostPass behaviour.
+                        const conf = computeConfidence(caller_file ?? '', methodNode.method_file ?? '', null) -
+                            CHA_DISPATCH_PENALTY;
+                        if (conf <= 0)
+                            continue;
+                        newEdges.push([source_id, methodNode.id, 'calls', conf, 0, 'cha']);
+                        newEdgeCount++;
+                        if (caller_file)
+                            affectedFiles.add(caller_file);
+                        if (methodNode.method_file)
+                            affectedFiles.add(methodNode.method_file);
+                    }
+                }
+                // Always traverse children — non-instantiated classes may have instantiated subclasses.
+                bfsQueue.push(cls);
+            }
+        }
+    }
+    if (newEdges.length > 0) {
+        db.transaction(() => batchInsertEdges(db, newEdges))();
+    }
+    return { newEdgeCount, affectedFiles };
+}
+// Extensions where `this`/`super` dispatch can occur (JS/TS family)
+const THIS_DISPATCH_EXTS = new Set(['.js', '.ts', '.tsx', '.jsx', '.mjs', '.cjs', '.mts', '.cts']);
+/**
+ * Phase 8.5: this/super dispatch post-pass for the native orchestrator path.
+ *
+ * The Rust build pipeline resolves typed receiver calls but does NOT persist raw
+ * unresolved call site receiver info (e.g. `this`, `super`) to the DB. This
+ * hybrid post-pass re-parses JS/TS/TSX files via WASM to collect call sites with
+ * `this`/`super` receivers, then resolves them through the class hierarchy stored
+ * in DB `extends` edges — mirroring what `buildChaPostPass` does on the WASM path.
+ *
+ * Only runs when `extends` edges exist in the DB; if there is no inheritance
+ * hierarchy there is nothing to resolve via `this`/`super` dispatch.
+ */
+async function runPostNativeThisDispatch(db, rootDir, changedFiles, isFullBuild) {
+    const t0 = Date.now();
+    const targetIds = new Set();
+    // Files containing endpoints of newly inserted edges — lets the caller scope
+    // role re-classification to the nodes whose fan-in/out actually changed.
+    const affectedFiles = new Set();
+    // Fast guard: need at least one extends edge for this/super to have meaning
+    const hasExtends = db.prepare(`SELECT 1 FROM edges WHERE kind = 'extends' LIMIT 1`).get();
+    if (!hasExtends)
+        return { elapsedMs: 0, targetIds, affectedFiles };
+    // Build parents map: child class → direct parent class (from `extends` edges)
+    const parentRows = db
+        .prepare(`
+      SELECT src.name AS child_name, tgt.name AS parent_name
+      FROM edges e
+      JOIN nodes src ON e.source_id = src.id
+      JOIN nodes tgt ON e.target_id = tgt.id
+      WHERE e.kind = 'extends'
+    `)
+        .all();
+    const parents = new Map();
+    for (const row of parentRows) {
+        if (!parents.has(row.child_name))
+            parents.set(row.child_name, row.parent_name);
+    }
+    if (parents.size === 0)
+        return { elapsedMs: 0, targetIds, affectedFiles };
+    const chaCtx = {
+        implementors: new Map(), // not needed for this/super resolution
+        parents,
+        instantiatedTypes: new Set(), // not needed for this/super resolution
+    };
+    // Determine which files to re-parse.
+    //
+    // On a full build we do NOT re-parse every JS/TS file — that would WASM-parse
+    // the entire project on top of the native pass, causing a massive regression
+    // (measured: +358% ms/file on codegraph itself). Instead we restrict to files
+    // that are part of the class inheritance hierarchy: both subclass files (which
+    // contain `super.X()` calls dispatching to a parent) and parent-class files
+    // (whose method bodies contain `this.X()` calls that CHA must resolve). Any
+    // file not in the hierarchy has no `extends` relationship, so `this`/`super`
+    // calls in it either resolve locally (same-class dispatch, already handled by
+    // the direct-call edge) or have no class context — and will be skipped by
+    // `resolveThisDispatch` anyway.
+    let relFiles;
+    if (isFullBuild || !changedFiles) {
+        const rows = db
+            .prepare(`
+        SELECT DISTINCT file FROM (
+          SELECT src.file AS file
+          FROM edges e
+          JOIN nodes src ON e.source_id = src.id
+          WHERE e.kind = 'extends' AND src.file IS NOT NULL
+          UNION
+          SELECT tgt.file AS file
+          FROM edges e
+          JOIN nodes tgt ON e.target_id = tgt.id
+          WHERE e.kind = 'extends' AND tgt.file IS NOT NULL
+        )
+      `)
+            .all();
+        relFiles = rows
+            .map((r) => r.file)
+            .filter((f) => THIS_DISPATCH_EXTS.has(path.extname(f).toLowerCase()));
+    }
+    else {
+        // NOTE: Only files explicitly listed in changedFiles are re-parsed.
+        // If a parent-class method is replaced (new node ID) but the child file is
+        // unchanged, the stale super.method() edge is not refreshed here. A full
+        // rebuild (isFullBuild=true) is required to recover in that scenario.
+        relFiles = changedFiles.filter((f) => THIS_DISPATCH_EXTS.has(path.extname(f).toLowerCase()));
+    }
+    if (relFiles.length === 0)
+        return { elapsedMs: 0, targetIds, affectedFiles };
+    // DB-backed CallNodeLookup — resolveThisDispatch only calls byName()
+    const findByNameStmt = db.prepare(`SELECT id, file, kind FROM nodes WHERE name = ?`);
+    const lookup = {
+        byName: (name) => findByNameStmt.all(name),
+        byNameAndFile: (name, file) => findByNameStmt.all(name).filter((n) => n.file === file),
+        isBarrel: () => false,
+        resolveBarrel: () => null,
+        nodeId: () => undefined,
+    };
+    // Seed seen-pairs from existing call edges on source nodes in our file set
+    const seen = new Set();
+    const CHUNK = 500;
+    for (let i = 0; i < relFiles.length; i += CHUNK) {
+        const chunk = relFiles.slice(i, i + CHUNK);
+        const ph = chunk.map(() => '?').join(',');
+        const rows = db
+            .prepare(`SELECT e.source_id, e.target_id
+         FROM edges e
+         JOIN nodes n ON e.source_id = n.id
+         WHERE e.kind = 'calls' AND n.file IN (${ph})`)
+            .all(...chunk);
+        for (const r of rows)
+            seen.add(`${r.source_id}|${r.target_id}`);
+    }
+    // Find the innermost containing method/function for a call at `line` in `file`.
+    // COALESCE maps NULL end_line to a large sentinel so unbounded nodes sort last
+    // (SQLite ASC orders NULLs first, so a raw `end_line - line` would pick them first).
+    const findCallerByLineStmt = db.prepare(`
+    SELECT id, name FROM nodes
+    WHERE file = ? AND kind IN ('method', 'function')
+    AND line <= ? AND (end_line IS NULL OR end_line >= ?)
+    ORDER BY COALESCE(end_line - line, 999999999) ASC
+    LIMIT 1
+  `);
+    // Re-parse the files to obtain raw call sites with receiver info. Only
+    // `calls` (with receivers) are consumed here.
+    //
+    // The native engine is preferred: this pass only runs after a native
+    // orchestrator build, so the addon is already loaded and re-parses the
+    // hierarchy file set in single-digit milliseconds with the same
+    // receiver-annotated call sites as the WASM extractor. Booting the WASM
+    // runtime here instead cost ~40–110ms per full build (in-process
+    // web-tree-sitter + grammar init dominated) — part of the v3.12.0
+    // publish-gate regression. Files the native engine cannot parse (extension
+    // outside NATIVE_SUPPORTED_EXTENSIONS, e.g. .mts/.cts) and native parse
+    // failures fall back to the WASM backfill path so the sweep stays complete.
+    const absFiles = relFiles.map((f) => path.join(rootDir, f));
+    const nativeAbs = absFiles.filter((f) => NATIVE_SUPPORTED_EXTENSIONS.has(path.extname(f).toLowerCase()));
+    const callsByRel = new Map();
+    // Track native-supported files that returned null (per-file parse error) so
+    // they can be included in the WASM fallback set below, ensuring no file's
+    // this/super call sites are silently discarded.
+    const nativeNullFiles = new Set();
+    let nativeParsed = false;
+    if (nativeAbs.length > 0) {
+        const native = loadNative();
+        if (native) {
+            try {
+                const results = native.parseFiles(nativeAbs, rootDir, false, false);
+                for (let i = 0; i < results.length; i++) {
+                    const r = results[i];
+                    if (!r) {
+                        // Per-file parse failure — fall back to WASM for this file.
+                        const abs = nativeAbs[i];
+                        if (abs)
+                            nativeNullFiles.add(abs);
+                        continue;
+                    }
+                    callsByRel.set(normalizePath(path.relative(rootDir, r.file)), r.calls ?? []);
+                }
+                nativeParsed = true;
+            }
+            catch (e) {
+                debug(`this-dispatch native re-parse failed, falling back to WASM: ${toErrorMessage(e)}`);
+            }
+        }
+    }
+    // WASM handles: (a) non-native extensions (e.g. .mts/.cts), (b) the entire
+    // file list when the native batch threw, and (c) individual files where the
+    // native addon returned null (per-file parse error).
+    const wasmAbs = nativeParsed
+        ? [
+            ...absFiles.filter((f) => !NATIVE_SUPPORTED_EXTENSIONS.has(path.extname(f).toLowerCase())),
+            ...nativeNullFiles,
+        ]
+        : absFiles;
+    const wasmResults = wasmAbs.length > 0
+        ? await parseFilesWasmForBackfill(wasmAbs, rootDir, { symbolsOnly: true })
+        : new Map();
+    for (const [relPath, symbols] of wasmResults) {
+        callsByRel.set(relPath, symbols.calls ?? []);
+    }
+    const newEdges = [];
+    for (const [relPath, calls] of callsByRel) {
+        for (const call of calls) {
+            // Only 'this' and 'super' are class-instance receivers in JS/TS.
+            // 'self' refers to WindowOrWorkerGlobalScope — not a class instance — so
+            // filtering it here prevents spurious dispatch edges from Worker call sites.
+            if (call.receiver !== 'this' && call.receiver !== 'super')
+                continue;
+            const callerRow = findCallerByLineStmt.get(relPath, call.line, call.line);
+            if (!callerRow)
+                continue;
+            const targets = resolveThisDispatch(call.name, callerRow.name, call.receiver, chaCtx, lookup);
+            for (const t of targets) {
+                const key = `${callerRow.id}|${t.id}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const conf = computeConfidence(relPath, t.file, null) - CHA_DISPATCH_PENALTY;
+                if (conf <= 0)
+                    continue;
+                newEdges.push([callerRow.id, t.id, 'calls', conf, 0, 'cha']);
+                targetIds.add(t.id);
+                affectedFiles.add(relPath);
+                if (t.file)
+                    affectedFiles.add(t.file);
+            }
+        }
+    }
+    if (newEdges.length > 0) {
+        db.transaction(() => batchInsertEdges(db, newEdges))();
+        debug(`this/super dispatch post-pass: inserted ${newEdges.length} edge(s)`);
+    }
+    // Free WASM parse trees — mirrors the cleanup in backfillNativeDroppedFiles
+    for (const [, symbols] of wasmResults) {
+        const tree = symbols._tree;
+        if (tree && typeof tree.delete === 'function') {
+            try {
+                tree.delete();
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        }
+        symbols._tree = undefined;
+        symbols._langId = undefined;
+    }
+    return { elapsedMs: Date.now() - t0, targetIds, affectedFiles };
+}
 /** Format timing result from native orchestrator phases + JS post-processing. */
-function formatNativeTimingResult(p, structurePatchMs, analysisTiming) {
+function formatNativeTimingResult(p, structurePatchMs, analysisTiming, thisDispatchMs) {
     return {
         phases: {
             setupMs: +(p.setupMs ?? 0).toFixed(1),
@@ -255,6 +653,7 @@ function formatNativeTimingResult(p, structurePatchMs, analysisTiming) {
             edgesMs: +(p.edgesMs ?? 0).toFixed(1),
             structureMs: +((p.structureMs ?? 0) + structurePatchMs).toFixed(1),
             rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+            thisDispatchMs: +thisDispatchMs.toFixed(1),
             astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
             complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
             cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
@@ -572,6 +971,41 @@ async function backfillNativeDroppedFiles(ctx, gap) {
         symbols._langId = undefined;
     }
 }
+/**
+ * Backfill the `technique` column on `calls` edges written by the native Rust
+ * orchestrator, which does not write the column itself.
+ *
+ * For full builds, all `calls` edges in the DB are new so a global UPDATE is
+ * correct.  For incremental builds, only changed-file source nodes are updated
+ * to avoid overwriting previously-set technique values on unchanged edges.
+ */
+function backfillEdgeTechniquesAfterNativeOrchestrator(db, isFullBuild, changedFiles) {
+    // Quiet incremental: no files changed → no new edges inserted, nothing to tag.
+    // Running the global UPDATE here would mis-tag pre-migration NULL-technique edges
+    // from unchanged files as 'ts-native'.
+    if (!isFullBuild && changedFiles && changedFiles.length === 0) {
+        return;
+    }
+    if (isFullBuild || !changedFiles) {
+        db.prepare("UPDATE edges SET technique = 'ts-native' WHERE kind = 'calls' AND technique IS NULL").run();
+        return;
+    }
+    // Incremental: scope to source nodes whose file is one of the changed files.
+    // Chunk to stay within SQLite's SQLITE_LIMIT_VARIABLE_NUMBER (999 on older builds).
+    const CHUNK_SIZE = 500;
+    const tx = db.transaction(() => {
+        for (let i = 0; i < changedFiles.length; i += CHUNK_SIZE) {
+            const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+            const placeholders = chunk.map(() => '?').join(',');
+            db.prepare(`UPDATE edges SET technique = 'ts-native'
+         WHERE kind = 'calls' AND technique IS NULL
+         AND source_id IN (
+           SELECT id FROM nodes WHERE file IN (${placeholders})
+         )`).run(...chunk);
+        }
+    });
+    tx();
+}
 /**
  * Try the native build orchestrator.
  *
@@ -696,10 +1130,13 @@ export async function tryNativeOrchestrator(ctx) {
             ctx.opts.complexity !== false ||
             ctx.opts.cfg !== false ||
             ctx.opts.dataflow !== false);
+    // ── DB handoff ────────────────────────────────────────────────────────────
+    // Ensure a proper better-sqlite3 connection is open before any post-pass that
+    // writes edges (dropped-language backfill, CHA) and before structure/analysis.
+    // When analysis fallback is needed the handoff already happened above; when
+    // neither structure nor analysis is needed the proxy conversion is deferred to
+    // here so CHA and technique-backfill can still write rows.
     if (needsStructure || needsAnalysisFallback) {
-        // When analysis fallback is needed, handoff to better-sqlite3 — the
-        // analysis engine uses the suspend/resume WAL pattern that requires a
-        // real better-sqlite3 connection, not the NativeDbProxy.
         if (needsAnalysisFallback && ctx.nativeFirstProxy) {
             closeNativeDb(ctx, 'pre-analysis-fallback');
             ctx.db = openDb(ctx.dbPath);
@@ -707,16 +1144,10 @@ export async function tryNativeOrchestrator(ctx) {
         }
         else if (!ctx.nativeFirstProxy && !handoffWalAfterNativeBuild(ctx)) {
             // DB reopen failed — return partial result
-            return formatNativeTimingResult(p, 0, analysisTiming);
-        }
-        const fileSymbols = reconstructFileSymbolsFromDb(ctx);
-        if (needsStructure) {
-            structurePatchMs = await runPostNativeStructure(ctx, fileSymbols, !!result.isFullBuild, result.changedFiles);
-        }
-        if (needsAnalysisFallback) {
-            analysisTiming = await runPostNativeAnalysis(ctx, fileSymbols, result.changedFiles);
+            return formatNativeTimingResult(p, 0, analysisTiming, 0);
         }
     }
+    // ── Edge-writing post-passes (run before structure so roles see full graph) ──
     // Engine parity: the native orchestrator silently drops files whose
     // Rust extractor/grammar is missing or fails (e.g. HCL, Scala, Swift on
     // stale native binaries). WASM handles those — backfill via WASM so both
@@ -741,7 +1172,63 @@ export async function tryNativeOrchestrator(ctx) {
         gap.staleRel.length > 0) {
         await backfillNativeDroppedFiles(ctx, gap);
     }
+    // Phase 8.5: expand CHA call edges (interface dispatch → concrete implementations).
+    // Returns the affected files so role re-classification below can be scoped to
+    // the nodes whose fan-in/out actually changed.
+    //
+    // Function-as-object-property methods (`fn.method = function() {}`) are extracted
+    // natively by the Rust engine (#1432) and resolved in-build by its edge builder, so
+    // no WASM re-parse post-pass is needed for them. `Foo.prototype.bar = fn` likewise.
+    const { newEdgeCount: chaEdgeCount, affectedFiles: chaAffectedFiles } = runPostNativeCha(ctx.db);
+    // Phase 8.5: this/super dispatch — hybrid WASM re-parse to resolve call sites
+    // whose raw receiver info the Rust pipeline does not persist to DB.
+    const { elapsedMs: thisDispatchMs, targetIds: thisDispatchTargetIds, affectedFiles: thisDispatchAffectedFiles, } = await runPostNativeThisDispatch(ctx.db, ctx.rootDir, result.changedFiles, !!result.isFullBuild);
+    // Role re-classification after JS edge-writing post-passes.
+    // The Rust orchestrator classifies roles before these post-passes (CHA,
+    // this-dispatch) add edges, so roles for the edge endpoints are stale.
+    // Scoped to the files containing those endpoints: a new edge only changes
+    // fan-in/out for its own source and target nodes, so re-classifying their
+    // files restores correctness without re-running the classifier over the
+    // whole graph (which cost ~130ms per build on codegraph itself and was a
+    // major part of the v3.12.0 native full-build benchmark regression).
+    if (chaEdgeCount > 0 || thisDispatchTargetIds.size > 0) {
+        const affectedFiles = [...new Set([...chaAffectedFiles, ...thisDispatchAffectedFiles])];
+        // When edges were inserted but all their endpoint nodes have null `file`
+        // columns (rare but possible), affectedFiles stays empty even though
+        // fan-in/out changed. Fall back to full-graph re-classification in that
+        // case — scoped classification with an empty set would be a no-op, leaving
+        // roles stale for those nodes.
+        const scopedFiles = affectedFiles.length > 0 ? affectedFiles : null;
+        try {
+            const { classifyNodeRoles } = (await import('../../../../features/structure.js'));
+            classifyNodeRoles(ctx.db, scopedFiles);
+            debug(scopedFiles
+                ? `Post-pass role re-classification complete (${scopedFiles.length} file(s))`
+                : 'Post-pass role re-classification complete (full graph — null-file endpoints)');
+        }
+        catch (err) {
+            debug(`Post-pass role re-classification 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, CHA post-pass, and
+    // this/super dispatch) so every new edge in this build cycle gets a label.
+    backfillEdgeTechniquesAfterNativeOrchestrator(ctx.db, !!result.isFullBuild, result.changedFiles);
+    // ── Structure and analysis fallback (run after edge-writing so roles see full graph) ──
+    // Reconstruct fileSymbols once for both structure and analysis to avoid two
+    // expensive DB scans. The DB handoff above already ensured ctx.db is a proper
+    // better-sqlite3 connection when either flag is set.
+    if (needsStructure || needsAnalysisFallback) {
+        const fileSymbols = reconstructFileSymbolsFromDb(ctx);
+        if (needsStructure) {
+            structurePatchMs = await runPostNativeStructure(ctx, fileSymbols, !!result.isFullBuild, result.changedFiles);
+        }
+        if (needsAnalysisFallback) {
+            analysisTiming = await runPostNativeAnalysis(ctx, fileSymbols, result.changedFiles);
+        }
+    }
     closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
-    return formatNativeTimingResult(p, structurePatchMs, analysisTiming);
+    return formatNativeTimingResult(p, structurePatchMs, analysisTiming, thisDispatchMs);
 }
 //# sourceMappingURL=native-orchestrator.js.map