optave-codegraph 3.13.0

package/dist/domain/graph/builder/stages/finalize.js

@@ -0,0 +1,274 @@
+/**
+ * Stage: finalize
+ *
+ * WASM cleanup, stats logging, drift detection, build metadata, registry, journal.
+ */
+import fs from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { closeDbPair, closeDbPairDeferred, getBuildMeta, setBuildMeta, } from '../../../../db/index.js';
+import { computeConfigHash } from '../../../../infrastructure/config.js';
+import { debug, info, warn } from '../../../../infrastructure/logger.js';
+import { CODEGRAPH_VERSION } from '../../../../shared/version.js';
+import { writeJournalHeader } from '../../journal.js';
+/** Release cached WASM parse trees to free memory. */
+function releaseWasmTrees(allSymbols) {
+    for (const [, symbols] of allSymbols) {
+        const tree = symbols._tree;
+        if (tree && typeof tree.delete === 'function') {
+            try {
+                tree.delete();
+            }
+            catch {
+                /* ignore cleanup errors */
+            }
+        }
+        symbols._tree = undefined;
+        symbols._langId = undefined;
+    }
+}
+/**
+ * Detect significant drift between current and previous node/edge counts.
+ * Skipped for small incremental changes where count fluctuation is expected.
+ */
+function detectIncrementalDrift(ctx, nodeCount, actualEdgeCount) {
+    const { db, allSymbols, config } = ctx;
+    const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
+    if (ctx.isFullBuild || allSymbols.size <= 3)
+        return;
+    const prevNodes = useNativeDb
+        ? ctx.nativeDb.getBuildMeta('node_count')
+        : getBuildMeta(db, 'node_count');
+    const prevEdges = useNativeDb
+        ? ctx.nativeDb.getBuildMeta('edge_count')
+        : getBuildMeta(db, 'edge_count');
+    if (!prevNodes || !prevEdges)
+        return;
+    const prevN = Number(prevNodes);
+    const prevE = Number(prevEdges);
+    if (prevN <= 0)
+        return;
+    const nodeDrift = Math.abs(nodeCount - prevN) / prevN;
+    const edgeDrift = prevE > 0 ? Math.abs(actualEdgeCount - prevE) / prevE : 0;
+    const driftThreshold = config.build?.driftThreshold ?? 0.2;
+    if (nodeDrift > driftThreshold || edgeDrift > driftThreshold) {
+        warn(`Incremental build diverged significantly from previous counts (nodes: ${prevN}\u2192${nodeCount} [${(nodeDrift * 100).toFixed(1)}%], edges: ${prevE}\u2192${actualEdgeCount} [${(edgeDrift * 100).toFixed(1)}%], threshold: ${(driftThreshold * 100).toFixed(0)}%). Consider rebuilding with --no-incremental.`);
+    }
+}
+/**
+ * Persist build metadata (engine, version, counts, timestamp).
+ * Skipped for small incremental builds to avoid WAL fsync cost.
+ */
+function persistBuildMetadata(ctx, nodeCount, actualEdgeCount, buildNow) {
+    const useNativeDb = ctx.engineName === 'native' && !!ctx.nativeDb;
+    if (!ctx.isFullBuild && ctx.allSymbols.size <= 3)
+        return;
+    // When the native engine is active, persist the binary's CARGO_PKG_VERSION
+    // (ctx.nativeBinaryVersion). The Rust orchestrator's check_version_mismatch
+    // compares against that exact value, so writing the platform package.json
+    // version (ctx.engineVersion) — which can drift from the binary in CI
+    // hot-swap flows (#1066) — would force every subsequent native build to
+    // be a full rebuild.
+    const codeVersionToWrite = ctx.engineName === 'native' && ctx.nativeBinaryVersion
+        ? ctx.nativeBinaryVersion
+        : CODEGRAPH_VERSION;
+    // Persist the repo root so downstream commands (e.g. `codegraph embed`)
+    // can resolve relative file paths regardless of the invoking cwd.
+    // Use realpathSync (symlink-resolving) to match the Rust engine's
+    // std::fs::canonicalize — otherwise the JS write here would overwrite the
+    // canonical path Rust wrote for native full builds and could re-introduce
+    // a non-canonical path when the project root is behind a symlink.
+    const resolvedRootDir = path.resolve(ctx.rootDir);
+    let rootDirToWrite = resolvedRootDir;
+    try {
+        rootDirToWrite = fs.realpathSync(resolvedRootDir);
+    }
+    catch {
+        /* realpath can fail (e.g. path no longer exists); fall back to resolve() */
+    }
+    const configHash = computeConfigHash(ctx.config);
+    try {
+        if (useNativeDb) {
+            ctx.nativeDb.setBuildMeta(Object.entries({
+                engine: ctx.engineName,
+                engine_version: codeVersionToWrite,
+                codegraph_version: codeVersionToWrite,
+                schema_version: String(ctx.schemaVersion),
+                built_at: buildNow.toISOString(),
+                node_count: String(nodeCount),
+                edge_count: String(actualEdgeCount),
+                root_dir: rootDirToWrite,
+                config_hash: configHash,
+            }).map(([key, value]) => ({ key, value: String(value) })));
+        }
+        else {
+            setBuildMeta(ctx.db, {
+                engine: ctx.engineName,
+                engine_version: codeVersionToWrite,
+                codegraph_version: codeVersionToWrite,
+                schema_version: String(ctx.schemaVersion),
+                built_at: buildNow.toISOString(),
+                node_count: nodeCount,
+                edge_count: actualEdgeCount,
+                root_dir: rootDirToWrite,
+                config_hash: configHash,
+            });
+        }
+    }
+    catch (err) {
+        warn(`Failed to write build metadata: ${err.message}`);
+    }
+}
+/** Format the "X exports have zero consumers" warning, with correct plural agreement. */
+function unusedExportsMessage(count) {
+    return `${count} exported symbol${count > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`;
+}
+/** Run all three advisory checks via the batched native FFI. */
+function runAdvisoryChecksNative(ctx, hasEmbeddings, buildNow) {
+    const result = ctx.nativeDb.runAdvisoryChecks(hasEmbeddings);
+    if (result.orphanedEmbeddings > 0) {
+        warn(`${result.orphanedEmbeddings} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`);
+    }
+    if (result.embedBuiltAt) {
+        const embedTime = new Date(result.embedBuiltAt).getTime();
+        if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
+            warn('Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.');
+        }
+    }
+    if (result.unusedExports > 0) {
+        warn(unusedExportsMessage(result.unusedExports));
+    }
+}
+function checkOrphanedEmbeddings(ctx) {
+    try {
+        const orphaned = ctx.db
+            .prepare('SELECT COUNT(*) as c FROM embeddings WHERE node_id NOT IN (SELECT id FROM nodes)')
+            .get().c;
+        if (orphaned > 0) {
+            warn(`${orphaned} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`);
+        }
+    }
+    catch {
+        /* ignore - embeddings table may have been dropped */
+    }
+}
+function checkStaleEmbeddings(ctx, buildNow) {
+    try {
+        const embedBuiltAt = ctx.db.prepare("SELECT value FROM embedding_meta WHERE key = 'built_at'").get()?.value;
+        if (!embedBuiltAt)
+            return;
+        const embedTime = new Date(embedBuiltAt).getTime();
+        if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
+            warn('Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.');
+        }
+    }
+    catch {
+        /* ignore - embedding_meta table may not exist */
+    }
+}
+function checkUnusedExports(ctx) {
+    try {
+        const unusedCount = ctx.db
+            .prepare(`SELECT COUNT(*) as c FROM nodes
+         WHERE exported = 1 AND kind != 'file'
+           AND id NOT IN (
+             SELECT DISTINCT e.target_id FROM edges e
+             JOIN nodes caller ON e.source_id = caller.id
+             JOIN nodes target ON e.target_id = target.id
+             WHERE e.kind = 'calls' AND caller.file != target.file
+           )`)
+            .get().c;
+        if (unusedCount > 0)
+            warn(unusedExportsMessage(unusedCount));
+    }
+    catch {
+        /* exported column may not exist on older DBs */
+    }
+}
+/**
+ * Run advisory checks on full builds: orphaned embeddings, stale embeddings,
+ * and unused exports. Informational only — does not affect correctness.
+ */
+function runAdvisoryChecks(ctx, hasEmbeddings, buildNow) {
+    if (ctx.engineName === 'native' && ctx.nativeDb?.runAdvisoryChecks) {
+        runAdvisoryChecksNative(ctx, hasEmbeddings, buildNow);
+        return;
+    }
+    if (hasEmbeddings) {
+        checkOrphanedEmbeddings(ctx);
+        checkStaleEmbeddings(ctx, buildNow);
+    }
+    checkUnusedExports(ctx);
+}
+export async function finalize(ctx) {
+    const { allSymbols, rootDir, isFullBuild, hasEmbeddings, opts } = ctx;
+    const t0 = performance.now();
+    releaseWasmTrees(allSymbols);
+    // Capture a single wall-clock timestamp for the current build — used for
+    // both the stale-embeddings comparison and the persisted built_at metadata.
+    const buildNow = new Date();
+    const useNative = ctx.engineName === 'native' && !!ctx.nativeDb?.getFinalizeCounts;
+    let nodeCount;
+    let actualEdgeCount;
+    if (useNative) {
+        const counts = ctx.nativeDb.getFinalizeCounts();
+        nodeCount = counts.nodeCount;
+        actualEdgeCount = counts.edgeCount;
+    }
+    else {
+        nodeCount = ctx.db.prepare('SELECT COUNT(*) as c FROM nodes').get().c;
+        actualEdgeCount = ctx.db.prepare('SELECT COUNT(*) as c FROM edges').get().c;
+    }
+    info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
+    info(`Stored in ${ctx.dbPath}`);
+    detectIncrementalDrift(ctx, nodeCount, actualEdgeCount);
+    persistBuildMetadata(ctx, nodeCount, actualEdgeCount, buildNow);
+    // Skip expensive advisory queries for incremental builds — these are
+    // informational warnings that don't affect correctness and cost ~40-60ms.
+    if (!isFullBuild) {
+        debug('Finalize: skipping advisory queries (orphaned/stale embeddings, unused exports) for incremental build');
+    }
+    else {
+        runAdvisoryChecks(ctx, hasEmbeddings, buildNow);
+    }
+    // Intentionally measured before closeDb / writeJournalHeader / auto-registration:
+    // for the deferred-close path the close is async (setImmediate), and for full
+    // builds the metric captures finalize logic only — DB close cost is tracked
+    // separately via timing.closeDbMs when available.
+    ctx.timing.finalizeMs = performance.now() - t0;
+    // Close NativeDatabase (fast, ~1ms) then better-sqlite3 (WAL checkpoint).
+    // For small incremental builds, defer the expensive WAL checkpoint to the
+    // next event loop tick. Skip for temp directories (tests) — they rmSync
+    // immediately after build.
+    const pair = { db: ctx.db, nativeDb: ctx.nativeDb };
+    const isTempDir = path.resolve(rootDir).startsWith(path.resolve(tmpdir()));
+    if (!isFullBuild && allSymbols.size <= ctx.config.build.smallFilesThreshold && !isTempDir) {
+        closeDbPairDeferred(pair);
+    }
+    else {
+        closeDbPair(pair);
+    }
+    // Write journal header after successful build
+    writeJournalHeader(rootDir, Date.now());
+    // Skip auto-registration for incremental builds — the repo was already
+    // registered during the initial full build. The dynamic import + file I/O
+    // costs ~100ms which dominates incremental finalize time.
+    if (!opts.skipRegistry && isFullBuild) {
+        const tmpDir = path.resolve(tmpdir());
+        const resolvedRoot = path.resolve(rootDir);
+        if (resolvedRoot.startsWith(tmpDir)) {
+            debug(`Skipping auto-registration for temp directory: ${resolvedRoot}`);
+        }
+        else {
+            try {
+                const { registerRepo } = (await import('../../../../infrastructure/registry.js'));
+                registerRepo(rootDir);
+            }
+            catch (err) {
+                debug(`Auto-registration failed: ${err.message}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=finalize.js.map

package/dist/domain/graph/builder/stages/finalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"finalize.js","sourceRoot":"","sources":["../../../../../src/domain/graph/builder/stages/finalize.ts"],"names":[],"mappings":"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"}

package/dist/domain/graph/builder/stages/insert-nodes.d.ts

@@ -0,0 +1,35 @@
+import type { FileToParse, MetadataUpdate } from '../../../../types.js';
+import type { PipelineContext } from '../context.js';
+/** Shape of precomputed file data gathered from filesToParse entries. */
+interface PrecomputedFileData {
+    file: string;
+    relPath?: string;
+    content?: string;
+    hash?: string;
+    stat?: {
+        mtime: number;
+        size: number;
+    } | null;
+    _reverseDepOnly?: boolean;
+}
+/** A single file_hashes row. */
+interface FileHashRecord {
+    file: string;
+    hash: string;
+    mtime: number;
+    size: number;
+}
+/**
+ * Build file hash entries for every collected file, including those that
+ * produced zero symbols (empty files, parsers that silently no-op'd, or
+ * optional-language extensions whose grammar wasn't installed). Iterating the
+ * symbol map instead would skip such files and leave them missing from
+ * `file_hashes`, which permanently breaks the JS-side fast-skip pre-flight on
+ * any subsequent no-op rebuild (#1068).
+ *
+ * Exported for unit testing.
+ */
+export declare function buildFileHashes(filesToParse: FileToParse[], precomputedData: Map<string, PrecomputedFileData>, metadataUpdates: MetadataUpdate[], rootDir: string): FileHashRecord[];
+export declare function insertNodes(ctx: PipelineContext): Promise<void>;
+export {};
+//# sourceMappingURL=insert-nodes.d.ts.map

package/dist/domain/graph/builder/stages/insert-nodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"insert-nodes.d.ts","sourceRoot":"","sources":["../../../../../src/domain/graph/builder/stages/insert-nodes.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAGV,WAAW,EACX,cAAc,EAEf,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AASrD,yEAAyE;AACzE,UAAU,mBAAmB;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC9C,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAsDD,gCAAgC;AAChC,UAAU,cAAc;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAuFD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,WAAW,EAAE,EAC3B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,EACjD,eAAe,EAAE,cAAc,EAAE,EACjC,OAAO,EAAE,MAAM,GACd,cAAc,EAAE,CAUlB;AA6ND,wBAAsB,WAAW,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAuDrE"}

package/dist/domain/graph/builder/stages/insert-nodes.js

@@ -0,0 +1,351 @@
+/**
+ * Stage: insertNodes
+ *
+ * Batch-inserts file nodes, definitions, exports, children, and contains/parameter_of edges.
+ * Updates file hashes for incremental builds.
+ *
+ * When the native engine is available, delegates all SQLite writes to Rust via
+ * `bulkInsertNodes` — eliminating JS↔C boundary overhead. Falls back to the
+ * JS implementation on failure or when native is unavailable.
+ */
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { bulkNodeIdsByFile } from '../../../../db/index.js';
+import { debug } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
+import { toErrorMessage } from '../../../../shared/errors.js';
+import { batchInsertEdges, batchInsertNodes, fileHash, fileStat, readFileSafe, } from '../helpers.js';
+/** Marshal allSymbols into the batch format expected by native bulkInsertNodes. */
+function marshalSymbolBatches(allSymbols) {
+    const batches = [];
+    for (const [relPath, symbols] of allSymbols) {
+        batches.push({
+            file: relPath,
+            definitions: symbols.definitions.map((def) => ({
+                name: def.name,
+                kind: def.kind,
+                line: def.line,
+                endLine: def.endLine ?? undefined,
+                visibility: def.visibility ?? undefined,
+                children: (def.children ?? []).map((c) => ({
+                    name: c.name,
+                    kind: c.kind,
+                    line: c.line,
+                    endLine: c.endLine ?? undefined,
+                    visibility: c.visibility ?? undefined,
+                })),
+            })),
+            exports: symbols.exports.map((exp) => ({
+                name: exp.name,
+                kind: exp.kind,
+                line: exp.line,
+            })),
+        });
+    }
+    return batches;
+}
+/** Resolve the (hash, mtime, size) tuple for a relPath, reading from disk if needed. */
+function resolveHashFromPrecomputed(relPath, precomputed, rootDir, caller) {
+    if (precomputed.hash) {
+        let mtime;
+        let size;
+        if (precomputed.stat) {
+            mtime = precomputed.stat.mtime;
+            size = precomputed.stat.size;
+        }
+        else {
+            const rawStat = fileStat(path.join(rootDir, relPath));
+            mtime = rawStat ? rawStat.mtime : 0;
+            size = rawStat ? rawStat.size : 0;
+        }
+        return { file: relPath, hash: precomputed.hash, mtime, size };
+    }
+    const absPath = path.join(rootDir, relPath);
+    let code;
+    try {
+        code = readFileSafe(absPath);
+    }
+    catch (e) {
+        debug(`${caller}: readFileSafe failed for ${relPath}: ${toErrorMessage(e)}`);
+        code = null;
+    }
+    if (code === null)
+        return null;
+    const stat = fileStat(absPath);
+    return {
+        file: relPath,
+        hash: fileHash(code),
+        mtime: stat ? stat.mtime : 0,
+        size: stat ? stat.size : 0,
+    };
+}
+/**
+ * Walk every collected file once and yield a `FileHashRecord` for it, plus one
+ * record per metadata-only update.  Shared by `buildFileHashes` (native path)
+ * and `updateFileHashes` (JS fallback) so the iteration and hash-resolution
+ * logic stays in one place.
+ *
+ * Files marked `_reverseDepOnly` are skipped — their hashes are already
+ * correct in the DB.
+ */
+function* iterFileHashRecords(filesToParse, precomputedData, metadataUpdates, rootDir, caller) {
+    const seen = new Set();
+    for (const item of filesToParse) {
+        const relPath = item.relPath ?? normalizePath(path.relative(rootDir, item.file));
+        if (seen.has(relPath))
+            continue;
+        seen.add(relPath);
+        const precomputed = precomputedData.get(relPath);
+        if (precomputed?._reverseDepOnly)
+            continue;
+        const record = resolveHashFromPrecomputed(relPath, precomputed ?? {}, rootDir, caller);
+        if (record)
+            yield record;
+    }
+    // Metadata-only updates (self-heal mtime/size without re-parse)
+    for (const item of metadataUpdates) {
+        yield {
+            file: item.relPath,
+            hash: item.hash,
+            mtime: item.stat ? item.stat.mtime : 0,
+            size: item.stat ? item.stat.size : 0,
+        };
+    }
+}
+/**
+ * Build file hash entries for every collected file, including those that
+ * produced zero symbols (empty files, parsers that silently no-op'd, or
+ * optional-language extensions whose grammar wasn't installed). Iterating the
+ * symbol map instead would skip such files and leave them missing from
+ * `file_hashes`, which permanently breaks the JS-side fast-skip pre-flight on
+ * any subsequent no-op rebuild (#1068).
+ *
+ * Exported for unit testing.
+ */
+export function buildFileHashes(filesToParse, precomputedData, metadataUpdates, rootDir) {
+    return [
+        ...iterFileHashRecords(filesToParse, precomputedData, metadataUpdates, rootDir, 'buildFileHashes'),
+    ];
+}
+// ── Native fast-path ─────────────────────────────────────────────────
+function tryNativeInsert(ctx) {
+    if (!ctx.nativeDb?.bulkInsertNodes)
+        return false;
+    const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+    const batches = marshalSymbolBatches(allSymbols);
+    const precomputedData = new Map();
+    for (const item of filesToParse) {
+        if (item.relPath)
+            precomputedData.set(item.relPath, item);
+    }
+    const fileHashes = buildFileHashes(filesToParse, precomputedData, metadataUpdates, rootDir);
+    // In native-first mode (single rusqlite connection), no WAL dance is needed.
+    // In dual-connection mode, checkpoint JS side before native write, then
+    // checkpoint native side after (#696, #709, #715, #717).
+    let result;
+    if (ctx.nativeFirstProxy) {
+        result = ctx.nativeDb.bulkInsertNodes(batches, fileHashes, removed);
+    }
+    else {
+        try {
+            if (ctx.db) {
+                ctx.db.pragma('wal_checkpoint(TRUNCATE)');
+            }
+            result = ctx.nativeDb.bulkInsertNodes(batches, fileHashes, removed);
+        }
+        finally {
+            try {
+                ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+            }
+            catch (e) {
+                debug(`tryNativeInsert: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`);
+            }
+        }
+    }
+    return result;
+}
+// ── JS fallback: Phase 1 ────────────────────────────────────────────
+function insertDefinitionsAndExports(db, allSymbols) {
+    const phase1Rows = [];
+    const exportKeys = [];
+    for (const [relPath, symbols] of allSymbols) {
+        phase1Rows.push([relPath, 'file', relPath, 0, null, null, null, null, null]);
+        for (const def of symbols.definitions) {
+            const dotIdx = def.name.lastIndexOf('.');
+            const scope = dotIdx !== -1 ? def.name.slice(0, dotIdx) : null;
+            phase1Rows.push([
+                def.name,
+                def.kind,
+                relPath,
+                def.line,
+                def.endLine || null,
+                null,
+                def.name,
+                scope,
+                def.visibility || null,
+            ]);
+        }
+        for (const exp of symbols.exports) {
+            phase1Rows.push([exp.name, exp.kind, relPath, exp.line, null, null, exp.name, null, null]);
+            exportKeys.push([exp.name, exp.kind, relPath, exp.line]);
+        }
+    }
+    batchInsertNodes(db, phase1Rows);
+    // Mark exported symbols in batches (cache prepared statements by chunk size)
+    if (exportKeys.length > 0) {
+        const EXPORT_CHUNK = 500;
+        const exportStmtCache = new Map();
+        for (let i = 0; i < exportKeys.length; i += EXPORT_CHUNK) {
+            const end = Math.min(i + EXPORT_CHUNK, exportKeys.length);
+            const chunkSize = end - i;
+            let updateStmt = exportStmtCache.get(chunkSize);
+            if (!updateStmt) {
+                const conditions = Array.from({ length: chunkSize }, () => '(name = ? AND kind = ? AND file = ? AND line = ?)').join(' OR ');
+                updateStmt = db.prepare(`UPDATE nodes SET exported = 1 WHERE ${conditions}`);
+                exportStmtCache.set(chunkSize, updateStmt);
+            }
+            const vals = [];
+            for (let j = i; j < end; j++) {
+                const k = exportKeys[j];
+                vals.push(k[0], k[1], k[2], k[3]);
+            }
+            updateStmt.run(...vals);
+        }
+    }
+}
+// ── JS fallback: Phase 2+3 ──────────────────────────────────────────
+/** Build the in-memory `name|kind|line` → node-id map for a single file. */
+function loadFileNodeIdMap(db, relPath) {
+    const map = new Map();
+    for (const row of bulkNodeIdsByFile(db, relPath)) {
+        map.set(`${row.name}|${row.kind}|${row.line}`, row.id);
+    }
+    return map;
+}
+/**
+ * First pass: for every file, emit file→def containment edges and collect
+ * the child-node insertion rows.
+ */
+function collectChildRowsAndFileEdges(db, allSymbols, childRows, edgeRows) {
+    for (const [relPath, symbols] of allSymbols) {
+        const nodeIdMap = loadFileNodeIdMap(db, relPath);
+        const fileId = nodeIdMap.get(`${relPath}|file|0`);
+        for (const def of symbols.definitions) {
+            const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+            if (fileId && defId) {
+                edgeRows.push([fileId, defId, 'contains', 1.0, 0]);
+            }
+            if (!def.children?.length || !defId)
+                continue;
+            for (const child of def.children) {
+                childRows.push([
+                    child.name,
+                    child.kind,
+                    relPath,
+                    child.line,
+                    child.endLine || null,
+                    defId,
+                    `${def.name}.${child.name}`,
+                    def.name,
+                    child.visibility || null,
+                ]);
+            }
+        }
+    }
+}
+/**
+ * Second pass (after child nodes have been inserted): emit def→child
+ * containment edges and child→def `parameter_of` edges.
+ */
+function collectChildEdges(db, allSymbols, edgeRows) {
+    for (const [relPath, symbols] of allSymbols) {
+        const nodeIdMap = loadFileNodeIdMap(db, relPath);
+        for (const def of symbols.definitions) {
+            if (!def.children?.length)
+                continue;
+            const defId = nodeIdMap.get(`${def.name}|${def.kind}|${def.line}`);
+            if (!defId)
+                continue;
+            for (const child of def.children) {
+                const childId = nodeIdMap.get(`${child.name}|${child.kind}|${child.line}`);
+                if (!childId)
+                    continue;
+                edgeRows.push([defId, childId, 'contains', 1.0, 0]);
+                if (child.kind === 'parameter') {
+                    edgeRows.push([childId, defId, 'parameter_of', 1.0, 0]);
+                }
+            }
+        }
+    }
+}
+function insertChildrenAndEdges(db, allSymbols) {
+    const childRows = [];
+    const edgeRows = [];
+    collectChildRowsAndFileEdges(db, allSymbols, childRows, edgeRows);
+    // Insert children first (so they exist for edge lookup)
+    batchInsertNodes(db, childRows);
+    collectChildEdges(db, allSymbols, edgeRows);
+    batchInsertEdges(db, edgeRows);
+}
+// ── JS fallback: Phase 4 ────────────────────────────────────────────
+function updateFileHashes(_db, filesToParse, precomputedData, metadataUpdates, rootDir, upsertHash) {
+    if (!upsertHash)
+        return;
+    // Iterate every collected file (#1068): files that produced zero symbols
+    // (empty, parser no-op, or grammar-missing optional language) still need a
+    // hash row, otherwise the next no-op rebuild's fast-skip pre-flight rejects.
+    for (const record of iterFileHashRecords(filesToParse, precomputedData, metadataUpdates, rootDir, 'updateFileHashes')) {
+        upsertHash.run(record.file, record.hash, record.mtime, record.size);
+    }
+}
+// ── Main entry point ────────────────────────────────────────────────
+export async function insertNodes(ctx) {
+    const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+    // Populate fileSymbols before any DB writes (used by later stages)
+    for (const [relPath, symbols] of allSymbols) {
+        ctx.fileSymbols.set(relPath, symbols);
+    }
+    const t0 = performance.now();
+    // Try native Rust path first — single transaction, no JS↔C overhead
+    if (ctx.engineName === 'native') {
+        try {
+            if (tryNativeInsert(ctx)) {
+                ctx.timing.insertMs = performance.now() - t0;
+                // Removed-file hash cleanup is handled inside the native call
+                return;
+            }
+        }
+        catch (e) {
+            debug(`insertNodes: native insert failed, falling back to JS: ${toErrorMessage(e)}`);
+        }
+    }
+    // JS fallback
+    const precomputedData = new Map();
+    for (const item of filesToParse) {
+        if (item.relPath)
+            precomputedData.set(item.relPath, item);
+    }
+    let upsertHash;
+    try {
+        upsertHash = ctx.db.prepare('INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)');
+    }
+    catch (e) {
+        debug(`insertNodes: file_hashes prepare failed (table may not exist): ${toErrorMessage(e)}`);
+        upsertHash = null;
+    }
+    const insertAll = ctx.db.transaction(() => {
+        insertDefinitionsAndExports(ctx.db, allSymbols);
+        insertChildrenAndEdges(ctx.db, allSymbols);
+        updateFileHashes(ctx.db, filesToParse, precomputedData, metadataUpdates, rootDir, upsertHash);
+    });
+    insertAll();
+    ctx.timing.insertMs = performance.now() - t0;
+    // Clean up removed file hashes
+    if (upsertHash && removed.length > 0) {
+        const deleteHash = ctx.db.prepare('DELETE FROM file_hashes WHERE file = ?');
+        for (const relPath of removed) {
+            deleteHash.run(relPath);
+        }
+    }
+}
+//# sourceMappingURL=insert-nodes.js.map