@ninjaxtools/slopdex 0.15.0 → 0.18.0

package/dist/chunk-N6D66ASM.js

@@ -0,0 +1,2217 @@
+import {
+  IndexDatabase
+} from "./chunk-6LHZCHEB.js";
+import {
+  OpenAIDescriptionProvider,
+  isDescriptionProviderName
+} from "./chunk-TSURHRFF.js";
+import {
+  analysisSimilarity
+} from "./chunk-KQRS5P4U.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, still working-tree rows, no checkout to clear,
+   * and no recorded errors to retry. 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.needsDiagnosticsScan()) return false;
+    if (this.#database.filesWithErrors().length > 0) 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) => {
+      if (file.unavailable || file.errors.length > 0) return false;
+      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 diagnosticsScan = this.#database.needsDiagnosticsScan();
+    const retryPaths = new Set(this.#database.filesWithErrors());
+    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 && !diagnosticsScan && !retryPaths.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);
+        if ((diagnosticsScan || retryPaths.has(targetPath) || entry.size > this.#maxFileSize || !indexed || indexed.sourceMode === "git" && indexed.blobOid !== entry.oid) && !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 && !diagnosticsScan && !retryPaths.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 && !diagnosticsScan && 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();
+    for (const dirtyId of dirty) {
+      throwIfAborted(options.signal);
+      const full = this.similarToFunction(dirtyId, {
+        ...includeDescriptions ? { includeDescriptions: true } : {},
+        limit: triples.length - 1,
+        minSimilarity: floor
+      });
+      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, width);
+      this.#database.storeSimilarityNeighbors(dirtyId, mode, top, {
+        codeEmbeddingId: triple.codeEmbeddingId,
+        descriptionEmbeddingId: triple.descriptionEmbeddingId,
+        fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
+        cachedWidth: width,
+        generation,
+        floor,
+        complete: full.length <= width
+      });
+      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 cached = this.#database.cachedSimilarityNeighbors(triple.functionId, mode);
+      const kept = cached.filter((match) => match.similarity >= floor && !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 && 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, width + 1);
+      const merged = plusOne.slice(0, width);
+      const contributorsComplete = triples.every((candidate) => dirty.has(candidate.functionId) || states.get(candidate.functionId)?.complete === true);
+      const complete = plusOne.length <= width && contributorsComplete;
+      const unchanged = merged.length === cached.length && merged.every((match, index) => match.function.id === cached[index].function.id && match.similarity === cached[index].similarity);
+      if (unchanged) {
+        const narrowed = cached.some((match) => match.similarity < floor);
+        this.#database.touchSimilarityCacheState(triple.functionId, mode, {
+          codeEmbeddingId: triple.codeEmbeddingId,
+          descriptionEmbeddingId: triple.descriptionEmbeddingId,
+          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
+          cachedWidth: width,
+          generation,
+          floor: narrowed ? floor : states.get(triple.functionId)?.floor ?? floor,
+          storedCount: merged.length,
+          complete
+        });
+      } else {
+        this.#database.storeSimilarityNeighbors(triple.functionId, mode, merged, {
+          codeEmbeddingId: triple.codeEmbeddingId,
+          descriptionEmbeddingId: triple.descriptionEmbeddingId,
+          fileDescriptionEmbeddingId: triple.fileDescriptionEmbeddingId,
+          cachedWidth: width,
+          generation,
+          floor,
+          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-N6D66ASM.js.map