@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/word-index.js

@@ -1,1426 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { createDeadline, forEachCooperatively, yieldIfOverBudget } from "./cooperative-budget.js";
-import { incrementDegradationCount } from "./degradation-ledger.js";
-import { KIND_EXTENSIONS } from "./file-kinds.js";
-import { isTestFileName } from "./file-role.js";
-import { PathKeyedMap } from "./path-keyed-map.js";
-import { isAtOrAboveHomeDir, normalizeEphemeralMapKey } from "./path-utils.js";
-import { createSingleFlight } from "./single-flight.js";
-import { createDebounceScheduler } from "./persist-debounce.js";
-import { getWordIndexMaxFilesDerived } from "./project-scale.js";
-import { compactPostingsIntoArena, compactPostingsIntoArenaCooperatively, countPostingBackingStores, countPostingEntries, estimateWordIndexStoreBytes, WordForwardEntry, WordIndexFileTable, WordPostingList } from "./word-index-store.js";
-import { logWordIndex } from "./word-index-logger.js";
-export const wordIndexKey = normalizeEphemeralMapKey;
-const STOPWORDS = new Set([
-  "the",
-  "and",
-  "for",
-  "let",
-  "var",
-  "const",
-  "function",
-  "return",
-  "if",
-  "else",
-  "import",
-  "export",
-  "from",
-  "class",
-  "interface",
-  "type",
-  "enum",
-  "new",
-  "this",
-  "self",
-  "void",
-  "null",
-  "true",
-  "false",
-  "async",
-  "await",
-  "public",
-  "private",
-  "protected",
-  "static",
-  "def",
-  "fn",
-  "func",
-  "struct",
-  "impl",
-  "pub",
-  "use",
-  "mod",
-  "in",
-  "of",
-  "as",
-  "is",
-  "not",
-  "with"
-]);
-const VENDOR_DIR_RE = /(^|[\\/])(?:tests?|__tests__|spec|specs|__mocks__|vendor|node_modules|examples?|fixtures?|\.git|dist|build|coverage)([\\/]|$)/i;
-const DOC_FILE_RE = /\.(?:md|mdx|markdown|json|json5|jsonc|txt|rst|lock|ya?ml|toml|csv)$/i;
-const TEST_VENDOR_PENALTY = 0.3;
-const DOC_FILE_PENALTY = 0.5;
-const BM25_K1 = 1.2;
-const BM25_B = 0.75;
-function isTestOrVendor(file) {
-  return isTestFileName(file) || VENDOR_DIR_RE.test(file);
-}
-function isDocFile(file) {
-  return DOC_FILE_RE.test(file);
-}
-export function splitIdentifier(identifier) {
-  const parts = new Set;
-  const whole = identifier.toLowerCase();
-  if (whole.length >= 2 && !STOPWORDS.has(whole))
-    parts.add(whole);
-  for (const chunk of identifier.split(/[^A-Za-z0-9]+/)) {
-    if (!chunk)
-      continue;
-    const spaced = chunk.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[A-Z](?=[A-Z][a-z])/g, "$& ").replace(/([A-Za-z])([0-9])/g, "$1 $2").replace(/([0-9])([A-Za-z])/g, "$1 $2");
-    for (const sub of spaced.split(/\s+/)) {
-      const token = sub.toLowerCase();
-      if (token.length >= 2 && !STOPWORDS.has(token))
-        parts.add(token);
-    }
-  }
-  return [...parts];
-}
-export function tokenizeLine(line) {
-  const tokens = [];
-  const matches = line.match(/[A-Za-z_$][A-Za-z0-9_$]*/g);
-  if (!matches)
-    return tokens;
-  for (const match of matches) {
-    for (const token of splitIdentifier(match))
-      tokens.push(token);
-  }
-  return tokens;
-}
-const WORD_INDEX_BUILD_YIELD_BUDGET_MS = 8;
-const WORD_INDEX_LONG_LINE_YIELD_CHARS = 4096;
-function createEmptyWordIndex(truncated) {
-  return {
-    postings: new Map,
-    fileTable: new WordIndexFileTable,
-    docLengths: new PathKeyedMap(wordIndexKey),
-    totalTokens: 0,
-    docCount: 0,
-    truncated,
-    forward: new PathKeyedMap(wordIndexKey),
-    fileMtimes: new PathKeyedMap(wordIndexKey),
-    fileSizes: new PathKeyedMap(wordIndexKey),
-    replacementStats: { count: 0, totalMs: 0, maxMs: 0 },
-    dirtyFiles: new Set,
-    postingStoreCount: 0,
-    recompactFlight: createSingleFlight()
-  };
-}
-export function countWordIndexPostingEntries(index) {
-  return countPostingEntries(index);
-}
-export function estimateWordIndexResidentBytes(index) {
-  return estimateWordIndexStoreBytes(index);
-}
-function recordOrphanWordIndexFileId(fileId, token, seam) {
-  incrementDegradationCount({
-    kind: "word-index-orphan-file-id",
-    subject: `fileId:${fileId}`,
-    reason: `${seam} dropped a posting for token "${token}": the file table has no path for this id`
-  });
-}
-export function wordIndexPostingHits(index, token) {
-  const list = index.postings.get(token);
-  if (!list)
-    return [];
-  const hits = [];
-  for (let i = 0;i < list.length; i += 1) {
-    const fileId = list.fileIdAt(i);
-    const file = index.fileTable.pathFor(fileId);
-    if (file === undefined) {
-      recordOrphanWordIndexFileId(fileId, token, "decode");
-      continue;
-    }
-    hits.push({ file, line: list.lineAt(i) });
-  }
-  return hits;
-}
-function compactWordIndexPostings(index) {
-  compactPostingsIntoArena(index.postings);
-  index.postingStoreCount = countPostingBackingStores(index.postings);
-}
-function notePostingStoresAllocated(index, count) {
-  index.postingStoreCount = (index.postingStoreCount ?? 0) + count;
-}
-const WORD_INDEX_RECOMPACT_STORE_FLOOR = 64;
-const WORD_INDEX_RECOMPACT_STORE_FRACTION = 0.1;
-function wordIndexRecompactThreshold(index) {
-  return Math.max(WORD_INDEX_RECOMPACT_STORE_FLOOR, Math.floor(index.postings.size * WORD_INDEX_RECOMPACT_STORE_FRACTION));
-}
-async function recompactWordIndexPostingsIfNeeded(index, root) {
-  const threshold = wordIndexRecompactThreshold(index);
-  const beforeStores = countPostingBackingStores(index.postings);
-  if (beforeStores <= threshold) {
-    index.postingStoreCount = beforeStores;
-    return;
-  }
-  const beforeBytes = estimateWordIndexResidentBytes(index);
-  await compactPostingsIntoArenaCooperatively(index.postings);
-  const afterStores = countPostingBackingStores(index.postings);
-  index.postingStoreCount = afterStores;
-  const afterBytes = estimateWordIndexResidentBytes(index);
-  const firstForRoot = incrementDegradationCount({
-    kind: "word-index-arena-recompact",
-    subject: path.resolve(root),
-    reason: `arena store threshold ${threshold} exceeded`,
-    metadata: { beforeBytes, afterBytes, beforeStores, afterStores }
-  });
-  if (firstForRoot) {
-    logWordIndex({
-      phase: "incremental_refresh",
-      cwd: path.resolve(root),
-      trigger: "incremental_refresh",
-      reason: `arena_recompact beforeBytes=${beforeBytes} afterBytes=${afterBytes} beforeStores=${beforeStores} afterStores=${afterStores}`
-    });
-  }
-}
-function enqueueWordIndexRecompact(index, root) {
-  if ((index.postingStoreCount ?? 0) <= wordIndexRecompactThreshold(index)) {
-    return Promise.resolve();
-  }
-  const flight = index.recompactFlight ??= createSingleFlight();
-  return flight.run("recompact", () => enqueueAsyncWordIndexOperation(index, () => recompactWordIndexPostingsIfNeeded(index, root)));
-}
-function scheduleWordIndexRecompact(index, filePath) {
-  enqueueWordIndexRecompact(index, path.dirname(filePath));
-}
-export async function flushWordIndexRecompactionsForTests(index) {
-  await (asyncWordIndexOperations.get(index) ?? Promise.resolve());
-}
-function recordWordIndexReplacement(index, startedAt) {
-  const stats = index.replacementStats ?? { count: 0, totalMs: 0, maxMs: 0 };
-  const durationMs = Math.max(0, Date.now() - startedAt);
-  stats.count += 1;
-  stats.totalMs += durationMs;
-  stats.maxMs = Math.max(stats.maxMs, durationMs);
-  index.replacementStats = stats;
-}
-function internWordIndexFile(index, filePath) {
-  return index.fileTable.intern(wordIndexKey(filePath), filePath);
-}
-function appendWordIndexPostings(index, filePath, perTokenHits) {
-  const fileId = internWordIndexFile(index, filePath);
-  const tokenLineCounts = new Map;
-  for (const [token, lineNumbers] of perTokenHits) {
-    let list = index.postings.get(token);
-    if (list) {
-      if (list.reserve(list.length + lineNumbers.length)) {
-        notePostingStoresAllocated(index, 1);
-      }
-    } else {
-      list = new WordPostingList(token, lineNumbers.length);
-      index.postings.set(token, list);
-      notePostingStoresAllocated(index, 1);
-    }
-    tokenLineCounts.set(list.token, lineNumbers.length);
-    for (const line of lineNumbers)
-      list.push(fileId, line);
-  }
-  return tokenLineCounts;
-}
-function commitWordIndexDocumentReplacement(index, doc, perTokenHits, docLength, startedAt) {
-  const tokenLineCounts = appendWordIndexPostings(index, doc.path, perTokenHits);
-  index.docLengths.set(doc.path, docLength);
-  index.forward.set(doc.path, WordForwardEntry.fromTally(tokenLineCounts));
-  index.fileMtimes.set(doc.path, -1);
-  index.fileSizes.set(doc.path, Buffer.byteLength(doc.content, "utf-8"));
-  index.dirtyFiles?.add(wordIndexKey(doc.path));
-  index.totalTokens += docLength;
-  index.docCount += 1;
-  recordWordIndexReplacement(index, startedAt);
-}
-function indexWordLine(index, fileId, line, lineNumber, tokenLineCounts) {
-  const lineTokens = tokenizeLine(line);
-  const seenOnLine = new Set;
-  for (const token of lineTokens) {
-    if (seenOnLine.has(token))
-      continue;
-    seenOnLine.add(token);
-    let list = index.postings.get(token);
-    if (!list) {
-      list = new WordPostingList(token, 1);
-      index.postings.set(token, list);
-    }
-    list.push(fileId, lineNumber);
-    const canonical = list.token;
-    tokenLineCounts.set(canonical, (tokenLineCounts.get(canonical) ?? 0) + 1);
-  }
-  return lineTokens.length;
-}
-function finishWordIndexDocument(index, doc, docLength, tokenLineCounts) {
-  index.docLengths.set(doc.path, docLength);
-  index.forward?.set(doc.path, WordForwardEntry.fromTally(tokenLineCounts));
-  index.fileMtimes.set(doc.path, doc.mtimeMs ?? 0);
-  index.fileSizes.set(doc.path, doc.size ?? Buffer.byteLength(doc.content, "utf-8"));
-  index.dirtyFiles?.add(wordIndexKey(doc.path));
-  index.totalTokens += docLength;
-  index.docCount += 1;
-}
-function indexWordDocument(index, doc) {
-  const fileId = internWordIndexFile(index, doc.path);
-  const lines = doc.content.split(/\r?\n/);
-  const tokenLineCounts = new Map;
-  let docLength = 0;
-  for (let i = 0;i < lines.length; i += 1) {
-    docLength += indexWordLine(index, fileId, lines[i], i + 1, tokenLineCounts);
-  }
-  finishWordIndexDocument(index, doc, docLength, tokenLineCounts);
-}
-export function buildWordIndex(files) {
-  const index = createEmptyWordIndex(files.truncated ?? false);
-  for (const doc of files)
-    indexWordDocument(index, doc);
-  compactWordIndexPostings(index);
-  return index;
-}
-export async function buildWordIndexAsync(files, shouldContinue = () => true) {
-  const index = createEmptyWordIndex(files.truncated ?? false);
-  const deadline = createDeadline(WORD_INDEX_BUILD_YIELD_BUDGET_MS);
-  for (const doc of files) {
-    if (!shouldContinue())
-      throw new Error("word index build superseded");
-    const fileId = internWordIndexFile(index, doc.path);
-    const lines = doc.content.split(/\r?\n/);
-    const tokenLineCounts = new Map;
-    let docLength = 0;
-    for (let i = 0;i < lines.length; i += 1) {
-      const line = lines[i];
-      docLength += indexWordLine(index, fileId, line, i + 1, tokenLineCounts);
-      if (line.length >= WORD_INDEX_LONG_LINE_YIELD_CHARS || deadline.expired()) {
-        await yieldIfOverBudget(deadline);
-        if (!shouldContinue())
-          throw new Error("word index build superseded");
-      }
-    }
-    finishWordIndexDocument(index, doc, docLength, tokenLineCounts);
-    if (deadline.expired() && await yieldIfOverBudget(deadline)) {
-      if (!shouldContinue())
-        throw new Error("word index build superseded");
-    }
-  }
-  compactWordIndexPostings(index);
-  return index;
-}
-export function removeWordIndexDocument(index, filePath) {
-  if (!index.forward)
-    return false;
-  const tokenLineCounts = index.forward.get(filePath);
-  if (!tokenLineCounts)
-    return false;
-  const removedKey = wordIndexKey(filePath);
-  const removedId = index.fileTable.idFor(removedKey);
-  if (removedId === undefined)
-    return false;
-  for (const token of tokenLineCounts.keys()) {
-    const list = index.postings.get(token);
-    if (!list)
-      continue;
-    const next = list.withoutFile(removedId);
-    if (next.length > 0) {
-      index.postings.set(token, next);
-      notePostingStoresAllocated(index, 1);
-    } else
-      index.postings.delete(token);
-  }
-  const docLength = index.docLengths.get(filePath) ?? 0;
-  index.docLengths.delete(filePath);
-  index.forward.delete(filePath);
-  index.fileMtimes.delete(filePath);
-  index.fileSizes.delete(filePath);
-  index.dirtyFiles?.add(wordIndexKey(filePath));
-  index.fileTable.release(removedKey);
-  index.totalTokens -= docLength;
-  index.docCount = Math.max(0, index.docCount - 1);
-  return true;
-}
-export function updateWordIndexDocument(index, doc) {
-  if (!index.forward)
-    return false;
-  const startedAt = Date.now();
-  if (index.forward.has(doc.path)) {
-    removeWordIndexDocument(index, doc.path);
-  }
-  const lines = doc.content.split(/\r?\n/);
-  const perTokenHits = new Map;
-  let docLength = 0;
-  for (let i = 0;i < lines.length; i += 1) {
-    const lineTokens = tokenizeLine(lines[i]);
-    docLength += lineTokens.length;
-    const seenOnLine = new Set;
-    for (const token of lineTokens) {
-      if (seenOnLine.has(token))
-        continue;
-      seenOnLine.add(token);
-      const arr = perTokenHits.get(token);
-      if (arr)
-        arr.push(i + 1);
-      else
-        perTokenHits.set(token, [i + 1]);
-    }
-  }
-  commitWordIndexDocumentReplacement(index, doc, perTokenHits, docLength, startedAt);
-  scheduleWordIndexRecompact(index, doc.path);
-  return true;
-}
-const asyncWordIndexOperations = new WeakMap;
-function enqueueAsyncWordIndexOperation(index, operation) {
-  const previous = asyncWordIndexOperations.get(index) ?? Promise.resolve();
-  const run = previous.catch(() => {
-    return;
-  }).then(operation);
-  const settled = run.then(() => {
-    return;
-  }, () => {
-    return;
-  });
-  asyncWordIndexOperations.set(index, settled);
-  return run.finally(() => {
-    if (asyncWordIndexOperations.get(index) === settled) {
-      asyncWordIndexOperations.delete(index);
-    }
-  });
-}
-async function stageWordIndexDocumentRemoval(index, filePath, shouldContinue) {
-  if (!index.forward)
-    return;
-  const tokenLineCounts = index.forward.get(filePath);
-  if (!tokenLineCounts)
-    return;
-  const removedKey = wordIndexKey(filePath);
-  const removedId = index.fileTable.idFor(removedKey);
-  if (removedId === undefined)
-    return;
-  const postings = new Map;
-  const deadline = createDeadline(WORD_INDEX_BUILD_YIELD_BUDGET_MS);
-  for (const token of tokenLineCounts.keys()) {
-    if (!shouldContinue())
-      throw new Error("word index refresh superseded");
-    const list = index.postings.get(token);
-    if (!list)
-      continue;
-    const survivors = list.withoutFile(removedId);
-    postings.set(token, survivors.length > 0 ? survivors : undefined);
-    if (deadline.expired() && await yieldIfOverBudget(deadline)) {
-      if (!shouldContinue())
-        throw new Error("word index refresh superseded");
-    }
-  }
-  return { postings, docLength: index.docLengths.get(filePath) ?? 0 };
-}
-function commitWordIndexDocumentRemoval(index, filePath, staged) {
-  for (const [token, list] of staged.postings) {
-    if (list) {
-      index.postings.set(token, list);
-      notePostingStoresAllocated(index, 1);
-    } else
-      index.postings.delete(token);
-  }
-  index.docLengths.delete(filePath);
-  index.forward?.delete(filePath);
-  index.fileMtimes.delete(filePath);
-  index.fileSizes.delete(filePath);
-  index.dirtyFiles?.add(wordIndexKey(filePath));
-  index.fileTable.release(wordIndexKey(filePath));
-  index.totalTokens -= staged.docLength;
-  index.docCount = Math.max(0, index.docCount - 1);
-}
-export async function removeWordIndexDocumentAsync(index, filePath, shouldContinue = () => true) {
-  return enqueueAsyncWordIndexOperation(index, async () => {
-    const staged = await stageWordIndexDocumentRemoval(index, filePath, shouldContinue);
-    if (!staged)
-      return false;
-    if (!shouldContinue())
-      throw new Error("word index refresh superseded");
-    commitWordIndexDocumentRemoval(index, filePath, staged);
-    return true;
-  });
-}
-export async function updateWordIndexDocumentForEdit(index, doc) {
-  const updated = await updateWordIndexDocumentAsync(index, doc);
-  if (updated)
-    scheduleWordIndexRecompact(index, doc.path);
-  return updated;
-}
-export async function updateWordIndexDocumentAsync(index, doc, shouldContinue = () => true) {
-  return enqueueAsyncWordIndexOperation(index, () => updateWordIndexDocumentAsyncUnsafe(index, doc, shouldContinue));
-}
-async function updateWordIndexDocumentAsyncUnsafe(index, doc, shouldContinue) {
-  if (!index.forward)
-    return false;
-  const startedAt = Date.now();
-  const removal = index.forward.has(doc.path) ? await stageWordIndexDocumentRemoval(index, doc.path, shouldContinue) : undefined;
-  if (index.forward.has(doc.path) && !removal)
-    return false;
-  const perTokenHits = new Map;
-  let docLength = 0;
-  const lines = doc.content.split(/\r?\n/);
-  await forEachCooperatively(lines, (line, i) => {
-    const lineTokens = tokenizeLine(line);
-    docLength += lineTokens.length;
-    const seenOnLine = new Set;
-    for (const token of lineTokens) {
-      if (seenOnLine.has(token))
-        continue;
-      seenOnLine.add(token);
-      const arr = perTokenHits.get(token);
-      if (arr)
-        arr.push(i + 1);
-      else
-        perTokenHits.set(token, [i + 1]);
-    }
-  }, {
-    budgetMs: WORD_INDEX_BUILD_YIELD_BUDGET_MS,
-    shouldContinue,
-    abortMessage: "word index refresh superseded"
-  });
-  if (!shouldContinue())
-    throw new Error("word index refresh superseded");
-  if (removal)
-    commitWordIndexDocumentRemoval(index, doc.path, removal);
-  commitWordIndexDocumentReplacement(index, doc, perTokenHits, docLength, startedAt);
-  return true;
-}
-export const WORD_INDEX_MAX_BYTES = 512 * 1024;
-export async function collectWordIndexDocs(root, shouldContinue = () => true, preflightFiles) {
-  const { collectSourceFilesAsync } = await import("./source-filter.js");
-  const maxFiles = preflightFiles?.length ?? getWordIndexMaxFilesDerived(root);
-  const files = preflightFiles ? preflightFiles.map((file) => file.path) : await collectSourceFilesAsync(root, {
-    maxFiles,
-    prioritizeCodeKinds: true
-  });
-  const truncated = preflightFiles?.truncated ?? files.length === maxFiles;
-  const docs = Object.assign([], { truncated, skipped: 0 });
-  if (!shouldContinue())
-    return docs;
-  const deadline = createDeadline(WORD_INDEX_BUILD_YIELD_BUDGET_MS);
-  for (const file of files.slice(0, maxFiles)) {
-    if (!shouldContinue())
-      return docs;
-    try {
-      const stat = fs.statSync(file);
-      if (stat.size <= WORD_INDEX_MAX_BYTES) {
-        docs.push({
-          path: file,
-          content: fs.readFileSync(file, "utf-8"),
-          mtimeMs: stat.mtimeMs,
-          size: stat.size
-        });
-      } else {
-        docs.skipped += 1;
-      }
-    } catch {
-      docs.skipped += 1;
-    }
-    if (deadline.expired() && await yieldIfOverBudget(deadline)) {
-      if (!shouldContinue())
-        return docs;
-    }
-  }
-  return docs;
-}
-const WORD_INDEX_STAT_CONCURRENCY = 8;
-const WORD_INDEX_INCREMENTAL_CHURN_THRESHOLD = 0.3;
-const WORD_INDEX_DENSE_REFRESH_MIN_DOCUMENTS = 32;
-const WORD_INDEX_FILE_READ_TOKEN_COST = 300;
-const WORD_INDEX_POSTING_SCAN_TOKEN_COST = 0.2;
-export async function refreshWordIndexIncrementally(index, root, shouldContinue = () => true, options = {}) {
-  if (!index.forward || !index.fileMtimes || !index.fileSizes) {
-    return {
-      mode: "full-required",
-      reason: "missing-incremental-metadata",
-      timings: { sourceWalkMs: 0, statWalkMs: 0, refreshReadsMs: 0 }
-    };
-  }
-  const { collectSourceFilesAsync } = await import("./source-filter.js");
-  const maxFiles = getWordIndexMaxFilesDerived(root);
-  const sourceWalkStartMs = Date.now();
-  const walked = await collectSourceFilesAsync(root, {
-    maxFiles,
-    prioritizeCodeKinds: true
-  });
-  const sourceWalkMs = Date.now() - sourceWalkStartMs;
-  if (!shouldContinue())
-    throw new Error("word index refresh superseded");
-  const current = new Map;
-  const statWalkStartMs = Date.now();
-  const statFile = options.statFile ?? ((file) => fs.promises.stat(file));
-  const requestedConcurrency = options.statConcurrency ?? WORD_INDEX_STAT_CONCURRENCY;
-  const statConcurrency = Number.isFinite(requestedConcurrency) && requestedConcurrency > 0 ? Math.max(1, Math.floor(requestedConcurrency)) : WORD_INDEX_STAT_CONCURRENCY;
-  const statResults = [];
-  statResults.length = walked.length;
-  let cursor = 0;
-  let superseded = false;
-  const worker = async () => {
-    while (true) {
-      if (!shouldContinue()) {
-        superseded = true;
-        return;
-      }
-      const slot = cursor++;
-      if (slot >= walked.length)
-        return;
-      const file = walked[slot];
-      try {
-        const stat = await statFile(file);
-        if (stat.size <= WORD_INDEX_MAX_BYTES) {
-          statResults[slot] = {
-            path: file,
-            mtimeMs: stat.mtimeMs,
-            size: stat.size
-          };
-        }
-      } catch {}
-    }
-  };
-  await Promise.all(Array.from({ length: Math.min(statConcurrency, walked.length) }, () => worker()));
-  if (superseded || !shouldContinue()) {
-    throw new Error("word index refresh superseded");
-  }
-  const statWalkMs = Date.now() - statWalkStartMs;
-  for (const result of statResults) {
-    if (result)
-      current.set(wordIndexKey(result.path), result);
-  }
-  const timings = { sourceWalkMs, statWalkMs, refreshReadsMs: 0 };
-  const preflightFiles = Object.assign([...current.values()], {
-    truncated: walked.length === maxFiles
-  });
-  const oldSet = new Set([...index.docLengths.keys()].map(wordIndexKey));
-  let changedSet = 0;
-  for (const key of oldSet)
-    if (!current.has(key))
-      changedSet++;
-  for (const key of current.keys())
-    if (!oldSet.has(key))
-      changedSet++;
-  const denominator = Math.max(oldSet.size, current.size, 1);
-  if (changedSet / denominator > WORD_INDEX_INCREMENTAL_CHURN_THRESHOLD) {
-    return {
-      mode: "full-required",
-      reason: "file-set-churn",
-      preflightFiles,
-      timings
-    };
-  }
-  let staleDocuments = 0;
-  for (const { path: file, mtimeMs, size } of current.values()) {
-    if (index.fileMtimes.get(file) !== mtimeMs || (index.fileSizes.get(file) ?? -1) !== size) {
-      staleDocuments += 1;
-    }
-  }
-  let postingEntries = 0;
-  let weightedPostingEntries = 0;
-  for (const list of index.postings.values()) {
-    postingEntries += list.length;
-    weightedPostingEntries += list.length * list.length;
-  }
-  const expectedPostingLength = postingEntries > 0 ? weightedPostingEntries / postingEntries : 0;
-  let distinctTokenEntries = 0;
-  for (const tokenLineCounts of index.forward.values()) {
-    distinctTokenEntries += tokenLineCounts.size;
-  }
-  const expectedDocumentTokens = index.docCount > 0 ? distinctTokenEntries / index.docCount : 0;
-  const estimatedIncrementalWork = staleDocuments * (expectedDocumentTokens * expectedPostingLength * WORD_INDEX_POSTING_SCAN_TOKEN_COST + WORD_INDEX_FILE_READ_TOKEN_COST);
-  const estimatedFullRebuildWork = index.totalTokens + current.size * WORD_INDEX_FILE_READ_TOKEN_COST;
-  if (staleDocuments >= WORD_INDEX_DENSE_REFRESH_MIN_DOCUMENTS && staleDocuments / Math.max(current.size, 1) > WORD_INDEX_INCREMENTAL_CHURN_THRESHOLD || estimatedIncrementalWork > estimatedFullRebuildWork) {
-    return {
-      mode: "full-required",
-      reason: "stale-document-churn",
-      preflightFiles,
-      timings
-    };
-  }
-  const deadline = createDeadline(WORD_INDEX_BUILD_YIELD_BUDGET_MS);
-  let dropped = 0;
-  for (const key of oldSet) {
-    if (!current.has(key)) {
-      if (!await removeWordIndexDocumentAsync(index, key, shouldContinue)) {
-        throw new Error(`failed to drop word-index document: ${key}`);
-      }
-      dropped++;
-    }
-  }
-  let refreshed = 0;
-  let skipped = 0;
-  const refreshReadsStartMs = Date.now();
-  for (const { path: file, mtimeMs, size } of current.values()) {
-    if (index.fileMtimes.get(file) !== mtimeMs || (index.fileSizes.get(file) ?? -1) !== size) {
-      let content;
-      try {
-        content = fs.readFileSync(file, "utf-8");
-      } catch {
-        skipped++;
-        continue;
-      }
-      if (!await updateWordIndexDocumentAsync(index, { path: file, content }, shouldContinue)) {
-        throw new Error(`failed to refresh word-index document: ${file}`);
-      }
-      index.fileMtimes.set(file, mtimeMs);
-      index.fileSizes.set(file, size);
-      refreshed++;
-    }
-    if (deadline.expired() && await yieldIfOverBudget(deadline)) {
-      if (!shouldContinue())
-        throw new Error("word index refresh superseded");
-    }
-  }
-  timings.refreshReadsMs = Date.now() - refreshReadsStartMs;
-  await enqueueWordIndexRecompact(index, root);
-  index.truncated = walked.length === maxFiles;
-  return {
-    mode: "incremental",
-    refreshed,
-    dropped,
-    skipped,
-    reused: current.size - refreshed - skipped,
-    timings
-  };
-}
-const WORD_INDEX_QUERY_FILTER_KEYS = [
-  "lang",
-  "file",
-  "ext"
-];
-
-export class WordIndexQueryError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "WordIndexQueryError";
-  }
-}
-const WORD_INDEX_FILTER_TOKEN_RE = /^(-)?([A-Za-z][A-Za-z0-9_-]*):(.+)$/;
-export function parseWordIndexQuery(query) {
-  const filters = [];
-  const termParts = [];
-  for (const raw of query.split(/\s+/)) {
-    if (!raw)
-      continue;
-    const match = raw.match(WORD_INDEX_FILTER_TOKEN_RE);
-    if (!match) {
-      termParts.push(raw);
-      continue;
-    }
-    const [, negation, keyRaw, value] = match;
-    const key = keyRaw.toLowerCase();
-    if (!value) {
-      termParts.push(raw);
-      continue;
-    }
-    if (!WORD_INDEX_QUERY_FILTER_KEYS.includes(key)) {
-      termParts.push(raw);
-      continue;
-    }
-    filters.push({
-      key,
-      value,
-      negated: negation === "-"
-    });
-  }
-  return { terms: termParts.join(" "), filters };
-}
-function resolveLangExtensions(value) {
-  const kind = value.toLowerCase();
-  const extensions = KIND_EXTENSIONS[kind];
-  if (!extensions) {
-    const known = Object.keys(KIND_EXTENSIONS).sort((a, b) => a < b ? -1 : a > b ? 1 : 0).join(", ");
-    throw new WordIndexQueryError(`Unknown lang: "${value}" in word-index query — supported languages: ${known}.`);
-  }
-  return extensions;
-}
-function normalizeExtFilterValue(value) {
-  return `.${value.replace(/^\.+/, "").toLowerCase()}`;
-}
-function resolveWordIndexFilter(filter) {
-  if (filter.key === "lang") {
-    const extensions = resolveLangExtensions(filter.value);
-    return {
-      key: filter.key,
-      negated: filter.negated,
-      test: (file) => extensions.includes(path.extname(file).toLowerCase())
-    };
-  }
-  if (filter.key === "ext") {
-    const normalized = normalizeExtFilterValue(filter.value);
-    return {
-      key: filter.key,
-      negated: filter.negated,
-      test: (file) => path.extname(file).toLowerCase() === normalized
-    };
-  }
-  const needle = wordIndexKey(filter.value);
-  return {
-    key: filter.key,
-    negated: filter.negated,
-    test: (_file, displayPath) => displayPath.includes(needle)
-  };
-}
-export function buildWordIndexQueryFilter(filters) {
-  if (filters.length === 0)
-    return;
-  const resolved = filters.map(resolveWordIndexFilter);
-  const positivesByKey = new Map;
-  const negatives = [];
-  for (const r of resolved) {
-    if (r.negated) {
-      negatives.push(r);
-      continue;
-    }
-    const group = positivesByKey.get(r.key) ?? [];
-    group.push(r);
-    positivesByKey.set(r.key, group);
-  }
-  return (file) => {
-    const displayPath = wordIndexKey(file);
-    for (const negative of negatives) {
-      if (negative.test(file, displayPath))
-        return false;
-    }
-    for (const group of positivesByKey.values()) {
-      if (!group.some((r) => r.test(file, displayPath)))
-        return false;
-    }
-    return true;
-  };
-}
-function combineFileFilters(a, b) {
-  if (!a)
-    return b;
-  if (!b)
-    return a;
-  return (file) => a(file) && b(file);
-}
-export function searchWordIndex(index, query, options = {}) {
-  const { demoteTestVendor = true, demoteDocs = true, centrality, limit = 20, fileFilter } = options;
-  const parsedQuery = parseWordIndexQuery(query);
-  const queryFilter = buildWordIndexQueryFilter(parsedQuery.filters);
-  const combinedFilter = combineFileFilters(fileFilter, queryFilter);
-  const queryTokens = [...new Set(tokenizeLine(parsedQuery.terms))];
-  if (queryTokens.length === 0)
-    return [];
-  const docCount = index.docCount || 1;
-  const avgDocLength = index.totalTokens / docCount || 1;
-  const scores = new Map;
-  for (const token of queryTokens) {
-    const posting = index.postings.get(token);
-    if (!posting)
-      continue;
-    const linesByFileId = new Map;
-    for (let i = 0;i < posting.length; i += 1) {
-      const fileId = posting.fileIdAt(i);
-      const arr = linesByFileId.get(fileId);
-      if (arr)
-        arr.push(posting.lineAt(i));
-      else
-        linesByFileId.set(fileId, [posting.lineAt(i)]);
-    }
-    const docFrequency = linesByFileId.size;
-    const idf = Math.log(1 + (docCount - docFrequency + 0.5) / (docFrequency + 0.5));
-    for (const [fileId, lines] of linesByFileId) {
-      const file = index.fileTable.pathFor(fileId);
-      if (file === undefined) {
-        recordOrphanWordIndexFileId(fileId, token, "search");
-        continue;
-      }
-      if (combinedFilter && !combinedFilter(file))
-        continue;
-      const termFrequency = lines.length;
-      const docLength = index.docLengths.get(file) ?? avgDocLength;
-      const denominator = termFrequency + BM25_K1 * (1 - BM25_B + BM25_B * (docLength / avgDocLength));
-      const termScore = idf * (termFrequency * (BM25_K1 + 1) / denominator);
-      const entry = scores.get(file) ?? {
-        score: 0,
-        hits: 0,
-        lines: new Set
-      };
-      entry.score += termScore;
-      entry.hits += termFrequency;
-      for (const line of lines)
-        entry.lines.add(line);
-      scores.set(file, entry);
-    }
-  }
-  const results = [];
-  for (const [file, entry] of scores) {
-    let score = entry.score;
-    if (demoteTestVendor && isTestOrVendor(file))
-      score *= TEST_VENDOR_PENALTY;
-    if (demoteDocs && isDocFile(file))
-      score *= DOC_FILE_PENALTY;
-    const connections = centrality?.get(file);
-    if (connections && connections > 0) {
-      score *= 1 + Math.log(1 + connections) / 4;
-    }
-    results.push({
-      file,
-      score,
-      hits: entry.hits,
-      lines: [...entry.lines].sort((a, b) => a - b)
-    });
-  }
-  results.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
-  return results.slice(0, Math.max(0, limit));
-}
-export function centralityFromReverseDeps(index, reverseDeps, normalizeKey = (file) => file) {
-  const centrality = new Map;
-  if (!reverseDeps)
-    return centrality;
-  for (const file of index.docLengths.keys()) {
-    const importers = reverseDeps[normalizeKey(file)];
-    if (importers && importers.length > 0) {
-      centrality.set(file, importers.length);
-    }
-  }
-  return centrality;
-}
-export const WORD_INDEX_FORMAT_VERSION = 2;
-const WORD_INDEX_INT32_MAX = 2147483647;
-const WORD_INDEX_PACKED_FILE_ID_MAX = 4194303;
-function isCanonicalWordIndexNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) && Number.isSafeInteger(value) && !Object.is(value, -0);
-}
-function isCanonicalWordIndexToken(token) {
-  return typeof token === "string" && token.length >= 2 && token === token.toLowerCase() && /^[a-z0-9_$]+$/.test(token) && !STOPWORDS.has(token);
-}
-const serializedWordIndexCaches = new WeakMap;
-let _lastSerializeWork;
-export function getLastWordIndexSerializeWork() {
-  return _lastSerializeWork;
-}
-function serializeWordIndexFull(index) {
-  const files = [...index.docLengths.keys()];
-  const slotByFileId = new Map;
-  files.forEach((file, i) => {
-    const fileId = index.fileTable.idFor(wordIndexKey(file));
-    if (fileId !== undefined)
-      slotByFileId.set(fileId, i);
-  });
-  const postings = [];
-  for (const [token, list] of index.postings) {
-    const flat = [];
-    for (let i = 0;i < list.length; i += 1) {
-      const slot = slotByFileId.get(list.fileIdAt(i));
-      if (slot === undefined)
-        continue;
-      flat.push(slot, list.lineAt(i));
-    }
-    if (flat.length > 0)
-      postings.push([token, flat]);
-  }
-  const forward = index.forward ? files.map((file, i) => [
-    i,
-    [...index.forward.get(file)?.entries() ?? []]
-  ]) : undefined;
-  const serialized = {
-    version: WORD_INDEX_FORMAT_VERSION,
-    files,
-    postings,
-    docLengths: files.map((file) => index.docLengths.get(file) ?? 0),
-    totalTokens: index.totalTokens,
-    indexedFileCount: index.docCount,
-    truncated: index.truncated,
-    fileMtimes: files.map((file) => index.fileMtimes.get(file) ?? 0),
-    fileSizes: files.map((file) => index.fileSizes.get(file) ?? 0),
-    forward
-  };
-  const tokensByFile = new Map;
-  if (index.forward) {
-    for (const file of files) {
-      tokensByFile.set(wordIndexKey(file), new Set(index.forward.get(file)?.keys() ?? []));
-    }
-  }
-  _lastSerializeWork = {
-    affectedTokenCount: postings.length,
-    tookFullPath: true
-  };
-  return { serialized, slotByFileId, tokensByFile };
-}
-function serializeWordIndexIncrementally(index, cache) {
-  const files = [...index.docLengths.keys()];
-  const priorFiles = cache.serialized.files;
-  const currentKeys = new Set(files.map(wordIndexKey));
-  const priorKeys = new Set(priorFiles.map(wordIndexKey));
-  if ([...priorKeys].some((key) => !currentKeys.has(key))) {
-    return serializeWordIndexFull(index);
-  }
-  const dirty = index.dirtyFiles;
-  if (dirty && dirty.size * 2 > files.length) {
-    return serializeWordIndexFull(index);
-  }
-  const filesInWireOrder = [
-    ...priorFiles,
-    ...files.filter((file) => !priorKeys.has(wordIndexKey(file)))
-  ];
-  if (!dirty || dirty.size === 0) {
-    _lastSerializeWork = { affectedTokenCount: 0, tookFullPath: false };
-    return cache;
-  }
-  const slotByFileId = new Map(cache.slotByFileId);
-  for (let i = priorFiles.length;i < filesInWireOrder.length; i += 1) {
-    const fileId = index.fileTable.idFor(wordIndexKey(filesInWireOrder[i]));
-    if (fileId !== undefined)
-      slotByFileId.set(fileId, i);
-  }
-  const postings = cache.serialized.postings.slice();
-  const postingAt = new Map;
-  postings.forEach(([token], i) => postingAt.set(token, i));
-  const removedTokens = new Set;
-  const tokensByFile = new Map(cache.tokensByFile);
-  const fileByKey = new Map(filesInWireOrder.map((file) => [wordIndexKey(file), file]));
-  const affectedTokens = new Set;
-  for (const fileKey of dirty) {
-    const file = fileByKey.get(fileKey);
-    const oldTokens = tokensByFile.get(fileKey) ?? new Set;
-    const currentEntry = file === undefined ? undefined : index.forward?.get(file);
-    const currentTokens = new Set(currentEntry?.keys() ?? []);
-    for (const token of oldTokens)
-      affectedTokens.add(token);
-    for (const token of currentTokens)
-      affectedTokens.add(token);
-    if (file === undefined)
-      tokensByFile.delete(fileKey);
-    else
-      tokensByFile.set(fileKey, currentTokens);
-  }
-  for (const token of affectedTokens) {
-    const list = index.postings.get(token);
-    const flat = [];
-    if (list) {
-      for (let i = 0;i < list.length; i += 1) {
-        const slot = slotByFileId.get(list.fileIdAt(i));
-        if (slot !== undefined)
-          flat.push(slot, list.lineAt(i));
-      }
-    }
-    const at = postingAt.get(token);
-    if (flat.length === 0) {
-      if (at !== undefined)
-        removedTokens.add(token);
-    } else if (at === undefined) {
-      postings.push([token, flat]);
-      postingAt.set(token, postings.length - 1);
-    } else {
-      postings[at] = [postings[at][0], flat];
-    }
-  }
-  const compactedPostings = removedTokens.size ? postings.filter(([token]) => !removedTokens.has(token)) : postings;
-  const forward = index.forward ? cache.serialized.forward?.slice().map((entry) => [entry[0], entry[1]]) ?? [] : undefined;
-  for (const fileKey of dirty) {
-    const file = fileByKey.get(fileKey);
-    const fileId = file === undefined ? undefined : index.fileTable.idFor(wordIndexKey(file));
-    const slot = fileId === undefined ? undefined : slotByFileId.get(fileId);
-    if (slot === undefined || !forward || file === undefined)
-      continue;
-    forward[slot] = [slot, [...index.forward?.get(file)?.entries() ?? []]];
-  }
-  const serialized = {
-    ...cache.serialized,
-    files: filesInWireOrder,
-    postings: compactedPostings,
-    docLengths: filesInWireOrder.map((file) => index.docLengths.get(file) ?? 0),
-    fileMtimes: filesInWireOrder.map((file) => index.fileMtimes.get(file) ?? 0),
-    fileSizes: filesInWireOrder.map((file) => index.fileSizes.get(file) ?? 0),
-    forward,
-    totalTokens: index.totalTokens,
-    indexedFileCount: index.docCount,
-    truncated: index.truncated
-  };
-  _lastSerializeWork = {
-    affectedTokenCount: affectedTokens.size,
-    tookFullPath: false
-  };
-  return { serialized, slotByFileId, tokensByFile };
-}
-export function serializeWordIndex(index) {
-  const prior = serializedWordIndexCaches.get(index);
-  const cache = prior ? serializeWordIndexIncrementally(index, prior) : serializeWordIndexFull(index);
-  serializedWordIndexCaches.set(index, cache);
-  index.dirtyFiles?.clear();
-  return cache.serialized;
-}
-export function deserializeWordIndex(data) {
-  if (!data || data.version !== WORD_INDEX_FORMAT_VERSION || !Array.isArray(data.files) || !Array.isArray(data.postings) || !Array.isArray(data.docLengths) || !Array.isArray(data.fileMtimes)) {
-    return null;
-  }
-  let canonical = data.docLengths.length === data.files.length && data.fileMtimes.length === data.files.length;
-  let needsDeepSanitize = !Array.isArray(data.forward);
-  if (needsDeepSanitize)
-    canonical = false;
-  const fileKeys = new Set;
-  for (const file of data.files) {
-    if (typeof file !== "string")
-      return null;
-    const key = wordIndexKey(file);
-    if (fileKeys.has(key)) {
-      canonical = false;
-      needsDeepSanitize = true;
-    }
-    fileKeys.add(key);
-  }
-  const docLengths = new PathKeyedMap(wordIndexKey);
-  const fileTable = new WordIndexFileTable;
-  const fileIdBySlot = data.files.map((file) => fileTable.intern(wordIndexKey(file), file));
-  const slotByFileId = new Map;
-  fileIdBySlot.forEach((fileId, slot) => {
-    if (!slotByFileId.has(fileId))
-      slotByFileId.set(fileId, slot);
-  });
-  const fileMtimes = new PathKeyedMap(wordIndexKey);
-  const fileSizes = new PathKeyedMap(wordIndexKey);
-  data.files.forEach((file, i) => {
-    const value = data.docLengths[i];
-    if (!isCanonicalWordIndexNumber(value) || value < 0)
-      canonical = false;
-    docLengths.set(file, isCanonicalWordIndexNumber(value) && value >= 0 ? value : 0);
-  });
-  data.files.forEach((file, i) => {
-    const value = data.fileMtimes[i];
-    if (typeof value !== "number" || !Number.isFinite(value))
-      canonical = false;
-    fileMtimes.set(file, typeof value === "number" && Number.isFinite(value) ? value : 0);
-  });
-  if (Array.isArray(data.fileSizes) && data.fileSizes.length === data.files.length) {
-    data.files.forEach((file, i) => {
-      const value = data.fileSizes?.[i];
-      if (!isCanonicalWordIndexNumber(value) || value < 0)
-        canonical = false;
-      fileSizes.set(file, isCanonicalWordIndexNumber(value) && value >= 0 ? value : 0);
-    });
-  } else {
-    canonical = false;
-  }
-  const postings = new Map;
-  const postingTokens = new Set;
-  const postingFileCounts = new Map;
-  for (const posting of data.postings) {
-    if (!Array.isArray(posting) || posting.length !== 2) {
-      canonical = false;
-      needsDeepSanitize = true;
-      continue;
-    }
-    const [token, flat] = posting;
-    if (!isCanonicalWordIndexToken(token) || postingTokens.has(token) || !Array.isArray(flat) || flat.length === 0 || flat.length % 2 !== 0) {
-      canonical = false;
-      needsDeepSanitize = true;
-      continue;
-    }
-    postingTokens.add(token);
-    const lanes = [];
-    const seenPairs = new Set;
-    const observedCounts = new Map;
-    for (let i = 0;i < flat.length; i += 2) {
-      const slot = flat[i];
-      const line = flat[i + 1];
-      if (!isCanonicalWordIndexNumber(slot) || slot < 0 || slot >= fileIdBySlot.length || !isCanonicalWordIndexNumber(line) || line < 1 || line > WORD_INDEX_INT32_MAX) {
-        canonical = false;
-        needsDeepSanitize = true;
-        continue;
-      }
-      const fileId = fileIdBySlot[slot];
-      const pairKey = fileId <= WORD_INDEX_PACKED_FILE_ID_MAX ? fileId * (WORD_INDEX_INT32_MAX + 1) + line : `${fileId}:${line}`;
-      if (seenPairs.has(pairKey)) {
-        canonical = false;
-        needsDeepSanitize = true;
-      }
-      seenPairs.add(pairKey);
-      lanes.push(fileId, line);
-      observedCounts.set(fileId, (observedCounts.get(fileId) ?? 0) + 1);
-    }
-    if (lanes.length === 0)
-      continue;
-    const list = WordPostingList.fromLanes(token, lanes);
-    postings.set(token, list);
-    postingFileCounts.set(token, observedCounts);
-  }
-  compactPostingsIntoArena(postings);
-  let forward;
-  if (Array.isArray(data.forward)) {
-    const candidate = data.files.map(() => new Map);
-    const forwardTotals = new Map;
-    if (data.forward.length !== data.files.length)
-      canonical = false;
-    if (data.forward.length !== data.files.length)
-      needsDeepSanitize = true;
-    for (const [entryIndex, entry] of data.forward.entries()) {
-      if (!Array.isArray(entry) || entry.length !== 2) {
-        canonical = false;
-        needsDeepSanitize = true;
-        continue;
-      }
-      const [fileIdx, tokenCounts] = entry;
-      if (!isCanonicalWordIndexNumber(fileIdx) || fileIdx !== entryIndex || fileIdx < 0 || fileIdx >= data.files.length || !Array.isArray(tokenCounts)) {
-        canonical = false;
-        needsDeepSanitize = true;
-        continue;
-      }
-      for (const pair of tokenCounts) {
-        if (!Array.isArray(pair) || pair.length !== 2 || !isCanonicalWordIndexToken(pair[0]) || !isCanonicalWordIndexNumber(pair[1]) || pair[1] < 1 || pair[1] > WORD_INDEX_INT32_MAX || candidate[fileIdx].has(pair[0])) {
-          canonical = false;
-          needsDeepSanitize = true;
-          continue;
-        }
-        candidate[fileIdx].set(pair[0], pair[1]);
-        forwardTotals.set(pair[0], (forwardTotals.get(pair[0]) ?? 0) + pair[1]);
-      }
-    }
-    let forwardMatchesPostings = true;
-    for (const [token, list] of postings) {
-      if (forwardTotals.get(token) !== list.length) {
-        forwardMatchesPostings = false;
-      }
-      const observed = postingFileCounts.get(token);
-      if (!observed) {
-        forwardMatchesPostings = false;
-        continue;
-      }
-      for (const [fileId, count] of observed) {
-        const slot = slotByFileId.get(fileId);
-        if (slot === undefined || candidate[slot].get(token) !== count) {
-          forwardMatchesPostings = false;
-        }
-      }
-    }
-    for (const token of forwardTotals.keys()) {
-      if (!postingTokens.has(token))
-        forwardMatchesPostings = false;
-    }
-    if (!forwardMatchesPostings)
-      canonical = false;
-    if (!forwardMatchesPostings)
-      needsDeepSanitize = true;
-    forward = new PathKeyedMap(wordIndexKey);
-    for (let i = 0;i < data.files.length; i += 1) {
-      forward.set(data.files[i], WordForwardEntry.fromTally(candidate[i]));
-    }
-  } else if (Object.prototype.hasOwnProperty.call(data, "forward")) {
-    canonical = false;
-    needsDeepSanitize = true;
-  }
-  if (needsDeepSanitize) {
-    const actualForwardCounts = data.files.map(() => new Map);
-    for (const [token, list] of postings) {
-      const seenPairs = new Set;
-      const sanitized = new WordPostingList(token, list.length);
-      for (let i = 0;i < list.length; i += 1) {
-        const fileId = list.fileIdAt(i);
-        const line = list.lineAt(i);
-        const pairKey = `${fileId}:${line}`;
-        if (seenPairs.has(pairKey))
-          continue;
-        seenPairs.add(pairKey);
-        sanitized.push(fileId, line);
-        const slot = slotByFileId.get(fileId);
-        if (slot !== undefined) {
-          const counts = actualForwardCounts[slot];
-          counts.set(token, (counts.get(token) ?? 0) + 1);
-        }
-      }
-      postings.set(token, sanitized);
-    }
-    compactPostingsIntoArena(postings);
-    if (Array.isArray(data.forward)) {
-      forward = new PathKeyedMap(wordIndexKey);
-      for (let i = 0;i < data.files.length; i += 1) {
-        const canonicalSlot = slotByFileId.get(fileIdBySlot[i]) ?? i;
-        forward.set(data.files[i], WordForwardEntry.fromTally(actualForwardCounts[canonicalSlot]));
-      }
-    }
-  }
-  const expectedTotalTokens = [...docLengths.values()].reduce((total, length) => total + length, 0);
-  const totalTokens = isCanonicalWordIndexNumber(expectedTotalTokens) ? expectedTotalTokens : 0;
-  if (!isCanonicalWordIndexNumber(data.totalTokens) || data.totalTokens !== totalTokens) {
-    canonical = false;
-  }
-  if (typeof data.indexedFileCount !== "number" || data.indexedFileCount !== docLengths.size) {
-    canonical = false;
-  }
-  if (typeof data.truncated !== "boolean")
-    canonical = false;
-  const index = {
-    postings,
-    fileTable,
-    docLengths,
-    totalTokens,
-    docCount: docLengths.size,
-    truncated: data.truncated === true,
-    forward,
-    fileMtimes,
-    fileSizes,
-    postingStoreCount: countPostingBackingStores(postings),
-    recompactFlight: createSingleFlight(),
-    dirtyFiles: new Set
-  };
-  const tokensByFile = new Map;
-  if (forward) {
-    for (const file of data.files) {
-      tokensByFile.set(wordIndexKey(file), new Set(forward.get(file)?.keys() ?? []));
-    }
-  }
-  if (canonical) {
-    serializedWordIndexCaches.set(index, {
-      serialized: data,
-      slotByFileId,
-      tokensByFile
-    });
-  }
-  return index;
-}
-const buildStatuses = new Map;
-export function getWordIndexBuildStatus(cwd) {
-  return buildStatuses.get(path.resolve(cwd));
-}
-export function _resetWordIndexBuildGuardForTests() {
-  buildStatuses.clear();
-}
-export function triggerBackgroundWordIndexBuild(cwd, dbg, options = {}) {
-  const key = path.resolve(cwd);
-  if (isAtOrAboveHomeDir(key, options.homeDir)) {
-    const reason = `root at/above home directory (${key})`;
-    dbg?.(`word-index cold-build: skipped — ${reason}`);
-    logWordIndex({
-      phase: "cold_build_refused",
-      cwd: key,
-      trigger: "cold_query",
-      reason
-    });
-    const status = { state: "refused", reason };
-    buildStatuses.set(key, status);
-    return status;
-  }
-  const current = buildStatuses.get(key);
-  if (current?.state === "building")
-    return current;
-  const status = { state: "building" };
-  buildStatuses.set(key, status);
-  (async () => {
-    const startMs = Date.now();
-    try {
-      const { loadProjectSnapshot, saveProjectSnapshot, PROJECT_SNAPSHOT_VERSION } = await import("./project-snapshot.js");
-      const docs = await collectWordIndexDocs(key);
-      const index = await buildWordIndexAsync(docs);
-      const existing = loadProjectSnapshot(key);
-      const snapshot = existing ?? {
-        version: PROJECT_SNAPSHOT_VERSION,
-        projectRoot: key,
-        generatedAt: new Date().toISOString(),
-        seq: 0,
-        files: {},
-        symbols: {},
-        reverseDeps: {},
-        cachedExports: []
-      };
-      snapshot.generatedAt = new Date().toISOString();
-      snapshot.wordIndex = serializeWordIndex(index);
-      saveProjectSnapshot(key, snapshot);
-      dbg?.(`word-index cold-build: ${index.docCount} files, ${index.postings.size} tokens (${Date.now() - startMs}ms)`);
-      logWordIndex({
-        phase: "cold_build",
-        cwd: key,
-        trigger: "cold_query",
-        durationMs: Date.now() - startMs,
-        indexedFileCount: index.docCount,
-        tokens: index.postings.size,
-        postingEntries: countWordIndexPostingEntries(index),
-        residentBytes: estimateWordIndexResidentBytes(index),
-        truncated: index.truncated,
-        skipped: docs.skipped
-      });
-      buildStatuses.delete(key);
-    } catch (err) {
-      const reason = err instanceof Error ? err.message : String(err);
-      buildStatuses.set(key, { state: "failed", reason });
-      dbg?.(`word-index cold-build: failed: ${reason}`);
-      logWordIndex({
-        phase: "cold_build_failed",
-        cwd: key,
-        trigger: "cold_query",
-        durationMs: Date.now() - startMs,
-        error: reason
-      });
-    }
-  })();
-  return status;
-}
-const WORD_INDEX_PERSIST_DEBOUNCE_MS_DEFAULT = 1500;
-function wordIndexPersistDebounceMs() {
-  const raw = Number(process.env.DM_LENS_WORD_INDEX_PERSIST_DEBOUNCE_MS);
-  return Number.isFinite(raw) && raw >= 0 ? raw : WORD_INDEX_PERSIST_DEBOUNCE_MS_DEFAULT;
-}
-let wordIndexPersistScheduler;
-function getWordIndexPersistScheduler() {
-  if (wordIndexPersistScheduler)
-    return wordIndexPersistScheduler;
-  wordIndexPersistScheduler = createDebounceScheduler({
-    debounceMs: wordIndexPersistDebounceMs,
-    write(_key, pending) {
-      writeWordIndexSnapshot(pending.cwd, pending.index, pending.dbg);
-    }
-  });
-  return wordIndexPersistScheduler;
-}
-async function writeWordIndexSnapshot(cwd, index, dbg) {
-  const persistStartedAt = Date.now();
-  try {
-    const { loadProjectSnapshot, saveProjectSnapshot, PROJECT_SNAPSHOT_VERSION } = await import("./project-snapshot.js");
-    const existing = loadProjectSnapshot(cwd);
-    const snapshot = existing ?? {
-      version: PROJECT_SNAPSHOT_VERSION,
-      projectRoot: path.resolve(cwd),
-      generatedAt: new Date().toISOString(),
-      seq: 0,
-      files: {},
-      symbols: {},
-      reverseDeps: {},
-      cachedExports: []
-    };
-    snapshot.generatedAt = new Date().toISOString();
-    const serializeStartedAt = performance.now();
-    snapshot.wordIndex = serializeWordIndex(index);
-    const serializeMs = performance.now() - serializeStartedAt;
-    saveProjectSnapshot(cwd, snapshot);
-    const writeMs = performance.now() - serializeStartedAt - serializeMs;
-    dbg?.(`word-index persist: ${index.docCount} files, ${index.postings.size} tokens`);
-    logWordIndex({
-      phase: "persist_succeeded",
-      cwd: path.resolve(cwd),
-      trigger: "per_edit",
-      durationMs: Date.now() - persistStartedAt,
-      serializeMs,
-      writeMs,
-      indexedFileCount: index.docCount,
-      tokens: index.postings.size,
-      postingEntries: countWordIndexPostingEntries(index),
-      residentBytes: estimateWordIndexResidentBytes(index),
-      replacementCount: index.replacementStats?.count ?? 0,
-      totalReplacementMs: index.replacementStats?.totalMs ?? 0,
-      maxReplacementMs: index.replacementStats?.maxMs ?? 0
-    });
-    index.replacementStats = { count: 0, totalMs: 0, maxMs: 0 };
-  } catch (err) {
-    dbg?.(`word-index persist: failed: ${err}`);
-    logWordIndex({
-      phase: "persist_failed",
-      cwd: path.resolve(cwd),
-      trigger: "per_edit",
-      indexedFileCount: index.docCount,
-      error: err instanceof Error ? err.message : String(err)
-    });
-  }
-}
-export function scheduleWordIndexPersist(cwd, index, dbg) {
-  const key = path.resolve(cwd);
-  getWordIndexPersistScheduler().schedule(key, { cwd: key, index, dbg });
-}
-export function flushWordIndexPersistsForTests() {
-  getWordIndexPersistScheduler().flushAll();
-}