@optave/codegraph 3.7.0 → 3.8.1

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

@@ -6,12 +6,21 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDbPair, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
+import {
+  closeDbPair,
+  getBuildMeta,
+  initSchema,
+  MIGRATIONS,
+  openDb,
+  setBuildMeta,
+} from '../../../db/index.js';
 import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
-import { info, warn } from '../../../infrastructure/logger.js';
+import { debug, info, warn } from '../../../infrastructure/logger.js';
 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 } from '../../../types.js';
+import type { BuildGraphOpts, BuildResult, Definition, ExtractorOutput } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
 import { PipelineContext } from './context.js';
@@ -35,18 +44,28 @@ function initializeEngine(ctx: PipelineContext): void {
     dataflow: ctx.opts.dataflow !== false,
     ast: ctx.opts.ast !== false,
     nativeDb: ctx.nativeDb,
-    // WAL checkpoint callbacks for dual-connection WAL guard (#696).
+    // WAL checkpoint callbacks for dual-connection WAL guard (#696, #715).
     // Feature modules (ast, cfg, complexity, dataflow) receive `db` as a
     // parameter and cannot tolerate close/reopen (stale reference). Instead,
-    // checkpoint the WAL so native writes start with a clean slate. Features
-    // return early on native success and never read native-written WAL data
-    // through the JS connection, so a post-write checkpoint is unnecessary.
+    // checkpoint the WAL so native writes start with a clean slate.
+    // After native writes, resumeJsDb checkpoints through rusqlite so
+    // better-sqlite3 never reads WAL frames from a different SQLite library.
     suspendJsDb: ctx.nativeDb
       ? () => {
           ctx.db.pragma('wal_checkpoint(TRUNCATE)');
         }
       : undefined,
-    resumeJsDb: ctx.nativeDb ? () => {} : undefined,
+    resumeJsDb: ctx.nativeDb
+      ? () => {
+          try {
+            ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+          } catch (e) {
+            debug(
+              `resumeJsDb: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
+            );
+          }
+        }
+      : undefined,
   };
   const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
   ctx.engineName = engineName as 'native' | 'wasm';
@@ -120,8 +139,16 @@ function setupPipeline(ctx: PipelineContext): void {
     try {
       ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
       ctx.nativeDb.initSchema();
+      // Checkpoint WAL through rusqlite so better-sqlite3 sees a clean DB
+      // with no cross-library WAL frames (#715, #717).
+      ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
     } catch (err) {
-      warn(`NativeDatabase init failed, falling back to JS: ${(err as Error).message}`);
+      warn(`NativeDatabase setup failed, falling back to JS: ${toErrorMessage(err)}`);
+      try {
+        ctx.nativeDb?.close();
+      } catch (e) {
+        debug(`setupNativeDb: close failed during fallback: ${toErrorMessage(e)}`);
+      }
       ctx.nativeDb = undefined;
     }
     // Always run JS initSchema so better-sqlite3 sees the schema —
@@ -169,6 +196,58 @@ function formatTimingResult(ctx: PipelineContext): BuildResult {
   };
 }
 
+// ── NativeDb lifecycle helpers ──────────────────────────────────────────
+
+/** Checkpoint WAL through rusqlite and close the native connection. */
+function closeNativeDb(ctx: PipelineContext, label: string): void {
+  if (!ctx.nativeDb) return;
+  try {
+    ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+  } catch (e) {
+    debug(`${label} WAL checkpoint failed: ${toErrorMessage(e)}`);
+  }
+  try {
+    ctx.nativeDb.close();
+  } catch (e) {
+    debug(`${label} nativeDb close failed: ${toErrorMessage(e)}`);
+  }
+  ctx.nativeDb = undefined;
+}
+
+/** Try to reopen the native connection for a given pipeline phase. */
+function reopenNativeDb(ctx: PipelineContext, label: string): void {
+  const native = loadNative();
+  if (!native?.NativeDatabase) return;
+  try {
+    ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+  } catch (e) {
+    debug(`reopen nativeDb for ${label} failed: ${toErrorMessage(e)}`);
+    ctx.nativeDb = undefined;
+  }
+}
+
+/** Close nativeDb and clear stale references in engineOpts. */
+function suspendNativeDb(ctx: PipelineContext, label: string): void {
+  closeNativeDb(ctx, label);
+  if (ctx.engineOpts?.nativeDb) {
+    ctx.engineOpts.nativeDb = undefined;
+  }
+}
+
+/**
+ * After native writes, reopen the JS db connection to get a fresh page cache.
+ * Rusqlite WAL truncation invalidates better-sqlite3's internal WAL index,
+ * causing SQLITE_CORRUPT on the next read (#715, #736).
+ */
+function refreshJsDb(ctx: PipelineContext): void {
+  try {
+    ctx.db.close();
+  } catch (e) {
+    debug(`refreshJsDb close failed: ${toErrorMessage(e)}`);
+  }
+  ctx.db = openDb(ctx.dbPath);
+}
+
 // ── Pipeline stages execution ───────────────────────────────────────────
 
 async function runPipelineStages(ctx: PipelineContext): Promise<void> {
@@ -179,17 +258,7 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // that use suspendJsDb/resumeJsDb WAL checkpoint pattern (#696).
   const hadNativeDb = !!ctx.nativeDb;
   if (ctx.db && ctx.nativeDb) {
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
-    // Also clear stale reference in engineOpts to prevent stages from
-    // calling methods on the closed NativeDatabase.
-    if (ctx.engineOpts?.nativeDb) {
-      ctx.engineOpts.nativeDb = undefined;
-    }
+    suspendNativeDb(ctx, 'pre-collect');
   }
 
   await collectFiles(ctx);
@@ -198,7 +267,22 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   if (ctx.earlyExit) return;
 
   await parseFiles(ctx);
+
+  // Temporarily reopen nativeDb for insertNodes — it uses the WAL checkpoint
+  // guard internally (same pattern as feature modules). Closed again before
+  // resolveImports/buildEdges which don't yet have the guard (#709).
+  if (hadNativeDb && ctx.engineName === 'native') {
+    reopenNativeDb(ctx, 'insertNodes');
+  }
+
   await insertNodes(ctx);
+
+  // Close nativeDb after insertNodes — remaining pipeline stages use JS paths.
+  if (ctx.nativeDb && ctx.db) {
+    closeNativeDb(ctx, 'post-insertNodes');
+    refreshJsDb(ctx);
+  }
+
   await resolveImports(ctx);
   await buildEdges(ctx);
   await buildStructure(ctx);
@@ -206,33 +290,23 @@ async function runPipelineStages(ctx: PipelineContext): Promise<void> {
   // Reopen nativeDb for feature modules (ast, cfg, complexity, dataflow)
   // which use suspendJsDb/resumeJsDb WAL checkpoint before native writes.
   if (hadNativeDb) {
-    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;
-        }
-      }
+    reopenNativeDb(ctx, 'analyses');
+    if (ctx.nativeDb && ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = ctx.nativeDb;
+    }
+    if (!ctx.nativeDb && ctx.engineOpts) {
+      ctx.engineOpts.nativeDb = undefined;
     }
   }
 
   await runAnalyses(ctx);
 
-  // Close nativeDb after analyses — finalize uses JS paths for setBuildMeta
-  // and closeDbPair handles cleanup. Avoids dual-connection during finalize.
+  // 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).
   if (ctx.nativeDb) {
-    try {
-      ctx.nativeDb.close();
-    } catch {
-      /* ignore close errors */
-    }
-    ctx.nativeDb = undefined;
+    refreshJsDb(ctx);
   }
 
   await finalize(ctx);
@@ -256,6 +330,257 @@ export async function buildGraph(
 
   try {
     setupPipeline(ctx);
+
+    // ── Rust orchestrator fast path (#695) ────────────────────────────
+    // When available, run the entire build pipeline in Rust with zero
+    // napi crossings (eliminates WAL dual-connection dance). Falls back
+    // to the JS pipeline on failure or when native is unavailable.
+    //
+    // Native addon 3.8.0 has a path bug: file_symbols keys are absolute
+    // paths but known_files are relative, causing zero import/call edges.
+    // Skip the orchestrator for affected versions (fixed in 3.9.0+).
+    const orchestratorBuggy = !!ctx.engineVersion && semverCompare(ctx.engineVersion, '3.8.0') <= 0;
+    const forceJs =
+      process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1' ||
+      ctx.forceFullRebuild ||
+      orchestratorBuggy ||
+      ctx.engineName !== 'native';
+    if (forceJs) {
+      const reason =
+        process.env.CODEGRAPH_FORCE_JS_PIPELINE === '1'
+          ? 'CODEGRAPH_FORCE_JS_PIPELINE=1'
+          : ctx.forceFullRebuild
+            ? 'forceFullRebuild'
+            : orchestratorBuggy
+              ? `buggy addon ${ctx.engineVersion}`
+              : `engine=${ctx.engineName}`;
+      debug(`Skipping native orchestrator: ${reason}`);
+    }
+    if (!forceJs && ctx.nativeDb?.buildGraph) {
+      try {
+        const resultJson = ctx.nativeDb.buildGraph(
+          ctx.rootDir,
+          JSON.stringify(ctx.config),
+          JSON.stringify(ctx.aliases),
+          JSON.stringify(opts),
+        );
+        const result = JSON.parse(resultJson) as {
+          phases: Record<string, number>;
+          earlyExit?: boolean;
+          nodeCount?: number;
+          edgeCount?: number;
+          fileCount?: number;
+          changedFiles?: string[];
+          changedCount?: number;
+          removedCount?: number;
+          isFullBuild?: boolean;
+        };
+
+        if (result.earlyExit) {
+          info('No changes detected');
+          closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+          return;
+        }
+
+        // Log incremental status to match JS pipeline output
+        const changed = result.changedCount ?? 0;
+        const removed = result.removedCount ?? 0;
+        if (!result.isFullBuild && (changed > 0 || removed > 0)) {
+          info(`Incremental: ${changed} changed, ${removed} removed`);
+        }
+
+        // Map Rust timing fields to the JS BuildResult format.
+        // Rust handles collect+detect+parse+insert+resolve+edges+structure+roles.
+        const p = result.phases;
+
+        // Sync build_meta so JS-side version/engine checks work on next build.
+        // Note: the Rust orchestrator also writes codegraph_version (using
+        // CARGO_PKG_VERSION). We intentionally overwrite it here with the npm
+        // package version so that the JS-side "version changed → full rebuild"
+        // detection (line ~97) compares against the authoritative JS version.
+        // The two versions are kept in lockstep by the release process.
+        setBuildMeta(ctx.db, {
+          engine: ctx.engineName,
+          engine_version: ctx.engineVersion || '',
+          codegraph_version: 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(
+          `Native build orchestrator completed: ${result.nodeCount ?? 0} nodes, ${result.edgeCount ?? 0} edges, ${result.fileCount ?? 0} files`,
+        );
+
+        // ── Run analysis phases (AST, complexity, CFG, dataflow) ──────
+        // Not yet ported to Rust. After the native orchestrator finishes,
+        // reconstruct a minimal fileSymbols map from the DB and run analyses
+        // via the JS engine (native standalone functions + WASM fallback).
+        let analysisTiming = { astMs: 0, complexityMs: 0, cfgMs: 0, dataflowMs: 0 };
+        const needsAnalysis =
+          opts.ast !== false ||
+          opts.complexity !== false ||
+          opts.cfg !== false ||
+          opts.dataflow !== false;
+
+        if (needsAnalysis) {
+          // WAL handoff: checkpoint through rusqlite, close nativeDb,
+          // reopen better-sqlite3 with a fresh page cache (#715, #736).
+          try {
+            ctx.nativeDb!.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+          } catch {
+            /* ignore checkpoint errors */
+          }
+          try {
+            ctx.nativeDb!.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.nativeDb = undefined;
+          try {
+            ctx.db.close();
+          } catch {
+            /* ignore close errors */
+          }
+          ctx.db = null!; // avoid closeDbPair operating on a stale handle
+          try {
+            ctx.db = openDb(ctx.dbPath);
+          } catch (reopenErr) {
+            warn(
+              `Failed to reopen DB for analysis after native build: ${(reopenErr as Error).message}`,
+            );
+            // Native build succeeded but we can't run analyses — return partial result
+            return {
+              phases: {
+                setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+                parseMs: +(p.parseMs ?? 0).toFixed(1),
+                insertMs: +(p.insertMs ?? 0).toFixed(1),
+                resolveMs: +(p.resolveMs ?? 0).toFixed(1),
+                edgesMs: +(p.edgesMs ?? 0).toFixed(1),
+                structureMs: +(p.structureMs ?? 0).toFixed(1),
+                rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+                astMs: 0,
+                complexityMs: 0,
+                cfgMs: 0,
+                dataflowMs: 0,
+                finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
+              },
+            };
+          }
+
+          // Reconstruct minimal fileSymbols from DB for analysis visitors.
+          // Each entry needs definitions with name/kind/line/endLine so the
+          // engine can match complexity/CFG results to the right functions.
+          // For incremental builds, scope to only the files that were parsed
+          // in this cycle (matching the JS pipeline's behaviour in run-analyses.ts).
+          const changedFiles = result.changedFiles;
+          let query =
+            'SELECT file, name, kind, line, end_line as endLine FROM nodes WHERE file IS NOT NULL';
+          const params: string[] = [];
+          if (changedFiles && changedFiles.length > 0) {
+            const placeholders = changedFiles.map(() => '?').join(',');
+            query += ` AND file IN (${placeholders})`;
+            params.push(...changedFiles);
+          }
+          query += ' ORDER BY file, line';
+          const rows = ctx.db.prepare(query).all(...params) as {
+            file: string;
+            name: string;
+            kind: string;
+            line: number;
+            endLine: number | null;
+          }[];
+
+          const fileSymbols = new Map<string, ExtractorOutput>();
+          for (const row of rows) {
+            let entry = fileSymbols.get(row.file);
+            if (!entry) {
+              entry = {
+                definitions: [],
+                calls: [],
+                imports: [],
+                classes: [],
+                exports: [],
+                typeMap: new Map(),
+              };
+              fileSymbols.set(row.file, entry);
+            }
+            entry.definitions.push({
+              name: row.name,
+              kind: row.kind as Definition['kind'],
+              line: row.line,
+              endLine: row.endLine ?? 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;
+            }
+          }
+
+          try {
+            const { runAnalyses: runAnalysesFn } = await import('../../../ast-analysis/engine.js');
+            analysisTiming = await runAnalysesFn(
+              ctx.db,
+              fileSymbols,
+              ctx.rootDir,
+              opts,
+              ctx.engineOpts,
+            );
+          } catch (err) {
+            warn(`Analysis phases failed after native build: ${toErrorMessage(err)}`);
+          }
+
+          // Close nativeDb after analyses
+          if (ctx.nativeDb) {
+            try {
+              ctx.nativeDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+            } catch {
+              /* ignore checkpoint errors */
+            }
+            try {
+              ctx.nativeDb.close();
+            } catch {
+              /* ignore close errors */
+            }
+            ctx.nativeDb = undefined;
+            if (ctx.engineOpts) ctx.engineOpts.nativeDb = undefined;
+          }
+        }
+
+        closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+        return {
+          phases: {
+            setupMs: +((p.setupMs ?? 0) + (p.collectMs ?? 0) + (p.detectMs ?? 0)).toFixed(1),
+            parseMs: +(p.parseMs ?? 0).toFixed(1),
+            insertMs: +(p.insertMs ?? 0).toFixed(1),
+            resolveMs: +(p.resolveMs ?? 0).toFixed(1),
+            edgesMs: +(p.edgesMs ?? 0).toFixed(1),
+            structureMs: +(p.structureMs ?? 0).toFixed(1),
+            rolesMs: +(p.rolesMs ?? 0).toFixed(1),
+            astMs: +(analysisTiming.astMs ?? 0).toFixed(1),
+            complexityMs: +(analysisTiming.complexityMs ?? 0).toFixed(1),
+            cfgMs: +(analysisTiming.cfgMs ?? 0).toFixed(1),
+            dataflowMs: +(analysisTiming.dataflowMs ?? 0).toFixed(1),
+            finalizeMs: +(p.finalizeMs ?? 0).toFixed(1),
+          },
+        };
+      } catch (err) {
+        warn(
+          `Native build orchestrator failed, falling back to JS pipeline: ${toErrorMessage(err)}`,
+        );
+        // Fall through to JS pipeline
+      }
+    }
+
     await runPipelineStages(ctx);
   } catch (err) {
     if (!ctx.earlyExit && ctx.db) {

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

@@ -155,6 +155,146 @@ function buildBarrelEdges(
   }
 }
 
+// ── Import edges (native engine) ────────────────────────────────────────
+
+function buildImportEdgesNative(
+  ctx: PipelineContext,
+  getNodeIdStmt: NodeIdStmt,
+  allEdgeRows: EdgeRowTuple[],
+  native: NativeAddon,
+): void {
+  const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
+
+  // 1. Build per-file input data
+  const files: Array<{
+    file: string;
+    fileNodeId: number;
+    isBarrelOnly: boolean;
+    imports: Array<{
+      source: string;
+      names: string[];
+      reexport: boolean;
+      typeOnly: boolean;
+      dynamicImport: boolean;
+      wildcardReexport: boolean;
+    }>;
+    definitionNames: string[];
+  }> = [];
+
+  // Collect all file node IDs we'll need (sources + targets)
+  const fileNodeIds: Array<{ file: string; nodeId: number }> = [];
+  const seenNodeFiles = new Set<string>();
+
+  const addFileNodeId = (relPath: string): { id: number } | undefined => {
+    if (seenNodeFiles.has(relPath)) return fileNodeRowCache.get(relPath);
+    const row = getNodeIdStmt.get(relPath, 'file', relPath, 0);
+    if (row) {
+      seenNodeFiles.add(relPath);
+      fileNodeIds.push({ file: relPath, nodeId: row.id });
+      fileNodeRowCache.set(relPath, row);
+    }
+    return row;
+  };
+  const fileNodeRowCache = new Map<string, { id: number }>();
+
+  // 2. Pre-resolve all imports and build resolved imports array.
+  // Keys use forward-slash-normalized rootDir + "/" + relPath to match the Rust
+  // lookup format (format!("{}/{}", root_dir.replace('\\', "/"), file)).
+  // On Windows, rootDir has backslashes but Rust normalizes them — the JS side
+  // must do the same or every resolve key lookup misses (#750).
+  const resolvedImports: Array<{ key: string; resolvedPath: string }> = [];
+  const fwdRootDir = rootDir.replace(/\\/g, '/');
+
+  for (const [relPath, symbols] of fileSymbols) {
+    const fileNodeRow = addFileNodeId(relPath);
+    if (!fileNodeRow) continue;
+
+    const importInfos: Array<{
+      source: string;
+      names: string[];
+      reexport: boolean;
+      typeOnly: boolean;
+      dynamicImport: boolean;
+      wildcardReexport: boolean;
+    }> = [];
+
+    for (const imp of symbols.imports) {
+      // Pre-resolve and register target file node
+      const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+      addFileNodeId(resolvedPath);
+
+      // Key matches Rust's format!("{}/{}", root_dir.replace('\\', "/"), file_input.file)
+      resolvedImports.push({ key: `${fwdRootDir}/${relPath}|${imp.source}`, resolvedPath });
+
+      importInfos.push({
+        source: imp.source,
+        names: imp.names,
+        reexport: !!imp.reexport,
+        typeOnly: !!imp.typeOnly,
+        dynamicImport: !!imp.dynamicImport,
+        wildcardReexport: !!imp.wildcardReexport,
+      });
+    }
+
+    files.push({
+      file: relPath,
+      fileNodeId: fileNodeRow.id,
+      isBarrelOnly: barrelOnlyFiles.has(relPath),
+      imports: importInfos,
+      definitionNames: symbols.definitions.map((d) => d.name),
+    });
+  }
+
+  // 4. Flatten reexportMap
+  const fileReexports: Array<{
+    file: string;
+    reexports: Array<{
+      source: string;
+      names: string[];
+      wildcardReexport: boolean;
+    }>;
+  }> = [];
+  if (ctx.reexportMap) {
+    for (const [file, entries] of ctx.reexportMap) {
+      const reexports = (
+        entries as Array<{ source: string; names: string[]; wildcardReexport: boolean }>
+      ).map((re) => ({
+        source: re.source,
+        names: re.names,
+        wildcardReexport: !!re.wildcardReexport,
+      }));
+      fileReexports.push({ file, reexports });
+
+      // Register reexport target files for node ID lookup
+      for (const re of reexports) {
+        addFileNodeId(re.source);
+      }
+    }
+  }
+
+  // 5. Compute barrel file list
+  const barrelFiles: string[] = [];
+  for (const [relPath] of fileSymbols) {
+    if (isBarrelFile(ctx, relPath)) {
+      barrelFiles.push(relPath);
+    }
+  }
+
+  // 6. Call native
+  const nativeEdges = native.buildImportEdges!(
+    files,
+    resolvedImports,
+    fileReexports,
+    fileNodeIds,
+    barrelFiles,
+    rootDir,
+  ) as NativeEdge[];
+
+  for (const e of nativeEdges) {
+    allEdgeRows.push([e.sourceId, e.targetId, e.kind, e.confidence, e.dynamic]);
+  }
+}
+
 // ── Call edges (native engine) ──────────────────────────────────────────
 
 function buildCallEdgesNative(
@@ -594,7 +734,28 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
       }
     }
 
-    buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+    // Skip native import-edge path for small incremental builds (≤3 files):
+    // napi-rs marshaling overhead exceeds computation savings.
+    const useNativeImportEdges =
+      native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+    if (useNativeImportEdges) {
+      const beforeLen = allEdgeRows.length;
+      buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
+      // Fallback: if native produced 0 import edges but there are imports to
+      // process, the native binary may have a key-format mismatch (e.g. Windows
+      // path separators — #750).  Retry with the JS implementation.
+      // NOTE: This also fires for codebases where every import targets an
+      // external package (npm deps) that the resolver intentionally skips.
+      // In that case the JS path resolves zero edges too, so the only cost
+      // is the redundant JS traversal — no correctness impact.
+      const hasImports = [...ctx.fileSymbols.values()].some((s) => s.imports.length > 0);
+      if (allEdgeRows.length === beforeLen && hasImports) {
+        debug('Native buildImportEdges produced 0 edges — falling back to JS');
+        buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+      }
+    } else {
+      buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+    }
 
     // Skip native call-edge path for small incremental builds (≤3 files):
     // napi-rs marshaling overhead for allNodes exceeds computation savings.