@optave/codegraph 3.11.2 → 3.13.0

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

@@ -41,9 +41,16 @@ import {
   NATIVE_SUPPORTED_EXTENSIONS,
   parseFilesWasmForBackfill,
 } from '../../../parser.js';
+import { computeConfidence } from '../../resolve.js';
+import type { CallNodeLookup } from '../call-resolver.js';
+import type { ChaContext } from '../cha.js';
+import { resolveThisDispatch } from '../cha.js';
 import type { PipelineContext } from '../context.js';
 import {
+  batchInsertEdges,
   batchInsertNodes,
+  CHA_DISPATCH_PENALTY,
+  CHA_TYPED_DISPATCH_CONFIDENCE,
   collectFiles as collectFilesUtil,
   fileHash,
   fileStat,
@@ -382,11 +389,630 @@ async function runPostNativeAnalysis(
   return timing;
 }
 
+/**
+ * Phase 8.6: 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.
+ *
+ * `changedFiles` controls candidate scoping on incremental builds:
+ *   - null  → full build; scan all call→method edges (existing behaviour).
+ *   - array → incremental; two cheap gate queries decide scope:
+ *       Gate A: any class/interface/trait/struct/record nodes in changed files?
+ *               If yes, a new implementor may have appeared — full scan required.
+ *       Gate B: any `calls` edges from changed-file sources targeting
+ *               class/constructor/function-kind nodes? If yes, the RTA set may
+ *               have grown (also covers the older-schema fallback where
+ *               constructor calls target `constructor`/`function` nodes instead
+ *               of `class` nodes) — full scan required.
+ *       If neither gate fires: scope `callToMethods` to `src.file IN changedFiles`
+ *       (safe because no hierarchy or RTA evidence changed).
+ *
+ * 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: BetterSqlite3Database,
+  changedFiles: string[] | null,
+): {
+  newEdgeCount: number;
+  affectedFiles: Set<string>;
+} {
+  const affectedFiles = new Set<string>();
+  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() as Array<{ child_name: string; parent_name: string }>;
+
+  const implementors = new Map<string, string[]>();
+  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() as Array<{ name: string }>;
+  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() as Array<{ name: string }>;
+  }
+  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');
+  }
+
+  // ── Incremental candidate scoping ──────────────────────────────────────────
+  // On incremental builds, two gate queries decide whether to restrict the
+  // candidate scan to changed-file call sites or run the full graph scan.
+  //
+  // Gate A: did a changed file add/change a class hierarchy node?
+  //   A new `extends`/`implements` edge means a previously-untracked implementor
+  //   is now in the hierarchy — unchanged call sites in OTHER files may gain new
+  //   valid expansions, so the full scan is required.
+  //   Note: *removed* class nodes are safe — Rust's `purge_changed_files` runs
+  //   before this post-pass and deletes stale nodes and their hierarchy edges, so
+  //   Gate A queries the post-purge DB. A deleted class returns no row here, which
+  //   is correct: its stale CHA edges were already cleaned up by the Rust purge.
+  //
+  // Gate B: did a changed file add new RTA evidence (`new ConcreteX()`)?
+  //   A new `calls` edge to a class/constructor/function-kind target means the
+  //   instantiated set grew — previously RTA-filtered expansions in unchanged
+  //   caller files become admissible, so the full scan is required.
+  //   (`constructor`/`function` cover the older native engine fallback schema.)
+  //
+  // If neither gate fires, the hierarchy and RTA set are unchanged for all files
+  // outside changedFiles, so restricting to changed-file sources is safe.
+  let scopeToChangedFiles = false; // true → add WHERE src.file IN changedFiles
+  if (changedFiles !== null && changedFiles.length > 0) {
+    // Gate A: class/interface/trait/struct/record nodes in changed files?
+    const CHUNK_SIZE = 500;
+    let gateAFired = false;
+    for (let i = 0; i < changedFiles.length && !gateAFired; i += CHUNK_SIZE) {
+      const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+      const ph = chunk.map(() => '?').join(',');
+      const row = db
+        .prepare(
+          `SELECT 1 FROM nodes
+           WHERE file IN (${ph})
+           AND kind IN ('class', 'interface', 'trait', 'struct', 'record')
+           LIMIT 1`,
+        )
+        .get(...chunk);
+      if (row) gateAFired = true;
+    }
+
+    // Gate B: calls from changed-file sources to class/instantiable-kind targets
+    // (also covers older-schema fallback and future CHA extensions to struct/record).
+    // Includes class/interface/trait/struct/record (future CHA extension safety) and
+    // constructor/function (older native engine schema fallback).
+    let gateBFired = false;
+    if (!gateAFired) {
+      for (let i = 0; i < changedFiles.length && !gateBFired; i += CHUNK_SIZE) {
+        const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+        const ph = chunk.map(() => '?').join(',');
+        const row = db
+          .prepare(
+            `SELECT 1 FROM edges e
+             JOIN nodes src ON e.source_id = src.id
+             JOIN nodes tgt ON e.target_id = tgt.id
+             WHERE e.kind = 'calls'
+             AND tgt.kind IN ('class', 'interface', 'trait', 'struct', 'record', 'constructor', 'function')
+             AND src.file IN (${ph})
+             LIMIT 1`,
+          )
+          .get(...chunk);
+        if (row) gateBFired = true;
+      }
+    }
+
+    if (!gateAFired && !gateBFired) {
+      scopeToChangedFiles = true;
+      debug(
+        `runPostNativeCha: neither gate fired — scoping candidate scan to ${changedFiles.length} changed file(s)`,
+      );
+    } else {
+      debug(
+        `runPostNativeCha: ${gateAFired ? 'Gate A (hierarchy)' : 'Gate B (RTA)'} fired — running full scan`,
+      );
+    }
+  }
+
+  // Find existing call edges targeting qualified methods (e.g., 'IWorker.doWork').
+  // Include caller_file and method_file so affectedFiles can be populated for
+  // incremental role reclassification; confidence uses CHA_TYPED_DISPATCH_CONFIDENCE matching runChaPostPass.
+  // When scopeToChangedFiles is true, restrict to call sites in the changed files
+  // (safe because no hierarchy or RTA evidence changed outside those files).
+  let callToMethods: Array<{
+    source_id: number;
+    caller_name: string;
+    method_name: string;
+    caller_file: string | null;
+  }>;
+  if (scopeToChangedFiles && changedFiles && changedFiles.length > 0) {
+    const CHUNK_SIZE = 500;
+    const rows: Array<{
+      source_id: number;
+      caller_name: string;
+      method_name: string;
+      caller_file: string | null;
+    }> = [];
+    for (let i = 0; i < changedFiles.length; i += CHUNK_SIZE) {
+      const chunk = changedFiles.slice(i, i + CHUNK_SIZE);
+      const ph = chunk.map(() => '?').join(',');
+      const chunkRows = db
+        .prepare(
+          `SELECT e.source_id, src.name AS caller_name, 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
+           AND (e.technique IS NULL OR e.technique != 'cha-expanded')
+           AND src.file IN (${ph})`,
+        )
+        .all(...chunk) as Array<{
+        source_id: number;
+        caller_name: string;
+        method_name: string;
+        caller_file: string | null;
+      }>;
+      rows.push(...chunkRows);
+    }
+    callToMethods = rows;
+  } else {
+    callToMethods = db
+      .prepare(`
+        SELECT e.source_id, src.name AS caller_name, 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
+        AND (e.technique IS NULL OR e.technique != 'cha-expanded')
+      `)
+      .all() as Array<{
+      source_id: number;
+      caller_name: string;
+      method_name: string;
+      caller_file: string | null;
+    }>;
+  }
+
+  // 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<string>();
+  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) as Array<{ source_id: number; target_id: number }>;
+      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: Array<[number, number, string, number, number, string]> = [];
+  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: string[] = [typeName];
+    const bfsVisited = new Set<string>([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) as Array<{
+            id: number;
+            method_file: string | null;
+          }>;
+          for (const methodNode of methodNodes) {
+            if (methodNode.id === source_id) continue; // skip self-loops
+            const key = `${source_id}|${methodNode.id}`;
+            if (seen.has(key)) continue;
+            seen.add(key);
+            const conf = CHA_TYPED_DISPATCH_CONFIDENCE;
+            newEdges.push([source_id, methodNode.id, 'calls', conf, 0, 'cha-expanded']);
+            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))();
+    // Account for post-pass edges excluded from the build summary line (#1452),
+    // mirroring the this/super dispatch post-pass insertion log.
+    debug(`CHA expansion post-pass: inserted ${newEdgeCount} edge(s)`);
+  }
+  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.
+ *
+ * Also handles function-as-object-property methods (`f.h = function() { this.g() }`):
+ * these use `this` to reference sibling properties on the same object (`f`), so
+ * `resolveThisDispatch` resolves them by treating the dot-prefix of the caller name
+ * (`f` from `f.h`) as the class and looking up `f.g` directly — no `extends` edge needed.
+ *
+ * Runs when either `extends` edges exist (class inheritance) OR dot-named `method`
+ * nodes exist (func-prop assignments); skips only when neither is present.
+ */
+async function runPostNativeThisDispatch(
+  db: BetterSqlite3Database,
+  rootDir: string,
+  changedFiles: string[] | undefined,
+  isFullBuild: boolean,
+): Promise<{ elapsedMs: number; targetIds: Set<number>; affectedFiles: Set<string> }> {
+  const t0 = performance.now();
+  const targetIds = new Set<number>();
+  // 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<string>();
+
+  // Fast guard: need at least one extends edge (class inheritance) OR a dot-named
+  // method node (func-prop assignment: `f.h = function() { this.g() }`) for
+  // this/super dispatch to produce any edges.
+  const hasExtends = db.prepare(`SELECT 1 FROM edges WHERE kind = 'extends' LIMIT 1`).get();
+  const hasFuncPropMethod = db
+    .prepare(`SELECT 1 FROM nodes WHERE kind = 'method' AND INSTR(name, '.') > 0 LIMIT 1`)
+    .get();
+  if (!hasExtends && !hasFuncPropMethod) return { elapsedMs: 0, targetIds, affectedFiles };
+
+  // Build parents map: child class → direct parent class (from `extends` edges).
+  // May be empty when only func-prop methods exist (no class inheritance) —
+  // resolveThisDispatch handles that case via direct class-prefix lookup.
+  const parentRows = hasExtends
+    ? (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() as Array<{ child_name: string; parent_name: string }>)
+    : [];
+
+  const parents = new Map<string, string>();
+  for (const row of parentRows) {
+    if (!parents.has(row.child_name)) parents.set(row.child_name, row.parent_name);
+  }
+  // Note: parents may be empty when hasFuncPropMethod but !hasExtends — that is
+  // intentional. resolveThisDispatch still resolves `this.g()` inside `f.h` by
+  // treating `f` (the dot-prefix of callerName `f.h`) as the class and looking
+  // up `f.g` directly via lookup.byName(), without traversing the parents chain.
+
+  const chaCtx: ChaContext = {
+    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 with
+  // `super.X()` calls and parent-class files with `this.X()` calls) OR that
+  // contain dot-named method nodes (func-prop assignments whose bodies may call
+  // `this.sibling()`). Any file not in either set has no class or object context
+  // where `this`/`super` dispatch would produce new edges.
+  let relFiles: string[];
+  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
+          UNION
+          -- Files with func-prop method definitions (e.g. f.h = function(){this.g()}).
+          -- Only include files where the method's owner prefix is NOT a known class name —
+          -- this keeps the re-parse set small (func-prop files only, not all class-method files).
+          -- AND name IS NOT NULL guards the NOT IN sub-select: if any class node had a NULL
+          -- name the entire NOT IN clause would silently return no rows (SQL NULL semantics).
+          SELECT n.file AS file
+          FROM nodes n
+          WHERE n.kind = 'method'
+          AND INSTR(n.name, '.') > 0
+          AND n.file IS NOT NULL
+          AND SUBSTR(n.name, 1, INSTR(n.name, '.') - 1) NOT IN (
+            SELECT name FROM nodes WHERE kind IN ('class', 'struct', 'interface', 'type')
+            AND name IS NOT NULL
+          )
+        )
+      `)
+      .all() as Array<{ file: string }>;
+    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: CallNodeLookup = {
+    byName: (name) => findByNameStmt.all(name) as Array<{ id: number; file: string; kind: string }>,
+    byNameAndFile: (name, file) =>
+      (findByNameStmt.all(name) as Array<{ id: number; file: string; kind: string }>).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<string>();
+  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) as Array<{ source_id: number; target_id: number }>;
+    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<string, { name: string; receiver?: string; line: number }[]>();
+  // 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<string>();
+  let nativeParsed = false;
+  if (nativeAbs.length > 0) {
+    const native = loadNative();
+    if (native) {
+      try {
+        const results = native.parseFiles(nativeAbs, rootDir, false, false) as Array<{
+          file: string;
+          calls?: { name: string; receiver?: string; line: number }[];
+        } | null>;
+        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<string, ExtractorOutput>();
+  for (const [relPath, symbols] of wasmResults) {
+    callsByRel.set(relPath, symbols.calls ?? []);
+  }
+
+  const newEdges: Array<[number, number, string, number, number, string]> = [];
+
+  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) as
+        | { id: number; name: string }
+        | undefined;
+      if (!callerRow) continue;
+
+      const targets = resolveThisDispatch(
+        call.name,
+        callerRow.name,
+        call.receiver as 'this' | 'super',
+        chaCtx,
+        lookup,
+        relPath,
+      );
+
+      for (const t of targets) {
+        if (t.id === callerRow.id) continue; // skip self-loops
+        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;
+        // Tag super-dispatch edges distinctly so runPostNativeCha can exclude them
+        // from further CHA expansion (super calls are not virtual dispatch).
+        const technique = call.receiver === 'super' ? 'super-dispatch' : 'cha';
+        newEdges.push([callerRow.id, t.id, 'calls', conf, 0, technique]);
+        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 as { _tree?: { delete?: () => void } })._tree;
+    if (tree && typeof tree.delete === 'function') {
+      try {
+        tree.delete();
+      } catch {
+        /* ignore cleanup errors */
+      }
+    }
+    (symbols as { _tree?: unknown; _langId?: unknown })._tree = undefined;
+    (symbols as { _tree?: unknown; _langId?: unknown })._langId = undefined;
+  }
+
+  return { elapsedMs: performance.now() - t0, targetIds, affectedFiles };
+}
+
+interface PostPassTimings {
+  gapDetectMs: number;
+  chaMs: number;
+  thisDispatchMs: number;
+  reclassifyMs: number;
+  techniqueBackfillMs: number;
+}
+
 /** Format timing result from native orchestrator phases + JS post-processing. */
 function formatNativeTimingResult(
   p: Record<string, number>,
   structurePatchMs: number,
   analysisTiming: { astMs: number; complexityMs: number; cfgMs: number; dataflowMs: number },
+  postPass: PostPassTimings,
 ): BuildResult {
   return {
     phases: {
@@ -399,6 +1025,11 @@ function formatNativeTimingResult(
       edgesMs: +(p.edgesMs ?? 0).toFixed(1),
       structureMs: +((p.structureMs ?? 0) + structurePatchMs).toFixed(1),
       rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+      gapDetectMs: +postPass.gapDetectMs.toFixed(1),
+      chaMs: +postPass.chaMs.toFixed(1),
+      thisDispatchMs: +postPass.thisDispatchMs.toFixed(1),
+      reclassifyMs: +postPass.reclassifyMs.toFixed(1),
+      techniqueBackfillMs: +postPass.techniqueBackfillMs.toFixed(1),
       astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
       complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
       cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
@@ -599,10 +1230,35 @@ async function backfillNativeDroppedFiles(
 
   if (missingAbs.length === 0) return;
 
+  // Parse all missing files via WASM first so we can distinguish real native
+  // extractor failures (WASM finds symbols but native didn't) from files the
+  // Rust engine legitimately skipped (gitignored artifacts, empty declaration
+  // files, etc. where WASM also produces 0 symbols). Both categories are
+  // backfilled — only the former triggers a WARN (#1566).
+  const wasmResults = await parseFilesWasmForBackfill(missingAbs, ctx.rootDir);
+
+  // Build two sets from wasmResults:
+  //   wasmParsedFiles  — rel-paths present in wasmResults (WASM succeeded, even 0 symbols)
+  //   wasmFoundSymbols — subset where WASM found ≥1 symbol
+  // Files absent from wasmParsedFiles were skipped by WASM entirely (extension
+  // not in _extToLang, wasmExtractSymbols returned null, or a read error).
+  // Those files do NOT end up in the batchInsertNodes loop below.
+  const wasmParsedFiles = new Set<string>();
+  const wasmFoundSymbols = new Set<string>();
+  for (const [relPath, symbols] of wasmResults) {
+    wasmParsedFiles.add(relPath);
+    if ((symbols.definitions?.length ?? 0) > 0 || (symbols.exports?.length ?? 0) > 0) {
+      wasmFoundSymbols.add(relPath);
+    }
+  }
+
   // Classify drops so users see per-extension reasons instead of just a count
   // (#1011). `unsupported-by-native` is a legitimate parser limit (no Rust
   // extractor); `native-extractor-failure` indicates a real native bug since
-  // the language IS supported by the addon yet the file was dropped anyway.
+  // the language IS supported by the addon yet WASM found symbols the native
+  // engine should have extracted. Files where both engines produce 0 symbols
+  // are legitimately empty (e.g. gitignored napi-generated declaration stubs)
+  // and logged at debug level only.
   const { byReason, totals } = classifyNativeDrops(missingRel);
   if (totals['unsupported-by-native'] > 0) {
     const buckets = byReason['unsupported-by-native'];
@@ -611,12 +1267,54 @@ async function backfillNativeDroppedFiles(
     );
   }
   if (totals['native-extractor-failure'] > 0) {
-    const buckets = byReason['native-extractor-failure'];
-    warn(
-      `Native orchestrator dropped ${totals['native-extractor-failure']} file(s) across ${buckets.size} extension(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM:${formatDropExtensionSummary(buckets)}`,
-    );
+    // Three-way split of native-extractor-failure files:
+    //   realFailureBuckets  — WASM found symbols → real Rust extractor bug (WARN)
+    //   emptyFileBuckets    — WASM parsed but found 0 symbols → gitignored/empty (debug)
+    //                         These DO receive a file-node insert in the loop below.
+    //   wasmSkipBuckets     — WASM skipped entirely (ext unknown or parse error) →
+    //                         no file-node insert, and no WARN (debug only, distinct
+    //                         message to avoid overstating backfill coverage).
+    const allFailurePaths = byReason['native-extractor-failure'];
+    const realFailureBuckets = new Map<string, string[]>();
+    const emptyFileBuckets = new Map<string, string[]>();
+    const wasmSkipBuckets = new Map<string, string[]>();
+    for (const [ext, paths] of allFailurePaths) {
+      for (const relPath of paths) {
+        let bucket: Map<string, string[]>;
+        if (wasmFoundSymbols.has(relPath)) {
+          bucket = realFailureBuckets;
+        } else if (wasmParsedFiles.has(relPath)) {
+          bucket = emptyFileBuckets;
+        } else {
+          bucket = wasmSkipBuckets;
+        }
+        let list = bucket.get(ext);
+        if (!list) {
+          list = [];
+          bucket.set(ext, list);
+        }
+        list.push(relPath);
+      }
+    }
+    if (realFailureBuckets.size > 0) {
+      const realCount = [...realFailureBuckets.values()].reduce((s, a) => s + a.length, 0);
+      warn(
+        `Native orchestrator dropped ${realCount} file(s) across ${realFailureBuckets.size} extension(s) in natively-supported languages — likely a Rust extractor bug. Backfilling via WASM:${formatDropExtensionSummary(realFailureBuckets)}`,
+      );
+    }
+    if (emptyFileBuckets.size > 0) {
+      const emptyCount = [...emptyFileBuckets.values()].reduce((s, a) => s + a.length, 0);
+      debug(
+        `Native orchestrator skipped ${emptyCount} file(s) in natively-supported languages that also produced 0 symbols via WASM (likely gitignored or empty); backfilling file nodes:${formatDropExtensionSummary(emptyFileBuckets)}`,
+      );
+    }
+    if (wasmSkipBuckets.size > 0) {
+      const skipCount = [...wasmSkipBuckets.values()].reduce((s, a) => s + a.length, 0);
+      debug(
+        `Native orchestrator skipped ${skipCount} file(s) in natively-supported languages that WASM also could not parse (unregistered extension or parse error); no file-node inserted:${formatDropExtensionSummary(wasmSkipBuckets)}`,
+      );
+    }
   }
-  const wasmResults = await parseFilesWasmForBackfill(missingAbs, ctx.rootDir);
 
   const rows: unknown[][] = [];
   const exportKeys: unknown[][] = [];
@@ -740,6 +1438,50 @@ async function backfillNativeDroppedFiles(
   }
 }
 
+/**
+ * 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: BetterSqlite3Database,
+  isFullBuild: boolean,
+  changedFiles: string[] | undefined,
+): void {
+  // 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.
  *
@@ -814,7 +1556,7 @@ export async function tryNativeOrchestrator(
     // Even on no-op rebuilds, dropped-language files added since the last
     // full build are still missing from `nodes`/`file_hashes` (#1083), and
     // WASM-only files deleted from disk leave stale rows behind (#1073).
-    // The orchestrator's file_collector skipped them, so its earlyExit
+    // The orchestrator's collect_files skipped them, so its earlyExit
     // doesn't imply DB consistency. Run the gap repair before returning.
     const gap = detectDroppedLanguageGap(ctx);
     if (gap.missingAbs.length > 0 || gap.staleRel.length > 0) {
@@ -856,9 +1598,9 @@ export async function tryNativeOrchestrator(
     built_at: new Date().toISOString(),
   });
 
-  info(
-    `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,
-  );
+  // The build summary is logged after the JS edge-writing post-passes below
+  // (dropped-language backfill, CHA, this/super dispatch) so the reported
+  // counts include their edges (#1452).
 
   // ── Post-native structure + analysis ──────────────────────────────
   let analysisTiming = {
@@ -881,19 +1623,165 @@ export async function tryNativeOrchestrator(
       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);
       ctx.nativeFirstProxy = false;
     } else if (!ctx.nativeFirstProxy && !handoffWalAfterNativeBuild(ctx)) {
-      // DB reopen failed — return partial result
-      return formatNativeTimingResult(p, 0, analysisTiming);
+      // DB reopen failed — return partial result (no post-pass phases completed)
+      return formatNativeTimingResult(p, 0, analysisTiming, {
+        gapDetectMs: 0,
+        chaMs: 0,
+        thisDispatchMs: 0,
+        reclassifyMs: 0,
+        techniqueBackfillMs: 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
+  // engines process the same file set (#967).
+  //
+  // Detect the gap once (fs walk + 2 DB queries) and use it for both gating
+  // and the backfill itself. On quiet incrementals we still pay the walk so
+  // we can detect brand-new files in dropped-language extensions — a gap that
+  // the orchestrator's `detect_removed_files` filter (#1070) leaves open
+  // (#1083, #1091). The pre-check is cheap because the expensive part (WASM
+  // re-parse of the missing set) is gated below.
+  const gapDetectStart = performance.now();
+  const gap = detectDroppedLanguageGap(ctx);
+  const backfillHappened = gap.missingAbs.length > 0 || gap.staleRel.length > 0;
+  if (backfillHappened) {
+    await backfillNativeDroppedFiles(ctx, gap);
+  }
+  const gapDetectMs = performance.now() - gapDetectStart;
+
+  // 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.
+  // Runs BEFORE the CHA expansion pass so that super.method() → Parent.method edges
+  // (technique='cha') are in the DB when runPostNativeCha expands them to sibling
+  // class overrides (e.g. PostMixin.m → B.m when PostMixin and B both extend A).
+  const {
+    elapsedMs: thisDispatchMs,
+    targetIds: thisDispatchTargetIds,
+    affectedFiles: thisDispatchAffectedFiles,
+  } = await runPostNativeThisDispatch(
+    ctx.db as unknown as BetterSqlite3Database,
+    ctx.rootDir,
+    result.changedFiles,
+    !!result.isFullBuild,
+  );
+
+  // Phase 8.6: 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.
+  //
+  // Runs AFTER this/super dispatch so super.method() edges are already in the DB.
+  // The 'cha-expanded' technique tag on this pass's own output prevents re-expansion
+  // of those edges in subsequent incremental builds, while 'cha'-tagged edges from
+  // this/super dispatch remain eligible for expansion here.
+  //
+  // 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 chaStart = performance.now();
+  const { newEdgeCount: chaEdgeCount, affectedFiles: chaAffectedFiles } = runPostNativeCha(
+    ctx.db as unknown as BetterSqlite3Database,
+    // null = full build (scan all call→method edges); array = incremental (gate queries decide scope)
+    result.isFullBuild ? null : (result.changedFiles ?? null),
+  );
+  const chaMs = performance.now() - chaStart;
+
+  // 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).
+  let reclassifyMs = 0;
+  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;
+    const reclassifyStart = performance.now();
+    try {
+      const { classifyNodeRoles } = (await import('../../../../features/structure.js')) as {
+        classifyNodeRoles: (
+          db: BetterSqlite3Database,
+          changedFiles?: string[] | null,
+        ) => Record<string, number>;
+      };
+      classifyNodeRoles(ctx.db as unknown as BetterSqlite3Database, 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)}`);
+    }
+    reclassifyMs = performance.now() - reclassifyStart;
+  }
+
+  // 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.
+  const techniqueBackfillStart = performance.now();
+  backfillEdgeTechniquesAfterNativeOrchestrator(ctx.db, !!result.isFullBuild, result.changedFiles);
+  const techniqueBackfillMs = performance.now() - techniqueBackfillStart;
+
+  // Re-count nodes/edges now that all edge-writing post-passes have run: the
+  // Rust orchestrator captured its counts before the JS post-passes added
+  // edges, so both its summary and build_meta under-report (#1452).
+  //
+  // Fast path: skip the COUNT(*) scan when no post-pass wrote any edges.
+  // COUNT(*) on large tables (50K+ edges) is non-trivial, especially via the
+  // NativeDbProxy napi-rs round-trip. When all post-passes were no-ops, the
+  // Rust orchestrator's counts are still accurate — no re-count needed.
+  let finalNodeCount = result.nodeCount ?? 0;
+  let finalEdgeCount = result.edgeCount ?? 0;
+  const postPassWroteData = backfillHappened || chaEdgeCount > 0 || thisDispatchTargetIds.size > 0;
+  if (postPassWroteData) {
+    try {
+      const counts = (ctx.db as unknown as BetterSqlite3Database)
+        .prepare('SELECT (SELECT COUNT(*) FROM nodes) AS n, (SELECT COUNT(*) FROM edges) AS e')
+        .get() as { n: number; e: number };
+      if (counts.n !== finalNodeCount || counts.e !== finalEdgeCount) {
+        finalNodeCount = counts.n;
+        finalEdgeCount = counts.e;
+        setBuildMeta(ctx.db, { node_count: finalNodeCount, edge_count: finalEdgeCount });
+      }
+    } catch (err) {
+      debug(`Post-pass node/edge re-count failed: ${toErrorMessage(err)}`);
     }
+  }
+  info(
+    `Native build orchestrator completed: ${finalNodeCount} nodes, ${finalEdgeCount} edges, ${result.fileCount ?? 0} files`,
+  );
 
+  // ── 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) {
@@ -910,33 +1798,12 @@ export async function tryNativeOrchestrator(
     }
   }
 
-  // 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
-  // engines process the same file set (#967).
-  //
-  // Detect the gap once (fs walk + 2 DB queries, ~20–30ms) and use it for
-  // both gating and the backfill itself. On dirty incrementals/full builds
-  // the orchestrator signals trigger backfill, so the walk happens once
-  // (instead of redundantly inside backfill). On quiet incrementals we
-  // still pay the walk so we can detect brand-new files in dropped-language
-  // extensions — a gap that the orchestrator's `detect_removed_files`
-  // filter (#1070) leaves open (#1083, #1091). The pre-check is cheap
-  // because the expensive part (WASM re-parse of the missing set) is
-  // gated below.
-  const removedCount = result.removedCount ?? 0;
-  const changedCount = result.changedCount ?? 0;
-  const gap = detectDroppedLanguageGap(ctx);
-  if (
-    result.isFullBuild ||
-    removedCount > 0 ||
-    changedCount > 0 ||
-    gap.missingAbs.length > 0 ||
-    gap.staleRel.length > 0
-  ) {
-    await backfillNativeDroppedFiles(ctx, gap);
-  }
-
   closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
-  return formatNativeTimingResult(p, structurePatchMs, analysisTiming);
+  return formatNativeTimingResult(p, structurePatchMs, analysisTiming, {
+    gapDetectMs,
+    chaMs,
+    thisDispatchMs,
+    reclassifyMs,
+    techniqueBackfillMs,
+  });
 }