@unbrained/pm-cli 2026.9.7 → 2026.9.9

package/dist/core/search/background-refresh.js

@@ -1,287 +1,3 @@
-/**
- * @module core/search/background-refresh
- *
- * Powers search, embeddings, and semantic retrieval behavior for Background Refresh.
- */
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="d8d5f7e9-5293-564b-bc44-f5ba30336893")}catch(e){}}();
-import { spawn } from "node:child_process";
-import { mkdirSync, rmSync, statSync } from "node:fs";
-import path from "node:path";
-import { pathExists, readFileIfExists, writeFileAtomic, } from "../fs/fs-utils.js";
-import { acquireLock } from "../lock/lock.js";
-import { resolvePmPackageRootFromModule } from "../packages/root.js";
-import { readSettingsWithMetadata } from "../store/settings.js";
-import { toErrorMessage } from "../shared/primitives.js";
-import { resolveAuthor } from "../shared/author.js";
-import { resolveSettingsWithSemanticRuntimeDefaults } from "./semantic-defaults.js";
-/** Shared lock id for any process that rewrites the local vector store. Reindex and the background mutation-refresh worker both acquire this so they never write concurrently and corrupt the store. Exported so `pm reindex` reuses the same id rather than duplicating the literal. */
-export const REINDEX_LOCK_ID = "reindex";
-const PENDING_QUEUE_REL_PATH = "search/pending-refresh.json";
-const PENDING_QUEUE_GATE_REL_PATH = "search/pending-refresh.gate.lock";
-const PENDING_QUEUE_GATE_STALE_MS = 30_000;
-const SEARCH_REFRESH_INLINE_ENV = "PM_SEARCH_REFRESH_INLINE";
-const SEARCH_REFRESH_CHILD_ENV = "PM_SEARCH_REFRESH_CHILD";
-/** Delay before a settings-failed worker dispatches one replacement child, preventing a tight retry loop while preserving eventual queue recovery. */
-export const SEARCH_REFRESH_RETRY_DELAY_MS = 30_000;
-function parseBooleanTrueLike(value) {
-    if (typeof value !== "string") {
-        return false;
-    }
-    const normalized = value.trim().toLowerCase();
-    return (normalized === "1" ||
-        normalized === "true" ||
-        normalized === "yes" ||
-        normalized === "on");
-}
-/** Mutation search refresh runs inline (blocking) under test runners, inside the background worker child itself, or when explicitly requested. Otherwise the semantic refresh is dispatched to a detached child so mutations return without waiting on embeddings. Mirrors the telemetry-flush inline gate so the full test suite stays deterministic. */
-export function shouldRunSearchRefreshInForeground() {
-    if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_INLINE_ENV])) {
-        return true;
-    }
-    if (parseBooleanTrueLike(process.env[SEARCH_REFRESH_CHILD_ENV])) {
-        return true;
-    }
-    const nodeEnv = (process.env.NODE_ENV ?? "").trim().toLowerCase();
-    return (typeof process.env.VITEST === "string" ||
-        typeof process.env.VITEST_WORKER_ID === "string" ||
-        nodeEnv === "test");
-}
-function pendingQueuePath(pmRoot) {
-    return path.join(pmRoot, PENDING_QUEUE_REL_PATH);
-}
-function pendingQueueGatePath(pmRoot) {
-    return path.join(pmRoot, PENDING_QUEUE_GATE_REL_PATH);
-}
-function acquireQueueGate(pmRoot) {
-    const gatePath = pendingQueueGatePath(pmRoot);
-    try {
-        if (Date.now() - statSync(gatePath).mtimeMs < PENDING_QUEUE_GATE_STALE_MS) {
-            return false;
-        }
-        rmSync(gatePath, { recursive: true, force: true });
-    }
-    catch {
-        // Missing gate is the common case; fall through to create it.
-    }
-    try {
-        mkdirSync(path.dirname(gatePath), { recursive: true });
-        mkdirSync(gatePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function releaseQueueGate(pmRoot) {
-    try {
-        rmSync(pendingQueueGatePath(pmRoot), { recursive: true, force: true });
-    }
-    catch {
-        // Best effort; a stale gate self-heals after PENDING_QUEUE_GATE_STALE_MS.
-    }
-}
-async function withQueueGate(pmRoot, fn, fallback) {
-    // Briefly serialize read-modify-write access to the pending queue across the
-    // mutation process and the worker child. Acquisition is best effort; if a
-    // healthy gate is held we skip rather than risk a torn queue.
-    for (let attempt = 0; attempt < 50; attempt += 1) {
-        if (acquireQueueGate(pmRoot)) {
-            try {
-                return await fn();
-            }
-            finally {
-                releaseQueueGate(pmRoot);
-            }
-        }
-        await delay(20);
-    }
-    return fallback;
-}
-function delay(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
-async function readPendingQueueIds(pmRoot) {
-    const raw = await readFileIfExists(pendingQueuePath(pmRoot));
-    if (!raw || raw.trim().length === 0) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed.ids)) {
-            return [];
-        }
-        return parsed.ids.filter((id) => typeof id === "string" && id.length > 0);
-    }
-    catch {
-        return [];
-    }
-}
-async function writePendingQueueIds(pmRoot, ids) {
-    await writeFileAtomic(pendingQueuePath(pmRoot), `${JSON.stringify({ ids })}\n`);
-}
-/** Merge mutated item ids into the persistent pending-refresh queue. */
-export async function enqueuePendingRefreshIds(pmRoot, itemIds) {
-    const incoming = itemIds.filter((id) => typeof id === "string" && id.trim().length > 0);
-    if (incoming.length === 0) {
-        return;
-    }
-    const mergeIncoming = async () => {
-        const existing = await readPendingQueueIds(pmRoot);
-        const merged = [...new Set([...existing, ...incoming])].sort((left, right) => left.localeCompare(right));
-        await writePendingQueueIds(pmRoot, merged);
-    };
-    const gated = await withQueueGate(pmRoot, async () => {
-        await mergeIncoming();
-        return true;
-    }, false);
-    if (!gated) {
-        // The gate stayed contended past the retry budget. Never silently drop a
-        // mutation's refresh work: fall back to a best-effort unguarded merge.
-        // writeFileAtomic keeps the file valid; the only risk is losing a concurrent
-        // writer's delta, which its own next dispatch and the vector_index_stale
-        // warning both recover.
-        await mergeIncoming();
-    }
-}
-/** Atomically read and clear the pending-refresh queue, returning drained ids. */
-export async function drainPendingRefreshIds(pmRoot) {
-    return withQueueGate(pmRoot, async () => {
-        const ids = await readPendingQueueIds(pmRoot);
-        if (ids.length > 0) {
-            await writePendingQueueIds(pmRoot, []);
-        }
-        return ids;
-    }, []);
-}
-function searchRefreshRunnerPath() {
-    return path.join(resolvePmPackageRootFromModule(import.meta.url, ["../../.."]), "dist", "cli", "search-refresh.js");
-}
-/** Spawn the detached refresh worker child for this pm root. Best effort: a failed dispatch must never keep the CLI alive or fail a mutation; the next mutation re-dispatches and `vector_index_stale` warns about the catch-up window in the meantime. */
-function dispatchRefreshChild(pmRoot) {
-    try {
-        const child = spawn(process.execPath, [searchRefreshRunnerPath()], {
-            detached: true,
-            stdio: "ignore",
-            env: {
-                ...process.env,
-                PM_PATH: pmRoot,
-                [SEARCH_REFRESH_CHILD_ENV]: "1",
-            },
-        });
-        // A detached child can emit an async 'error' event (e.g. spawn EAGAIN/ENOENT,
-        // resource limits). Swallow it so it never becomes an unhandled error that
-        // crashes the parent CLI; dispatch is best effort.
-        child.on("error", () => { });
-        child.unref();
-    }
-    catch {
-        // Best effort — see doc comment above.
-    }
-}
-function scheduleDelayedRefreshRetry(pmRoot) {
-    setTimeout(() => dispatchRefreshChild(pmRoot), SEARCH_REFRESH_RETRY_DELAY_MS);
-}
-/** Enqueue mutated ids and dispatch a detached worker child to refresh semantic embeddings without blocking the mutation. The reindex lock the worker acquires serializes concurrent refreshes, so the spawn itself stays unconditional and cheap; a worker that loses the lock exits and its ids are drained by the holder. */
-export async function scheduleBackgroundSemanticRefresh(pmRoot, itemIds) {
-    await enqueuePendingRefreshIds(pmRoot, itemIds);
-    dispatchRefreshChild(pmRoot);
-}
-/** Drain the pending queue and refresh semantic vectors under the reindex lock so the local vector store is never rewritten concurrently. If the lock is held by another worker we exit immediately — that holder drains our enqueued ids. After releasing we re-check the queue once and re-dispatch if a sibling enqueued ids during our final window, guaranteeing eventual processing. */
-export async function runSemanticRefreshWorker(pmRoot, refresh, scheduleRetry = scheduleDelayedRefreshRetry) {
-    const warnings = [];
-    const processed = [];
-    if (!(await pathExists(pmRoot))) {
-        return { processed, rounds: 0, warnings };
-    }
-    let settings;
-    try {
-        const settingsRead = await readSettingsWithMetadata(pmRoot);
-        const readFailure = settingsRead.warnings.find((warning) => warning.startsWith("settings_read_"));
-        if (readFailure) {
-            scheduleRetry(pmRoot);
-            return {
-                processed,
-                rounds: 0,
-                warnings: [
-                    `search_background_refresh_settings_read_failed:${readFailure}`,
-                ],
-            };
-        }
-        settings = resolveSettingsWithSemanticRuntimeDefaults(settingsRead.settings).settings;
-    }
-    catch (error) {
-        scheduleRetry(pmRoot);
-        return {
-            processed,
-            rounds: 0,
-            warnings: [
-                `search_background_refresh_settings_read_failed:${toErrorMessage(error)}`,
-            ],
-        };
-    }
-    let release = null;
-    try {
-        release = await acquireLock(pmRoot, REINDEX_LOCK_ID, settings.locks.ttl_seconds, resolveAuthor(undefined, "pm-search-refresh"), false, settings.governance.force_required_for_stale_lock, settings.locks.wait_ms);
-    }
-    catch {
-        // acquireLock owns the bounded wait budget; queued ids remain for the next dispatch.
-    }
-    if (!release) {
-        return { processed, rounds: 0, warnings };
-    }
-    let rounds = 0;
-    let failed = false;
-    let retryPending = false;
-    try {
-        for (;;) {
-            const ids = await drainPendingRefreshIds(pmRoot);
-            if (ids.length === 0) {
-                break;
-            }
-            rounds += 1;
-            try {
-                const result = await refresh(pmRoot, ids);
-                warnings.push(...result.warnings);
-                if (result.warnings.some((warning) => warning.startsWith("search_semantic_refresh_skipped:settings_read_failed:"))) {
-                    await enqueuePendingRefreshIds(pmRoot, ids);
-                    failed = true;
-                    retryPending = true;
-                    break;
-                }
-                processed.push(...result.refreshed);
-            }
-            catch (error) {
-                warnings.push(`search_background_refresh_failed:${toErrorMessage(error)}`);
-                // Re-enqueue so the work is retried by a later dispatch rather than lost.
-                await enqueuePendingRefreshIds(pmRoot, ids);
-                failed = true;
-                break;
-            }
-        }
-    }
-    finally {
-        await release?.();
-    }
-    if (retryPending) {
-        scheduleRetry(pmRoot);
-    }
-    // Close the race where a sibling enqueued ids between our last empty drain and
-    // releasing the lock: re-dispatch so those ids are eventually processed. Skip
-    // this after a refresh failure — the failed ids were re-enqueued and an
-    // immediate respawn would just fail again, spinning indefinitely. They wait
-    // for the next mutation's dispatch instead.
-    const remaining = failed ? [] : await readPendingQueueIds(pmRoot);
-    if (remaining.length > 0) {
-        dispatchRefreshChild(pmRoot);
-    }
-    return {
-        processed: [...new Set(processed)].sort((a, b) => a.localeCompare(b)),
-        rounds,
-        warnings,
-    };
-}
+!(function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="22112449-f1ab-5b6b-a9bb-37e5d3c5b83a")}catch(e2){}})();import{spawn}from"node:child_process";import{mkdirSync,rmSync,statSync}from"node:fs";import path from"node:path";import{pathExists,readFileIfExists,writeFileAtomic}from"../fs/fs-utils.js";import{acquireLock}from"../lock/lock.js";import{resolvePmPackageRootFromModule}from"../packages/root.js";import{readSettingsWithMetadata}from"../store/settings.js";import{toErrorMessage}from"../shared/primitives.js";import{resolveAuthor}from"../shared/author.js";import{resolveSettingsWithSemanticRuntimeDefaults}from"./semantic-defaults.js";const REINDEX_LOCK_ID="reindex";const PENDING_QUEUE_REL_PATH="search/pending-refresh.json";const PENDING_QUEUE_GATE_REL_PATH="search/pending-refresh.gate.lock";const PENDING_QUEUE_GATE_STALE_MS=3e4;const SEARCH_REFRESH_INLINE_ENV="PM_SEARCH_REFRESH_INLINE";const SEARCH_REFRESH_CHILD_ENV="PM_SEARCH_REFRESH_CHILD";const SEARCH_REFRESH_RETRY_DELAY_MS=3e4;function parseBooleanTrueLike(value){if(typeof value!=="string"){return false}const normalized=value.trim().toLowerCase();return normalized==="1"||normalized==="true"||normalized==="yes"||normalized==="on"}function shouldRunSearchRefreshInForeground(){if(parseBooleanTrueLike(process.env[SEARCH_REFRESH_INLINE_ENV])){return true}if(parseBooleanTrueLike(process.env[SEARCH_REFRESH_CHILD_ENV])){return true}const nodeEnv=(process.env.NODE_ENV??"").trim().toLowerCase();return typeof process.env.VITEST==="string"||typeof process.env.VITEST_WORKER_ID==="string"||nodeEnv==="test"}function pendingQueuePath(pmRoot){return path.join(pmRoot,PENDING_QUEUE_REL_PATH)}function pendingQueueGatePath(pmRoot){return path.join(pmRoot,PENDING_QUEUE_GATE_REL_PATH)}function acquireQueueGate(pmRoot){const gatePath=pendingQueueGatePath(pmRoot);try{if(Date.now()-statSync(gatePath).mtimeMs<PENDING_QUEUE_GATE_STALE_MS){return false}rmSync(gatePath,{recursive:true,force:true})}catch{}try{mkdirSync(path.dirname(gatePath),{recursive:true});mkdirSync(gatePath);return true}catch{return false}}function releaseQueueGate(pmRoot){try{rmSync(pendingQueueGatePath(pmRoot),{recursive:true,force:true})}catch{}}async function withQueueGate(pmRoot,fn,fallback){for(let attempt=0;attempt<50;attempt+=1){if(acquireQueueGate(pmRoot)){try{return await fn()}finally{releaseQueueGate(pmRoot)}}await delay(20)}return fallback}function delay(ms){return new Promise(resolve=>{setTimeout(resolve,ms)})}async function readPendingQueueIds(pmRoot){const raw=await readFileIfExists(pendingQueuePath(pmRoot));if(!raw||raw.trim().length===0){return[]}try{const parsed=JSON.parse(raw);if(!Array.isArray(parsed.ids)){return[]}return parsed.ids.filter(id=>typeof id==="string"&&id.length>0)}catch{return[]}}async function writePendingQueueIds(pmRoot,ids){await writeFileAtomic(pendingQueuePath(pmRoot),`${JSON.stringify({ids})}
+`)}async function enqueuePendingRefreshIds(pmRoot,itemIds){const incoming=itemIds.filter(id=>typeof id==="string"&&id.trim().length>0);if(incoming.length===0){return}const mergeIncoming=async()=>{const existing=await readPendingQueueIds(pmRoot);const merged=[...new Set([...existing,...incoming])].sort((left,right)=>left.localeCompare(right));await writePendingQueueIds(pmRoot,merged)};const gated=await withQueueGate(pmRoot,async()=>{await mergeIncoming();return true},false);if(!gated){await mergeIncoming()}}async function drainPendingRefreshIds(pmRoot){return withQueueGate(pmRoot,async()=>{const ids=await readPendingQueueIds(pmRoot);if(ids.length>0){await writePendingQueueIds(pmRoot,[])}return ids},[])}function searchRefreshRunnerPath(){return path.join(resolvePmPackageRootFromModule(import.meta.url,["../../.."]),"dist","cli","search-refresh.js")}function dispatchRefreshChild(pmRoot){try{const child=spawn(process.execPath,[searchRefreshRunnerPath()],{detached:true,stdio:"ignore",env:{...process.env,PM_PATH:pmRoot,[SEARCH_REFRESH_CHILD_ENV]:"1"}});child.on("error",()=>{});child.unref()}catch{}}function scheduleDelayedRefreshRetry(pmRoot){setTimeout(()=>dispatchRefreshChild(pmRoot),SEARCH_REFRESH_RETRY_DELAY_MS)}async function scheduleBackgroundSemanticRefresh(pmRoot,itemIds){await enqueuePendingRefreshIds(pmRoot,itemIds);dispatchRefreshChild(pmRoot)}async function runSemanticRefreshWorker(pmRoot,refresh,scheduleRetry=scheduleDelayedRefreshRetry){const warnings=[];const processed=[];if(!await pathExists(pmRoot)){return{processed,rounds:0,warnings}}let settings;try{const settingsRead=await readSettingsWithMetadata(pmRoot);const readFailure=settingsRead.warnings.find(warning=>warning.startsWith("settings_read_"));if(readFailure){scheduleRetry(pmRoot);return{processed,rounds:0,warnings:[`search_background_refresh_settings_read_failed:${readFailure}`]}}settings=resolveSettingsWithSemanticRuntimeDefaults(settingsRead.settings).settings}catch(error){scheduleRetry(pmRoot);return{processed,rounds:0,warnings:[`search_background_refresh_settings_read_failed:${toErrorMessage(error)}`]}}let release=null;try{release=await acquireLock(pmRoot,REINDEX_LOCK_ID,settings.locks.ttl_seconds,resolveAuthor(void 0,"pm-search-refresh"),false,settings.governance.force_required_for_stale_lock,settings.locks.wait_ms)}catch{}if(!release){return{processed,rounds:0,warnings}}let rounds=0;let failed=false;let retryPending=false;try{for(;;){const ids=await drainPendingRefreshIds(pmRoot);if(ids.length===0){break}rounds+=1;try{const result=await refresh(pmRoot,ids);warnings.push(...result.warnings);if(result.warnings.some(warning=>warning.startsWith("search_semantic_refresh_skipped:settings_read_failed:"))){await enqueuePendingRefreshIds(pmRoot,ids);failed=true;retryPending=true;break}processed.push(...result.refreshed)}catch(error){warnings.push(`search_background_refresh_failed:${toErrorMessage(error)}`);await enqueuePendingRefreshIds(pmRoot,ids);failed=true;break}}}finally{await release?.()}if(retryPending){scheduleRetry(pmRoot)}const remaining=failed?[]:await readPendingQueueIds(pmRoot);if(remaining.length>0){dispatchRefreshChild(pmRoot)}return{processed:[...new Set(processed)].sort((a,b)=>a.localeCompare(b)),rounds,warnings}}export{REINDEX_LOCK_ID,SEARCH_REFRESH_RETRY_DELAY_MS,drainPendingRefreshIds,enqueuePendingRefreshIds,runSemanticRefreshWorker,scheduleBackgroundSemanticRefresh,shouldRunSearchRefreshInForeground};
 //# sourceMappingURL=background-refresh.js.map
-//# debugId=d8d5f7e9-5293-564b-bc44-f5ba30336893

package/dist/core/search/bm25.js

@@ -1,147 +1,2 @@
-
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3fd6ed70-6633-5886-90a6-3d4cc16b3ef0")}catch(e){}}();
-import { tokenizeAlphaNumeric } from "../shared/text-normalization.js";
-/** Default Okapi BM25 term-frequency saturation parameter. `1.2` is the widely used Lucene/Elasticsearch default: higher values reduce the diminishing returns of repeated terms more slowly (terms keep accruing weight), lower values saturate sooner. */
-export const DEFAULT_BM25_K1 = 1.2;
-/** Default Okapi BM25 length-normalization parameter. `0.75` is the Lucene default: `0` disables length normalization entirely, `1` fully normalizes a document's score by its length relative to the corpus average. */
-export const DEFAULT_BM25_B = 0.75;
-/**
- * Tokenize a document/query string into BM25 terms. Shares
- * {@link tokenizeAlphaNumeric} with the lexical scorer so the BM25 vocabulary is
- * identical to the rest of search: lowercase, alphanumeric runs, no stop-word
- * removal or stemming (kept deliberately simple and language-agnostic).
- */
-export function tokenizeBm25(text) {
-    return tokenizeAlphaNumeric(text);
-}
-/** Count occurrences of each token in a token list. */
-function buildTermFrequencies(tokens) {
-    const frequencies = new Map();
-    for (const token of tokens) {
-        frequencies.set(token, (frequencies.get(token) ?? 0) + 1);
-    }
-    return frequencies;
-}
-/**
- * Build a BM25 index from a corpus. Computes each document's term frequencies
- * and length, the per-term document frequency, the corpus size, and the average
- * document length. Empty documents (no tokens) are retained with length `0` so
- * they can still be scored (they simply never match a query term). An empty
- * corpus yields an index with `averageDocumentLength` `0`, which
- * {@link scoreBm25Query} handles without dividing by zero.
- */
-export function buildBm25Index(documents) {
-    const stats = [];
-    const documentFrequency = new Map();
-    let totalLength = 0;
-    for (const document of documents) {
-        const tokens = tokenizeBm25(document.text);
-        const termFrequencies = buildTermFrequencies(tokens);
-        totalLength += tokens.length;
-        for (const term of termFrequencies.keys()) {
-            documentFrequency.set(term, (documentFrequency.get(term) ?? 0) + 1);
-        }
-        stats.push({ id: document.id, termFrequencies, length: tokens.length });
-    }
-    const documentCount = stats.length;
-    return {
-        documents: stats,
-        documentFrequency,
-        documentCount,
-        averageDocumentLength: documentCount > 0 ? totalLength / documentCount : 0,
-    };
-}
-/** Inverse document frequency for one term using the BM25 "plus-one" variant (`ln(1 + (N - n + 0.5) / (n + 0.5))`) used by Lucene. The `1 +` inside the logarithm keeps the IDF strictly non-negative even for a term that appears in every document, so a common term can never subtract from a document's score. */
-function inverseDocumentFrequency(documentCount, termDocumentFrequency) {
-    return Math.log(1 +
-        (documentCount - termDocumentFrequency + 0.5) /
-            (termDocumentFrequency + 0.5));
-}
-/** Score every document in the index against a query and return an id → score map containing only documents with a strictly positive score (a document that matches no query term is omitted, mirroring the lexical scorer's "no match → no hit" contract). Query tokens are de-duplicated so a token repeated in the query does not multiply its own contribution. Returns an empty map for an empty index, an empty query, or a query whose terms appear in no document. */
-export function scoreBm25Query(index, queryTokens, params) {
-    const scores = new Map();
-    // Empty corpus, or a corpus where every document is empty (avgdl 0): no term
-    // can match, so return early. Guarding here also guarantees a non-zero
-    // average document length below, keeping the length-normalization division
-    // safe without an unreachable fallback branch.
-    if (index.documentCount === 0 || index.averageDocumentLength === 0) {
-        return scores;
-    }
-    const distinctQueryTerms = [
-        ...new Set(queryTokens.filter((token) => token.length > 0)),
-    ];
-    if (distinctQueryTerms.length === 0) {
-        return scores;
-    }
-    // Precompute the IDF for each query term once rather than per document.
-    const idfByTerm = new Map();
-    for (const term of distinctQueryTerms) {
-        const termDocumentFrequency = index.documentFrequency.get(term);
-        if (termDocumentFrequency === undefined) {
-            continue;
-        }
-        idfByTerm.set(term, inverseDocumentFrequency(index.documentCount, termDocumentFrequency));
-    }
-    if (idfByTerm.size === 0) {
-        return scores;
-    }
-    for (const document of index.documents) {
-        let score = 0;
-        for (const [term, idf] of idfByTerm) {
-            const termFrequency = document.termFrequencies.get(term);
-            if (termFrequency === undefined) {
-                continue;
-            }
-            const lengthNormalization = 1 -
-                params.b +
-                (params.b * document.length) / index.averageDocumentLength;
-            const denominator = termFrequency + params.k1 * lengthNormalization;
-            score += idf * ((termFrequency * (params.k1 + 1)) / denominator);
-        }
-        if (score > 0) {
-            scores.set(document.id, score);
-        }
-    }
-    return scores;
-}
-/** Coerce one persisted BM25 parameter to a finite number within `[min, max]`. A finite number is clamped to the range (preserving user intent — e.g. `k1=5000` becomes `1000` rather than being silently ignored); any non-number or non-finite value (string, `NaN`, `Infinity`, missing) falls back to `fallback` so a malformed `settings.json` can never crash or skew scoring. */
-function resolveClampedParam(candidate, fallback, min, max) {
-    if (typeof candidate !== "number" || !Number.isFinite(candidate)) {
-        return fallback;
-    }
-    return Math.min(max, Math.max(min, candidate));
-}
-/** Flatten a structured search-corpus record (the shape produced by `buildSearchCorpus`) into a single whitespace-joined string of its *values* only — field names/object keys are deliberately excluded so corpus-wide keys (`title`, `description`, …) never enter the BM25 vocabulary and skew IDF. Strings and numbers contribute their text; arrays and nested objects (tags, dependencies, the plan corpus) are walked recursively; everything else is dropped. */
-export function flattenSearchCorpusText(corpus) {
-    const collectValueText = (value) => {
-        if (typeof value === "string") {
-            return [value];
-        }
-        if (typeof value === "number") {
-            return [String(value)];
-        }
-        if (Array.isArray(value)) {
-            return value.flatMap(collectValueText);
-        }
-        if (typeof value === "object" && value !== null) {
-            return Object.values(value).flatMap(collectValueText);
-        }
-        return [];
-    };
-    return collectValueText(Object.values(corpus)).join(" ");
-}
-/**
- * Resolve the effective BM25 parameters from `settings.search.bm25`, applying
- * {@link DEFAULT_BM25_K1}/{@link DEFAULT_BM25_B} when unset and clamping `k1` to
- * `[0, 1000]` and `b` to `[0, 1]`. Tolerant of partial/invalid config: each
- * knob is resolved independently so one bad value does not discard the other.
- */
-export function resolveBm25Params(settings) {
-    const bm25 = settings?.search?.bm25;
-    return {
-        k1: resolveClampedParam(bm25?.k1, DEFAULT_BM25_K1, 0, 1_000),
-        b: resolveClampedParam(bm25?.b, DEFAULT_BM25_B, 0, 1),
-    };
-}
+!(function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=new e.Error().stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="bc52818b-d37f-5d00-954d-d50203a433c2")}catch(e2){}})();import{tokenizeAlphaNumeric}from"../shared/text-normalization.js";const DEFAULT_BM25_K1=1.2;const DEFAULT_BM25_B=.75;function tokenizeBm25(text){return tokenizeAlphaNumeric(text)}function buildTermFrequencies(tokens){const frequencies=new Map;for(const token of tokens){frequencies.set(token,(frequencies.get(token)??0)+1)}return frequencies}function buildBm25Index(documents){const stats=[];const documentFrequency=new Map;let totalLength=0;for(const document of documents){const tokens=tokenizeBm25(document.text);const termFrequencies=buildTermFrequencies(tokens);totalLength+=tokens.length;for(const term of termFrequencies.keys()){documentFrequency.set(term,(documentFrequency.get(term)??0)+1)}stats.push({id:document.id,termFrequencies,length:tokens.length})}const documentCount=stats.length;return{documents:stats,documentFrequency,documentCount,averageDocumentLength:documentCount>0?totalLength/documentCount:0}}function inverseDocumentFrequency(documentCount,termDocumentFrequency){return Math.log(1+(documentCount-termDocumentFrequency+.5)/(termDocumentFrequency+.5))}function scoreBm25Query(index,queryTokens,params){const scores=new Map;if(index.documentCount===0||index.averageDocumentLength===0){return scores}const distinctQueryTerms=[...new Set(queryTokens.filter(token=>token.length>0))];if(distinctQueryTerms.length===0){return scores}const idfByTerm=new Map;for(const term of distinctQueryTerms){const termDocumentFrequency=index.documentFrequency.get(term);if(termDocumentFrequency===void 0){continue}idfByTerm.set(term,inverseDocumentFrequency(index.documentCount,termDocumentFrequency))}if(idfByTerm.size===0){return scores}for(const document of index.documents){let score=0;for(const[term,idf]of idfByTerm){const termFrequency=document.termFrequencies.get(term);if(termFrequency===void 0){continue}const lengthNormalization=1-params.b+params.b*document.length/index.averageDocumentLength;const denominator=termFrequency+params.k1*lengthNormalization;score+=idf*(termFrequency*(params.k1+1)/denominator)}if(score>0){scores.set(document.id,score)}}return scores}function resolveClampedParam(candidate,fallback,min,max){if(typeof candidate!=="number"||!Number.isFinite(candidate)){return fallback}return Math.min(max,Math.max(min,candidate))}function flattenSearchCorpusText(corpus){const collectValueText=value=>{if(typeof value==="string"){return[value]}if(typeof value==="number"){return[String(value)]}if(Array.isArray(value)){return value.flatMap(collectValueText)}if(typeof value==="object"&&value!==null){return Object.values(value).flatMap(collectValueText)}return[]};return collectValueText(Object.values(corpus)).join(" ")}function resolveBm25Params(settings){const bm25=settings?.search?.bm25;return{k1:resolveClampedParam(bm25?.k1,DEFAULT_BM25_K1,0,1e3),b:resolveClampedParam(bm25?.b,DEFAULT_BM25_B,0,1)}}export{DEFAULT_BM25_B,DEFAULT_BM25_K1,buildBm25Index,flattenSearchCorpusText,resolveBm25Params,scoreBm25Query,tokenizeBm25};
 //# sourceMappingURL=bm25.js.map
-//# debugId=3fd6ed70-6633-5886-90a6-3d4cc16b3ef0