@optave/codegraph 3.4.0 → 3.5.0

package/src/domain/analysis/module-map.ts

@@ -380,11 +380,7 @@ export function moduleMapData(customDbPath: string, limit = 20, opts: { noTests?
   }
 }
 
-export function statsData(
-  customDbPath: string,
-  // biome-ignore lint/suspicious/noExplicitAny: config shape is dynamic
-  opts: { noTests?: boolean; config?: any } = {},
-) {
+export function statsData(customDbPath: string, opts: { noTests?: boolean; config?: any } = {}) {
   const db = openReadonlyOrFail(customDbPath);
   try {
     const noTests = opts.noTests || false;

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

@@ -4,14 +4,15 @@
  * Each stage reads what it needs and writes what it produces.
  * This replaces the closure-captured locals in the old monolithic buildGraph().
  */
-import type BetterSqlite3 from 'better-sqlite3';
 import type {
+  BetterSqlite3Database,
   BuildGraphOpts,
   CodegraphConfig,
   EngineOpts,
   ExtractorOutput,
   FileToParse,
   MetadataUpdate,
+  NativeDatabase,
   NodeRow,
   ParseChange,
   PathAliases,
@@ -20,7 +21,7 @@ import type {
 export class PipelineContext {
   // ── Inputs (set during setup) ──────────────────────────────────────
   rootDir!: string;
-  db!: BetterSqlite3.Database;
+  db!: BetterSqlite3Database;
   dbPath!: string;
   config!: CodegraphConfig;
   opts!: BuildGraphOpts;
@@ -31,6 +32,7 @@ export class PipelineContext {
   incremental!: boolean;
   forceFullRebuild: boolean = false;
   schemaVersion!: number;
+  nativeDb?: NativeDatabase;
 
   // ── File collection (set by collectFiles stage) ────────────────────
   allFiles!: string[];

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

@@ -6,11 +6,15 @@
 import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import type BetterSqlite3 from 'better-sqlite3';
 import { purgeFilesData } from '../../../db/index.js';
 import { warn } from '../../../infrastructure/logger.js';
 import { EXTENSIONS, IGNORE_DIRS } from '../../../shared/constants.js';
-import type { BetterSqlite3Database, CodegraphConfig, PathAliases } from '../../../types.js';
+import type {
+  BetterSqlite3Database,
+  CodegraphConfig,
+  PathAliases,
+  SqliteStatement,
+} from '../../../types.js';
 
 export const BUILTIN_RECEIVERS: Set<string> = new Set([
   'console',
@@ -132,8 +136,7 @@ export function loadPathAliases(rootDir: string): PathAliases {
     try {
       const raw = fs
         .readFileSync(configPath, 'utf-8')
-        .replace(/\/\/.*$/gm, '')
-        .replace(/\/\*[\s\S]*?\*\//g, '')
+        .replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\/|\/\/.*$/gm, (_, str) => str ?? '')
         .replace(/,\s*([\]}])/g, '$1');
       const config = JSON.parse(raw) as {
         compilerOptions?: { baseUrl?: string; paths?: Record<string, string[]> };
@@ -199,7 +202,7 @@ export function readFileSafe(filePath: string, retries: number = 2): string {
  * Purge all graph data for the specified files.
  */
 export function purgeFilesFromGraph(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   files: string[],
   options: Record<string, unknown> = {},
 ): void {
@@ -211,10 +214,10 @@ export function purgeFilesFromGraph(
 const BATCH_CHUNK = 500;
 
 // Statement caches keyed by chunk size — avoids recompiling for every batch.
-const nodeStmtCache = new WeakMap<BetterSqlite3.Database, Map<number, BetterSqlite3.Statement>>();
-const edgeStmtCache = new WeakMap<BetterSqlite3.Database, Map<number, BetterSqlite3.Statement>>();
+const nodeStmtCache = new WeakMap<BetterSqlite3Database, Map<number, SqliteStatement>>();
+const edgeStmtCache = new WeakMap<BetterSqlite3Database, Map<number, SqliteStatement>>();
 
-function getNodeStmt(db: BetterSqlite3.Database, chunkSize: number): BetterSqlite3.Statement {
+function getNodeStmt(db: BetterSqlite3Database, chunkSize: number): SqliteStatement {
   let cache = nodeStmtCache.get(db);
   if (!cache) {
     cache = new Map();
@@ -232,7 +235,7 @@ function getNodeStmt(db: BetterSqlite3.Database, chunkSize: number): BetterSqlit
   return stmt;
 }
 
-function getEdgeStmt(db: BetterSqlite3.Database, chunkSize: number): BetterSqlite3.Statement {
+function getEdgeStmt(db: BetterSqlite3Database, chunkSize: number): SqliteStatement {
   let cache = edgeStmtCache.get(db);
   if (!cache) {
     cache = new Map();
@@ -254,7 +257,7 @@ function getEdgeStmt(db: BetterSqlite3.Database, chunkSize: number): BetterSqlit
  * Batch-insert node rows via multi-value INSERT statements.
  * Each row: [name, kind, file, line, end_line, parent_id, qualified_name, scope, visibility]
  */
-export function batchInsertNodes(db: BetterSqlite3.Database, rows: unknown[][]): void {
+export function batchInsertNodes(db: BetterSqlite3Database, rows: unknown[][]): void {
   if (!rows.length) return;
   for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
     const end = Math.min(i + BATCH_CHUNK, rows.length);
@@ -273,7 +276,7 @@ export function batchInsertNodes(db: BetterSqlite3.Database, rows: unknown[][]):
  * Batch-insert edge rows via multi-value INSERT statements.
  * Each row: [source_id, target_id, kind, confidence, dynamic]
  */
-export function batchInsertEdges(db: BetterSqlite3.Database, rows: unknown[][]): void {
+export function batchInsertEdges(db: BetterSqlite3Database, rows: unknown[][]): void {
   if (!rows.length) return;
   for (let i = 0; i < rows.length; i += BATCH_CHUNK) {
     const end = Math.min(i + BATCH_CHUNK, rows.length);

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

@@ -9,11 +9,16 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
-import type BetterSqlite3 from 'better-sqlite3';
 import { bulkNodeIdsByFile } from '../../../db/index.js';
 import { warn } from '../../../infrastructure/logger.js';
 import { normalizePath } from '../../../shared/constants.js';
-import type { EngineOpts, ExtractorOutput, PathAliases } from '../../../types.js';
+import type {
+  BetterSqlite3Database,
+  EngineOpts,
+  ExtractorOutput,
+  PathAliases,
+  SqliteStatement,
+} from '../../../types.js';
 import { parseFileIncremental } from '../../parser.js';
 import { computeConfidence, resolveImportPath } from '../resolve.js';
 import { BUILTIN_RECEIVERS, readFileSafe } from './helpers.js';
@@ -64,7 +69,7 @@ function insertFileNodes(stmts: IncrementalStmts, relPath: string, symbols: Extr
 // ── Containment edges ──────────────────────────────────────────────────
 
 function buildContainmentEdges(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   stmts: IncrementalStmts,
   relPath: string,
   symbols: ExtractorOutput,
@@ -101,13 +106,13 @@ function buildContainmentEdges(
 // ── Reverse-dep cascade ────────────────────────────────────────────────
 
 // Lazily-cached prepared statements for reverse-dep operations
-let _revDepDb: BetterSqlite3.Database | null = null;
-let _findRevDepsStmt: BetterSqlite3.Statement | null = null;
-let _deleteOutEdgesStmt: BetterSqlite3.Statement | null = null;
+let _revDepDb: BetterSqlite3Database | null = null;
+let _findRevDepsStmt: SqliteStatement | null = null;
+let _deleteOutEdgesStmt: SqliteStatement | null = null;
 
-function getRevDepStmts(db: BetterSqlite3.Database): {
-  findRevDepsStmt: BetterSqlite3.Statement;
-  deleteOutEdgesStmt: BetterSqlite3.Statement;
+function getRevDepStmts(db: BetterSqlite3Database): {
+  findRevDepsStmt: SqliteStatement;
+  deleteOutEdgesStmt: SqliteStatement;
 } {
   if (_revDepDb !== db) {
     _revDepDb = db;
@@ -127,12 +132,12 @@ function getRevDepStmts(db: BetterSqlite3.Database): {
   };
 }
 
-function findReverseDeps(db: BetterSqlite3.Database, relPath: string): string[] {
+function findReverseDeps(db: BetterSqlite3Database, relPath: string): string[] {
   const { findRevDepsStmt } = getRevDepStmts(db);
   return (findRevDepsStmt.all(relPath, relPath) as Array<{ file: string }>).map((r) => r.file);
 }
 
-function deleteOutgoingEdges(db: BetterSqlite3.Database, relPath: string): void {
+function deleteOutgoingEdges(db: BetterSqlite3Database, relPath: string): void {
   const { deleteOutEdgesStmt } = getRevDepStmts(db);
   deleteOutEdgesStmt.run(relPath);
 }
@@ -157,7 +162,7 @@ async function parseReverseDep(
 }
 
 function rebuildReverseDepEdges(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   rootDir: string,
   depRelPath: string,
   symbols: ExtractorOutput,
@@ -187,7 +192,7 @@ function rebuildReverseDepEdges(
 // ── Directory containment edges ────────────────────────────────────────
 
 function rebuildDirContainment(
-  _db: BetterSqlite3.Database,
+  _db: BetterSqlite3Database,
   stmts: IncrementalStmts,
   relPath: string,
 ): number {
@@ -204,7 +209,7 @@ function rebuildDirContainment(
 
 // ── Ancillary table cleanup ────────────────────────────────────────────
 
-function purgeAncillaryData(db: BetterSqlite3.Database, relPath: string): void {
+function purgeAncillaryData(db: BetterSqlite3Database, relPath: string): void {
   const tryExec = (sql: string, ...args: string[]): void => {
     try {
       db.prepare(sql).run(...args);
@@ -239,15 +244,15 @@ function purgeAncillaryData(db: BetterSqlite3.Database, relPath: string): void {
 // ── Import edge building ────────────────────────────────────────────────
 
 // Lazily-cached prepared statements for barrel resolution (avoid re-preparing in hot loops)
-let _barrelDb: BetterSqlite3.Database | null = null;
-let _isBarrelStmt: BetterSqlite3.Statement | null = null;
-let _reexportTargetsStmt: BetterSqlite3.Statement | null = null;
-let _hasDefStmt: BetterSqlite3.Statement | null = null;
-
-function getBarrelStmts(db: BetterSqlite3.Database): {
-  isBarrelStmt: BetterSqlite3.Statement;
-  reexportTargetsStmt: BetterSqlite3.Statement;
-  hasDefStmt: BetterSqlite3.Statement;
+let _barrelDb: BetterSqlite3Database | null = null;
+let _isBarrelStmt: SqliteStatement | null = null;
+let _reexportTargetsStmt: SqliteStatement | null = null;
+let _hasDefStmt: SqliteStatement | null = null;
+
+function getBarrelStmts(db: BetterSqlite3Database): {
+  isBarrelStmt: SqliteStatement;
+  reexportTargetsStmt: SqliteStatement;
+  hasDefStmt: SqliteStatement;
 } {
   if (_barrelDb !== db) {
     _barrelDb = db;
@@ -273,14 +278,14 @@ function getBarrelStmts(db: BetterSqlite3.Database): {
   };
 }
 
-function isBarrelFile(db: BetterSqlite3.Database, relPath: string): boolean {
+function isBarrelFile(db: BetterSqlite3Database, relPath: string): boolean {
   const { isBarrelStmt } = getBarrelStmts(db);
   const reexportCount = (isBarrelStmt.get(relPath) as { c: number } | undefined)?.c;
   return (reexportCount || 0) > 0;
 }
 
 function resolveBarrelTarget(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   barrelPath: string,
   symbolName: string,
   visited: Set<string> = new Set(),
@@ -312,7 +317,7 @@ function resolveBarrelTarget(
  * Shared by buildImportEdges (primary file) and Pass 2 of the reverse-dep cascade.
  */
 function resolveBarrelImportEdges(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   stmts: IncrementalStmts,
   fileNodeId: number,
   resolvedPath: string,
@@ -344,7 +349,7 @@ function buildImportEdges(
   rootDir: string,
   fileNodeId: number,
   aliases: PathAliases,
-  db: BetterSqlite3.Database | null,
+  db: BetterSqlite3Database | null,
 ): number {
   let edgesAdded = 0;
   for (const imp of symbols.imports) {
@@ -504,7 +509,7 @@ function buildCallEdges(
  * Parse a single file and update the database incrementally.
  */
 export async function rebuildFile(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   rootDir: string,
   filePath: string,
   stmts: IncrementalStmts,

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

@@ -6,9 +6,11 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDb, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
+import { closeDbPair, getBuildMeta, initSchema, MIGRATIONS, openDb } from '../../../db/index.js';
 import { detectWorkspaces, loadConfig } from '../../../infrastructure/config.js';
 import { info, warn } from '../../../infrastructure/logger.js';
+import { loadNative } from '../../../infrastructure/native.js';
+import { CODEGRAPH_VERSION } from '../../../shared/version.js';
 import type { BuildGraphOpts, BuildResult } from '../../../types.js';
 import { getActiveEngine } from '../../parser.js';
 import { setWorkspaces } from '../resolve.js';
@@ -32,6 +34,7 @@ function initializeEngine(ctx: PipelineContext): void {
     engine: ctx.opts.engine || 'auto',
     dataflow: ctx.opts.dataflow !== false,
     ast: ctx.opts.ast !== false,
+    nativeDb: ctx.nativeDb,
   };
   const { name: engineName, version: engineVersion } = getActiveEngine(ctx.engineOpts);
   ctx.engineName = engineName as 'native' | 'wasm';
@@ -45,18 +48,29 @@ function checkEngineSchemaMismatch(ctx: PipelineContext): void {
   ctx.forceFullRebuild = false;
   if (!ctx.incremental) return;
 
-  const prevEngine = getBuildMeta(ctx.db, 'engine');
+  // Route metadata reads through NativeDatabase when available (Phase 6.13)
+  const meta = (key: string): string | null =>
+    ctx.nativeDb ? ctx.nativeDb.getBuildMeta(key) : getBuildMeta(ctx.db, key);
+
+  const prevEngine = meta('engine');
   if (prevEngine && prevEngine !== ctx.engineName) {
     info(`Engine changed (${prevEngine} → ${ctx.engineName}), promoting to full rebuild.`);
     ctx.forceFullRebuild = true;
   }
-  const prevSchema = getBuildMeta(ctx.db, 'schema_version');
+  const prevSchema = meta('schema_version');
   if (prevSchema && Number(prevSchema) !== ctx.schemaVersion) {
     info(
       `Schema version changed (${prevSchema} → ${ctx.schemaVersion}), promoting to full rebuild.`,
     );
     ctx.forceFullRebuild = true;
   }
+  const prevVersion = meta('codegraph_version');
+  if (prevVersion && prevVersion !== CODEGRAPH_VERSION) {
+    info(
+      `Codegraph version changed (${prevVersion} → ${CODEGRAPH_VERSION}), promoting to full rebuild.`,
+    );
+    ctx.forceFullRebuild = true;
+  }
 }
 
 function loadAliases(ctx: PipelineContext): void {
@@ -83,7 +97,23 @@ function setupPipeline(ctx: PipelineContext): void {
   ctx.rootDir = path.resolve(ctx.rootDir);
   ctx.dbPath = path.join(ctx.rootDir, '.codegraph', 'graph.db');
   ctx.db = openDb(ctx.dbPath);
-  initSchema(ctx.db);
+
+  // Use NativeDatabase for schema init when native engine is available (Phase 6.13).
+  // better-sqlite3 (ctx.db) is still always opened — needed for queries and stages
+  // that haven't been migrated to rusqlite yet.
+  const native = loadNative();
+  if (native?.NativeDatabase) {
+    try {
+      ctx.nativeDb = native.NativeDatabase.openReadWrite(ctx.dbPath);
+      ctx.nativeDb.initSchema();
+    } catch (err) {
+      warn(`NativeDatabase init failed, falling back to JS: ${(err as Error).message}`);
+      ctx.nativeDb = undefined;
+      initSchema(ctx.db);
+    }
+  } else {
+    initSchema(ctx.db);
+  }
 
   ctx.config = loadConfig(ctx.rootDir);
   ctx.incremental =
@@ -160,7 +190,9 @@ export async function buildGraph(
     setupPipeline(ctx);
     await runPipelineStages(ctx);
   } catch (err) {
-    if (!ctx.earlyExit && ctx.db) closeDb(ctx.db);
+    if (!ctx.earlyExit && ctx.db) {
+      closeDbPair({ db: ctx.db, nativeDb: ctx.nativeDb });
+    }
     throw err;
   }
 

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

@@ -6,19 +6,19 @@
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import type BetterSqlite3 from 'better-sqlite3';
-import { getNodeId } from '../../../../db/index.js';
-import { loadNative } from '../../../../infrastructure/native.js';
+import { getNodeId } from '#db/index.js';
+import { debug } from '#infrastructure/logger.js';
+import { loadNative } from '#infrastructure/native.js';
 import type {
+  BetterSqlite3Database,
   Call,
   ClassRelation,
-  Definition,
   ExtractorOutput,
   Import,
   NativeAddon,
   NodeRow,
   TypeMapEntry,
-} from '../../../../types.js';
+} from '#types';
 import { computeConfidence } from '../../resolve.js';
 import type { PipelineContext } from '../context.js';
 import { BUILTIN_RECEIVERS, batchInsertEdges } from '../helpers.js';
@@ -69,7 +69,7 @@ interface NormalizedTypeEntry {
 
 // ── Node lookup setup ───────────────────────────────────────────────────
 
-function makeGetNodeIdStmt(db: BetterSqlite3.Database): NodeIdStmt {
+function makeGetNodeIdStmt(db: BetterSqlite3Database): NodeIdStmt {
   return {
     get: (name: string, kind: string, file: string, line: number) => {
       const id = getNodeId(db, name, kind, file, line);
@@ -102,12 +102,15 @@ function buildImportEdges(
   const { fileSymbols, barrelOnlyFiles, rootDir } = ctx;
 
   for (const [relPath, symbols] of fileSymbols) {
-    if (barrelOnlyFiles.has(relPath)) continue;
+    const isBarrelOnly = barrelOnlyFiles.has(relPath);
     const fileNodeRow = getNodeIdStmt.get(relPath, 'file', relPath, 0);
     if (!fileNodeRow) continue;
     const fileNodeId = fileNodeRow.id;
 
     for (const imp of symbols.imports) {
+      // Barrel-only files: only emit reexport edges, skip regular imports
+      if (isBarrelOnly && !imp.reexport) continue;
+
       const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
       const targetRow = getNodeIdStmt.get(resolvedPath, 'file', resolvedPath, 0);
       if (!targetRow) continue;
@@ -559,33 +562,141 @@ function buildClassHierarchyEdges(
 
 // ── Main entry point ────────────────────────────────────────────────────
 
+/**
+ * For small incremental builds (≤5 changed files on a large codebase), scope
+ * the node loading query to only files that are relevant: changed files +
+ * their import targets. Falls back to loading ALL nodes for full builds or
+ * larger incremental changes.
+ */
+function loadNodes(ctx: PipelineContext): { rows: QueryNodeRow[]; scoped: boolean } {
+  const { db, fileSymbols, isFullBuild, batchResolved } = ctx;
+  const nodeKindFilter = `kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`;
+
+  // Gate: only scope for small incremental on large codebases
+  if (!isFullBuild && fileSymbols.size <= 5) {
+    const existingFileCount = (
+      db.prepare("SELECT COUNT(*) as c FROM nodes WHERE kind = 'file'").get() as { c: number }
+    ).c;
+    if (existingFileCount > 20) {
+      // Collect relevant files: changed files + their import targets
+      const relevantFiles = new Set<string>(fileSymbols.keys());
+      if (batchResolved) {
+        for (const resolvedPath of batchResolved.values()) {
+          relevantFiles.add(resolvedPath);
+        }
+      }
+      // Also add barrel-only files
+      for (const barrelPath of ctx.barrelOnlyFiles) {
+        relevantFiles.add(barrelPath);
+      }
+
+      const placeholders = [...relevantFiles].map(() => '?').join(',');
+      const rows = db
+        .prepare(
+          `SELECT id, name, kind, file, line FROM nodes WHERE ${nodeKindFilter} AND file IN (${placeholders})`,
+        )
+        .all(...relevantFiles) as QueryNodeRow[];
+      return { rows, scoped: true };
+    }
+  }
+
+  const rows = db
+    .prepare(`SELECT id, name, kind, file, line FROM nodes WHERE ${nodeKindFilter}`)
+    .all() as QueryNodeRow[];
+  return { rows, scoped: false };
+}
+
+/**
+ * For scoped node loading, patch nodesByName.get with a lazy SQL fallback
+ * so global name-only lookups (resolveByMethodOrGlobal, supplementReceiverEdges)
+ * can still find nodes outside the scoped set.
+ */
+function addLazyFallback(ctx: PipelineContext, scopedLoad: boolean): void {
+  if (!scopedLoad) return;
+  const { db } = ctx;
+  const fallbackStmt = db.prepare(
+    `SELECT id, name, kind, file, line FROM nodes WHERE name = ? AND kind != 'file'`,
+  );
+  const originalGet = ctx.nodesByName.get.bind(ctx.nodesByName);
+  ctx.nodesByName.get = (name: string) => {
+    const result = originalGet(name);
+    if (result !== undefined) return result;
+    const rows = fallbackStmt.all(name) as unknown as NodeRow[];
+    if (rows.length > 0) {
+      ctx.nodesByName.set(name, rows);
+      return rows;
+    }
+    return undefined;
+  };
+}
+
 export async function buildEdges(ctx: PipelineContext): Promise<void> {
   const { db, engineName } = ctx;
 
   const getNodeIdStmt = makeGetNodeIdStmt(db);
 
-  const allNodes = db
-    .prepare(
-      `SELECT id, name, kind, file, line FROM nodes WHERE kind IN ('function','method','class','interface','struct','type','module','enum','trait','record','constant')`,
-    )
-    .all() as QueryNodeRow[];
-  setupNodeLookups(ctx, allNodes);
+  const { rows: allNodesBefore, scoped: scopedLoad } = loadNodes(ctx);
+  setupNodeLookups(ctx, allNodesBefore);
+  addLazyFallback(ctx, scopedLoad);
 
   const t0 = performance.now();
-  const buildEdgesTx = db.transaction(() => {
-    const allEdgeRows: EdgeRowTuple[] = [];
+  const native = engineName === 'native' ? loadNative() : null;
+
+  // Phase 1: Compute edges inside a better-sqlite3 transaction.
+  // Barrel-edge deletion lives here so that the JS path (which also inserts
+  // edges in this transaction) keeps deletion + insertion atomic.
+  // When using the native rusqlite path, insertion happens in Phase 2 on a
+  // separate connection — a crash between Phase 1 and Phase 2 would leave
+  // barrel edges missing until the next incremental rebuild re-creates them.
+  const allEdgeRows: EdgeRowTuple[] = [];
+  const computeEdgesTx = db.transaction(() => {
+    if (ctx.barrelOnlyFiles.size > 0) {
+      const deleteOutgoingEdges = db.prepare(
+        'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+      );
+      for (const relPath of ctx.barrelOnlyFiles) {
+        deleteOutgoingEdges.run(relPath);
+      }
+    }
 
     buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
 
-    const native = engineName === 'native' ? loadNative() : null;
-    if (native?.buildCallEdges) {
-      buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodes, native);
+    // Skip native call-edge path for small incremental builds (≤3 files):
+    // napi-rs marshaling overhead for allNodes exceeds computation savings.
+    const useNativeCallEdges =
+      native?.buildCallEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
+    if (useNativeCallEdges) {
+      buildCallEdgesNative(ctx, getNodeIdStmt, allEdgeRows, allNodesBefore, native!);
     } else {
       buildCallEdgesJS(ctx, getNodeIdStmt, allEdgeRows);
     }
 
-    batchInsertEdges(db, allEdgeRows);
+    // When using native edge insert, skip JS insert here — do it after tx commits.
+    // Otherwise insert edges within this transaction for atomicity.
+    const useNativeEdgeInsert = !!ctx.nativeDb?.bulkInsertEdges;
+    if (!useNativeEdgeInsert) {
+      batchInsertEdges(db, allEdgeRows);
+    }
   });
-  buildEdgesTx();
+  computeEdgesTx();
+
+  // Phase 2: Native rusqlite bulk insert (outside better-sqlite3 transaction
+  // to avoid SQLITE_BUSY contention). Uses NativeDatabase persistent connection.
+  // Standalone napi functions were removed in 6.17.
+  if (ctx.nativeDb?.bulkInsertEdges && allEdgeRows.length > 0) {
+    const nativeEdges = allEdgeRows.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) {
+      debug('Native bulkInsertEdges failed — falling back to JS batchInsertEdges');
+      batchInsertEdges(db, allEdgeRows);
+    }
+  }
+
   ctx.timing.edgesMs = performance.now() - t0;
 }