@optave/codegraph 3.9.2 → 3.9.4

package/src/domain/graph/builder/pipeline.ts

@@ -23,7 +23,13 @@ import { loadNative } from '../../../infrastructure/native.js';
 import { semverCompare } from '../../../infrastructure/update-check.js';
 import { toErrorMessage } from '../../../shared/errors.js';
 import { CODEGRAPH_VERSION } from '../../../shared/version.js';
-import type { BuildGraphOpts, BuildResult, Definition, ExtractorOutput } from '../../../types.js';
+import type {
+  BetterSqlite3Database,
+  BuildGraphOpts,
+  BuildResult,
+  Definition,
+  ExtractorOutput,
+} from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -82,10 +88,17 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
     );
     ctx.forceFullRebuild = true;
   }
+  // When the native engine is active, the Rust addon's version (ctx.engineVersion)
+  // is written into codegraph_version by setBuildMeta after a native orchestrator
+  // build. The check must compare against the same version, otherwise JS and Rust
+  // fight over which version to record — causing every incremental build to be
+  // promoted to a full rebuild when npm and crate versions diverge.
+  const effectiveVersion =
+    ctx.engineName === 'native' && ctx.engineVersion ? ctx.engineVersion : CODEGRAPH_VERSION;
   const prevVersion = meta('codegraph_version');
-  if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
+  if (prevVersion && prevVersion !== effectiveVersion) {
     info(
-      `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
+      `Codegraph version changed (${prevVersion} → ${effectiveVersion}), promoting to full rebuild.`,
     );
     ctx.forceFullRebuild = true;
   }
@@ -120,42 +133,15 @@ function setupPipeline(ctx: PipelineContext): void {
   const native = enginePref !== 'wasm' ? loadNative() : null;
   ctx.nativeAvailable = !!native?.NativeDatabase;
 
-  // Native-first: use only rusqlite for the entire pipeline (no better-sqlite3).
-  // This eliminates the dual-connection WAL corruption problem and enables all
-  // native fast-paths (bulkInsertNodes, classifyRolesFull, etc.).
-  // Fallback: if native is unavailable or FORCE_JS is set, use better-sqlite3.
-  if (
-    ctx.nativeAvailable &&
-    native?.NativeDatabase &&
-    process.env.CODEGRAPH_FORCE_JS_PIPELINE !== '1'
-  ) {
-    try {
-      const dir = path.dirname(ctx.dbPath);
-      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-      acquireAdvisoryLock(ctx.dbPath);
-      ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-      ctx.nativeDb.initSchema();
-      const proxy = new NativeDbProxy(ctx.nativeDb);
-      proxy.__lockPath = `${ctx.dbPath}.lock`;
-      ctx.db = proxy as unknown as typeof ctx.db;
-      ctx.nativeFirstProxy = true;
-    } catch (err) {
-      warn(`NativeDatabase setup failed, falling back to better-sqlite3: ${toErrorMessage(err)}`);
-      try {
-        ctx.nativeDb?.close();
-      } catch {
-        /* ignore */
-      }
-      ctx.nativeDb = undefined;
-      ctx.nativeFirstProxy = false;
-      releaseAdvisoryLock(`${ctx.dbPath}.lock`);
-      ctx.db = openDb(ctx.dbPath);
-      initSchema(ctx.db);
-    }
-  } else {
-    ctx.db = openDb(ctx.dbPath);
-    initSchema(ctx.db);
-  }
+  // Always use better-sqlite3 for setup — it's cheap (~4ms) and only needed
+  // for metadata reads (schema mismatch check). NativeDatabase.openReadWrite
+  // is deferred to tryNativeOrchestrator, saving ~60ms on incremental builds
+  // where the Rust orchestrator handles the full pipeline, and avoiding the
+  // cost entirely on no-op builds that exit before reaching the orchestrator.
+  const dir = path.dirname(ctx.dbPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  ctx.db = openDb(ctx.dbPath);
+  initSchema(ctx.db);
 
   ctx.config = loadConfig(ctx.rootDir);
   ctx.incremental =
@@ -260,17 +246,16 @@ interface NativeOrchestratorResult {
   changedCount?: number;
   removedCount?: number;
   isFullBuild?: boolean;
-  /** Full changed files including reverse-dep files — used by JS structure fallback. */
-  structureScope?: string[];
   /** Whether the Rust pipeline handled the structure phase (small-incremental fast path). */
   structureHandled?: boolean;
+  /** Whether the Rust pipeline wrote AST/complexity/CFG/dataflow to DB. */
+  analysisComplete?: boolean;
 }
 
 // ── Native orchestrator helpers ───────────────────────────────────────
 
 /** Determine whether the native orchestrator should be skipped. Returns a reason string, or null if it should run. */
 function shouldSkipNativeOrchestrator(ctx: PipelineContext): string | null {
-  if (process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1') return 'CODEGRAPH_FORCE_JS_PIPELINE=1';
   if (ctx.forceFullRebuild) return 'forceFullRebuild';
   // v3.9.0 addon had buggy incremental purge (wrong SQL on analysis tables,
   // scoped removal over-detection). Fixed in v3.9.1 by PR #865. Gate on
@@ -452,7 +437,11 @@ async function runPostNativeStructure(
   return performance.now() - structureStart;
 }
 
-/** Run AST/complexity/CFG/dataflow analysis after native orchestrator. */
+/**
+ * JS fallback for AST/complexity/CFG/dataflow analysis after native orchestrator.
+ * Used when the Rust addon doesn't include analysis persistence (older addon
+ * version) or when analysis failed on the Rust side.
+ */
 async function runPostNativeAnalysis(
   ctx: PipelineContext,
   allFileSymbols: Map<string, ExtractorOutput>,
@@ -472,30 +461,43 @@ async function runPostNativeAnalysis(
     analysisFileSymbols = allFileSymbols;
   }
 
-  // In native-first mode, nativeDb is already open — no reopen needed.
-  if (!ctx.nativeFirstProxy) {
-    const native = loadNative();
-    if (native?.NativeDatabase) {
-      try {
-        ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
-        if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
-      } catch {
-        ctx.nativeDb = undefined;
-        if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
-      }
+  // Reopen nativeDb for analysis features (suspend/resume WAL pattern).
+  const native = loadNative();
+  if (native?.NativeDatabase) {
+    try {
+      ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+      if (ctx.engineOpts) ctx.engineOpts.nativeDb = ctx.nativeDb;
+    } catch {
+      ctx.nativeDb = undefined;
+      if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
     }
-  } else if (ctx.engineOpts) {
-    ctx.engineOpts.nativeDb = ctx.nativeDb;
+  }
+
+  // Flush JS WAL pages once so Rust can see them, then no-op callbacks.
+  // Previously each feature called wal_checkpoint(TRUNCATE) individually
+  // (~68ms each × 3-4 features). One FULL checkpoint suffices.
+  if (ctx.nativeDb && ctx.engineOpts) {
+    ctx.db.pragma('wal_checkpoint(FULL)');
+    ctx.engineOpts.suspendJsDb = () => {};
+    ctx.engineOpts.resumeJsDb = () => {};
   }
 
   try {
-    const { runAnalyses: runAnalysesFn } = await import('../../../ast-analysis/engine.js');
+    const { runAnalyses: runAnalysesFn } = (await import('../../../ast-analysis/engine.js')) as {
+      runAnalyses: (
+        db: BetterSqlite3Database,
+        fileSymbols: Map<string, ExtractorOutput>,
+        rootDir: string,
+        opts: Record<string, unknown>,
+        engineOpts?: Record<string, unknown>,
+      ) => Promise<{ astMs?: number; complexityMs?: number; cfgMs?: number; dataflowMs?: number }>;
+    };
     const result = await runAnalysesFn(
       ctx.db,
       analysisFileSymbols,
       ctx.rootDir,
-      ctx.opts,
-      ctx.engineOpts,
+      ctx.opts as Record<string, unknown>,
+      ctx.engineOpts as unknown as Record<string, unknown> | undefined,
     );
     timing.astMs = result.astMs ?? 0;
     timing.complexityMs = result.complexityMs ?? 0;
@@ -505,8 +507,10 @@ async function runPostNativeAnalysis(
     warn(`Analysis phases failed after native build: ${toErrorMessage(err)}`);
   }
 
-  // Close nativeDb after analyses (skip in native-first — single connection stays open)
-  if (ctx.nativeDb && !ctx.nativeFirstProxy) {
+  // Close nativeDb after analyses — TRUNCATE checkpoint flushes all Rust
+  // WAL writes so JS and external readers can see them. Runs once after
+  // all analysis features complete (not per-feature).
+  if (ctx.nativeDb) {
     try {
       ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
     } catch {
@@ -518,7 +522,11 @@ async function runPostNativeAnalysis(
       /* ignore close errors */
     }
     ctx.nativeDb = undefined;
-    if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+    if (ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = undefined;
+      ctx.engineOpts.suspendJsDb = undefined;
+      ctx.engineOpts.resumeJsDb = undefined;
+    }
   }
 
   return timing;
@@ -558,15 +566,26 @@ async function tryNativeOrchestrator(
     return undefined;
   }
 
-  // In native-first mode, nativeDb is already open from setupPipeline.
-  // Otherwise, open it on demand (deferred to skip overhead on no-op rebuilds).
+  // Open NativeDatabase on demand — deferred from setupPipeline to skip the
+  // ~60ms cost on no-op/early-exit builds. Close the better-sqlite3 connection
+  // first to avoid dual-connection WAL corruption.
   if (!ctx.nativeDb && ctx.nativeAvailable) {
     const native = loadNative();
     if (native?.NativeDatabase) {
       try {
+        // Close better-sqlite3 before opening rusqlite to avoid WAL conflicts.
+        // Uses raw close() instead of closeDb() intentionally — the advisory lock
+        // is kept and transferred to the NativeDbProxy below, not released here.
+        ctx.db.close();
+        acquireAdvisoryLock(ctx.dbPath);
         ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
         ctx.nativeDb.initSchema();
-        ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        // Replace ctx.db with a NativeDbProxy so post-native JS fallback
+        // (structure, analysis) can use it without reopening better-sqlite3.
+        const proxy = new NativeDbProxy(ctx.nativeDb);
+        proxy.__lockPath = `${ctx.dbPath}.lock`;
+        ctx.db = proxy as unknown as typeof ctx.db;
+        ctx.nativeFirstProxy = true;
       } catch (err) {
         warn(`NativeDatabase setup failed, falling back to JS: ${toErrorMessage(err)}`);
         try {
@@ -575,6 +594,10 @@ async function tryNativeOrchestrator(
           debug(`tryNativeOrchestrator: close failed during fallback: ${toErrorMessage(e)}`);
         }
         ctx.nativeDb = undefined;
+        ctx.nativeFirstProxy = false; // defensive: reset in case future refactors move the assignment above throwing lines
+        releaseAdvisoryLock(`${ctx.dbPath}.lock`);
+        // Reopen better-sqlite3 for JS pipeline fallback
+        ctx.db = openDb(ctx.dbPath);
       }
     }
   }
@@ -605,14 +628,18 @@ async function tryNativeOrchestrator(
   const p = result.phases;
 
   // Sync build_meta so JS-side version/engine checks work on next build.
+  // Use the Rust addon version as codegraph_version when the native
+  // orchestrator performed the build — the Rust side's check_version_mismatch
+  // compares this value against CARGO_PKG_VERSION.  Writing the JS
+  // CODEGRAPH_VERSION here would create a permanent mismatch whenever the
+  // npm package version diverges from the Rust crate version, forcing every
+  // subsequent native build to be a full rebuild (no incremental).
   setBuildMeta(ctx.db, {
     engine: ctx.engineName,
     engine_version: ctx.engineVersion || '',
-    codegraph_version: CODEGRAPH_VERSION,
+    codegraph_version: ctx.engineVersion || CODEGRAPH_VERSION,
     schema_version: String(ctx.schemaVersion),
     built_at: new Date().toISOString(),
-    node_count: String(result.nodeCount ?? 0),
-    edge_count: String(result.edgeCount ?? 0),
   });
 
   info(
@@ -620,41 +647,51 @@ async function tryNativeOrchestrator(
   );
 
   // ── Post-native structure + analysis ──────────────────────────────
-  let analysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+  let analysisTiming = {
+    astMs: +(p.astMs ?? 0),
+    complexityMs: +(p.complexityMs ?? 0),
+    cfgMs: +(p.cfgMs ?? 0),
+    dataflowMs: +(p.dataflowMs ?? 0),
+  };
   let structurePatchMs = 0;
-  const needsAnalysis =
-    ctx.opts.ast !== false ||
-    ctx.opts.complexity !== false ||
-    ctx.opts.cfg !== false ||
-    ctx.opts.dataflow !== false;
   // Skip JS structure when the Rust pipeline's small-incremental fast path
   // already handled it. For full builds and large incrementals where Rust
   // skipped structure, we must run the JS fallback.
   const needsStructure = !result.structureHandled;
-
-  if (needsAnalysis || needsStructure) {
-    // In native-first mode the proxy is already wired — no WAL handoff needed.
-    if (!ctx.nativeFirstProxy && !handoffWalAfterNativeBuild(ctx)) {
+  // When the Rust addon doesn't include analysis persistence (older addon
+  // version or analysis failed), fall back to JS-side analysis.
+  const needsAnalysisFallback =
+    !result.analysisComplete &&
+    (ctx.opts.ast !== false ||
+      ctx.opts.complexity !== false ||
+      ctx.opts.cfg !== false ||
+      ctx.opts.dataflow !== false);
+
+  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);
     }
 
-    // When structure was handled by Rust, we only need changed files for
-    // analysis — no need to load the entire graph from DB. When structure
-    // was NOT handled, we need all files to build the complete directory tree.
-    const scopeFiles = needsStructure ? undefined : result.changedFiles;
-    const fileSymbols = reconstructFileSymbolsFromDb(ctx, scopeFiles);
+    const fileSymbols = reconstructFileSymbolsFromDb(ctx);
 
     if (needsStructure) {
       structurePatchMs = await runPostNativeStructure(
         ctx,
         fileSymbols,
         !!result.isFullBuild,
-        result.structureScope ?? result.changedFiles,
+        result.changedFiles,
       );
     }
 
-    if (needsAnalysis) {
+    if (needsAnalysisFallback) {
       analysisTiming = await runPostNativeAnalysis(ctx, fileSymbols, result.changedFiles);
     }
   }
@@ -666,30 +703,7 @@ async function tryNativeOrchestrator(
 // ── Pipeline stages execution ───────────────────────────────────────────
 
 async function runPipelineStages(ctx: PipelineContext): Promise<void> {
-  // ── Native-first mode ────────────────────────────────────────────────
-  // When ctx.nativeFirstProxy is true, ctx.db is a NativeDbProxy backed by
-  // the single rusqlite connection (ctx.nativeDb). No dual-connection WAL
-  // dance is needed — every stage uses the same connection transparently.
-  if (ctx.nativeFirstProxy) {
-    // Ensure engineOpts.nativeDb is set so stages can use dedicated native methods.
-    if (ctx.engineOpts) {
-      ctx.engineOpts.nativeDb = ctx.nativeDb;
-    }
-
-    await collectFiles(ctx);
-    await detectChanges(ctx);
-    if (ctx.earlyExit) return;
-    await parseFiles(ctx);
-    await insertNodes(ctx);
-    await resolveImports(ctx);
-    await buildEdges(ctx);
-    await buildStructure(ctx);
-    await runAnalyses(ctx);
-    await finalize(ctx);
-    return;
-  }
-
-  // ── Legacy dual-connection mode (WASM / fallback) ────────────────────
+  // ── WASM / fallback dual-connection mode ─────────────────────────────
   // NativeDatabase is deferred — not opened during setup. collectFiles and
   // detectChanges only need better-sqlite3. If no files changed, we exit
   // early without ever opening the native connection, saving ~5ms.
@@ -697,6 +711,13 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // suspend it now to avoid dual-connection WAL corruption during stages.
   if (ctx.db && ctx.nativeDb) {
     suspendNativeDb(ctx, 'pre-collect');
+    // When nativeFirstProxy is true, ctx.db is a NativeDbProxy wrapping the
+    // now-closed NativeDatabase. Replace it with a real better-sqlite3
+    // connection so the JS pipeline stages can operate normally.
+    if (ctx.nativeFirstProxy) {
+      ctx.db = openDb(ctx.dbPath);
+      ctx.nativeFirstProxy = false;
+    }
   }
 
   await collectFiles(ctx);
@@ -728,25 +749,20 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   await buildEdges(ctx);
   await buildStructure(ctx);
 
-  // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow)
-  // which use suspendJsDb/resumeJsDb WAL checkpoint before native writes.
+  // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow).
   // Skip for small incremental builds — same rationale as insertNodes above.
+  //
+  // Perf: do ONE upfront FULL checkpoint to flush JS WAL pages so Rust
+  // can see the latest rows, then make suspendJsDb/resumeJsDb no-ops.
+  // Previously each feature called wal_checkpoint(TRUNCATE) individually
+  // (~68ms each × 3-4 features = ~200-270ms overhead on incremental builds).
   if (ctx.nativeAvailable && !smallIncremental) {
     reopenNativeDb(ctx, 'analyses');
     if (ctx.nativeDb && ctx.engineOpts) {
+      ctx.db.pragma('wal_checkpoint(FULL)');
       ctx.engineOpts.nativeDb = ctx.nativeDb;
-      ctx.engineOpts.suspendJsDb = () => {
-        ctx.db.pragma('wal_checkpoint(TRUNCATE)');
-      };
-      ctx.engineOpts.resumeJsDb = () => {
-        try {
-          ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-        } catch (e) {
-          debug(
-            `resumeJsDb: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
-          );
-        }
-      };
+      ctx.engineOpts.suspendJsDb = () => {};
+      ctx.engineOpts.resumeJsDb = () => {};
     }
     if (!ctx.nativeDb && ctx.engineOpts) {
       ctx.engineOpts.nativeDb = undefined;
@@ -757,11 +773,32 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
 
   await runAnalyses(ctx);
 
-  // Keep nativeDb open through finalize so persistBuildMetadata, advisory
-  // checks, and count queries use the native path.  closeDbPair inside
-  // finalize handles both connections.  Refresh the JS db so it has a
-  // valid page cache in case finalize falls back to JS paths (#751).
+  // Release WASM trees deterministically on the success path — same cleanup
+  // as the error-path catch block.  Without this, trees stay allocated until
+  // GC collects ctx, holding WASM memory for the rest of the build (#931).
+  if (ctx.allSymbols?.size > 0) {
+    for (const [, symbols] of ctx.allSymbols) {
+      const tree = symbols._tree as { delete?: () => void } | undefined;
+      if (tree && typeof tree.delete === 'function') {
+        try {
+          tree.delete();
+        } catch {
+          /* ignore cleanup errors */
+        }
+      }
+      symbols._tree = undefined;
+    }
+  }
+
+  // Flush Rust WAL writes (AST, complexity, CFG, dataflow) so the JS
+  // connection and any post-build readers can see them.  One TRUNCATE
+  // here replaces the N per-feature resumeJsDb checkpoints (#checkpoint-opt).
   if (ctx.nativeDb) {
+    try {
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+    } catch (e) {
+      debug(`post-analyses WAL checkpoint failed: ${toErrorMessage(e)}`);
+    }
     refreshJsDb(ctx);
   }
 
@@ -797,13 +834,42 @@ export async function buildGraph(
       if (nativeResult) return nativeResult;
     } catch (err) {
       warn(`Native build orchestrator failed, falling back to JS pipeline: ${toErrorMessage(err)}`);
-      // Fall through to JS pipeline
+      // The version gate in checkEngineSchemaMismatch was skipped because
+      // nativeAvailable was true. Now that we're falling back to the JS
+      // pipeline, perform the codegraph_version check here so a version
+      // bump still promotes to a full rebuild (#928).
+      if (ctx.incremental && !ctx.forceFullRebuild) {
+        const prevVersion = getBuildMeta(ctx.db, 'codegraph_version');
+        if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
+          info(
+            `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
+          );
+          ctx.forceFullRebuild = true;
+        }
+      }
     }
 
     await runPipelineStages(ctx);
   } catch (err) {
-    if (!ctx.earlyExit && ctx.db) {
-      closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+    if (!ctx.earlyExit) {
+      // Release WASM trees before closing DB to prevent V8 crash during
+      // GC cleanup of orphaned WASM objects (#931).
+      if (ctx.allSymbols?.size > 0) {
+        for (const [, symbols] of ctx.allSymbols) {
+          const tree = symbols._tree as { delete?: () => void } | undefined;
+          if (tree && typeof tree.delete === 'function') {
+            try {
+              tree.delete();
+            } catch {
+              /* ignore cleanup errors */
+            }
+          }
+          symbols._tree = undefined;
+        }
+      }
+      if (ctx.db) {
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+      }
     }
     throw err;
   }

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

@@ -699,6 +699,69 @@ function buildClassHierarchyEdges(
   }
 }
 
+// ── Reverse-dep edge reconnection (#932, #933) ─────────────────────────
+
+/**
+ * Reconnect edges that were saved before changed-file purge.
+ *
+ * Each saved edge records: sourceId (still valid — reverse-dep nodes were not
+ * purged) and target attributes (name, kind, file, line).  The target node was
+ * deleted and re-inserted with a new ID by insertNodes.  We look up the new ID
+ * by (name, kind, file) and re-create the edge.
+ */
+function reconnectReverseDepEdges(ctx: PipelineContext): void {
+  const { db } = ctx;
+  const findNodeStmt = db.prepare(
+    'SELECT id FROM nodes WHERE name = ? AND kind = ? AND file = ? ORDER BY ABS(line - ?) LIMIT 1',
+  );
+  const reconnectedRows: EdgeRowTuple[] = [];
+  let dropped = 0;
+
+  for (const saved of ctx.savedReverseDepEdges) {
+    const newTarget = findNodeStmt.get(
+      saved.tgtName,
+      saved.tgtKind,
+      saved.tgtFile,
+      saved.tgtLine,
+    ) as { id: number } | undefined;
+    if (newTarget) {
+      reconnectedRows.push([
+        saved.sourceId,
+        newTarget.id,
+        saved.edgeKind,
+        saved.confidence,
+        saved.dynamic,
+      ]);
+    } else {
+      // Target was removed or renamed in the changed file — edge is stale
+      dropped++;
+    }
+  }
+
+  if (reconnectedRows.length > 0) {
+    if (ctx.nativeDb?.bulkInsertEdges) {
+      const nativeEdges = reconnectedRows.map((r) => ({
+        sourceId: r[0],
+        targetId: r[1],
+        kind: r[2],
+        confidence: r[3],
+        dynamic: r[4],
+      }));
+      const ok = ctx.nativeDb.bulkInsertEdges(nativeEdges);
+      if (!ok) {
+        batchInsertEdges(db, reconnectedRows);
+      }
+    } else {
+      batchInsertEdges(db, reconnectedRows);
+    }
+  }
+
+  debug(
+    `Reconnected ${reconnectedRows.length} reverse-dep edges` +
+      (dropped > 0 ? ` (${dropped} dropped — targets removed/renamed)` : ''),
+  );
+}
+
 // ── Main entry point ────────────────────────────────────────────────────
 
 /**
@@ -798,10 +861,11 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       }
     }
 
-    // Skip native import-edge path for small incremental builds (≤3 files):
-    // napi-rs marshaling overhead exceeds computation savings.
+    // Skip native import-edge path for small incremental builds: napi-rs
+    // marshaling overhead (~13ms) exceeds Rust computation savings at this scale.
     const useNativeImportEdges =
-      native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+      native?.buildImportEdges &&
+      (ctx.isFullBuild || ctx.fileSymbols.size > ctx.config.build.smallFilesThreshold);
     if (useNativeImportEdges) {
       const beforeLen = allEdgeRows.length;
       buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
@@ -821,10 +885,11 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
     }
 
-    // Skip native call-edge path for small incremental builds (≤3 files):
-    // napi-rs marshaling overhead for allNodes exceeds computation savings.
+    // Skip native call-edge path for small incremental builds: napi-rs
+    // marshaling overhead for allNodes exceeds Rust computation savings.
     const useNativeCallEdges =
-      native?.buildCallEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+      native?.buildCallEdges &&
+      (ctx.isFullBuild || ctx.fileSymbols.size > ctx.config.build.smallFilesThreshold);
     if (useNativeCallEdges) {
       buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodesBefore, native!);
     } else {
@@ -858,5 +923,14 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
     }
   }
 
+  // Phase 3: Reconnect saved reverse-dep edges (#932, #933).
+  // When the WASM/JS path purged changed files, edges FROM reverse-dep files TO
+  // those files were deleted (target-side).  The reverse-dep files were NOT
+  // reparsed — instead we saved the edge topology before purge and now reconnect
+  // each edge to the new node IDs created by insertNodes.
+  if (ctx.savedReverseDepEdges.length > 0) {
+    reconnectReverseDepEdges(ctx);
+  }
+
   ctx.timing.edgesMs = performance.now() - t0;
 }

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

@@ -174,13 +174,13 @@ function updateChangedFileMetrics(ctx: PipelineContext, changedFiles: string[]):
     SELECT COUNT(DISTINCT n_src.file) AS cnt FROM edges e
     JOIN nodes n_src ON e.source_id = n_src.id
     JOIN nodes n_tgt ON e.target_id = n_tgt.id
-    WHERE e.kind = 'imports' AND n_tgt.file = ? AND n_src.file != n_tgt.file
+    WHERE e.kind IN ('imports', 'imports-type') AND n_tgt.file = ? AND n_src.file != n_tgt.file
   `);
   const getFanOut = db.prepare(`
     SELECT COUNT(DISTINCT n_tgt.file) AS cnt FROM edges e
     JOIN nodes n_src ON e.source_id = n_src.id
     JOIN nodes n_tgt ON e.target_id = n_tgt.id
-    WHERE e.kind = 'imports' AND n_src.file = ? AND n_src.file != n_tgt.file
+    WHERE e.kind IN ('imports', 'imports-type') AND n_src.file = ? AND n_src.file != n_tgt.file
   `);
   const upsertMetric = db.prepare(`
     INSERT OR REPLACE INTO node_metrics