grepmax 0.26.48 → 0.26.50

package/dist/eval-relevance.js

@@ -0,0 +1,337 @@
+"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;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** Frozen local multi-corpus baseline, using the existing daemon with no fallback. */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+const lmdb_1 = require("lmdb");
+const config_1 = require("./config");
+const relevance_baseline_1 = require("./lib/eval/relevance-baseline");
+const daemon_client_1 = require("./lib/utils/daemon-client");
+const project_registry_1 = require("./lib/utils/project-registry");
+function git(root) {
+    try {
+        return {
+            head: (0, node_child_process_1.execFileSync)("git", ["rev-parse", "HEAD"], {
+                cwd: root,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim(),
+            dirty: (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain"], {
+                cwd: root,
+                encoding: "utf8",
+                stdio: ["ignore", "pipe", "ignore"],
+            }).trim().length > 0,
+        };
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function run() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        var _e, _f;
+        const { values } = (0, node_util_1.parseArgs)({
+            options: {
+                fixture: { type: "string" },
+                sha256: { type: "string" },
+                output: { type: "string" },
+                repeats: { type: "string", default: "2" },
+                help: { type: "boolean" },
+                diagnostics: { type: "boolean", default: false },
+            },
+        });
+        if (values.help) {
+            console.log("pnpm bench:relevance --fixture <json> --sha256 <frozen-sha256> --output <new-json> [--repeats 2] [--diagnostics]");
+            return;
+        }
+        if (!values.fixture || !values.sha256 || !values.output)
+            throw new Error("Required: --fixture, --sha256, --output");
+        if (fs.existsSync(values.output))
+            throw new Error("Output exists; use a new artifact path");
+        const checkpoint = `${values.output}.samples.jsonl`;
+        if (fs.existsSync(checkpoint))
+            throw new Error("Checkpoint exists; use a new artifact path");
+        const repeats = Number(values.repeats);
+        if (!Number.isInteger(repeats) || repeats < 1 || repeats > 5)
+            throw new Error("Repeats must be 1–5");
+        const fixturePath = path.resolve(values.fixture);
+        const fixture = (0, relevance_baseline_1.parseFrozenFixture)(fs.readFileSync(fixturePath), values.sha256);
+        const roots = new Map(fixture.corpora.map((r) => [
+            r.id,
+            fs.realpathSync(path.resolve(path.dirname(fixturePath), r.root)),
+        ]));
+        const startedAt = new Date().toISOString();
+        const ping = yield (0, daemon_client_1.sendDaemonCommand)({ cmd: "ping" }, { timeoutMs: 5000 });
+        if (!ping.ok || ping.ready !== true)
+            throw new Error("An already-ready daemon is required; no autostart/fallback");
+        if (values.diagnostics &&
+            ((_a = ping.capabilities) === null || _a === void 0 ? void 0 : _a.searchDiagnostics) !== 1)
+            throw new Error("Daemon lacks searchDiagnostics v1; install/restart a compatible daemon before measuring diagnostics");
+        const before = yield (0, daemon_client_1.sendDaemonCommand)({ cmd: "status" });
+        if (!before.ok)
+            throw new Error("Cannot capture daemon status");
+        const registry = (0, project_registry_1.listProjects)();
+        const cache = (0, lmdb_1.open)({
+            path: path.join(config_1.PATHS.globalRoot, "cache/meta.lmdb"),
+            compression: true,
+            readOnly: true,
+        });
+        const samples = [];
+        const preflight = [];
+        fs.writeFileSync(checkpoint, "", { flag: "wx" });
+        try {
+            for (const corpus of fixture.corpora) {
+                const root = roots.get(corpus.id);
+                const project = registry.find((p) => p.root === root);
+                if ((project === null || project === void 0 ? void 0 : project.status) !== "indexed")
+                    throw new Error(`Corpus is not indexed: ${corpus.id}`);
+                const files = [
+                    ...new Set(fixture.cases
+                        .filter((c) => c.corpus === corpus.id)
+                        .flatMap((c) => c.expected.map((t) => t.file))),
+                ];
+                const rows = yield (0, daemon_client_1.sendDaemonCommand)({
+                    cmd: "rows.locate",
+                    projectRoot: root,
+                    limit: 500,
+                    select: ["path", "defined_symbols", "start_line", "end_line"],
+                    matches: files.map((file) => ({ kind: "path", path: file })),
+                });
+                if (!rows.ok || !Array.isArray(rows.rows))
+                    throw new Error(`Target inventory failed: ${corpus.id}`);
+                preflight.push({
+                    corpus: corpus.id,
+                    root,
+                    git: git(root),
+                    project,
+                    files,
+                    targetRows: rows.rows,
+                    cache: files.map((file) => (Object.assign({ file }, cache.get(path.join(root, file))))),
+                });
+            }
+            // Sequential execution bounds load. Interleave corpora instead of running
+            // all of one corpus first; repetitions are reported separately from cases.
+            const ordered = [];
+            const groups = fixture.corpora.map((r) => fixture.cases.filter((c) => c.corpus === r.id));
+            for (let i = 0; i < Math.max(...groups.map((g) => g.length)); i++) {
+                for (const group of groups)
+                    if (group[i])
+                        ordered.push(group[i]);
+            }
+            for (let repetition = 1; repetition <= repeats; repetition++) {
+                for (const c of ordered) {
+                    const root = roots.get(c.corpus);
+                    const exclusions = new Set();
+                    const inventory = preflight.find((r) => r.corpus === c.corpus);
+                    for (const t of c.expected) {
+                        const file = path.join(root, t.file);
+                        if (fs.realpathSync(file) !== file)
+                            throw new Error(`Target aliases are not frozen: ${c.id}`);
+                        for (const reason of (0, relevance_baseline_1.sourceExclusions)(t.sourceSha256, (0, relevance_baseline_1.sha256)(fs.readFileSync(file)), (_b = cache.get(file)) === null || _b === void 0 ? void 0 : _b.hash))
+                            exclusions.add(reason);
+                        const indexed = inventory.targetRows
+                            .flat()
+                            .some((row) => (0, relevance_baseline_1.matchesTarget)({
+                            type: "text",
+                            score: 0,
+                            metadata: { path: String(row.path), hash: "" },
+                            defined_symbols: row.defined_symbols,
+                            generated_metadata: {
+                                start_line: Number(row.start_line),
+                                num_lines: Number(row.end_line) - Number(row.start_line) + 1,
+                            },
+                        }, root, t));
+                        if (!indexed)
+                            exclusions.add("target_not_in_index");
+                    }
+                    const start = performance.now();
+                    const response = exclusions.size === 0
+                        ? yield (0, daemon_client_1.sendDaemonCommand)({
+                            cmd: "search",
+                            projectRoot: root,
+                            query: c.query,
+                            limit: 20,
+                            pathPrefix: `${root}${path.sep}`,
+                            rerank: false,
+                            explain: true,
+                            diagnostics: values.diagnostics,
+                        }, { timeoutMs: 60000 })
+                        : { ok: false, error: "preflight_excluded" };
+                    const elapsedMs = performance.now() - start;
+                    if (values.diagnostics &&
+                        response.ok &&
+                        ((_c = response.diagnostics) === null || _c === void 0 ? void 0 : _c.schemaVersion) !== 1)
+                        exclusions.add("diagnostics_missing");
+                    if (!response.ok)
+                        exclusions.add(String((_e = response.error) !== null && _e !== void 0 ? _e : "search_failed"));
+                    const data = Array.isArray(response.data)
+                        ? response.data
+                        : [];
+                    const state = response.indexState;
+                    if (state &&
+                        (state.indexing ||
+                            state.verifying ||
+                            state.degraded ||
+                            Number(state.pendingFiles) > 0 ||
+                            Number(state.failedFiles) > 0))
+                        exclusions.add("index_unsettled");
+                    const warnings = Array.isArray(response.warnings)
+                        ? response.warnings
+                        : [];
+                    if (warnings.length)
+                        exclusions.add("search_warning");
+                    for (const t of c.expected) {
+                        const file = path.join(root, t.file);
+                        for (const reason of (0, relevance_baseline_1.sourceExclusions)(t.sourceSha256, (0, relevance_baseline_1.sha256)(fs.readFileSync(file)), (_d = cache.get(file)) === null || _d === void 0 ? void 0 : _d.hash))
+                            exclusions.add(reason);
+                        if (data.some((d) => { var _a; return ((_a = d.metadata) === null || _a === void 0 ? void 0 : _a.path) === file && d.metadata.hash !== t.sourceSha256; }))
+                            exclusions.add("returned_row_hash_mismatch");
+                    }
+                    const ranked = { data };
+                    samples.push(Object.assign(Object.assign({}, (0, relevance_baseline_1.scoreRelevance)(ranked, root, c)), { id: c.id, corpus: c.corpus, split: c.split, repetition,
+                        elapsedMs, exclusions: [...exclusions], query: c.query, intent: c.intent, origin: c.origin, warnings, indexState: state !== null && state !== void 0 ? state : null, error: response.ok ? null : response.error, diagnostics: (_f = response.diagnostics) !== null && _f !== void 0 ? _f : null, results: data.map((d) => { var _a, _b; var _c, _d, _e, _f, _g; return ({
+                            path: path.relative(root, String((_c = (_a = d.metadata) === null || _a === void 0 ? void 0 : _a.path) !== null && _c !== void 0 ? _c : "")),
+                            hash: (_d = (_b = d.metadata) === null || _b === void 0 ? void 0 : _b.hash) !== null && _d !== void 0 ? _d : null,
+                            symbols: (_e = d.defined_symbols) !== null && _e !== void 0 ? _e : [],
+                            range: (_f = d.generated_metadata) !== null && _f !== void 0 ? _f : null,
+                            score: d.score,
+                            scoreBreakdown: (_g = d.scoreBreakdown) !== null && _g !== void 0 ? _g : null,
+                        }); }) }));
+                    fs.appendFileSync(checkpoint, `${JSON.stringify(samples[samples.length - 1])}\n`);
+                    console.error(`${c.id} repeat=${repetition} rank=${samples[samples.length - 1].rank} excluded=${[...exclusions].join(",") || "none"}`);
+                }
+            }
+        }
+        finally {
+            cache.close();
+        }
+        const afterPing = yield (0, daemon_client_1.sendDaemonCommand)({ cmd: "ping" });
+        const after = yield (0, daemon_client_1.sendDaemonCommand)({ cmd: "status" });
+        if (!afterPing.ok ||
+            after.pid !== before.pid ||
+            afterPing.version !== ping.version) {
+            for (const sample of samples)
+                sample.exclusions.push("daemon_changed");
+        }
+        if ((0, relevance_baseline_1.sha256)(fs.readFileSync(fixturePath)) !== values.sha256)
+            throw new Error("Frozen fixture changed during execution");
+        const report = {
+            schemaVersion: 1,
+            startedAt,
+            finishedAt: new Date().toISOString(),
+            fixtureSha256: values.sha256,
+            fixture,
+            source: {
+                git: git(process.cwd()),
+                node: process.version,
+                evaluatorHash: (0, relevance_baseline_1.sha256)(fs.readFileSync(__filename)),
+                scoringHash: (0, relevance_baseline_1.sha256)(fs.readFileSync(path.join(__dirname, "lib/eval/relevance-baseline.ts"))),
+                searcherHash: (0, relevance_baseline_1.sha256)(fs.readFileSync(path.join(__dirname, "lib/search/searcher.ts"))),
+                diagnosticsHash: (0, relevance_baseline_1.sha256)(fs.readFileSync(path.join(__dirname, "lib/search/diagnostics.ts"))),
+            },
+            execution: {
+                transport: "existing-daemon-ipc",
+                requestedRerank: false,
+                explain: true,
+                requestedDiagnostics: values.diagnostics,
+                limit: 20,
+                repeats,
+                ping,
+                before,
+                afterPing,
+                after,
+                preflight,
+                diagnostics: {
+                    fusionPool: values.diagnostics
+                        ? "bounded-post-seed-head-200"
+                        : "unobserved",
+                    concentrationGate: values.diagnostics
+                        ? "per-sample-diagnostics"
+                        : "unobserved",
+                    daemonRankingEnvironment: values.diagnostics
+                        ? "allowlisted-per-sample-diagnostics"
+                        : "unobserved",
+                    ftsHealth: values.diagnostics
+                        ? "per-sample-diagnostics"
+                        : "warnings-and-score-breakdowns-only",
+                    trueRerankOff: "not-asserted",
+                },
+            },
+            summary: (0, relevance_baseline_1.summarizeRelevance)(samples),
+            byCorpus: fixture.corpora.map((r) => (Object.assign({ corpus: r.id }, (0, relevance_baseline_1.summarizeRelevance)(samples.filter((s) => s.corpus === r.id))))),
+            bySplit: ["dev", "heldout"].map((split) => (Object.assign({ split }, (0, relevance_baseline_1.summarizeRelevance)(samples.filter((s) => s.split === split))))),
+            byIntent: [...new Set(fixture.cases.map((c) => c.intent))].map((intent) => (Object.assign({ intent }, (0, relevance_baseline_1.summarizeRelevance)(samples.filter((s) => s.intent === intent))))),
+            samples,
+            researchGateReady: false,
+            limitations: [
+                "Curated source-grounded cases are not observed user-session misses",
+                values.diagnostics
+                    ? "Candidate trace is limited to the post-seed fusion head; absence from a truncated trace does not prove retrieval failure"
+                    : "Pipeline diagnostics were not requested",
+                "Client environment cannot change daemon ranking settings",
+                "Latencies mix ordinary daemon activity and first/repeated queries",
+            ],
+        };
+        fs.writeFileSync(values.output, `${JSON.stringify(report, null, 2)}\n`, {
+            flag: "wx",
+        });
+        console.log(JSON.stringify({
+            output: values.output,
+            summary: report.summary,
+            byCorpus: report.byCorpus,
+            bySplit: report.bySplit,
+        }, null, 2));
+        if (samples.some((s) => s.exclusions.length > 0))
+            process.exitCode = 2;
+    });
+}
+if (require.main === module)
+    run().catch((error) => {
+        console.error(error);
+        process.exitCode = 1;
+    });

package/dist/eval.js

@@ -527,9 +527,10 @@ function evaluateCase(response, evalCase, timeMs) {
     const avoidRank = response.data.findIndex((chunk) => { var _a, _b, _c; return (_b = (_a = chunk.metadata) === null || _a === void 0 ? void 0 : _a.path) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes(((_c = evalCase.avoidPath) === null || _c === void 0 ? void 0 : _c.toLowerCase()) || "_____"); });
     const hitAvoid = evalCase.avoidPath && avoidRank >= 0 && (rank === -1 || avoidRank < rank);
     const found = rank >= 0 && !hitAvoid;
-    const rr = found ? 1 / (rank + 1) : 0;
     const recall = found && rank < 10 ? 1 : 0;
+    const rr = recall ? 1 / (rank + 1) : 0;
     return {
+        rank: rank + 1,
         rr,
         found,
         recall,
@@ -619,7 +620,7 @@ function run() {
             console.log(`Eval results for store at: ${paths.lancedbDir}`);
             console.log("=".repeat(80));
             results.forEach((r) => {
-                const status = r.found ? `rank ${(1 / r.rr).toFixed(0)}` : "❌ missed";
+                const status = r.found ? `rank ${r.rank}` : "❌ missed";
                 const emoji = r.found ? (r.rr === 1 ? "🎯" : "✓") : "❌";
                 console.log(`${emoji} ${r.query}`);
                 console.log(`   => ${status} (target: ${r.path}) [${r.timeMs.toFixed(0)}ms]`);
@@ -628,7 +629,7 @@ function run() {
                 }
             });
             console.log("=".repeat(80));
-            console.log(`MRR: ${mrr.toFixed(3)}`);
+            console.log(`MRR@10: ${mrr.toFixed(3)}`);
             console.log(`Recall@10: ${recallAt10.toFixed(3)}`);
             console.log(`Avg query time: ${avgTime.toFixed(0)}ms`);
             console.log(`Total time: ${totalTime.toFixed(0)}ms`);

package/dist/lib/daemon/ipc-handler.js

@@ -50,6 +50,7 @@ exports.handleCommand = handleCommand;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const config_1 = require("../../config");
+const per_file_1 = require("../search/per-file");
 const logger_1 = require("../utils/logger");
 const operation_coordinator_1 = require("../utils/operation-coordinator");
 const path_containment_1 = require("../utils/path-containment");
@@ -152,6 +153,8 @@ function handleCommand(daemon, cmd, conn) {
                         capabilities: {
                             exclusiveGenerationRebuild: exports.EXCLUSIVE_GENERATION_REBUILD_PROTOCOL,
                             readVerbs: read_verbs_1.READ_VERBS_PROTOCOL,
+                            searchDiagnostics: 1,
+                            perFileSearch: 1,
                             // `watch`/`unwatch` accept holder/pid/ttlMs. A daemon without this
                             // treats `unwatch` as unwatch-for-everyone, so clients releasing a
                             // single lease must check it first.
@@ -231,6 +234,13 @@ function handleCommand(daemon, cmd, conn) {
                     conn.on("close", onClose);
                     try {
                         const limitRaw = typeof cmd.limit === "number" ? cmd.limit : 10;
+                        let maxPerFile;
+                        try {
+                            maxPerFile = (0, per_file_1.validateMaxPerFile)(cmd.maxPerFile);
+                        }
+                        catch (_m) {
+                            return { ok: false, error: "invalid maxPerFile" };
+                        }
                         if (!Number.isInteger(limitRaw) || limitRaw < 1 || limitRaw > 1000) {
                             return { ok: false, error: "invalid limit" };
                         }
@@ -295,10 +305,12 @@ function handleCommand(daemon, cmd, conn) {
                             projectRoot,
                             query,
                             limit: limitRaw,
+                            maxPerFile,
                             filters,
                             pathPrefix,
                             rerank: cmd.rerank === true,
                             explain: cmd.explain === true,
+                            diagnostics: cmd.diagnostics === true,
                             seeds: cmd.seeds &&
                                 typeof cmd.seeds === "object" &&
                                 !Array.isArray(cmd.seeds)

package/dist/lib/daemon/search-handler.js

@@ -45,6 +45,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleDaemonSearch = handleDaemonSearch;
 const embedding_generation_1 = require("../index/embedding-generation");
 const index_state_footer_1 = require("../output/index-state-footer");
+const per_file_1 = require("../search/per-file");
 const searcher_1 = require("../search/searcher");
 const retriever_1 = require("../skeleton/retriever");
 const project_registry_1 = require("../utils/project-registry");
@@ -57,6 +58,13 @@ function handleDaemonSearch(deps, payload, signal) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b, _c, _d;
         var _e, _f, _g;
+        let maxPerFile;
+        try {
+            maxPerFile = (0, per_file_1.validateMaxPerFile)(payload.maxPerFile);
+        }
+        catch (_h) {
+            return { ok: false, error: "invalid maxPerFile" };
+        }
         const { vectorDb, workerPool } = deps;
         if (!vectorDb || !workerPool) {
             return { ok: false, error: "daemon not ready" };
@@ -103,6 +111,8 @@ function handleDaemonSearch(deps, payload, signal) {
             result = yield searcher.search(payload.query, payload.limit, {
                 rerank: payload.rerank === true,
                 explain: payload.explain === true,
+                diagnostics: payload.diagnostics === true,
+                maxPerFile,
                 seeds: payload.seeds,
             }, payload.filters, payload.pathPrefix, undefined, signal);
         }
@@ -116,6 +126,8 @@ function handleDaemonSearch(deps, payload, signal) {
         const response = { ok: true, data: result.data };
         if ((_c = result.warnings) === null || _c === void 0 ? void 0 : _c.length)
             response.warnings = result.warnings;
+        if (payload.diagnostics === true && result.diagnostics)
+            response.diagnostics = result.diagnostics;
         // Annotate partial results when the index is still catching up, so an
         // agent can caveat or retry. Settled failures remain visible too.
         const idx = deps.getIndexState(root);
@@ -152,7 +164,7 @@ function handleDaemonSearch(deps, payload, signal) {
                     if (sk)
                         skeletons[p] = sk;
                 }
-                catch (_h) {
+                catch (_j) {
                     // best-effort — drop the entry, keep the search result
                 }
             }
@@ -167,7 +179,7 @@ function handleDaemonSearch(deps, payload, signal) {
                 const builder = new GraphBuilder(vectorDb, root);
                 response.graph = yield builder.buildGraphMultiHop(payload.query, 1);
             }
-            catch (_j) {
+            catch (_k) {
                 // best-effort — drop graph, keep results
             }
         }

package/dist/lib/eval/relevance-baseline.js

@@ -0,0 +1,174 @@
+"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.relevanceFixtureSchema = void 0;
+exports.sha256 = sha256;
+exports.parseFrozenFixture = parseFrozenFixture;
+exports.matchesTarget = matchesTarget;
+exports.scoreRelevance = scoreRelevance;
+exports.summarizeRelevance = summarizeRelevance;
+exports.sourceExclusions = sourceExclusions;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const zod_1 = require("zod");
+const digest = zod_1.z.string().regex(/^[a-f0-9]{64}$/);
+const targetSchema = zod_1.z
+    .object({
+    file: zod_1.z.string().min(1),
+    symbol: zod_1.z.string().min(1),
+    match: zod_1.z.enum(["symbol-or-range", "range"]).optional(),
+    startLine: zod_1.z.number().int().positive(),
+    endLine: zod_1.z.number().int().positive(),
+    sourceSha256: digest,
+})
+    .strict()
+    .refine((t) => t.endLine >= t.startLine, "Reversed target range");
+exports.relevanceFixtureSchema = zod_1.z
+    .object({
+    schemaVersion: zod_1.z.literal(1),
+    createdAt: zod_1.z.string().min(1),
+    purpose: zod_1.z.string().min(1),
+    corpora: zod_1.z
+        .array(zod_1.z
+        .object({
+        id: zod_1.z.string().min(1),
+        root: zod_1.z.string().min(1),
+        language: zod_1.z.string().min(1),
+    })
+        .strict())
+        .min(1),
+    cases: zod_1.z
+        .array(zod_1.z
+        .object({
+        id: zod_1.z.string().min(1),
+        corpus: zod_1.z.string().min(1),
+        split: zod_1.z.enum(["dev", "heldout"]),
+        origin: zod_1.z.enum(["curated-source", "observed-session"]),
+        intent: zod_1.z.string().min(1),
+        query: zod_1.z.string().min(1),
+        expected: zod_1.z.array(targetSchema).min(1),
+    })
+        .strict())
+        .min(1),
+})
+    .strict()
+    .superRefine((fixture, ctx) => {
+    for (const values of [fixture.corpora, fixture.cases]) {
+        if (new Set(values.map((v) => v.id)).size !== values.length) {
+            ctx.addIssue({ code: "custom", message: "Duplicate fixture IDs" });
+        }
+    }
+    for (const c of fixture.cases) {
+        if (!fixture.corpora.some((r) => r.id === c.corpus)) {
+            ctx.addIssue({
+                code: "custom",
+                message: `Unknown corpus: ${c.corpus}`,
+            });
+        }
+        for (const target of c.expected) {
+            if (path.isAbsolute(target.file) ||
+                target.file.split(/[\\/]/).includes("..")) {
+                ctx.addIssue({
+                    code: "custom",
+                    message: "Targets must be contained relative paths",
+                });
+            }
+        }
+    }
+});
+function sha256(bytes) {
+    return (0, node_crypto_1.createHash)("sha256").update(bytes).digest("hex");
+}
+function parseFrozenFixture(bytes, expectedSha256) {
+    if (!digest.safeParse(expectedSha256).success ||
+        sha256(bytes) !== expectedSha256) {
+        throw new Error("Fixture checksum mismatch; freeze the reviewed fixture before measuring");
+    }
+    return exports.relevanceFixtureSchema.parse(JSON.parse(bytes.toString("utf8")));
+}
+/** Exact file plus the frozen matching rule; legacy fixtures allow symbol or range. */
+function matchesTarget(chunk, root, target) {
+    var _a, _b, _c, _d;
+    if (typeof ((_a = chunk.metadata) === null || _a === void 0 ? void 0 : _a.path) !== "string")
+        return false;
+    if (path.resolve(chunk.metadata.path) !== path.resolve(root, target.file))
+        return false;
+    if (target.match !== "range" &&
+        ((_b = chunk.defined_symbols) === null || _b === void 0 ? void 0 : _b.includes(target.symbol)))
+        return true;
+    const start = (_c = chunk.generated_metadata) === null || _c === void 0 ? void 0 : _c.start_line;
+    const count = (_d = chunk.generated_metadata) === null || _d === void 0 ? void 0 : _d.num_lines;
+    if (typeof start !== "number" || typeof count !== "number" || count <= 0)
+        return false;
+    // SearchResponse ranges start at zero; source fixtures use one-based lines.
+    return start + 1 <= target.endLine && start + count >= target.startLine;
+}
+function scoreRelevance(response, root, c) {
+    const index = response.data.findIndex((chunk) => c.expected.some((t) => matchesTarget(chunk, root, t)));
+    const rank = index + 1;
+    return {
+        rank,
+        rrAt10: rank > 0 && rank <= 10 ? 1 / rank : 0,
+        recallAt10: rank > 0 && rank <= 10 ? 1 : 0,
+        hitAt1: rank === 1 ? 1 : 0,
+        found: rank > 0,
+    };
+}
+function summarizeRelevance(samples) {
+    const valid = samples.filter((s) => s.exclusions.length === 0);
+    const times = valid.map((s) => s.elapsedMs).sort((a, b) => a - b);
+    const mean = (key) => valid.length
+        ? valid.reduce((sum, s) => sum + s[key], 0) / valid.length
+        : null;
+    return {
+        cases: new Set(samples.map((s) => s.id)).size,
+        samples: samples.length,
+        validSamples: valid.length,
+        excludedSamples: samples.length - valid.length,
+        mrrAt10: mean("rrAt10"),
+        recallAt10: mean("recallAt10"),
+        hitsAt1: mean("hitAt1"),
+        medianMs: times.length ? times[Math.ceil(times.length / 2) - 1] : null,
+        p95Ms: times.length ? times[Math.ceil(times.length * 0.95) - 1] : null,
+    };
+}
+function sourceExclusions(frozenHash, sourceHash, cacheHash) {
+    const reasons = [];
+    if (sourceHash !== frozenHash)
+        reasons.push("source_changed");
+    if (cacheHash !== frozenHash)
+        reasons.push("index_cache_hash_mismatch");
+    return reasons;
+}