@ninjaxtools/slopdex 0.19.0 → 0.21.0

package/dist/chunk-HMKVMRLF.js

@@ -1,2221 +0,0 @@
-import {
-  IndexDatabase
-} from "./chunk-GBEJHETS.js";
-import {
-  OpenAIDescriptionProvider,
-  isDescriptionProviderName
-} from "./chunk-TSURHRFF.js";
-import {
-  analysisSimilarity
-} from "./chunk-5BO2LLXC.js";
-import {
-  DEFAULT_PARALLELISM,
-  assertPositiveInteger,
-  chunk,
-  compileNameRegex,
-  forEachConcurrent,
-  normalizeEmbeddingVector,
-  normalizeRelativePath,
-  sha256,
-  throwIfAborted
-} from "./chunk-VH5VGRCI.js";
-import {
-  CodeIndexError,
-  GitDivergenceError,
-  GitUnavailableError
-} from "./chunk-DKRB2XT5.js";
-
-// src/code-index.ts
-import { lstat as lstat3, readFile as readFile2, readdir } from "node:fs/promises";
-import { lstatSync, readFileSync } from "node:fs";
-import path5 from "node:path";
-
-// src/git/repository.ts
-import { spawn } from "node:child_process";
-import { lstat } from "node:fs/promises";
-import path from "node:path";
-var GitRepository = class {
-  constructor(rootDir) {
-    this.rootDir = rootDir;
-  }
-  rootDir;
-  async #run(args, allowExitOne = false) {
-    return await new Promise((resolve, reject) => {
-      const child = spawn("git", ["-C", this.rootDir, ...args], { stdio: ["ignore", "pipe", "pipe"] });
-      const stdout = [];
-      const stderr = [];
-      child.stdout.on("data", (value) => stdout.push(value));
-      child.stderr.on("data", (value) => stderr.push(value));
-      child.on("error", (error) => {
-        if (error.code === "ENOENT") {
-          reject(new GitUnavailableError("Git executable is not available.", { cause: error }));
-          return;
-        }
-        reject(error);
-      });
-      child.on("close", (code) => {
-        const exitCode = code ?? -1;
-        if (exitCode === 0 || allowExitOne && exitCode === 1) {
-          resolve({ stdout: Buffer.concat(stdout), code: exitCode });
-          return;
-        }
-        reject(new CodeIndexError(`Git command failed: ${Buffer.concat(stderr).toString("utf8").trim()}`));
-      });
-    });
-  }
-  async assertRepository() {
-    let result;
-    try {
-      result = await this.#run(["rev-parse", "--is-inside-work-tree"]);
-    } catch (error) {
-      if (error instanceof GitUnavailableError) throw error;
-      try {
-        await lstat(path.join(this.rootDir, ".git"));
-      } catch (markerError) {
-        if (markerError.code === "ENOENT") {
-          throw new GitUnavailableError(`${this.rootDir} is not a Git worktree.`, { cause: error });
-        }
-        throw markerError;
-      }
-      throw error;
-    }
-    if (result.stdout.toString("utf8").trim() !== "true") {
-      throw new GitUnavailableError(`${this.rootDir} is not a Git worktree.`);
-    }
-    const topLevel = (await this.#run(["rev-parse", "--show-toplevel"])).stdout.toString("utf8").trim();
-    if (path.resolve(topLevel) !== path.resolve(this.rootDir)) {
-      throw new CodeIndexError(`rootDir must be the Git worktree root: ${topLevel}`);
-    }
-  }
-  async workTreeChanges(base, excludePaths = []) {
-    const pathspecs = [".", ...excludePaths.map((filePath) => `:(top,literal,exclude)${filePath}`)];
-    const result = await this.#run([
-      "diff",
-      "--name-status",
-      "-z",
-      "--find-renames",
-      base,
-      "--",
-      ...pathspecs
-    ]);
-    const changes = parseChanges(splitNull(result.stdout));
-    const untracked = await this.#run([
-      "ls-files",
-      "--others",
-      "--exclude-standard",
-      "-z",
-      "--",
-      ...pathspecs
-    ]);
-    for (const filePath of splitNull(untracked.stdout)) changes.push({ status: "A", path: filePath });
-    return changes;
-  }
-  async resolveCommit(ref) {
-    const result = await this.#run(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]);
-    const oid = result.stdout.toString("ascii").trim();
-    if (!/^[0-9a-f]{40,64}$/.test(oid)) throw new CodeIndexError(`Could not resolve Git commit: ${ref}`);
-    return oid;
-  }
-  async isAncestor(ancestor, descendant) {
-    const result = await this.#run(["merge-base", "--is-ancestor", ancestor, descendant], true);
-    return result.code === 0;
-  }
-  async listTree(commit) {
-    const result = await this.#run(["ls-tree", "-r", "-z", "-l", "--full-tree", commit, "--"]);
-    const entries = /* @__PURE__ */ new Map();
-    for (const record of splitNull(result.stdout)) {
-      const tab = record.indexOf("	");
-      if (tab < 0) continue;
-      const [mode, type, oid, sizeText] = record.slice(0, tab).trim().split(/\s+/);
-      const filePath = record.slice(tab + 1);
-      const size = Number(sizeText);
-      if ((mode === "100644" || mode === "100755") && type === "blob" && oid && Number.isSafeInteger(size)) {
-        entries.set(filePath, { path: filePath, oid, mode, size });
-      }
-    }
-    return entries;
-  }
-  async readBlob(oid) {
-    return (await this.#run(["cat-file", "blob", oid])).stdout;
-  }
-  async diff(base, target) {
-    const result = await this.#run(["diff", "--name-status", "-z", "--find-renames", `${base}..${target}`, "--"]);
-    return parseChanges(splitNull(result.stdout));
-  }
-};
-function parseChanges(values) {
-  const changes = [];
-  for (let index = 0; index < values.length; ) {
-    const rawStatus = values[index++];
-    if (!rawStatus) continue;
-    const status = rawStatus[0];
-    if (status === "R" || status === "C") {
-      const oldPath = values[index++];
-      const filePath = values[index++];
-      if (oldPath && filePath) changes.push({ status, oldPath, path: filePath });
-    } else if (status === "A" || status === "M" || status === "D" || status === "T") {
-      const filePath = values[index++];
-      if (filePath) changes.push({ status, path: filePath });
-    } else {
-      throw new CodeIndexError(`Unsupported Git diff status: ${rawStatus}`);
-    }
-  }
-  return changes;
-}
-function splitNull(buffer) {
-  const value = buffer.toString("utf8");
-  const parts = value.split("\0");
-  if (parts.at(-1) === "") parts.pop();
-  return parts;
-}
-
-// src/gitignore.ts
-import { lstat as lstat2, readFile } from "node:fs/promises";
-import path2 from "node:path";
-import ignore from "ignore";
-var GitignoreRules = class _GitignoreRules {
-  constructor(readIgnore) {
-    this.readIgnore = readIgnore;
-  }
-  readIgnore;
-  #directories = /* @__PURE__ */ new Map();
-  #contents = /* @__PURE__ */ new Map();
-  static workingTree(rootDir) {
-    return new _GitignoreRules(async (relativePath) => {
-      const absolutePath = path2.join(rootDir, relativePath);
-      try {
-        const info = await lstat2(absolutePath);
-        if (!info.isFile() || info.isSymbolicLink()) return null;
-        return await readFile(absolutePath, "utf8");
-      } catch (error) {
-        if (["ENOENT", "ENOTDIR"].includes(error.code ?? "")) return null;
-        throw error;
-      }
-    });
-  }
-  async ignores(relativePath, directory = false) {
-    const parent = path2.posix.dirname(relativePath);
-    const rules = await this.#directory(parent === "." ? "" : parent);
-    return rules === null || rules.ignores(directory ? `${relativePath}/` : relativePath);
-  }
-  async assertUnchanged(signal) {
-    for (const [filePath, content] of this.#contents) {
-      throwIfAborted(signal);
-      if (await this.readIgnore(filePath) !== content) {
-        throw new CodeIndexError(`Gitignore rules changed while indexing: ${filePath}; retry the update.`);
-      }
-    }
-  }
-  #directory(directory) {
-    let result = this.#directories.get(directory);
-    if (!result) {
-      result = this.#loadDirectory(directory);
-      this.#directories.set(directory, result);
-    }
-    return result;
-  }
-  async #loadDirectory(directory) {
-    let parentRules;
-    if (directory) {
-      const parent = path2.posix.dirname(directory);
-      const rules2 = await this.#directory(parent === "." ? "" : parent);
-      if (rules2 === null || rules2.ignores(`${directory}/`)) return null;
-      parentRules = rules2;
-    }
-    const filePath = directory ? `${directory}/.gitignore` : ".gitignore";
-    const content = await this.readIgnore(filePath);
-    this.#contents.set(filePath, content);
-    if (content === null && parentRules) return parentRules;
-    const rules = ignore({ ignorecase: false });
-    if (parentRules) rules.add(parentRules);
-    if (content !== null) rules.add(directory ? scopedPatterns(content, directory) : content);
-    return rules;
-  }
-};
-function scopedPatterns(content, directory) {
-  const prefix = directory.replace(/[\\*?\[\]#!]/g, "\\$&");
-  return content.split(/\r?\n/).map((line) => {
-    const pattern = line.replace(/^\uFEFF/, "");
-    if (/^ *$/.test(pattern) || pattern.startsWith("#")) return pattern;
-    const negative = pattern.startsWith("!");
-    const body = negative ? pattern.slice(1) : pattern;
-    if (/^\/? *$/.test(body)) return "";
-    const anchored = body.startsWith("/") || body.replace(/\/ *$/, "").includes("/");
-    return `${negative ? "!" : ""}/${prefix}/${anchored ? "" : "**/"}${body.replace(/^\//, "")}`;
-  });
-}
-
-// src/parser/callable-parser.ts
-import path3 from "node:path";
-import Parser from "tree-sitter";
-import C from "tree-sitter-c";
-import Go from "tree-sitter-go";
-import Java from "tree-sitter-java";
-import JavaScript from "tree-sitter-javascript";
-import Python from "tree-sitter-python";
-import Rust from "tree-sitter-rust";
-import TypeScript from "tree-sitter-typescript";
-
-// src/parser/native-callables.ts
-function cFunctionName(node) {
-  if (!node) return null;
-  if (node.type === "identifier") return node.text;
-  return cFunctionName(node.childForFieldName("declarator") ?? (node.type === "parenthesized_declarator" ? node.namedChildren[0] ?? null : null));
-}
-function containsYield(node) {
-  if (node.type === "yield") return true;
-  if (["function_definition", "class_definition", "lambda"].includes(node.type)) return false;
-  return node.namedChildren.some(containsYield);
-}
-function unwrap(node) {
-  while (node?.type === "parenthesized_expression" && node.namedChildCount === 1) {
-    node = node.namedChildren[0];
-  }
-  return node;
-}
-function pythonIsMethod(node) {
-  const definition = node.parent?.type === "decorated_definition" ? node.parent : node;
-  return definition.parent?.parent?.type === "class_definition";
-}
-function pythonDocstring(body, content) {
-  const statement = body?.namedChildren[0];
-  if (statement?.type !== "expression_statement") return null;
-  const value = statement.namedChildren[0];
-  if (value?.type !== "string" && value?.type !== "concatenated_string") return null;
-  return content.slice(value.startIndex, value.endIndex);
-}
-function goReceiver(node) {
-  let type = node.childForFieldName("receiver")?.namedChildren[0]?.childForFieldName("type");
-  while (type?.type === "pointer_type") type = type.namedChildren[0] ?? null;
-  return type?.text ?? null;
-}
-function collectNativeCallables(root, content, language) {
-  const candidates = [];
-  const text = (node) => content.slice(node.startIndex, node.endIndex);
-  const add = (node, name, kind, scope, bound = false) => {
-    const body = node.childForFieldName("body");
-    if ((!body || body.isMissing) && !node.hasError) return false;
-    const sourceNode = language === "python" && node.parent?.type === "decorated_definition" ? node.parent : node;
-    const header = content.slice(node.startIndex, body?.startIndex ?? node.endIndex).trimEnd();
-    const documentation = language === "python" && body ? pythonDocstring(body, content) : null;
-    candidates.push({
-      node: sourceNode,
-      name,
-      kind,
-      scope,
-      signature: bound ? `${name} = ${header}` : header,
-      ...documentation ? { documentation } : {}
-    });
-    if (body) walk2(body, [...scope, name]);
-    return true;
-  };
-  const addBound = (value, name, scope) => {
-    const callable = unwrap(value);
-    if (!callable || !name || !["identifier", "attribute", "selector_expression"].includes(name.type)) return false;
-    const closureType = { python: "lambda", rust: "closure_expression", go: "func_literal", java: "lambda_expression" };
-    if (!(language in closureType) || callable.type !== closureType[language]) return false;
-    return add(callable, text(name), "function", scope, true);
-  };
-  const walk2 = (node, scope) => {
-    if (language === "python") {
-      if (node.type === "class_definition") {
-        const name = node.childForFieldName("name");
-        const body = node.childForFieldName("body");
-        if (body) walk2(body, name ? [...scope, text(name)] : scope);
-        return;
-      }
-      if (node.type === "function_definition") {
-        const name = node.childForFieldName("name");
-        const body = node.childForFieldName("body");
-        const method = pythonIsMethod(node);
-        const kind = method && ["__init__", "__new__"].includes(name?.text ?? "") ? "constructor" : body && containsYield(body) ? "generator" : method ? "method" : "function";
-        if (name) add(node, text(name), kind, scope);
-        return;
-      }
-      if (node.type === "assignment" || node.type === "named_expression") {
-        if (addBound(
-          node.childForFieldName("right") ?? node.childForFieldName("value"),
-          node.childForFieldName("left") ?? node.childForFieldName("name"),
-          scope
-        )) return;
-      }
-    } else if (language === "rust") {
-      if (["mod_item", "trait_item", "impl_item"].includes(node.type)) {
-        const body = node.childForFieldName("body");
-        const type = node.childForFieldName("type");
-        const trait = node.childForFieldName("trait");
-        const name = node.type === "impl_item" ? type && (trait ? `<${text(type)} as ${text(trait)}>` : text(type)) : node.childForFieldName("name")?.text;
-        if (body) walk2(body, name ? [...scope, name] : scope);
-        return;
-      }
-      if (node.type === "function_item") {
-        const name = node.childForFieldName("name");
-        const owner = node.parent?.parent?.type;
-        if (name) add(node, text(name), owner === "impl_item" || owner === "trait_item" ? "method" : "function", scope);
-        return;
-      }
-      if (node.type === "let_declaration" && addBound(node.childForFieldName("value"), node.childForFieldName("pattern"), scope)) return;
-    } else if (language === "go") {
-      if (node.type === "function_declaration" || node.type === "method_declaration") {
-        const name = node.childForFieldName("name");
-        const receiver = goReceiver(node);
-        if (name) add(node, text(name), receiver ? "method" : "function", receiver ? [...scope, receiver] : scope);
-        return;
-      }
-      if (["short_var_declaration", "assignment_statement", "var_spec"].includes(node.type)) {
-        const names = node.type === "var_spec" ? node.childrenForFieldName("name") : node.childForFieldName("left")?.namedChildren ?? [];
-        const values = (node.childForFieldName("right") ?? node.childForFieldName("value"))?.namedChildren ?? [];
-        if (names.length === values.length) {
-          for (let i = 0; i < names.length; i += 1) {
-            if (!addBound(values[i], names[i], scope)) walk2(values[i], scope);
-          }
-          return;
-        }
-      }
-    } else if (language === "java") {
-      if (["class_declaration", "interface_declaration", "enum_declaration", "record_declaration", "annotation_type_declaration", "enum_constant"].includes(node.type)) {
-        const name = node.childForFieldName("name");
-        for (const child of node.namedChildren) walk2(child, name ? [...scope, text(name)] : scope);
-        return;
-      }
-      if (node.type === "class_body" && node.parent?.type === "object_creation_expression") {
-        const anonymousScope = [...scope, `<anonymous@${node.startPosition.row + 1}:${node.startPosition.column + 1}>`];
-        for (const child of node.namedChildren) walk2(child, anonymousScope);
-        return;
-      }
-      if (["method_declaration", "constructor_declaration", "compact_constructor_declaration"].includes(node.type)) {
-        const name = node.childForFieldName("name");
-        if (name) add(node, text(name), node.type === "method_declaration" ? "method" : "constructor", scope);
-        return;
-      }
-      if (node.type === "variable_declarator" && addBound(node.childForFieldName("value"), node.childForFieldName("name"), scope)) return;
-    } else if (language === "c" && node.type === "function_definition") {
-      const name = cFunctionName(node.childForFieldName("declarator"));
-      if (name) add(node, name, "function", scope);
-      return;
-    }
-    if (["lambda", "closure_expression", "func_literal", "lambda_expression"].includes(node.type)) return;
-    for (const child of node.namedChildren) walk2(child, scope);
-  };
-  walk2(root, []);
-  return candidates;
-}
-
-// src/parser/diagnostics.ts
-function parseDiagnostics(root, content, filePath, language, candidates) {
-  if (!root.hasError) return [];
-  const errors = [];
-  const brokenNodes = /* @__PURE__ */ new Set();
-  const issue = (node, qualifiedName, message) => ({
-    path: filePath,
-    language,
-    scope: qualifiedName === null ? "file" : "function",
-    code: "parse-error",
-    message,
-    qualifiedName,
-    startLine: node.startPosition.row + 1,
-    startColumn: node.startPosition.column + 1,
-    endLine: node.endPosition.row + 1,
-    endColumn: node.endPosition.column + 1,
-    source: content.slice(node.startIndex, node.endIndex)
-  });
-  for (const candidate of candidates) {
-    if (!candidate.node.hasError) continue;
-    const name = [...candidate.scope, candidate.name].join(".");
-    errors.push(issue(candidate.node, name, `Cannot fully parse callable ${name}; omitted from the searchable index.`));
-    brokenNodes.add(candidate.node.id);
-  }
-  const walk2 = (node, insideBrokenCallable) => {
-    const inside = insideBrokenCallable || brokenNodes.has(node.id);
-    if (node.isError || node.isMissing) {
-      if (!inside) errors.push(issue(node, null, node.isMissing ? `Tree-sitter expected ${node.type}.` : "Tree-sitter could not parse this source region."));
-      const children = node.children;
-      for (let index = 0; index < children.length; index += 1) {
-        if (!["function", "def", "fn", "func"].includes(children[index].type)) continue;
-        let next = index + 1;
-        if (children[next]?.type === "*") next += 1;
-        const name = children[next];
-        if (name && ["identifier", "field_identifier"].includes(name.type)) {
-          errors.push(issue(node, name.text, `Cannot parse declaration for ${name.text}; name recovered from an error node.`));
-        }
-      }
-      return;
-    }
-    for (const child of node.children) if (child.hasError || child.isError || child.isMissing) walk2(child, inside);
-  };
-  walk2(root, false);
-  return errors;
-}
-
-// src/parser/callable-parser.ts
-var parsers = /* @__PURE__ */ new Map();
-var CALLABLE_PARSER_CACHE_VERSION = "callable-parser-v1";
-function languageForPath(filePath) {
-  switch (path3.extname(filePath).toLowerCase()) {
-    case ".ts":
-    case ".mts":
-    case ".cts":
-      return "typescript";
-    case ".tsx":
-      return "tsx";
-    case ".js":
-    case ".mjs":
-    case ".cjs":
-      return "javascript";
-    case ".jsx":
-      return "jsx";
-    case ".py":
-    case ".pyw":
-      return "python";
-    case ".rs":
-      return "rust";
-    case ".go":
-      return "go";
-    case ".java":
-      return "java";
-    case ".c":
-    case ".h":
-      return "c";
-    default:
-      return null;
-  }
-}
-function getParser(language) {
-  const existing = parsers.get(language);
-  if (existing) return existing;
-  const parser = new Parser();
-  if (language === "typescript") parser.setLanguage(TypeScript.typescript);
-  else if (language === "tsx") parser.setLanguage(TypeScript.tsx);
-  else if (language === "python") parser.setLanguage(Python);
-  else if (language === "rust") parser.setLanguage(Rust);
-  else if (language === "go") parser.setLanguage(Go);
-  else if (language === "java") parser.setLanguage(Java);
-  else if (language === "c") parser.setLanguage(C);
-  else parser.setLanguage(JavaScript);
-  parsers.set(language, parser);
-  return parser;
-}
-function parseTree(parser, content, relativePath) {
-  try {
-    return parser.parse(content, void 0, { bufferSize: Buffer.byteLength(content) + 1 });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new CodeIndexError(`Cannot index ${relativePath}: tree-sitter failed: ${message}`, { cause: error });
-  }
-}
-function maskSyntax(value, replacement) {
-  return replacement + value.slice(replacement.length).replace(/[^\r\n]/g, " ");
-}
-function recoverUnsupportedTypeScriptSyntax(parser, tree, content, relativePath) {
-  const errors = [];
-  const collectErrors = (node) => {
-    if (node.isError || node.isMissing) errors.push(node);
-    for (const child of node.children) collectErrors(child);
-  };
-  collectErrors(tree.rootNode);
-  if (errors.length === 0) return null;
-  let recoveredContent = content;
-  let changed = false;
-  const taggedTemplateTypeArguments = /* @__PURE__ */ new Map();
-  for (const error of errors) {
-    const parent = error.parent;
-    if (error.isMissing && error.type === "!" && parent?.type === "type_arguments" && /^\s*`/.test(content.slice(parent.endIndex))) {
-      taggedTemplateTypeArguments.set(parent.startIndex, parent);
-    }
-  }
-  for (const node of [...taggedTemplateTypeArguments.values()].toSorted((left, right) => right.startIndex - left.startIndex)) {
-    const value = recoveredContent.slice(node.startIndex, node.endIndex);
-    recoveredContent = `${recoveredContent.slice(0, node.startIndex)}${value.replace(/[^\r\n]/g, " ")}${recoveredContent.slice(node.endIndex)}`;
-    changed = true;
-  }
-  for (const node of errors.filter((candidate) => {
-    const parent = candidate.parent;
-    return !candidate.isMissing && candidate.type === "ERROR" && candidate.text === "type" && parent?.type === "export_statement" && content.slice(parent.startIndex, candidate.startIndex).trim() === "export" && /^\s*\*/.test(content.slice(candidate.endIndex, parent.endIndex));
-  }).toSorted((left, right) => right.startIndex - left.startIndex)) {
-    recoveredContent = `${recoveredContent.slice(0, node.startIndex)}    ${recoveredContent.slice(node.endIndex)}`;
-    changed = true;
-  }
-  recoveredContent = recoveredContent.replace(
-    /\bimport\s*\(\s*(["'])(?:\\.|(?!\1)[^\\])*\1\s*\)/g,
-    (value) => {
-      changed = true;
-      return maskSyntax(value, "X");
-    }
-  );
-  if (!changed) return null;
-  const recoveredTree = parseTree(parser, recoveredContent, relativePath);
-  return recoveredTree.rootNode.hasError ? null : recoveredTree;
-}
-function textFor(content, node) {
-  return content.slice(node.startIndex, node.endIndex);
-}
-function fieldText(content, node, field) {
-  const child = node.childForFieldName(field);
-  return child ? textFor(content, child) : null;
-}
-function callableKind(node, name) {
-  if (node.type === "method_definition" && name === "constructor") return "constructor";
-  if (node.type.includes("generator") || /^\s*(?:async\s+)?\*/.test(node.text)) return "generator";
-  return node.type === "method_definition" ? "method" : "function";
-}
-function bindingName(content, node) {
-  const nameNode = node.childForFieldName("name");
-  if (!nameNode || !["identifier", "property_identifier", "private_property_identifier"].includes(nameNode.type)) {
-    return null;
-  }
-  return textFor(content, nameNode).replace(/^#/, "");
-}
-function assignmentName(content, node) {
-  const left = node.childForFieldName("left");
-  if (!left) return null;
-  const value = textFor(content, left).trim();
-  const match = value.match(/(?:^|[.#])([A-Za-z_$][\w$]*)$/);
-  return match?.[1] ?? null;
-}
-function objectScopeName(content, node) {
-  const parent = node.parent;
-  if (!parent) return null;
-  if (parent.type === "variable_declarator" && parent.childForFieldName("value")?.id === node.id) {
-    return bindingName(content, parent);
-  }
-  if (parent.type === "pair" && parent.childForFieldName("value")?.id === node.id) {
-    return fieldText(content, parent, "key")?.replace(/["']/g, "") ?? null;
-  }
-  if (parent.type === "assignment_expression" && parent.childForFieldName("right")?.id === node.id) {
-    return assignmentName(content, parent);
-  }
-  return null;
-}
-function walk(node, content, scope, candidates) {
-  if (["class_declaration", "abstract_class_declaration", "class"].includes(node.type)) {
-    const name = fieldText(content, node, "name") ?? objectScopeName(content, node);
-    const nextScope = name ? [...scope, name] : scope;
-    for (const child of node.namedChildren) walk(child, content, nextScope, candidates);
-    return;
-  }
-  if (node.type === "internal_module" || node.type === "module") {
-    const name = fieldText(content, node, "name")?.replace(/["']/g, "");
-    const nextScope = name ? [...scope, name] : scope;
-    for (const child of node.namedChildren) walk(child, content, nextScope, candidates);
-    return;
-  }
-  if (node.type === "object") {
-    const name = objectScopeName(content, node);
-    const nextScope = name ? [...scope, name] : scope;
-    for (const child of node.namedChildren) walk(child, content, nextScope, candidates);
-    return;
-  }
-  if (["function_declaration", "generator_function_declaration"].includes(node.type)) {
-    const name = fieldText(content, node, "name");
-    const body = node.childForFieldName("body");
-    if (name && (body || node.hasError)) {
-      candidates.push({ node, name, kind: callableKind(node, name), scope });
-      if (body) walk(body, content, [...scope, name], candidates);
-    }
-    return;
-  }
-  if (node.type === "method_definition") {
-    const name = fieldText(content, node, "name")?.replace(/^#/, "");
-    const body = node.childForFieldName("body");
-    if (name && (body || node.hasError)) {
-      candidates.push({ node, name, kind: callableKind(node, name), scope });
-      if (body) walk(body, content, [...scope, name], candidates);
-    }
-    return;
-  }
-  if (["public_field_definition", "property_definition", "field_definition"].includes(node.type)) {
-    const name = (fieldText(content, node, "name") ?? fieldText(content, node, "property"))?.replace(/^#/, "");
-    const value = node.childForFieldName("value");
-    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
-      const kind = callableKind(value, name) === "generator" ? "generator" : "method";
-      candidates.push({ node: value, name, kind, scope });
-      const body = value.childForFieldName("body");
-      if (body) walk(body, content, [...scope, name], candidates);
-      return;
-    }
-  }
-  if (node.type === "variable_declarator") {
-    const name = bindingName(content, node);
-    const value = node.childForFieldName("value");
-    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
-      candidates.push({ node: value, name, kind: callableKind(value, name), scope });
-      const body = value.childForFieldName("body");
-      if (body) walk(body, content, [...scope, name], candidates);
-      return;
-    }
-  }
-  if (node.type === "pair") {
-    const name = fieldText(content, node, "key")?.replace(/["']/g, "");
-    const value = node.childForFieldName("value");
-    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
-      candidates.push({ node: value, name, kind: callableKind(value, name), scope });
-      const body = value.childForFieldName("body");
-      if (body) walk(body, content, [...scope, name], candidates);
-      return;
-    }
-  }
-  if (node.type === "assignment_expression") {
-    const name = assignmentName(content, node);
-    const value = node.childForFieldName("right");
-    if (name && value && ["arrow_function", "function_expression", "generator_function"].includes(value.type)) {
-      candidates.push({ node: value, name, kind: callableKind(value, name), scope });
-      const body = value.childForFieldName("body");
-      if (body) walk(body, content, [...scope, name], candidates);
-      return;
-    }
-  }
-  if (["function_expression", "generator_function"].includes(node.type)) {
-    const name = fieldText(content, node, "name");
-    const body = node.childForFieldName("body");
-    if (name && body) {
-      candidates.push({ node, name, kind: callableKind(node, name), scope });
-      walk(body, content, [...scope, name], candidates);
-      return;
-    }
-  }
-  for (const child of node.namedChildren) walk(child, content, scope, candidates);
-}
-function signatureFor(content, node, name) {
-  const parameters = node.childForFieldName("parameters");
-  const parameter = node.childForFieldName("parameter");
-  const typeParameters = node.childForFieldName("type_parameters");
-  const returnType = node.childForFieldName("return_type");
-  const async = node.children.some((child) => child.type === "async") ? "async " : "";
-  const generator = node.children.some((child) => child.type === "*") ? "*" : "";
-  const parameterText = parameters ? textFor(content, parameters) : parameter ? `(${textFor(content, parameter)})` : "";
-  return `${async}${generator}${name}${typeParameters ? textFor(content, typeParameters) : ""}${parameterText}${returnType ? textFor(content, returnType) : ""}`;
-}
-function parseCallables(relativePath, content, onWarning = console.warn) {
-  return parseFileCallables(relativePath, content, onWarning).callables;
-}
-function parseFileCallables(relativePath, content, onWarning = console.warn) {
-  let result;
-  try {
-    result = extractCallables(relativePath, content);
-  } catch (error) {
-    const message = `Cannot index ${relativePath}: ${error instanceof Error ? error.message : String(error)}`;
-    onWarning(message);
-    return { callables: [], errors: [{
-      path: relativePath,
-      language: languageForPath(relativePath),
-      scope: "file",
-      code: "parse-failed",
-      message,
-      qualifiedName: null,
-      startLine: null,
-      startColumn: null,
-      endLine: null,
-      endColumn: null,
-      source: content
-    }] };
-  }
-  if (result.errors.length > 0) {
-    onWarning(`Cannot fully parse ${relativePath}: tree-sitter reported syntax errors; indexing recoverable callables only.`);
-  }
-  return result;
-}
-function extractCallables(relativePath, content) {
-  const language = languageForPath(relativePath);
-  if (!language) return { callables: [], errors: [] };
-  const parser = getParser(language);
-  const parsedTree = parseTree(parser, content, relativePath);
-  const tree = parsedTree.rootNode.hasError && (language === "typescript" || language === "tsx") ? recoverUnsupportedTypeScriptSyntax(parser, parsedTree, content, relativePath) ?? parsedTree : parsedTree;
-  const candidates = [];
-  if (["typescript", "tsx", "javascript", "jsx"].includes(language)) {
-    walk(tree.rootNode, content, [], candidates);
-  } else {
-    candidates.push(...collectNativeCallables(tree.rootNode, content, language));
-  }
-  candidates.sort((left, right) => left.node.startIndex - right.node.startIndex);
-  const errors = parseDiagnostics(tree.rootNode, content, relativePath, language, candidates);
-  const occurrences = /* @__PURE__ */ new Map();
-  const callables = [];
-  for (const { node, name, kind, scope, signature: candidateSignature, documentation } of candidates) {
-    const qualifiedName = [...scope, name].join(".");
-    const baseIdentity = `${relativePath}\0${qualifiedName}\0${kind}`;
-    const occurrence = occurrences.get(baseIdentity) ?? 0;
-    occurrences.set(baseIdentity, occurrence + 1);
-    if (node.hasError) continue;
-    try {
-      const identityKey = sha256(`${baseIdentity}\0${occurrence}`);
-      const source = textFor(content, node);
-      const signature = candidateSignature ?? signatureFor(content, node, name);
-      const embeddingInput = [
-        `language: ${language}`,
-        `kind: ${kind}`,
-        `symbol: ${qualifiedName}`,
-        signature ? `signature: ${signature}` : null,
-        documentation ? `documentation:
-${documentation}` : null,
-        "source:",
-        source
-      ].filter((value) => value !== null).join("\n");
-      callables.push({
-        path: relativePath,
-        language,
-        kind,
-        name,
-        qualifiedName,
-        signature,
-        identityKey,
-        startLine: node.startPosition.row + 1,
-        startColumn: node.startPosition.column + 1,
-        endLine: node.endPosition.row + 1,
-        endColumn: node.endPosition.column + 1,
-        lineCount: node.endPosition.row - node.startPosition.row + 1,
-        source,
-        sourceHash: sha256(source),
-        embeddingInput
-      });
-    } catch (error) {
-      errors.push({
-        path: relativePath,
-        language,
-        scope: "function",
-        code: "extraction-error",
-        qualifiedName,
-        message: `Cannot extract ${qualifiedName}: ${error instanceof Error ? error.message : String(error)}`,
-        startLine: node.startPosition.row + 1,
-        startColumn: node.startPosition.column + 1,
-        endLine: node.endPosition.row + 1,
-        endColumn: node.endPosition.column + 1,
-        source: textFor(content, node)
-      });
-    }
-  }
-  return { callables, errors };
-}
-
-// src/source-policy.ts
-import path4 from "node:path";
-var DEFAULT_EXCLUDED_SEGMENTS = /* @__PURE__ */ new Set([
-  ".git",
-  ".slopdex",
-  "node_modules",
-  "dist",
-  "build",
-  "coverage",
-  "vendor",
-  "generated",
-  ".venv",
-  "venv",
-  "__pycache__",
-  ".tox",
-  ".mypy_cache",
-  ".pytest_cache",
-  "target"
-]);
-var SourcePolicy = class {
-  #include;
-  #exclude;
-  constructor(include = [], exclude = []) {
-    this.#include = include;
-    this.#exclude = exclude;
-  }
-  includes(relativePath) {
-    const normalized = relativePath.replaceAll("\\", "/");
-    if (!languageForPath(normalized)) return false;
-    if (hasExcludedSegment(normalized)) return false;
-    if (this.#exclude.some((pattern) => path4.matchesGlob(normalized, pattern))) return false;
-    return this.#include.length === 0 || this.#include.some((pattern) => path4.matchesGlob(normalized, pattern));
-  }
-  traversesDirectory(relativePath) {
-    return !hasExcludedSegment(relativePath.replaceAll("\\", "/"));
-  }
-};
-function hasExcludedSegment(relativePath) {
-  return relativePath.split("/").some((segment) => DEFAULT_EXCLUDED_SEGMENTS.has(segment));
-}
-
-// src/code-index.ts
-var DEFAULT_MAX_FILE_SIZE = 1024 * 1024;
-var DEFAULT_BATCH_SIZE = 32;
-var RERANK_CANDIDATE_MULTIPLIER = 5;
-var DEFAULT_SIMILARITY_CACHE_WIDTH = 50;
-var MAX_SIMILARITY_CACHE_WIDTH = 200;
-var CodeIndex = class {
-  rootDir;
-  indexPath;
-  provider;
-  reranker;
-  descriptionProvider;
-  #database;
-  #policy;
-  #maxFileSize;
-  #embeddingBatchSize;
-  #parallelism;
-  #onProgress;
-  #git;
-  #onWarning;
-  constructor(options) {
-    this.rootDir = path5.resolve(options.rootDir);
-    this.indexPath = path5.resolve(options.indexPath ?? path5.join(this.rootDir, ".slopdex", "index.sqlite"));
-    this.provider = options.provider;
-    this.reranker = options.reranker;
-    if (this.reranker?.candidateCount !== void 0) {
-      assertPositiveInteger(this.reranker.candidateCount, "reranker candidate count");
-    }
-    if (this.reranker?.maximumCandidateCount !== void 0) {
-      assertPositiveInteger(this.reranker.maximumCandidateCount, "reranker maximum candidate count");
-      if (this.reranker.candidateCount !== void 0 && this.reranker.candidateCount > this.reranker.maximumCandidateCount) {
-        throw new CodeIndexError("reranker candidate count must not exceed its maximum candidate count.");
-      }
-    }
-    const profile = normalizeProfile(options.provider.profile);
-    assertPositiveInteger(profile.dimensions, "embedding dimensions");
-    this.#database = new IndexDatabase(this.indexPath, this.rootDir, profile, options.readOnly ?? false);
-    this.#parallelism = options.parallelism ?? DEFAULT_PARALLELISM;
-    assertPositiveInteger(this.#parallelism, "parallelism");
-    this.#onProgress = options.onProgress;
-    const storedDescriptionProfile = this.#database.descriptionProfile();
-    this.descriptionProvider = options.descriptionProvider ?? new OpenAIDescriptionProvider({
-      ...storedDescriptionProfile && isDescriptionProviderName(storedDescriptionProfile.provider) ? { provider: storedDescriptionProfile.provider, model: storedDescriptionProfile.model } : {},
-      parallelism: this.#parallelism,
-      ...options.verbose ? { verbose: true } : {}
-    });
-    this.#policy = new SourcePolicy(options.include, options.exclude);
-    this.#maxFileSize = options.maxFileSize ?? DEFAULT_MAX_FILE_SIZE;
-    this.#embeddingBatchSize = options.embeddingBatchSize ?? DEFAULT_BATCH_SIZE;
-    this.#onWarning = options.onWarning ?? console.warn;
-    assertPositiveInteger(this.#maxFileSize, "maxFileSize");
-    assertPositiveInteger(this.#embeddingBatchSize, "embeddingBatchSize");
-    this.#git = new GitRepository(this.rootDir);
-  }
-  #progress(phase, completed, total) {
-    this.#onProgress?.({ phase, completed, total });
-  }
-  close() {
-    this.#database.close();
-  }
-  status() {
-    return this.#database.status();
-  }
-  allFunctions() {
-    return this.#database.allFunctions();
-  }
-  indexErrors() {
-    return this.#database.indexErrors();
-  }
-  async updateFiles(options) {
-    throwIfAborted(options.signal);
-    const gitignore = GitignoreRules.workingTree(this.rootDir);
-    const generation = this.#database.getGeneration();
-    const normalizedRenames = (options.renames ?? []).map(({ from, to }) => ({
-      from: normalizeRelativePath(this.rootDir, from),
-      to: normalizeRelativePath(this.rootDir, to)
-    }));
-    validateRenames(normalizedRenames);
-    const upsertPaths = [...new Set((options.upsert ?? []).map((value) => normalizeRelativePath(this.rootDir, value)))];
-    const deletePaths = [...new Set((options.delete ?? []).map((value) => normalizeRelativePath(this.rootDir, value)))];
-    const renameMap = new Map(
-      normalizedRenames.map(({ from, to }) => [to, from])
-    );
-    for (const target of renameMap.keys()) {
-      if (!upsertPaths.includes(target)) upsertPaths.push(target);
-    }
-    const prepared = [];
-    for (const relativePath of upsertPaths) {
-      throwIfAborted(options.signal);
-      if (!this.#policy.includes(relativePath) || await gitignore.ignores(relativePath)) {
-        throw new CodeIndexError(`Unsupported or excluded source file: ${relativePath}`);
-      }
-      const renameSource = renameMap.get(relativePath);
-      const originalPath = renameSource ? this.#database.previousPath(renameSource) ?? renameSource : void 0;
-      const file = await this.#prepareWorkingFile(relativePath, {
-        blobOid: null,
-        sourceMode: "working-tree",
-        indexedCommit: null,
-        ...originalPath ? { previousPath: originalPath } : {},
-        ...renameSource ? { replacePath: renameSource } : {}
-      }, true);
-      if (file) prepared.push(file);
-    }
-    let embeddingsCreated = await this.#attachEmbeddings(prepared, options.signal);
-    for (let attempt = 0; ; attempt += 1) {
-      await gitignore.assertUnchanged(options.signal);
-      const changed = [];
-      for (let index = 0; index < prepared.length; index += 1) {
-        const file = prepared[index];
-        if (!this.#workingFileChangedSynchronously(file)) continue;
-        if (attempt >= 2) throw new CodeIndexError(`Source changed repeatedly while indexing: ${file.path}; retry the update.`);
-        const refreshed = await this.#prepareWorkingFile(file.path, {
-          blobOid: null,
-          sourceMode: "working-tree",
-          indexedCommit: null,
-          ...file.previousPath ? { previousPath: file.previousPath } : {},
-          ...file.replacePath ? { replacePath: file.replacePath } : {}
-        }, true);
-        if (!refreshed) throw new CodeIndexError(`Source changed while indexing: ${file.path}; retry the update.`);
-        prepared[index] = refreshed;
-        changed.push(refreshed);
-      }
-      if (changed.length === 0) break;
-      embeddingsCreated += await this.#attachEmbeddings(changed, options.signal);
-    }
-    return this.#database.applyUpdate({
-      files: prepared,
-      deletePaths: [...deletePaths, ...renameMap.values()],
-      expectedGeneration: generation,
-      embeddingsCreated
-    });
-  }
-  async updateFromWorkingTree(options = {}) {
-    throwIfAborted(options.signal);
-    const generation = this.#database.getGeneration();
-    const indexedFiles = this.#database.getFileStates();
-    const gitignore = GitignoreRules.workingTree(this.rootDir);
-    let sourcePaths = await this.#workingTreeSourcePaths(gitignore, options.signal);
-    let prepared = await this.#prepareWorkingPaths(sourcePaths, options.signal);
-    let embeddingsCreated = await this.#attachEmbeddings(prepared, options.signal);
-    while (true) {
-      await gitignore.assertUnchanged(options.signal);
-      const pathsAgain = await this.#workingTreeSourcePaths(gitignore, options.signal);
-      if (JSON.stringify(pathsAgain) !== JSON.stringify(sourcePaths)) {
-        sourcePaths = pathsAgain;
-        prepared = await this.#prepareWorkingPaths(sourcePaths, options.signal);
-        embeddingsCreated += await this.#attachEmbeddings(prepared, options.signal);
-        continue;
-      }
-      const changed = [];
-      for (let index = 0; index < prepared.length; index += 1) {
-        const file = prepared[index];
-        if (!await this.#workingFileChanged(file)) continue;
-        const refreshed = await this.#prepareWorkingFile(file.path, {
-          blobOid: null,
-          sourceMode: "working-tree",
-          indexedCommit: null
-        });
-        if (!refreshed) {
-          sourcePaths = await this.#workingTreeSourcePaths(gitignore, options.signal);
-          prepared = await this.#prepareWorkingPaths(sourcePaths, options.signal);
-          changed.push(...prepared);
-          break;
-        }
-        prepared[index] = refreshed;
-        changed.push(refreshed);
-      }
-      if (changed.length === 0) break;
-      embeddingsCreated += await this.#attachEmbeddings(changed, options.signal);
-    }
-    await gitignore.assertUnchanged(options.signal);
-    if (this.#isWorkingTreeClean(indexedFiles, prepared)) {
-      return emptyStats(this.#database.getCheckpoint());
-    }
-    return this.#database.applyUpdate({
-      files: prepared,
-      deletePaths: indexedFiles.map((file) => file.path),
-      checkpoint: null,
-      expectedGeneration: generation,
-      completeDiagnosticsScan: true,
-      embeddingsCreated
-    });
-  }
-  /**
-   * Whether a working-tree refresh changed nothing: same file set, same
-   * content, same language, and still working-tree rows, with no checkout to
-   * clear. Recorded indexing errors never force a refresh on their own; a
-   * file with errors is retried only when its content changes or via an
-   * explicit updateFiles upsert. Skipping the write avoids a generation
-   * bump and, via foreign-key cascades, needlessly invalidating the
-   * similarity cache for unchanged files. Description state must already be
-   * quiescent: a refresh is what lazily clears stored descriptions after
-   * disableDescriptions, so a stale description count must fall through to
-   * the rewrite, and enabled indexes keep the legacy behavior.
-   */
-  #isWorkingTreeClean(indexedFiles, prepared) {
-    if (this.#database.getCheckpoint() !== null) return false;
-    if (this.#database.descriptionsEnabled()) return false;
-    if (indexedFiles.length !== prepared.length) return false;
-    const status = this.status();
-    if (status.descriptionCount > 0 || status.fileDescriptionCount > 0) return false;
-    const indexedByPath = new Map(indexedFiles.map((file) => [file.path, file]));
-    return prepared.every((file) => {
-      const indexed = indexedByPath.get(file.path);
-      return !!indexed && indexed.sourceMode === "working-tree" && indexed.blobOid === file.blobOid && indexed.language === file.language && indexed.contentHash === file.contentHash;
-    });
-  }
-  async updateFromGit(options = {}) {
-    throwIfAborted(options.signal);
-    await this.#git.assertRepository();
-    const relativeIndexPath = path5.relative(this.rootDir, this.indexPath).replaceAll(path5.sep, "/");
-    const indexArtifacts = relativeIndexPath && !relativeIndexPath.startsWith("../") ? [relativeIndexPath, `${relativeIndexPath}-shm`, `${relativeIndexPath}-wal`, `${relativeIndexPath}-journal`] : [];
-    const target = await this.#git.resolveCommit(options.target ?? "HEAD");
-    const head = await this.#git.resolveCommit("HEAD");
-    const overlayWorkingTree = target === head && options.includeWorkingTree !== false;
-    const checkpoint = this.#database.getCheckpoint();
-    const generation = this.#database.getGeneration();
-    const tooLargePaths = new Set(this.#database.filesWithFileTooLargeErrors());
-    let reconcileAll = checkpoint === null;
-    if (checkpoint && !await this.#git.isAncestor(checkpoint, target)) {
-      if (!options.rebuildOnDivergence) throw new GitDivergenceError(checkpoint, target);
-      reconcileAll = true;
-    }
-    const tree = await this.#git.listTree(target);
-    const indexedFiles = this.#database.getFileStates();
-    const indexedByPath = new Map(indexedFiles.map((file) => [file.path, file]));
-    const workingFiles = indexedFiles.filter((file) => file.sourceMode === "working-tree");
-    const workingChanges = overlayWorkingTree ? await this.#git.workTreeChanges(target, indexArtifacts) : [];
-    const gitignore = overlayWorkingTree ? GitignoreRules.workingTree(this.rootDir) : new GitignoreRules(async (filePath) => {
-      const entry = tree.get(filePath);
-      return entry ? (await this.#git.readBlob(entry.oid)).toString("utf8") : null;
-    });
-    const allowedPaths = /* @__PURE__ */ new Set();
-    const candidatePaths = /* @__PURE__ */ new Set([
-      ...tree.keys(),
-      ...workingChanges.map((change) => change.path),
-      ...indexedFiles.map((file) => file.path)
-    ]);
-    for (const filePath of candidatePaths) {
-      throwIfAborted(options.signal);
-      if (this.#policy.includes(filePath) && !await gitignore.ignores(filePath)) allowedPaths.add(filePath);
-    }
-    const visibleWorkingPaths = new Set(
-      workingChanges.filter((change) => change.status !== "D").map((change) => change.path)
-    );
-    const changes = reconcileAll || !checkpoint ? [] : await this.#git.diff(checkpoint, target);
-    const upserts = /* @__PURE__ */ new Map();
-    const deletes = /* @__PURE__ */ new Set();
-    const eligibleEntries = [...tree.values()].filter((entry) => allowedPaths.has(entry.path));
-    const eligibleTargetPaths = new Set(eligibleEntries.map((entry) => entry.path));
-    if (reconcileAll) {
-      const renameCandidates = indexedFiles.filter((file) => file.sourceMode === "git" && file.blobOid && !eligibleTargetPaths.has(file.path));
-      const claimedRenameSources = /* @__PURE__ */ new Set();
-      for (const entry of eligibleEntries) {
-        const indexed = indexedByPath.get(entry.path);
-        if (indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size > this.#maxFileSize === tooLargePaths.has(entry.path)) continue;
-        const matches = renameCandidates.filter((candidate) => candidate.blobOid === entry.oid && !claimedRenameSources.has(candidate.path));
-        const previousPath = matches.length === 1 ? matches[0].path : void 0;
-        if (previousPath) claimedRenameSources.add(previousPath);
-        upserts.set(entry.path, { entry, ...previousPath ? { previousPath } : {} });
-      }
-      for (const indexed of indexedFiles) {
-        if (!eligibleTargetPaths.has(indexed.path)) deletes.add(indexed.path);
-      }
-    } else {
-      this.#classifyGitChanges(changes, tree, upserts, deletes, allowedPaths);
-      const indexedPaths = new Set(indexedByPath.keys());
-      for (const targetPath of eligibleTargetPaths) {
-        const indexed = indexedByPath.get(targetPath);
-        const entry = tree.get(targetPath);
-        const sizeStateFlipped = indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size > this.#maxFileSize !== tooLargePaths.has(targetPath);
-        if ((!indexed || indexed.sourceMode === "git" && indexed.blobOid !== entry.oid || sizeStateFlipped) && !upserts.has(targetPath)) {
-          upserts.set(targetPath, { entry });
-        }
-      }
-      for (const indexedPath of indexedPaths) {
-        if (!eligibleTargetPaths.has(indexedPath)) deletes.add(indexedPath);
-      }
-    }
-    for (const dirtyFile of workingFiles) {
-      const entry = tree.get(dirtyFile.path);
-      const previousEntry = dirtyFile.previousPath ? tree.get(dirtyFile.previousPath) : void 0;
-      if (previousEntry && allowedPaths.has(previousEntry.path) && (entry !== void 0 || !visibleWorkingPaths.has(dirtyFile.path))) {
-        const currentPlan = entry ? upserts.get(dirtyFile.path) : void 0;
-        upserts.delete(dirtyFile.path);
-        upserts.delete(previousEntry.path);
-        upserts.set(previousEntry.path, { entry: previousEntry, previousPath: dirtyFile.path });
-        if (entry && allowedPaths.has(entry.path)) {
-          upserts.set(dirtyFile.path, currentPlan ?? { entry });
-        }
-        continue;
-      }
-      if (entry && allowedPaths.has(dirtyFile.path)) {
-        const planned = upserts.get(dirtyFile.path);
-        if (planned?.previousPath && !indexedByPath.has(planned.previousPath)) {
-          upserts.set(dirtyFile.path, { entry, previousPath: dirtyFile.path });
-        } else if (!planned) {
-          upserts.set(dirtyFile.path, { entry });
-        }
-        continue;
-      }
-      if (previousEntry && allowedPaths.has(previousEntry.path)) {
-        upserts.set(previousEntry.path, { entry: previousEntry, previousPath: dirtyFile.path });
-      } else {
-        deletes.add(dirtyFile.path);
-      }
-    }
-    for (const [filePath, { entry, previousPath }] of upserts) {
-      const indexed = indexedByPath.get(filePath);
-      if (!previousPath && indexed?.sourceMode === "git" && indexed.blobOid === entry.oid && entry.size > this.#maxFileSize === tooLargePaths.has(filePath)) upserts.delete(filePath);
-    }
-    const workingPrepared = [];
-    const workingDeletes = /* @__PURE__ */ new Set();
-    const skippedWorkingPaths = /* @__PURE__ */ new Set();
-    for (const change of workingChanges) {
-      throwIfAborted(options.signal);
-      if (change.status === "D") {
-        upserts.delete(change.path);
-        workingDeletes.add(change.path);
-        continue;
-      }
-      let previousPath;
-      let replacePath;
-      if (change.status === "R") {
-        const plannedBase = upserts.get(change.oldPath);
-        const existingAtTarget = indexedByPath.get(change.oldPath);
-        const existingAtFinal = indexedByPath.get(change.path);
-        const continuingRename = existingAtFinal?.sourceMode === "working-tree" && existingAtFinal.previousPath === change.oldPath;
-        replacePath = continuingRename ? change.path : existingAtTarget ? change.oldPath : existingAtFinal ? change.path : plannedBase?.previousPath && indexedByPath.has(plannedBase.previousPath) ? plannedBase.previousPath : void 0;
-        previousPath = existingAtFinal?.previousPath ?? change.oldPath;
-        upserts.delete(change.oldPath);
-        upserts.delete(change.path);
-        if (replacePath) deletes.delete(replacePath);
-        workingDeletes.add(change.oldPath);
-      } else {
-        const planned = upserts.get(change.path);
-        const existing = indexedByPath.get(change.path);
-        replacePath = existing ? change.path : planned?.previousPath && indexedByPath.has(planned.previousPath) ? planned.previousPath : void 0;
-        previousPath = existing?.previousPath ?? planned?.previousPath;
-        upserts.delete(change.path);
-        if (replacePath) deletes.delete(replacePath);
-      }
-      const relativePath = change.path;
-      if (!allowedPaths.has(relativePath)) {
-        if (replacePath) workingDeletes.add(replacePath);
-        workingDeletes.add(relativePath);
-        continue;
-      }
-      const file = await this.#prepareWorkingFile(relativePath, {
-        blobOid: null,
-        sourceMode: "working-tree",
-        indexedCommit: null
-      });
-      if (!file) {
-        if (replacePath) workingDeletes.add(replacePath);
-        workingDeletes.add(relativePath);
-        skippedWorkingPaths.add(relativePath);
-        continue;
-      }
-      if (!file.unavailable && !replacePath && change.status === "A") {
-        const contentHash = file.contentHash;
-        const renameCandidates = workingFiles.filter((file2) => file2.path !== relativePath && !visibleWorkingPaths.has(file2.path) && deletes.has(file2.path) && file2.contentHash === contentHash);
-        const renamed = renameCandidates.length === 1 ? renameCandidates[0] : void 0;
-        if (renamed) {
-          replacePath = renamed.path;
-          previousPath = renamed.previousPath ?? renamed.path;
-          deletes.delete(renamed.path);
-        }
-      }
-      workingPrepared.push({
-        ...file,
-        ...previousPath ? { previousPath } : {},
-        ...replacePath ? { replacePath } : {}
-      });
-    }
-    const prepared = [];
-    for (const { entry, previousPath } of upserts.values()) {
-      throwIfAborted(options.signal);
-      const provenance = {
-        blobOid: entry.oid,
-        sourceMode: "git",
-        indexedCommit: target,
-        ...previousPath ? { replacePath: previousPath } : {}
-      };
-      if (entry.size > this.#maxFileSize) {
-        prepared.push(this.#failedFile(entry.path, "file-too-large", `File exceeds maxFileSize (${this.#maxFileSize} bytes).`, provenance, entry.size));
-        continue;
-      }
-      try {
-        const content = await this.#git.readBlob(entry.oid);
-        prepared.push(this.#prepareFile(entry.path, content, provenance));
-      } catch (error) {
-        prepared.push(this.#failedFile(entry.path, "read-error", error instanceof Error ? error.message : String(error), provenance, entry.size));
-      }
-    }
-    let embeddingsCreated = await this.#attachEmbeddings([...prepared, ...workingPrepared], options.signal);
-    const noChanges = !reconcileAll && checkpoint === target && prepared.length === 0 && deletes.size === 0 && workingPrepared.length === 0 && workingDeletes.size === 0;
-    while (true) {
-      const resolvedAgain = await this.#git.resolveCommit(options.target ?? "HEAD");
-      if (resolvedAgain !== target) throw new CodeIndexError("Target Git ref changed while indexing; retry the update.");
-      if (!overlayWorkingTree) break;
-      const headAgain = await this.#git.resolveCommit("HEAD");
-      const workingChangesAgain = await this.#git.workTreeChanges(target, indexArtifacts);
-      if (headAgain !== head) throw new CodeIndexError("Git HEAD changed while indexing; retry the update.");
-      if (JSON.stringify(workingChangesAgain) !== JSON.stringify(workingChanges)) return await this.updateFromGit(options);
-      const changed = [];
-      for (let index = 0; index < workingPrepared.length; index += 1) {
-        const file = workingPrepared[index];
-        if (!await this.#workingFileChanged(file)) continue;
-        const refreshed = await this.#prepareWorkingFile(file.path, {
-          blobOid: null,
-          sourceMode: "working-tree",
-          indexedCommit: null,
-          ...file.previousPath ? { previousPath: file.previousPath } : {},
-          ...file.replacePath ? { replacePath: file.replacePath } : {}
-        });
-        if (!refreshed) return await this.updateFromGit(options);
-        workingPrepared[index] = refreshed;
-        changed.push(refreshed);
-      }
-      for (const relativePath of skippedWorkingPaths) {
-        const refreshed = await this.#prepareWorkingFile(relativePath, {
-          blobOid: null,
-          sourceMode: "working-tree",
-          indexedCommit: null
-        });
-        if (refreshed && !refreshed.unavailable) return await this.updateFromGit(options);
-      }
-      if (changed.length > 0) {
-        embeddingsCreated += await this.#attachEmbeddings(changed, options.signal);
-        continue;
-      }
-      await gitignore.assertUnchanged(options.signal);
-      break;
-    }
-    if (noChanges) {
-      if (this.#database.getCheckpoint() !== checkpoint || this.#database.getGeneration() !== generation) {
-        throw new CodeIndexError("Index changed while the update was being prepared; retry the update.");
-      }
-      return emptyStats(checkpoint);
-    }
-    return this.#database.applyUpdate({
-      files: prepared,
-      deletePaths: [...deletes],
-      workingTree: {
-        files: workingPrepared,
-        deletePaths: [...workingDeletes]
-      },
-      checkpoint: target,
-      expectedCheckpoint: checkpoint,
-      expectedGeneration: generation,
-      completeDiagnosticsScan: true,
-      embeddingsCreated
-    });
-  }
-  #classifyGitChanges(changes, tree, upserts, deletes, allowedPaths) {
-    for (const change of changes) {
-      if (change.status === "D") {
-        deletes.add(change.path);
-        continue;
-      }
-      if (change.status === "R") {
-        deletes.add(change.oldPath);
-        const entry2 = tree.get(change.path);
-        if (entry2 && allowedPaths.has(change.path)) {
-          upserts.set(change.path, { entry: entry2, previousPath: change.oldPath });
-        }
-        continue;
-      }
-      const entry = tree.get(change.path);
-      if (entry && allowedPaths.has(change.path)) upserts.set(change.path, { entry });
-      else deletes.add(change.path);
-    }
-  }
-  async #workingTreeSourcePaths(gitignore, signal) {
-    const relativeIndexPath = path5.relative(this.rootDir, this.indexPath).replaceAll(path5.sep, "/");
-    const indexArtifacts = new Set(relativeIndexPath && !relativeIndexPath.startsWith("../") ? [relativeIndexPath, `${relativeIndexPath}-shm`, `${relativeIndexPath}-wal`, `${relativeIndexPath}-journal`] : []);
-    const directories = [""];
-    const sourcePaths = [];
-    while (directories.length > 0) {
-      throwIfAborted(signal);
-      const relativeDirectory = directories.shift();
-      const entries = await readdir(path5.join(this.rootDir, relativeDirectory), { withFileTypes: true });
-      entries.sort((left, right) => left.name.localeCompare(right.name));
-      for (const entry of entries) {
-        const relativePath = relativeDirectory ? `${relativeDirectory.replaceAll(path5.sep, "/")}/${entry.name}` : entry.name;
-        if (entry.isDirectory()) {
-          if (this.#policy.traversesDirectory(relativePath) && !await gitignore.ignores(relativePath, true)) directories.push(relativePath);
-        } else if (entry.isFile() && !indexArtifacts.has(relativePath) && this.#policy.includes(relativePath) && !await gitignore.ignores(relativePath)) {
-          sourcePaths.push(relativePath);
-        }
-      }
-    }
-    sourcePaths.sort();
-    return sourcePaths;
-  }
-  async #prepareWorkingPaths(relativePaths, signal) {
-    const prepared = [];
-    for (const relativePath of relativePaths) {
-      throwIfAborted(signal);
-      const file = await this.#prepareWorkingFile(relativePath, {
-        blobOid: null,
-        sourceMode: "working-tree",
-        indexedCommit: null
-      });
-      if (file) prepared.push(file);
-    }
-    return prepared;
-  }
-  async #workingFileChanged(file) {
-    try {
-      const info = await lstat3(path5.join(this.rootDir, file.path));
-      if (!info.isFile() || info.isSymbolicLink() || info.size !== file.byteSize) return true;
-      if (info.size > this.#maxFileSize) return !file.errors.some((error) => error.code === "file-too-large");
-      const content = await readFile2(path5.join(this.rootDir, file.path));
-      return file.unavailable === true || sha256(content.toString("utf8")) !== file.contentHash;
-    } catch {
-      return file.unavailable !== true;
-    }
-  }
-  #workingFileChangedSynchronously(file) {
-    try {
-      const absolutePath = path5.join(this.rootDir, file.path);
-      const info = lstatSync(absolutePath);
-      if (!info.isFile() || info.isSymbolicLink() || info.size !== file.byteSize) return true;
-      if (info.size > this.#maxFileSize) return !file.errors.some((error) => error.code === "file-too-large");
-      const contentHash = sha256(readFileSync(absolutePath, "utf8"));
-      return file.unavailable === true || contentHash !== file.contentHash;
-    } catch {
-      return file.unavailable !== true;
-    }
-  }
-  #prepareFile(relativePath, buffer, provenance) {
-    const content = buffer.toString("utf8");
-    const contentHash = sha256(content);
-    const parseKey = sha256(`${CALLABLE_PARSER_CACHE_VERSION}\0${relativePath}\0${contentHash}`);
-    let parsed = this.#database.cachedParse(parseKey);
-    if (!parsed) {
-      parsed = parseFileCallables(relativePath, content, this.#onWarning);
-      if (!parsed.errors.some((error) => error.code === "parse-failed" || error.code === "extraction-error")) {
-        this.#database.storeParse(parseKey, parsed);
-      }
-    } else if (parsed.errors.length > 0) {
-      this.#onWarning(`Cannot fully parse ${relativePath}: tree-sitter reported syntax errors; indexing recoverable callables only.`);
-    }
-    const language = languageForPath(relativePath) ?? path5.extname(relativePath).slice(1);
-    return {
-      path: relativePath,
-      contentHash,
-      blobOid: provenance.blobOid,
-      sourceMode: provenance.sourceMode,
-      indexedCommit: provenance.indexedCommit,
-      language,
-      byteSize: buffer.byteLength,
-      source: content,
-      ...provenance.previousPath ? { previousPath: provenance.previousPath } : {},
-      ...provenance.replacePath ? { replacePath: provenance.replacePath } : {},
-      callables: parsed.callables,
-      errors: parsed.errors
-    };
-  }
-  async #prepareWorkingFile(relativePath, provenance, strict = false) {
-    let size = 0;
-    try {
-      const absolutePath = path5.join(this.rootDir, relativePath);
-      const info = await lstat3(absolutePath);
-      if (info.isSymbolicLink() || !info.isFile()) {
-        if (strict) throw new CodeIndexError(`Not a regular file or symbolic links are not supported: ${relativePath}`);
-        return null;
-      }
-      size = info.size;
-      if (size > this.#maxFileSize) {
-        return this.#failedFile(relativePath, "file-too-large", `File exceeds maxFileSize (${this.#maxFileSize} bytes).`, provenance, size);
-      }
-      return this.#prepareFile(relativePath, await readFile2(absolutePath), provenance);
-    } catch (error) {
-      if (error instanceof CodeIndexError) throw error;
-      return this.#failedFile(relativePath, "read-error", error instanceof Error ? error.message : String(error), provenance, size);
-    }
-  }
-  #failedFile(relativePath, code, message, provenance, byteSize) {
-    this.#onWarning(`Cannot index ${relativePath}: ${message}`);
-    return {
-      ...provenance,
-      path: relativePath,
-      contentHash: sha256(""),
-      source: "",
-      byteSize,
-      language: languageForPath(relativePath) ?? "unknown",
-      callables: [],
-      unavailable: true,
-      errors: [{
-        path: relativePath,
-        language: languageForPath(relativePath),
-        scope: "file",
-        code,
-        message,
-        qualifiedName: null,
-        startLine: null,
-        startColumn: null,
-        endLine: null,
-        endColumn: null,
-        source: null
-      }]
-    };
-  }
-  async #attachEmbeddings(files, signal) {
-    if (this.#database.descriptionsEnabled()) {
-      await this.#attachDescriptions(files.filter((file) => !file.unavailable), signal);
-    }
-    throwIfAborted(signal);
-    const profile = JSON.stringify(normalizeProfile(this.provider.profile));
-    const unique = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      for (const callable of file.callables) {
-        callable.embeddingKey = embeddingKey(profile, "document", callable.embeddingInput);
-        const values = unique.get(callable.embeddingKey) ?? [];
-        values.push(callable);
-        unique.set(callable.embeddingKey, values);
-      }
-    }
-    const missing = [];
-    for (const [key, callables] of unique) {
-      const vector = this.#database.cachedEmbedding(key);
-      if (vector) {
-        for (const callable of callables) callable.vector = vector;
-      } else {
-        missing.push([key, callables]);
-      }
-    }
-    if (missing.length === 0) return 0;
-    let completed = 0;
-    this.#progress("vectors", 0, missing.length);
-    await forEachConcurrent(chunk(missing, this.#embeddingBatchSize), this.#parallelism, async (batch, _index, workerSignal) => {
-      const vectors = await this.provider.embedDocuments(
-        batch.map(([, callables]) => callables[0].embeddingInput),
-        { signal: workerSignal }
-      );
-      if (vectors.length !== batch.length) throw new CodeIndexError("Embedding provider returned an unexpected number of vectors.");
-      vectors.forEach((vector, index) => {
-        const converted = normalizeEmbeddingVector(vector, this.provider.profile.dimensions);
-        this.#database.storeEmbedding(batch[index][0], converted);
-        for (const callable of batch[index][1]) callable.vector = converted;
-      });
-      completed += batch.length;
-      this.#progress("vectors", completed, missing.length);
-    }, signal);
-    throwIfAborted(signal);
-    return missing.length;
-  }
-  async #attachDescriptions(files, signal, options = {}) {
-    const profile = descriptionProfileJson(this.descriptionProvider.profile);
-    const embeddingProfile = JSON.stringify(normalizeProfile(this.provider.profile));
-    const prepared = /* @__PURE__ */ new Map();
-    const repository = path5.basename(this.rootDir);
-    let descriptionsCreated = 0;
-    let fileDescriptionsCreated = 0;
-    let pending = 0;
-    const tasks = [];
-    const strategy = this.descriptionProvider.profile.strategyVersion;
-    const useLiveReuse = !options.skipCallables && !options.reindexCache && !options.forceCallableDescriptions && !options.ignoreLiveDescriptions;
-    const liveCallableDescriptions = useLiveReuse ? this.#database.liveFunctionDescriptions(files.flatMap((file) => file.callables.map((callable) => callable.identityKey))) : /* @__PURE__ */ new Map();
-    const liveFileHashes = useLiveReuse && files.length > 0 ? this.#database.liveFileContentHashes(files.map((file) => file.replacePath ?? file.previousPath ?? file.path)) : /* @__PURE__ */ new Map();
-    for (const file of files) {
-      const lookupPath = file.replacePath ?? file.previousPath ?? file.path;
-      const storedFileDescription = this.#database.fileDescription(lookupPath);
-      const fileDescriptionKey = sha256(`${profile}\0${repository}\0${file.path}\0${file.contentHash}\0file`);
-      const fileAgnosticKey = sha256(`${strategy}\0${repository}\0${file.path}\0${file.contentHash}\0file`);
-      const fileCacheKey = options.reindexCache ? sha256(`${fileDescriptionKey}\0reindex\0${storedFileDescription?.description ?? ""}`) : fileDescriptionKey;
-      const refreshFileDescription = options.refreshFileDescriptions || !storedFileDescription;
-      const fileDescription = refreshFileDescription ? this.#database.cachedDescription(fileCacheKey) ?? (!options.reindexCache ? this.#database.cachedDescription(fileAgnosticKey) : void 0) : storedFileDescription.description;
-      const fileUnchanged = liveFileHashes.get(lookupPath) === file.contentHash;
-      const descriptions = (options.skipCallables ? [] : file.callables).map((callable) => {
-        const descriptionKey = sha256(`${profile}\0${repository}\0${file.path}\0${file.contentHash}\0${callable.identityKey}\0${callable.sourceHash}`);
-        const agnosticKey = sha256(`${strategy}\0${repository}\0${file.path}\0${file.contentHash}\0${callable.identityKey}\0${callable.sourceHash}`);
-        const cacheKey = options.reindexCache ? sha256(`${descriptionKey}\0reindex\0${this.#database.functionDescription(callable.identityKey) ?? ""}`) : descriptionKey;
-        if (useLiveReuse && fileUnchanged) {
-          const live = liveCallableDescriptions.get(callable.identityKey);
-          if (live?.description && live.sourceHash === callable.sourceHash) {
-            return {
-              callable,
-              descriptionKey,
-              cacheKey,
-              agnosticKey,
-              description: live.description
-            };
-          }
-        }
-        const description = options.forceCallableDescriptions || options.reindexCache ? this.#database.cachedDescription(cacheKey) : this.#database.cachedDescription(descriptionKey) ?? this.#database.cachedDescription(agnosticKey);
-        return {
-          callable,
-          descriptionKey,
-          cacheKey,
-          agnosticKey,
-          ...description ? { description } : {}
-        };
-      });
-      pending += (refreshFileDescription && !fileDescription ? 1 : 0) + descriptions.filter(({ description }) => !description).length;
-      tasks.push({
-        file,
-        fileCacheKey,
-        fileAgnosticKey,
-        fileDescriptionKey,
-        refreshFileDescription,
-        ...fileDescription ? { fileDescription } : {},
-        fileDescriptionPath: refreshFileDescription ? file.path : storedFileDescription.path,
-        fileDescriptionContentHash: refreshFileDescription ? file.contentHash : storedFileDescription.contentHash,
-        descriptions
-      });
-    }
-    let completed = 0;
-    if (pending > 0) this.#progress("descriptions", 0, pending);
-    await forEachConcurrent(tasks, this.#parallelism, async (task, _index, workerSignal) => {
-      const { file } = task;
-      const session = task.refreshFileDescription || task.descriptions.some(({ description }) => !description) ? this.descriptionProvider.startFile?.({ repository, path: file.path, fileSource: file.source }) : void 0;
-      let fileDescription = task.fileDescription;
-      let fileDescriptionAddedToSession = false;
-      if (task.refreshFileDescription && !fileDescription) {
-        const generated = session ? await session.describeFile({ signal: workerSignal }) : await this.descriptionProvider.describeFile(
-          { repository, path: file.path, fileSource: file.source },
-          { signal: workerSignal }
-        );
-        if (typeof generated !== "string" || !generated.trim()) {
-          throw new CodeIndexError("Description provider does not support file descriptions or returned an empty description.");
-        }
-        fileDescription = this.#database.storeDescription(task.fileCacheKey, generated.trim());
-        this.#database.storeDescription(task.fileAgnosticKey, fileDescription);
-        fileDescriptionsCreated += 1;
-        fileDescriptionAddedToSession = session !== void 0;
-        completed += 1;
-        this.#progress("descriptions", completed, pending);
-      }
-      if (session && fileDescription && !fileDescriptionAddedToSession) session.replayFile(fileDescription);
-      if (fileDescription) {
-        const value = prepareDescription(prepared, embeddingProfile, fileDescription, this.#database);
-        file.fileDescription = {
-          path: task.fileDescriptionPath,
-          contentHash: task.fileDescriptionContentHash,
-          descriptionKey: task.fileDescriptionKey,
-          value
-        };
-      }
-      for (const entry of task.descriptions) {
-        throwIfAborted(workerSignal);
-        const { callable, descriptionKey, cacheKey, agnosticKey } = entry;
-        let { description } = entry;
-        if (!description) {
-          const generated = session ? await session.describe(callable, { signal: workerSignal }) : await this.descriptionProvider.describe({ repository, callable, fileSource: file.source }, { signal: workerSignal });
-          if (typeof generated !== "string" || !generated.trim()) throw new CodeIndexError("Description provider returned an empty description.");
-          description = this.#database.storeDescription(cacheKey, generated.trim());
-          this.#database.storeDescription(agnosticKey, description);
-          descriptionsCreated += 1;
-          completed += 1;
-          this.#progress("descriptions", completed, pending);
-        } else {
-          session?.replay(callable, description);
-        }
-        callable.descriptionKey = descriptionKey;
-        callable.description = prepareDescription(prepared, embeddingProfile, description, this.#database);
-      }
-    }, signal);
-    const missing = [...prepared.values()].filter((description) => !description.vector);
-    if (missing.length > 0) {
-      let embedded = 0;
-      this.#progress("description-vectors", 0, missing.length);
-      await forEachConcurrent(chunk(missing, this.#embeddingBatchSize), this.#parallelism, async (batch, _index, workerSignal) => {
-        const vectors = await this.provider.embedDocuments(batch.map((value) => value.description), { signal: workerSignal });
-        if (vectors.length !== batch.length) throw new CodeIndexError("Embedding provider returned an unexpected number of description vectors.");
-        vectors.forEach((vector, index) => {
-          const converted = normalizeEmbeddingVector(vector, this.provider.profile.dimensions);
-          this.#database.storeEmbedding(batch[index].key, converted);
-          batch[index].vector = converted;
-        });
-        embedded += batch.length;
-        this.#progress("description-vectors", embedded, missing.length);
-      }, signal);
-    }
-    throwIfAborted(signal);
-    return { descriptionsCreated, fileDescriptionsCreated };
-  }
-  async useDescriptions(options = {}) {
-    throwIfAborted(options.signal);
-    const generation = this.#database.getGeneration();
-    const functions = this.allFunctions();
-    const status = this.status();
-    const storedProfile = this.#database.descriptionProfile();
-    const strategyChanged = (storedProfile?.strategyVersion ?? this.descriptionProvider.profile.strategyVersion) !== this.descriptionProvider.profile.strategyVersion;
-    const profileChanged = descriptionProfileJson(storedProfile ?? this.descriptionProvider.profile) !== descriptionProfileJson(this.descriptionProvider.profile);
-    if (this.#database.descriptionsEnabled() && !strategyChanged && functions.every((callable) => callable.descriptionEmbeddingId !== null) && status.fileDescriptionCount === status.describableFileCount) {
-      if (profileChanged) this.#database.updateDescriptionProfile(this.descriptionProvider.profile, generation);
-      return { descriptionsCreated: 0, fileDescriptionsCreated: 0, descriptionsEnabled: true };
-    }
-    const files = await this.#descriptionFiles(this.#database.getFileStates().filter((file) => file.describable), functions, options.signal);
-    const { descriptionsCreated, fileDescriptionsCreated } = await this.#attachDescriptions(files, options.signal, {
-      refreshFileDescriptions: strategyChanged,
-      ...strategyChanged ? { ignoreLiveDescriptions: true } : {}
-    });
-    const ids = new Map(functions.map((callable) => [callable.identityKey, callable.id]));
-    this.#database.enableDescriptions(files.flatMap((file) => file.callables.map((callable) => ({
-      id: ids.get(callable.identityKey),
-      description: callable.description
-    }))), files, this.descriptionProvider.profile, generation);
-    return { descriptionsCreated, fileDescriptionsCreated, descriptionsEnabled: true };
-  }
-  async reindexFiles(options = {}) {
-    throwIfAborted(options.signal);
-    if (!this.#database.descriptionsEnabled()) throw new CodeIndexError("Descriptions are not enabled; run descriptions enable first.");
-    const generation = this.#database.getGeneration();
-    const states = this.#database.getFileStates().filter((file) => file.describable && (file.fileDescriptionPath !== file.path || file.fileDescriptionContentHash !== file.contentHash));
-    const files = await this.#descriptionFiles(states, this.allFunctions(), options.signal);
-    const created = await this.#attachDescriptions(files, options.signal, {
-      refreshFileDescriptions: true,
-      ...options.includeCallables !== void 0 ? { forceCallableDescriptions: options.includeCallables } : {},
-      reindexCache: true,
-      skipCallables: !options.includeCallables
-    });
-    this.#database.updateDescriptions(files, options.includeCallables ?? false, generation, this.descriptionProvider.profile);
-    return { filesReindexed: files.length, ...created };
-  }
-  async #descriptionFiles(states, functions, signal) {
-    const byPath = groupBy(functions, (callable) => callable.path);
-    const files = [];
-    for (const file of states) {
-      throwIfAborted(signal);
-      const buffer = file.sourceMode === "git" && file.blobOid ? await this.#git.readBlob(file.blobOid) : await readFile2(path5.join(this.rootDir, file.path));
-      const source = buffer.toString("utf8");
-      if (sha256(source) !== file.contentHash) {
-        throw new CodeIndexError(`Source changed since indexing: ${file.path}; update the index first.`);
-      }
-      const callables = byPath.get(file.path) ?? [];
-      files.push({
-        path: file.path,
-        contentHash: file.contentHash,
-        blobOid: file.blobOid,
-        sourceMode: file.sourceMode,
-        indexedCommit: null,
-        language: file.language,
-        byteSize: buffer.byteLength,
-        source,
-        errors: [],
-        callables: callables.map(({ description: _description, descriptionEmbeddingId: _descriptionEmbeddingId, ...callable }) => ({
-          ...callable,
-          embeddingKey: ""
-        }))
-      });
-    }
-    return files;
-  }
-  disableDescriptions() {
-    this.#database.disableDescriptions();
-    return { descriptionsCreated: 0, fileDescriptionsCreated: 0, descriptionsEnabled: false };
-  }
-  async searchDescription(options) {
-    if (!this.#database.descriptionsEnabled()) throw new CodeIndexError("Descriptions are not enabled; run descriptions enable first.");
-    if (!options.query.trim()) throw new CodeIndexError("query must not be empty.");
-    const limit = options.limit;
-    if (limit !== void 0) assertPositiveInteger(limit, "limit");
-    const candidateLimit = this.#candidateLimit(limit);
-    compileNameRegex(options.nameRegex);
-    throwIfAborted(options.signal);
-    const vector = await this.#queryEmbedding(options.query, options.signal);
-    throwIfAborted(options.signal);
-    const includeFileDescriptions = this.#descriptionScoringAvailable();
-    const results = this.#database.searchVector(vector, {
-      descriptions: true,
-      ...candidateLimit === void 0 ? {} : { limit: candidateLimit },
-      minSimilarity: options.minSimilarity ?? -1,
-      ...includeFileDescriptions ? { fileDescriptionVector: vector } : {},
-      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {},
-      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
-    });
-    return await this.#rerank(options.query, results, limit, options.signal);
-  }
-  async similaritySearch(options) {
-    if (!options.query.trim()) throw new CodeIndexError("query must not be empty.");
-    const limit = options.limit;
-    if (limit !== void 0) assertPositiveInteger(limit, "limit");
-    const candidateLimit = this.#candidateLimit(limit);
-    compileNameRegex(options.nameRegex);
-    throwIfAborted(options.signal);
-    const vector = await this.#queryEmbedding(options.query, options.signal);
-    const includeDescriptions = this.#descriptionScoringAvailable();
-    const results = this.searchByVector(vector, {
-      ...includeDescriptions ? { descriptionVector: vector, fileDescriptionVector: vector } : {},
-      ...candidateLimit === void 0 ? {} : { limit: candidateLimit },
-      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {},
-      minSimilarity: options.minSimilarity ?? -1,
-      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {}
-    });
-    return await this.#rerank(options.query, results, limit, options.signal);
-  }
-  #candidateLimit(limit) {
-    if (limit === void 0) return void 0;
-    if (!this.reranker) return limit;
-    if (this.reranker.maximumCandidateCount !== void 0 && limit > this.reranker.maximumCandidateCount) {
-      throw new CodeIndexError(`${this.reranker.profile.provider} reranker supports at most ${this.reranker.maximumCandidateCount} results.`);
-    }
-    const preferred = this.reranker.candidateCount === void 0 ? limit * RERANK_CANDIDATE_MULTIPLIER : Math.max(limit, this.reranker.candidateCount);
-    return this.reranker.maximumCandidateCount === void 0 ? preferred : Math.min(preferred, this.reranker.maximumCandidateCount);
-  }
-  async #rerank(query, candidates, limit, signal) {
-    if (!this.reranker || candidates.length === 0) return limit === void 0 ? candidates : candidates.slice(0, limit);
-    const documents = candidates.map(({ function: callable }) => [
-      `path: ${callable.path}`,
-      callable.description ? `description:
-${callable.description}` : null,
-      callable.embeddingInput
-    ].filter((value) => value !== null).join("\n"));
-    const rerankLimit = limit === void 0 ? candidates.length : Math.min(limit, candidates.length);
-    const rankings = await this.reranker.rerank(query, documents, signal ? { limit: rerankLimit, signal } : { limit: rerankLimit });
-    throwIfAborted(signal);
-    const seen = /* @__PURE__ */ new Set();
-    if (rankings.length !== rerankLimit) {
-      throw new CodeIndexError(`${this.reranker.profile.provider} returned invalid reranking results.`);
-    }
-    for (const { index, score } of rankings) {
-      if (!Number.isInteger(index) || index < 0 || index >= candidates.length || typeof score !== "number" || !Number.isFinite(score) || seen.has(index)) {
-        throw new CodeIndexError(`${this.reranker.profile.provider} returned invalid reranking results.`);
-      }
-      seen.add(index);
-    }
-    return rankings.map(({ index, score }) => ({ ...candidates[index], rerankScore: score }));
-  }
-  async #queryEmbedding(query, signal) {
-    const profile = JSON.stringify(normalizeProfile(this.provider.profile));
-    const key = embeddingKey(profile, "query", query);
-    const cached = this.#database.cachedEmbedding(key);
-    if (cached) return cached;
-    const vector = normalizeEmbeddingVector(
-      await this.provider.embedQuery(query, signal ? { signal } : void 0),
-      this.provider.profile.dimensions
-    );
-    this.#database.storeEmbedding(key, vector);
-    return vector;
-  }
-  similarToFunction(functionId, options) {
-    const vector = this.#database.vectorForFunction(functionId);
-    return this.#database.searchVector(vector, {
-      ...options.includeDescriptions ? { descriptionVector: this.#database.vectorForFunction(functionId, "description") } : {},
-      ...options.includeDescriptions ? { fileDescriptionVector: this.#database.fileVectorForFunction(functionId) } : {},
-      limit: options.limit,
-      minSimilarity: options.minSimilarity,
-      ...options.maxSimilarity !== void 0 ? { maxSimilarity: options.maxSimilarity } : {},
-      excludeId: functionId,
-      ...options.excludePaths !== void 0 ? { excludePaths: options.excludePaths } : {},
-      ...options.minLines !== void 0 ? { minLines: options.minLines } : {},
-      ...options.nameRegex !== void 0 ? { nameRegex: options.nameRegex } : {}
-    });
-  }
-  vectorForFunction(functionId, kind = "code") {
-    return this.#database.vectorForFunction(functionId, kind);
-  }
-  get readOnly() {
-    return this.#database.isReadOnly;
-  }
-  similarityCacheInfo() {
-    return this.#database.similarityCacheInfo();
-  }
-  /**
-   * Incrementally refresh the persisted pairwise-similarity cache for same-index
-   * analysis. Only pairs scoring at or above `minSimilarity` (the caller's
-   * effective threshold) are stored; queries below the cached floor fall back to
-   * live vector search. Only functions whose embeddings changed (plus a merge
-   * pass over the remaining functions when the changed set is small) are
-   * re-queried; unchanged pairs are reused. Lowering the floor below what is
-   * cached re-queries every function, since the missing band cannot be rebuilt
-   * incrementally; raising it reuses the cache for free. A per-function state
-   * row records the embedding triple, floor, row count, and a completeness flag,
-   * so a sparse row set is never mistaken for an unfinished computation. Call
-   * before cross-search/cohesion, then read through
-   * {@link cachedSimilarToFunction}. Best-effort under concurrent writers: a
-   * later refresh repairs any rows raced by an overlapping update.
-   */
-  async refreshSimilarityCache(options = {}) {
-    const width = Math.min(
-      MAX_SIMILARITY_CACHE_WIDTH,
-      Math.max(1, Math.floor(options.width ?? DEFAULT_SIMILARITY_CACHE_WIDTH))
-    );
-    const floor = options.minSimilarity ?? -1;
-    const mode = analysisSimilarity(this.status()).similarityMode;
-    const includeDescriptions = mode !== "code";
-    if (this.#database.isReadOnly) {
-      return { similarityMode: mode, width, minSimilarity: floor, sourcesRefreshed: 0, pairsStored: 0, skipped: true };
-    }
-    throwIfAborted(options.signal);
-    const generation = this.#database.getGeneration();
-    const triples = this.#database.similarityCacheTriples();
-    if (triples.length <= 1) {
-      return { similarityMode: mode, width, minSimilarity: floor, sourcesRefreshed: 0, pairsStored: 0, skipped: false };
-    }
-    const states = this.#database.similarityCacheStates(mode);
-    const tripleById = new Map(triples.map((triple) => [triple.functionId, triple]));
-    const dirty = /* @__PURE__ */ new Set();
-    let expanding = false;
-    for (const triple of triples) {
-      throwIfAborted(options.signal);
-      const state = states.get(triple.functionId);
-      if (!state || state.codeEmbeddingId !== triple.codeEmbeddingId || state.descriptionEmbeddingId !== triple.descriptionEmbeddingId || state.fileDescriptionEmbeddingId !== triple.fileDescriptionEmbeddingId || state.cachedWidth < width && !state.complete) {
-        dirty.add(triple.functionId);
-      } else if (state.floor > floor) {
-        expanding = true;
-        dirty.add(triple.functionId);
-      }
-    }
-    if (dirty.size === 0 && !expanding) {
-      const counts = this.#database.similarityCacheCounts(mode);
-      for (const triple of triples) {
-        if ((counts.get(triple.functionId) ?? 0) < (states.get(triple.functionId)?.storedCount ?? 0)) {
-          dirty.add(triple.functionId);
-        }
-      }
-    }
-    let sourcesRefreshed = 0;
-    let pairsStored = 0;
-    if (dirty.size === 0) {
-      return { similarityMode: mode, width, minSimilarity: floor, sourcesRefreshed, pairsStored, skipped: false };
-    }
-    const report = options.onProgress ?? this.#onProgress;
-    const total = triples.length;
-    let completed = 0;
-    report?.({ phase: "similarity-cache", completed, total });
-    const fullRefresh = states.size === 0 || expanding || dirty.size > Math.max(8, Math.ceil(triples.length * 0.25));
-    if (fullRefresh) {
-      for (const triple of triples) {
-        throwIfAborted(options.signal);
-        const scanned = this.similarToFunction(triple.functionId, {
-          ...includeDescriptions ? { includeDescriptions: true } : {},
-          limit: Math.min(width + 1, triples.length - 1),
-          minSimilarity: floor
-        });
-        const neighbors = scanned.slice(0, width);
-        this.#database.storeSimilarityNeighbors(triple.functionId, mode, neighbors, {
-          codeEmbeddingId: triple.codeEmbeddingId,
-          descriptionEmbeddingId: triple.descriptionEmbeddingId,
-          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: width,
-          generation,
-          floor,
-          complete: scanned.length <= width
-        });
-        sourcesRefreshed += 1;
-        pairsStored += neighbors.length;
-        completed += 1;
-        report?.({ phase: "similarity-cache", completed, total });
-      }
-      return { similarityMode: mode, width, minSimilarity: floor, sourcesRefreshed, pairsStored, skipped: false };
-    }
-    const functionsById = new Map(this.allFunctions().map((callable) => [callable.id, callable]));
-    const lean = /* @__PURE__ */ new Map();
-    let scanFloor = floor;
-    for (const state of states.values()) scanFloor = Math.min(scanFloor, state.floor);
-    for (const dirtyId of dirty) {
-      throwIfAborted(options.signal);
-      const prior = states.get(dirtyId);
-      const keepWidth = Math.max(width, prior?.cachedWidth ?? width);
-      const full = this.similarToFunction(dirtyId, {
-        ...includeDescriptions ? { includeDescriptions: true } : {},
-        limit: triples.length - 1,
-        minSimilarity: scanFloor
-      });
-      const byTarget = /* @__PURE__ */ new Map();
-      for (const match of full) byTarget.set(match.function.id, match);
-      lean.set(dirtyId, byTarget);
-      const triple = tripleById.get(dirtyId);
-      const top = full.slice(0, keepWidth);
-      this.#database.storeSimilarityNeighbors(dirtyId, mode, top, {
-        codeEmbeddingId: triple.codeEmbeddingId,
-        descriptionEmbeddingId: triple.descriptionEmbeddingId,
-        fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-        cachedWidth: keepWidth,
-        generation,
-        floor: scanFloor,
-        complete: full.length <= keepWidth
-      });
-      sourcesRefreshed += 1;
-      pairsStored += top.length;
-      completed += 1;
-      report?.({ phase: "similarity-cache", completed, total });
-    }
-    for (const triple of triples) {
-      throwIfAborted(options.signal);
-      if (dirty.has(triple.functionId)) continue;
-      const prior = states.get(triple.functionId);
-      const keepFloor = Math.min(floor, prior?.floor ?? floor);
-      const keepWidth = Math.max(width, prior?.cachedWidth ?? width);
-      const cached = this.#database.cachedSimilarityNeighbors(triple.functionId, mode);
-      const kept = cached.filter((match) => match.similarity >= keepFloor && !dirty.has(match.function.id) && functionsById.has(match.function.id));
-      const added = [];
-      for (const [dirtyId, byTarget] of lean) {
-        if (dirtyId === triple.functionId) continue;
-        const match = byTarget.get(triple.functionId);
-        const dirtyFunction = functionsById.get(dirtyId);
-        if (match && match.similarity >= keepFloor && dirtyFunction) {
-          const { function: _function, ...scores } = match;
-          added.push({ ...scores, function: dirtyFunction });
-        }
-      }
-      const plusOne = [...kept, ...added].sort((left, right) => right.similarity - left.similarity || left.function.id - right.function.id).slice(0, keepWidth + 1);
-      const merged = plusOne.slice(0, keepWidth);
-      const complete = plusOne.length <= keepWidth && (prior?.complete ?? false);
-      const unchanged = merged.length === cached.length && merged.every((match, index) => match.function.id === cached[index].function.id && match.similarity === cached[index].similarity);
-      if (unchanged) {
-        this.#database.touchSimilarityCacheState(triple.functionId, mode, {
-          codeEmbeddingId: triple.codeEmbeddingId,
-          descriptionEmbeddingId: triple.descriptionEmbeddingId,
-          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: keepWidth,
-          generation,
-          floor: keepFloor,
-          storedCount: merged.length,
-          complete
-        });
-      } else {
-        this.#database.storeSimilarityNeighbors(triple.functionId, mode, merged, {
-          codeEmbeddingId: triple.codeEmbeddingId,
-          descriptionEmbeddingId: triple.descriptionEmbeddingId,
-          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: keepWidth,
-          generation,
-          floor: keepFloor,
-          complete
-        });
-        pairsStored += merged.length;
-      }
-      sourcesRefreshed += 1;
-      completed += 1;
-      report?.({ phase: "similarity-cache", completed, total });
-    }
-    return { similarityMode: mode, width, minSimilarity: floor, sourcesRefreshed, pairsStored, skipped: false };
-  }
-  /**
-   * Same-index neighbor lookup backed by {@link refreshSimilarityCache}.
-   * Returns cache rows filtered exactly like {@link similarToFunction} and falls
-   * back to a live vector query whenever the cache entry is missing, stale,
-   * computed at a higher floor than requested, or too truncated to satisfy the
-   * filters. A cache entry flagged complete holds every pair above its floor,
-   * so short results from it are exact and need no live query.
-   *
-   * Prefer {@link cachedSimilarityReader} inside per-function loops: it loads
-   * the validity snapshot once instead of re-reading it for every function.
-   */
-  cachedSimilarToFunction(functionId, options) {
-    return this.cachedSimilarityReader({
-      ...options.includeDescriptions ? { includeDescriptions: true } : {}
-    }).similarToFunction(functionId, options);
-  }
-  /**
-   * Snapshot the similarity-cache validity state (per-mode states, embedding
-   * triples, generation) once for a run of neighbor lookups. The returned
-   * lookup behaves exactly like {@link cachedSimilarToFunction} but avoids
-   * re-reading whole tables per function; refresh the cache first and create
-   * one reader per analysis run. Best-effort under concurrent writers, like the
-   * refresh itself: a concurrent mutation mid-run is picked up by the next run.
-   *
-   * A fallback scan doubles as a read-repair: when the entry is fresh but
-   * unusable (missing, recorded at a higher floor, or incomplete), the scan is
-   * widened to the full cache width and written back, so later lookups hit.
-   * Stale entries are left for the refresh, dense-at-max-width entries cannot
-   * be improved, and read-only indexes never write.
-   */
-  cachedSimilarityReader(options = {}) {
-    const mode = options.includeDescriptions ? "code-description-file-average" : "code";
-    const states = this.#database.similarityCacheStates(mode);
-    const triples = this.#database.similarityCacheTriples();
-    const tripleById = new Map(triples.map((triple) => [triple.functionId, triple]));
-    const generation = this.#database.getGeneration();
-    const readFiltered = (functionId, query) => this.#database.cachedSimilarityNeighbors(functionId, mode, {
-      limit: query.limit,
-      minSimilarity: query.minSimilarity,
-      ...query.maxSimilarity !== void 0 ? { maxSimilarity: query.maxSimilarity } : {},
-      ...query.minLines !== void 0 ? { minLines: query.minLines } : {},
-      ...query.nameRegex !== void 0 ? { nameRegex: query.nameRegex } : {},
-      ...query.excludePaths !== void 0 ? { excludePaths: query.excludePaths } : {}
-    });
-    return {
-      similarToFunction: (functionId, query) => {
-        const live = () => this.similarToFunction(functionId, query);
-        if (query.includeDescriptions === true !== (mode !== "code")) {
-          return live();
-        }
-        compileNameRegex(query.nameRegex);
-        const triple = tripleById.get(functionId);
-        if (!triple) {
-          return live();
-        }
-        const state = states.get(functionId);
-        const tripleMatches = !!state && triple.codeEmbeddingId === state.codeEmbeddingId && triple.descriptionEmbeddingId === state.descriptionEmbeddingId && triple.fileDescriptionEmbeddingId === state.fileDescriptionEmbeddingId;
-        if (state && (!tripleMatches || state.generation !== generation)) {
-          return live();
-        }
-        if (state && state.floor <= query.minSimilarity) {
-          const cached2 = readFiltered(functionId, query);
-          if (cached2.length >= query.limit) return cached2;
-          if (state.complete) return cached2;
-          if (state.storedCount >= MAX_SIMILARITY_CACHE_WIDTH) return live();
-        } else if (this.#database.isReadOnly || this.#database.getGeneration() !== generation) {
-          return live();
-        }
-        const repairFloor = Math.min(query.minSimilarity, state?.floor ?? query.minSimilarity);
-        const width = MAX_SIMILARITY_CACHE_WIDTH;
-        const scanned = this.similarToFunction(functionId, {
-          ...mode !== "code" ? { includeDescriptions: true } : {},
-          limit: Math.min(width + 1, tripleById.size - 1),
-          minSimilarity: repairFloor
-        });
-        const neighbors = scanned.slice(0, width);
-        const complete = scanned.length <= width;
-        this.#database.storeSimilarityNeighbors(functionId, mode, neighbors, {
-          codeEmbeddingId: triple.codeEmbeddingId,
-          descriptionEmbeddingId: triple.descriptionEmbeddingId,
-          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: width,
-          generation,
-          floor: repairFloor,
-          complete
-        });
-        states.set(functionId, {
-          codeEmbeddingId: triple.codeEmbeddingId,
-          descriptionEmbeddingId: triple.descriptionEmbeddingId,
-          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
-          cachedWidth: width,
-          generation,
-          floor: repairFloor,
-          storedCount: neighbors.length,
-          complete
-        });
-        const cached = readFiltered(functionId, query);
-        if (cached.length >= query.limit) return cached;
-        if (complete) return cached;
-        return live();
-      }
-    };
-  }
-  vectorForFile(filePath) {
-    return this.#database.vectorForFile(filePath);
-  }
-  searchByVector(vector, options) {
-    return this.#database.searchVector(normalizeEmbeddingVector(vector, this.provider.profile.dimensions), {
-      ...options,
-      ...options.descriptionVector !== void 0 ? { descriptionVector: normalizeEmbeddingVector(options.descriptionVector, this.provider.profile.dimensions) } : {},
-      ...options.fileDescriptionVector !== void 0 ? { fileDescriptionVector: normalizeEmbeddingVector(options.fileDescriptionVector, this.provider.profile.dimensions) } : {}
-    });
-  }
-  #descriptionScoringAvailable() {
-    const status = this.status();
-    return status.descriptionsEnabled && status.descriptionCount === status.functionCount && status.fileDescriptionCount === status.describableFileCount;
-  }
-  async sourceFunctions(filter) {
-    const nameRegex = compileNameRegex(filter.nameRegex);
-    const sourcePath = filter.path ? normalizeRelativePath(this.rootDir, filter.path) : void 0;
-    const uncommitted = filter.type === "uncommitted" || filter.type === "changed-since" && filter.uncommitted;
-    const functions = filter.type === "changed-since" ? await this.#functionsChangedSince(filter.commit) : this.allFunctions();
-    return functions.filter((callable) => (!uncommitted || callable.sourceMode === "working-tree") && (!sourcePath || callable.path === sourcePath || callable.path.startsWith(`${sourcePath}/`)) && (!nameRegex || nameRegex.test(callable.qualifiedName)));
-  }
-  async #functionsChangedSince(baseRef) {
-    await this.#git.assertRepository();
-    const checkpoint = this.#database.getCheckpoint();
-    if (!checkpoint) throw new CodeIndexError("changed-since requires an index with a Git checkpoint.");
-    const base = await this.#git.resolveCommit(baseRef);
-    if (!await this.#git.isAncestor(base, checkpoint)) {
-      throw new GitDivergenceError(base, checkpoint);
-    }
-    const changes = await this.#git.diff(base, checkpoint);
-    const baseTree = await this.#git.listTree(base);
-    const comparisonPaths = /* @__PURE__ */ new Map();
-    for (const change of changes) {
-      if (change.status === "D") continue;
-      if (change.status === "R") comparisonPaths.set(change.path, { basePath: change.oldPath, pathChanged: true });
-      else if (change.status === "A" || change.status === "C") comparisonPaths.set(change.path, { basePath: null, pathChanged: false });
-      else comparisonPaths.set(change.path, { basePath: change.path, pathChanged: false });
-    }
-    for (const dirtyFile of this.#database.getWorkingTreeFiles()) {
-      const basePath = dirtyFile.previousPath ?? comparisonPaths.get(dirtyFile.path)?.basePath ?? dirtyFile.path;
-      comparisonPaths.set(dirtyFile.path, { basePath, pathChanged: basePath !== dirtyFile.path });
-    }
-    const current = this.#database.functionsForPaths([...comparisonPaths.keys()]);
-    const baseFunctionsByCurrentPath = /* @__PURE__ */ new Map();
-    for (const [currentPath, { basePath }] of comparisonPaths) {
-      if (!basePath) {
-        baseFunctionsByCurrentPath.set(currentPath, []);
-        continue;
-      }
-      const entry = baseTree.get(basePath);
-      if (!entry) {
-        baseFunctionsByCurrentPath.set(currentPath, []);
-        continue;
-      }
-      const content = (await this.#git.readBlob(entry.oid)).toString("utf8");
-      baseFunctionsByCurrentPath.set(currentPath, parseCallables(basePath, content, this.#onWarning));
-    }
-    const currentByPath = groupBy(current, (callable) => callable.path);
-    const changedIds = /* @__PURE__ */ new Set();
-    for (const [currentPath, currentFunctions] of currentByPath) {
-      const comparison = comparisonPaths.get(currentPath);
-      for (const id of changedFunctionIds(
-        currentFunctions,
-        baseFunctionsByCurrentPath.get(currentPath) ?? [],
-        comparison.pathChanged
-      )) {
-        changedIds.add(id);
-      }
-    }
-    return current.filter((callable) => changedIds.has(callable.id));
-  }
-};
-function changedFunctionIds(current, base, pathChanged) {
-  if (pathChanged) return current.map((callable) => callable.id);
-  const currentGroups = groupBy(current, (callable) => `${callable.qualifiedName}\0${callable.kind}`);
-  const baseGroups = groupBy(base, (callable) => `${callable.qualifiedName}\0${callable.kind}`);
-  const changed = [];
-  for (const [key, currentGroup] of currentGroups) {
-    const baseGroup = baseGroups.get(key) ?? [];
-    const unmatchedBase = new Set(baseGroup.map((_, index) => index));
-    const unmatchedCurrent = new Set(currentGroup.map((_, index) => index));
-    for (let currentIndex = 0; currentIndex < currentGroup.length; currentIndex += 1) {
-      const exactBaseIndex = [...unmatchedBase].find(
-        (baseIndex) => baseGroup[baseIndex].sourceHash === currentGroup[currentIndex].sourceHash
-      );
-      if (exactBaseIndex !== void 0) {
-        unmatchedBase.delete(exactBaseIndex);
-        unmatchedCurrent.delete(currentIndex);
-      }
-    }
-    for (const currentIndex of unmatchedCurrent) changed.push(currentGroup[currentIndex].id);
-  }
-  return changed;
-}
-function normalizeProfile(profile) {
-  return {
-    provider: profile.provider,
-    model: profile.model,
-    dimensions: profile.dimensions,
-    strategyVersion: profile.strategyVersion ?? "callable-v2"
-  };
-}
-function descriptionProfileJson(profile) {
-  return JSON.stringify({
-    provider: profile.provider,
-    model: profile.model,
-    strategyVersion: profile.strategyVersion
-  });
-}
-function embeddingKey(profile, operation, input) {
-  return sha256(`${profile}\0${operation}\0${input}`);
-}
-function prepareDescription(prepared, embeddingProfile, description, database) {
-  const key = embeddingKey(embeddingProfile, "document", description);
-  let value = prepared.get(key);
-  if (!value) {
-    value = { key, description };
-    const vector = database.cachedEmbedding(key);
-    if (vector) value.vector = vector;
-    prepared.set(key, value);
-  }
-  return value;
-}
-function emptyStats(checkpoint) {
-  return {
-    filesUpdated: 0,
-    filesDeleted: 0,
-    functionsAdded: 0,
-    functionsUpdated: 0,
-    functionsDeleted: 0,
-    embeddingsCreated: 0,
-    checkpoint
-  };
-}
-function validateRenames(renames) {
-  const sources = new Set(renames.map((rename) => rename.from));
-  const targets = new Set(renames.map((rename) => rename.to));
-  if (sources.size !== renames.length || targets.size !== renames.length) {
-    throw new CodeIndexError("Rename sources and targets must be unique.");
-  }
-  if ([...sources].some((source) => targets.has(source))) {
-    throw new CodeIndexError("Chained or cyclic renames must be applied in separate updates.");
-  }
-}
-function groupBy(values, keyFor) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const value of values) {
-    const key = keyFor(value);
-    const group = groups.get(key) ?? [];
-    group.push(value);
-    groups.set(key, group);
-  }
-  return groups;
-}
-
-export {
-  CodeIndex
-};
-//# sourceMappingURL=chunk-HMKVMRLF.js.map