fix(cfg): avoid dual-connection WAL conflict in native bulkInsertCfg (#719)

* fix(cfg): move delete-before-insert into native bulkInsertCfg to avoid WAL conflict

The native bulk insert path called deleteCfgForNode via the JS
better-sqlite3 connection, then suspended the JS DB and inserted via
the native rusqlite connection. This dual-connection pattern caused a
WAL conflict that left cfg_blocks empty after builds.

Move the DELETE statements into the Rust bulk_insert_cfg function so
all operations happen on a single (native) connection within one
transaction. The JS side now sends entries with empty blocks/edges for
nodes that need deletion only.

* fix(cfg): disable native bulk CFG path to avoid dual-connection WAL conflict

The v3.6.0 native binary introduced bulkInsertCfg, but the CFG path
requires delete-before-insert where deletes go through JS (better-sqlite3)
and inserts through native (rusqlite), creating a WAL conflict that
silently drops all CFG data. Disable the native bulk path so the proven
JS-only persistNativeFileCfg handles both operations on a single connection.

The Rust-side fix (previous commit) will allow re-enabling the native path
once the next binary is published with delete logic inside bulkInsertCfg.

* fix(cfg): prefix unused engineOpts param with underscore

* fix: propagate CFG delete errors instead of silently swallowing (#719)

Author: carlos-alm

crates/codegraph-core/src/native_db.rs

@@ -858,7 +858,24 @@ impl NativeDatabase {
             )
             .map_err(|e| napi::Error::from_reason(format!("cfg_edges prepare failed: {e}")))?;
 
+            let mut del_edges = tx.prepare(
+                "DELETE FROM cfg_edges WHERE function_node_id = ?1",
+            )
+            .map_err(|e| napi::Error::from_reason(format!("cfg_edges del prepare failed: {e}")))?;
+            let mut del_blocks = tx.prepare(
+                "DELETE FROM cfg_blocks WHERE function_node_id = ?1",
+            )
+            .map_err(|e| napi::Error::from_reason(format!("cfg_blocks del prepare failed: {e}")))?;
+
             for entry in &entries {
+                // Delete existing CFG data for this node so the caller doesn't
+                // need to perform deletes on a separate (JS) connection, which
+                // would cause a WAL conflict with the native connection.
+                del_edges.execute(params![entry.node_id])
+                    .map_err(|e| napi::Error::from_reason(format!("cfg_edges delete failed: {e}")))?;
+                del_blocks.execute(params![entry.node_id])
+                    .map_err(|e| napi::Error::from_reason(format!("cfg_blocks delete failed: {e}")))?;
+
                 let mut block_db_ids: std::collections::HashMap<u32, i64> =
                     std::collections::HashMap::new();
                 for block in &entry.blocks {

src/features/cfg.ts

@@ -369,7 +369,7 @@ export async function buildCFGData(
   db: BetterSqlite3Database,
   fileSymbols: Map<string, FileSymbols>,
   rootDir: string,
-  engineOpts?: {
+  _engineOpts?: {
     nativeDb?: { bulkInsertCfg?(entries: Array<Record<string, unknown>>): number };
     suspendJsDb?: () => void;
     resumeJsDb?: () => void;
@@ -379,56 +379,11 @@ export async function buildCFGData(
   // skip WASM parser init, tree parsing, and JS visitor entirely — just persist.
   const allNative = allCfgNative(fileSymbols);
 
-  // ── Native bulk-insert fast path ──────────────────────────────────────
-  const nativeDb = engineOpts?.nativeDb;
-  if (allNative && nativeDb?.bulkInsertCfg) {
-    const entries: Array<Record<string, unknown>> = [];
-
-    for (const [relPath, symbols] of fileSymbols) {
-      const ext = path.extname(relPath).toLowerCase();
-      if (!CFG_EXTENSIONS.has(ext)) continue;
-
-      for (const def of symbols.definitions) {
-        if (def.kind !== 'function' && def.kind !== 'method') continue;
-        if (!def.line) continue;
-
-        const nodeId = getFunctionNodeId(db, def.name, relPath, def.line);
-        if (!nodeId) continue;
-
-        deleteCfgForNode(db, nodeId);
-        if (!def.cfg?.blocks?.length) continue;
-
-        const cfg = def.cfg as unknown as { blocks: CfgBuildBlock[]; edges: CfgBuildEdge[] };
-        entries.push({
-          nodeId,
-          blocks: cfg.blocks.map((b) => ({
-            index: b.index,
-            blockType: b.type,
-            startLine: b.startLine ?? null,
-            endLine: b.endLine ?? null,
-            label: b.label ?? null,
-          })),
-          edges: cfg.edges.map((e) => ({
-            sourceIndex: e.sourceIndex,
-            targetIndex: e.targetIndex,
-            kind: e.kind,
-          })),
-        });
-      }
-    }
-
-    if (entries.length > 0) {
-      let inserted: number;
-      try {
-        engineOpts?.suspendJsDb?.();
-        inserted = nativeDb.bulkInsertCfg(entries);
-      } finally {
-        engineOpts?.resumeJsDb?.();
-      }
-      info(`CFG (native bulk): ${inserted} blocks across ${entries.length} functions`);
-    }
-    return;
-  }
+  // NOTE: nativeDb.bulkInsertCfg is intentionally NOT used here.
+  // The CFG path requires delete-before-insert (deleteCfgForNode) which creates
+  // a dual-connection WAL conflict when deletes go through JS (better-sqlite3)
+  // and inserts go through native (rusqlite). The JS-only persistNativeFileCfg
+  // path below handles both on a single connection safely.
 
   const extToLang = buildExtToLangMap();
   let parsers: unknown = null;