project-librarian 0.5.4 → 0.5.6

package/dist/code-index/modes.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCodeIndexEngine = resolveCodeIndexEngine;
 exports.runCodeIndexMode = runCodeIndexMode;
 exports.runCodeQueryMode = runCodeQueryMode;
 exports.runCodeReportMode = runCodeReportMode;
@@ -70,17 +71,75 @@ function requireCompatibleDatabase(database, runtime) {
         ].join("\n"));
     }
 }
+function elapsedMs(started) {
+    return Number(process.hrtime.bigint() - started) / 1_000_000;
+}
+function measurePhase(timings, key, fn) {
+    const started = process.hrtime.bigint();
+    try {
+        return fn();
+    }
+    finally {
+        timings[key] = Number(((timings[key] ?? 0) + elapsedMs(started)).toFixed(3));
+    }
+}
+function emitCodeIndexPhaseTimings(timings) {
+    if (process.env.PROJECT_LIBRARIAN_CODE_INDEX_TIMINGS !== "1")
+        return;
+    console.error(`code_index_phase_timings ${JSON.stringify(timings)}`);
+}
+function configureBulkWriteConnection(database) {
+    database.exec(`
+    PRAGMA synchronous = OFF;
+    PRAGMA temp_store = MEMORY;
+    PRAGMA cache_size = -20000;
+  `);
+}
+function shouldUseNativeIncrementalForAuto(requestedEngine, runtime, staleFileCount) {
+    if (requestedEngine !== "auto" || !args_1.codeIndexIncrementalMode)
+        return false;
+    if (staleFileCount <= 0 || !runtime.nativeCodeIndexAvailable())
+        return false;
+    return true;
+}
+function resolveCodeIndexEngine(requestedEngine, context, shouldUseNativeAuto, incrementalMode = args_1.codeIndexIncrementalMode) {
+    if (requestedEngine !== "auto")
+        return requestedEngine;
+    if (incrementalMode)
+        return "typescript";
+    return shouldUseNativeAuto(context) ? "native-rust" : "typescript";
+}
 function runCodeIndexMode(runtime) {
+    const totalStarted = process.hrtime.bigint();
+    const phaseTimings = {};
     const databasePath = runtime.codeEvidenceDatabasePath();
     const scopes = runtime.codeScopes();
     const parserMode = runtime.selectedCodeParserMode();
+    const requestedEngine = runtime.selectedCodeIndexEngine();
     // Scale gate before ANY write or database work: below the measured threshold
     // the build halts with the evidence-citing warning unless --acknowledge-small-repo
     // was passed (2026-06-12 scale-aware guidance decision).
-    const discoveredFiles = (0, code_index_file_policy_1.discoverCodeFiles)(scopes);
+    const discoveredFiles = measurePhase(phaseTimings, "discover_files_ms", () => (0, code_index_file_policy_1.discoverCodeFiles)(scopes));
     const scaleGate = (0, code_index_file_policy_1.smallRepoCodeIndexGate)(discoveredFiles.length, args_1.acknowledgeSmallRepoMode);
     if (!scaleGate.proceed)
         runtime.fail(scaleGate.warning);
+    const engineSelectionContext = runtime.codeIndexEngineSelectionContext(discoveredFiles, parserMode);
+    const engine = resolveCodeIndexEngine(requestedEngine, engineSelectionContext, runtime.shouldUseNativeCodeIndexAuto);
+    if (engine === "native-rust") {
+        if (!args_1.codeIndexIncrementalMode) {
+            try {
+                measurePhase(phaseTimings, "native_helper_ms", () => runtime.runNativeCodeIndexMode({ databasePath, discoveredFiles, parserMode, requestedEngine, scopes }));
+                phaseTimings.total_ms = Number(elapsedMs(totalStarted).toFixed(3));
+                emitCodeIndexPhaseTimings(phaseTimings);
+                return;
+            }
+            catch (error) {
+                phaseTimings.total_ms = Number(elapsedMs(totalStarted).toFixed(3));
+                emitCodeIndexPhaseTimings(phaseTimings);
+                throw error;
+            }
+        }
+    }
     const existingIndex = fs.existsSync(databasePath.absolutePath);
     if (args_1.codeIndexIncrementalMode && !existingIndex) {
         runtime.fail(`--incremental requires an existing compatible code evidence index: ${databasePath.relativePath}`);
@@ -88,27 +147,30 @@ function runCodeIndexMode(runtime) {
     let incremental = false;
     if (existingIndex && !args_1.codeIndexFullMode) {
         let compatibility = { compatible: false, reason: "compatibility was not checked" };
-        const existingDatabase = runtime.openDatabase(databasePath.absolutePath);
-        try {
-            compatibility = (0, schema_1.incrementalCompatibility)(existingDatabase, scopes, parserMode);
-        }
-        finally {
-            existingDatabase.close();
-        }
+        measurePhase(phaseTimings, "compatibility_ms", () => {
+            const existingDatabase = runtime.openDatabase(databasePath.absolutePath);
+            try {
+                compatibility = (0, schema_1.incrementalCompatibility)(existingDatabase, scopes, parserMode);
+            }
+            finally {
+                existingDatabase.close();
+            }
+        });
         incremental = !args_1.codeIndexFullMode && compatibility.compatible;
         if (args_1.codeIndexIncrementalMode && !compatibility.compatible)
             runtime.fail(`--incremental cannot update ${databasePath.relativePath}: ${compatibility.reason}`);
     }
-    runtime.prepareOutputPath();
-    if (!incremental)
-        runtime.removeDatabaseFiles(databasePath.absolutePath);
-    const database = runtime.openDatabase(databasePath.absolutePath);
+    measurePhase(phaseTimings, "prepare_output_ms", () => {
+        runtime.prepareOutputPath();
+        if (!incremental)
+            runtime.removeDatabaseFiles(databasePath.absolutePath);
+    });
+    let database = runtime.openDatabase(databasePath.absolutePath);
     try {
         if (!incremental)
-            (0, schema_1.setupDatabase)(database);
-        const statements = (0, schema_1.createIndexStatements)(database);
-        const currentFingerprints = discoveredFiles.map((filePath) => runtime.readCodeFileFingerprint(filePath));
-        let reindexedFiles;
+            (0, schema_1.setupDatabase)(database, { secondaryIndexes: false });
+        const currentFingerprints = measurePhase(phaseTimings, "fingerprints_ms", () => discoveredFiles.map((filePath) => runtime.readCodeFileFingerprint(filePath)));
+        let reindexedFingerprints;
         let deletedPaths;
         let indexedPaths = new Set();
         let unchangedFiles = 0;
@@ -122,45 +184,87 @@ function runCodeIndexMode(runtime) {
                 }]));
             const currentPaths = new Set(currentFingerprints.map((file) => file.path));
             deletedPaths = indexedRows.map((row) => String(row.path)).filter((filePath) => !currentPaths.has(filePath));
-            reindexedFiles = [];
+            reindexedFingerprints = [];
             for (const file of currentFingerprints) {
                 const existing = indexed.get(file.path);
                 if (existing && existing.mtimeMs === file.mtimeMs && existing.size === file.size) {
                     unchangedFiles += 1;
                     continue;
                 }
-                reindexedFiles.push(runtime.readCodeFile(file.path, parserMode));
+                reindexedFingerprints.push(file);
             }
         }
         else {
             deletedPaths = [];
-            reindexedFiles = discoveredFiles.map((filePath) => runtime.readCodeFile(filePath, parserMode));
+            reindexedFingerprints = currentFingerprints;
         }
-        database.exec("BEGIN");
-        if (!incremental)
-            statements.insertMeta.run("created_at", new Date().toISOString());
-        (0, schema_1.writeIndexMetadata)(scopes, parserMode, statements);
-        for (const filePath of deletedPaths)
-            (0, schema_1.removeIndexedFile)(filePath, statements);
-        for (const file of reindexedFiles) {
-            if (incremental && indexedPaths.has(file.path))
-                (0, schema_1.removeIndexedFile)(file.path, statements);
-            runtime.indexCodeFile(file, statements);
+        const nativeIncrementalRequested = engine === "native-rust"
+            || shouldUseNativeIncrementalForAuto(requestedEngine, runtime, reindexedFingerprints.length + deletedPaths.length);
+        if (nativeIncrementalRequested) {
+            if (!runtime.nativeCodeIndexAvailable()) {
+                runtime.fail("--code-index-engine native-rust --incremental requires PROJECT_LIBRARIAN_NATIVE_INDEXER or a packaged native helper.");
+            }
+            if (!runtime.nativeCodeIndexIncrementalEligible(reindexedFingerprints, parserMode)) {
+                if (engine === "native-rust") {
+                    runtime.fail("--code-index-engine native-rust --incremental only supports native-eligible parser profiles; use --code-index-engine typescript for this incremental update.");
+                }
+            }
+            else {
+                database.close();
+                database = undefined;
+                measurePhase(phaseTimings, "native_helper_ms", () => runtime.runNativeCodeIndexIncrementalMode({
+                    databasePath,
+                    deletedPaths,
+                    discoveredFiles,
+                    parserMode,
+                    requestedEngine,
+                    reindexedFiles: reindexedFingerprints,
+                    scopes,
+                    unchangedFiles,
+                }));
+                phaseTimings.total_ms = Number(elapsedMs(totalStarted).toFixed(3));
+                emitCodeIndexPhaseTimings(phaseTimings);
+                return;
+            }
         }
-        database.exec("COMMIT");
+        const reindexedFiles = measurePhase(phaseTimings, "read_files_ms", () => reindexedFingerprints.map((file) => runtime.readCodeFile(file.path, parserMode, file)));
+        const activeDatabase = database;
+        const statements = (0, schema_1.createIndexStatements)(activeDatabase);
+        measurePhase(phaseTimings, "sqlite_write_ms", () => {
+            configureBulkWriteConnection(activeDatabase);
+            activeDatabase.exec("BEGIN");
+            if (!incremental)
+                statements.insertMeta.run("created_at", new Date().toISOString());
+            (0, schema_1.writeIndexMetadata)(scopes, parserMode, statements);
+            for (const filePath of deletedPaths)
+                (0, schema_1.removeIndexedFile)(filePath, statements);
+            for (const file of reindexedFiles) {
+                if (incremental && indexedPaths.has(file.path))
+                    (0, schema_1.removeIndexedFile)(file.path, statements);
+                runtime.indexCodeFile(file, statements);
+            }
+            if (!incremental)
+                (0, schema_1.createSecondaryIndexes)(activeDatabase);
+            activeDatabase.exec("COMMIT");
+        });
+        phaseTimings.total_ms = Number(elapsedMs(totalStarted).toFixed(3));
         console.log("Project wiki code evidence index complete.");
         console.log(`database: ${databasePath.relativePath}`);
         console.log(`mode: ${incremental ? "incremental" : "full"}`);
+        console.log(`engine: ${engine}`);
+        if (requestedEngine === "auto")
+            console.log("engine_selection: auto");
         console.log(`parser_mode: ${parserMode}`);
         console.log(`scopes: ${scopes.join(", ")}`);
         console.log(`files: ${currentFingerprints.length}`);
         console.log(`reindexed_files: ${reindexedFiles.length}`);
         console.log(`deleted_files: ${deletedPaths.length}`);
         console.log(`unchanged_files: ${unchangedFiles}`);
+        emitCodeIndexPhaseTimings(phaseTimings);
     }
     catch (error) {
         try {
-            database.exec("ROLLBACK");
+            database?.exec("ROLLBACK");
         }
         catch {
             // Ignore rollback failures after setup errors.
@@ -168,7 +272,7 @@ function runCodeIndexMode(runtime) {
         throw error;
     }
     finally {
-        database.close();
+        database?.close();
     }
 }
 function runCodeQueryMode(runtime) {

package/dist/code-index/native-helper-matrix.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedNativeHelperTriples = exports.nativeCodeIndexHelperTargets = void 0;
+exports.nativeCodeIndexHelperTargetForTriple = nativeCodeIndexHelperTargetForTriple;
+exports.nativeCodeIndexHelperPlatformFromTriple = nativeCodeIndexHelperPlatformFromTriple;
+exports.nativeCodeIndexHelperTripleForPlatform = nativeCodeIndexHelperTripleForPlatform;
+exports.nativeCodeIndexHelperTargets = [
+    {
+        arch: "arm64",
+        architecture: "arm64",
+        format: "mach-o",
+        libc: "",
+        platform: "darwin",
+        runner: "macos-14",
+        rustTarget: "aarch64-apple-darwin",
+        triple: "darwin-arm64",
+    },
+    {
+        arch: "x64",
+        architecture: "x64",
+        format: "mach-o",
+        libc: "",
+        platform: "darwin",
+        runner: "macos-15-intel",
+        rustTarget: "x86_64-apple-darwin",
+        triple: "darwin-x64",
+    },
+    {
+        arch: "arm64",
+        architecture: "arm64",
+        format: "elf",
+        libc: "",
+        platform: "linux",
+        runner: "ubuntu-24.04-arm",
+        rustTarget: "aarch64-unknown-linux-gnu",
+        triple: "linux-arm64",
+    },
+    {
+        arch: "arm64",
+        architecture: "arm64",
+        format: "elf",
+        libc: "musl",
+        platform: "linux",
+        runner: "ubuntu-24.04-arm",
+        rustTarget: "aarch64-unknown-linux-musl",
+        triple: "linux-arm64-musl",
+    },
+    {
+        arch: "x64",
+        architecture: "x64",
+        format: "elf",
+        libc: "",
+        platform: "linux",
+        runner: "ubuntu-latest",
+        rustTarget: "x86_64-unknown-linux-gnu",
+        triple: "linux-x64",
+    },
+    {
+        arch: "x64",
+        architecture: "x64",
+        format: "elf",
+        libc: "musl",
+        platform: "linux",
+        runner: "ubuntu-latest",
+        rustTarget: "x86_64-unknown-linux-musl",
+        triple: "linux-x64-musl",
+    },
+    {
+        arch: "arm64",
+        architecture: "arm64",
+        format: "pe",
+        libc: "",
+        platform: "win32",
+        runner: "windows-11-arm",
+        rustTarget: "aarch64-pc-windows-msvc",
+        triple: "win32-arm64",
+    },
+    {
+        arch: "x64",
+        architecture: "x64",
+        format: "pe",
+        libc: "",
+        platform: "win32",
+        runner: "windows-latest",
+        rustTarget: "x86_64-pc-windows-msvc",
+        triple: "win32-x64",
+    },
+];
+exports.supportedNativeHelperTriples = exports.nativeCodeIndexHelperTargets.map((target) => target.triple);
+function nativeCodeIndexHelperTargetForTriple(triple) {
+    return exports.nativeCodeIndexHelperTargets.find((target) => target.triple === triple);
+}
+function nativeCodeIndexHelperPlatformFromTriple(triple) {
+    return nativeCodeIndexHelperTargetForTriple(triple)?.platform ?? String(triple).split("-")[0] ?? "";
+}
+function nativeCodeIndexHelperTripleForPlatform(platform, arch, libc = "") {
+    const normalizedLibc = platform === "linux" && libc === "musl" ? "musl" : "";
+    return exports.nativeCodeIndexHelperTargets.find((target) => (target.platform === platform && target.arch === arch && target.libc === normalizedLibc))?.triple ?? `${platform}-${arch}`;
+}

package/dist/code-index/native-helper.js

@@ -0,0 +1,292 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeCodeIndexHelperPlatformTriple = nativeCodeIndexHelperPlatformTriple;
+exports.nativeCodeIndexHelperBinaryName = nativeCodeIndexHelperBinaryName;
+exports.packagedNativeCodeIndexHelperPath = packagedNativeCodeIndexHelperPath;
+exports.requireNativeCodeIndexHelperPath = requireNativeCodeIndexHelperPath;
+exports.nativeCodeIndexHelperAvailability = nativeCodeIndexHelperAvailability;
+exports.nativeCodeIndexHelperAvailable = nativeCodeIndexHelperAvailable;
+exports.buildNativeCodeIndexJob = buildNativeCodeIndexJob;
+exports.runNativeCodeIndexHelper = runNativeCodeIndexHelper;
+exports.runNativeCodeIndexRowsHelper = runNativeCodeIndexRowsHelper;
+const childProcess = __importStar(require("node:child_process"));
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const native_helper_matrix_1 = require("./native-helper-matrix");
+const workspace_1 = require("../workspace");
+const supportedNativeHelperTripleSet = new Set(native_helper_matrix_1.supportedNativeHelperTriples);
+function nativeCodeIndexLinuxLibcVariant(platform = process.platform) {
+    if (platform !== "linux")
+        return "";
+    const report = process.report;
+    if (!report || typeof report.getReport !== "function")
+        return "";
+    try {
+        return report.getReport().header?.glibcVersionRuntime ? "glibc" : "musl";
+    }
+    catch {
+        return "";
+    }
+}
+function nativeCodeIndexHelperPlatformTriple(platform = process.platform, arch = process.arch, libc = nativeCodeIndexLinuxLibcVariant(platform)) {
+    return (0, native_helper_matrix_1.nativeCodeIndexHelperTripleForPlatform)(platform, arch, libc);
+}
+function nativeCodeIndexHelperBinaryName(platform = process.platform) {
+    return platform === "win32" ? "project-librarian-indexer.exe" : "project-librarian-indexer";
+}
+function nativeCodeIndexHelperPackageRoot(options = {}) {
+    return path.resolve(options.packageRoot ?? path.join(__dirname, ".."));
+}
+function packagedNativeCodeIndexHelperPath(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    return path.join(nativeCodeIndexHelperPackageRoot(options), "native", nativeCodeIndexHelperPlatformTriple(platform, arch, options.libc), nativeCodeIndexHelperBinaryName(platform));
+}
+function configuredHelperPath(options = {}) {
+    const optionPath = (options.helperPath ?? "").trim();
+    if (optionPath)
+        return { helperPath: optionPath, source: "option" };
+    const envPath = ((options.env ?? process.env).PROJECT_LIBRARIAN_NATIVE_INDEXER ?? "").trim();
+    if (envPath)
+        return { helperPath: envPath, source: "environment" };
+    return { helperPath: "", source: "missing" };
+}
+function helperPathLabel(source) {
+    if (source === "option")
+        return "native helper path";
+    if (source === "environment")
+        return "PROJECT_LIBRARIAN_NATIVE_INDEXER";
+    return "packaged native helper";
+}
+function requireUsableHelperPath(helperPath, source) {
+    const label = helperPathLabel(source);
+    if (!path.isAbsolute(helperPath)) {
+        throw new Error(`${label} must be an absolute path: ${helperPath}`);
+    }
+    const resolved = path.resolve(helperPath);
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`${label} does not exist: ${resolved}`);
+    }
+    const stat = fs.statSync(resolved);
+    if (!stat.isFile()) {
+        throw new Error(`${label} must point to an executable file: ${resolved}`);
+    }
+    fs.accessSync(resolved, fs.constants.X_OK);
+    return resolved;
+}
+function requireNativeCodeIndexHelperPath(options = {}) {
+    const availability = nativeCodeIndexHelperAvailability(options);
+    if (availability.available)
+        return availability.helperPath;
+    throw new Error(availability.reason);
+}
+function nativeCodeIndexHelperAvailability(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const arch = options.arch ?? process.arch;
+    const platformTriple = nativeCodeIndexHelperPlatformTriple(platform, arch, options.libc);
+    const packagedHelperPath = packagedNativeCodeIndexHelperPath({ ...options, arch, platform });
+    const configured = configuredHelperPath(options);
+    if (configured.helperPath) {
+        try {
+            return {
+                available: true,
+                helperPath: requireUsableHelperPath(configured.helperPath, configured.source),
+                packagedHelperPath,
+                platformTriple,
+                reason: "",
+                source: configured.source,
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                helperPath: "",
+                packagedHelperPath,
+                platformTriple,
+                reason: error instanceof Error ? error.message : String(error),
+                source: configured.source,
+            };
+        }
+    }
+    if (!supportedNativeHelperTripleSet.has(platformTriple)) {
+        return {
+            available: false,
+            helperPath: "",
+            packagedHelperPath,
+            platformTriple,
+            reason: `packaged native code index helper does not support this platform: ${platformTriple}; set PROJECT_LIBRARIAN_NATIVE_INDEXER to a compatible helper path`,
+            source: "missing",
+        };
+    }
+    if (fs.existsSync(packagedHelperPath)) {
+        try {
+            return {
+                available: true,
+                helperPath: requireUsableHelperPath(packagedHelperPath, "packaged"),
+                packagedHelperPath,
+                platformTriple,
+                reason: "",
+                source: "packaged",
+            };
+        }
+        catch (error) {
+            return {
+                available: false,
+                helperPath: "",
+                packagedHelperPath,
+                platformTriple,
+                reason: error instanceof Error ? error.message : String(error),
+                source: "packaged",
+            };
+        }
+    }
+    return {
+        available: false,
+        helperPath: "",
+        packagedHelperPath,
+        platformTriple,
+        reason: `--code-index-engine native-rust requires PROJECT_LIBRARIAN_NATIVE_INDEXER or a packaged native helper at ${packagedHelperPath}`,
+        source: "missing",
+    };
+}
+function nativeCodeIndexHelperAvailable(options = {}) {
+    return nativeCodeIndexHelperAvailability(options).available;
+}
+function writeJobManifest(job) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "project-librarian-native-indexer-"));
+    const manifestPath = path.join(tmpDir, "job.json");
+    fs.writeFileSync(manifestPath, `${JSON.stringify(job)}\n`);
+    return manifestPath;
+}
+function buildNativeCodeIndexJob(input) {
+    const { mode = "full", ...rest } = input;
+    return {
+        abi_version: 1,
+        engine: "native-rust",
+        mode,
+        project_root: (0, workspace_1.normalizePath)(workspace_1.root),
+        ...rest,
+    };
+}
+function validateNativeCodeIndexSummary(job, summary) {
+    if (summary.engine !== job.engine) {
+        throw new Error(`native code index helper summary engine mismatch: expected ${job.engine}, got ${summary.engine ?? "(missing)"}`);
+    }
+    if (summary.schema_version !== job.schema_version) {
+        throw new Error(`native code index helper summary schema mismatch: expected ${job.schema_version}, got ${summary.schema_version ?? "(missing)"}`);
+    }
+    if (summary.mode !== job.mode) {
+        throw new Error(`native code index helper summary mode mismatch: expected ${job.mode}, got ${summary.mode ?? "(missing)"}`);
+    }
+    const database = summary.database ?? summary.database_path ?? "";
+    if (path.resolve(database) !== path.resolve(job.database_path)) {
+        throw new Error(`native code index helper summary database mismatch: expected ${job.database_path}, got ${database || "(missing)"}`);
+    }
+    if (!Number.isInteger(summary.files) || (summary.files ?? -1) < 0) {
+        throw new Error("native code index helper summary files must be a non-negative integer");
+    }
+    if (summary.native_files !== undefined && summary.native_files !== job.files.length) {
+        throw new Error(`native code index helper summary native_files mismatch: expected ${job.files.length}, got ${summary.native_files}`);
+    }
+    if ((summary.unsupported_profiles ?? []).length > 0) {
+        throw new Error(`native code index helper reported unsupported profiles: ${(summary.unsupported_profiles ?? []).join(", ")}`);
+    }
+    return summary;
+}
+function runNativeCodeIndexHelper(job, options = {}) {
+    const helperPath = requireNativeCodeIndexHelperPath(options);
+    const manifestPath = writeJobManifest(job);
+    try {
+        const result = childProcess.spawnSync(helperPath, ["--manifest", manifestPath], {
+            cwd: workspace_1.root,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        if (result.status !== 0) {
+            const detail = (result.stderr || result.stdout || "").trim();
+            throw new Error(`native code index helper failed (${result.status ?? "signal"}): ${detail || helperPath}`);
+        }
+        let summary;
+        try {
+            summary = JSON.parse(result.stdout || "{}");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`native code index helper returned invalid JSON: ${message}`);
+        }
+        return validateNativeCodeIndexSummary(job, summary);
+    }
+    finally {
+        fs.rmSync(path.dirname(manifestPath), { recursive: true, force: true });
+    }
+}
+function validateNativeRows(value) {
+    if (typeof value !== "object" || value === null) {
+        throw new Error("native code index helper row stream must be an object");
+    }
+    const rows = value;
+    for (const key of ["configs", "edges", "files", "imports", "routes", "symbols"]) {
+        if (!Array.isArray(rows[key])) {
+            throw new Error(`native code index helper row stream missing array: ${key}`);
+        }
+    }
+    return rows;
+}
+function runNativeCodeIndexRowsHelper(job, options = {}) {
+    if (job.output_mode !== "row-stream") {
+        throw new Error("native row helper requires output_mode row-stream");
+    }
+    if (!job.rows_path) {
+        throw new Error("native row helper requires rows_path");
+    }
+    const summary = runNativeCodeIndexHelper(job, options);
+    let rowsJson = "";
+    try {
+        rowsJson = fs.readFileSync(job.rows_path, "utf8");
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`native code index helper did not write rows: ${message}`);
+    }
+    try {
+        return { rows: validateNativeRows(JSON.parse(rowsJson)), summary };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`native code index helper returned invalid row stream: ${message}`);
+    }
+}