@wrongstack/tools 1.0.11 → 1.0.12

package/dist/{chunk-NEYUPZL6.js → chunk-6D3UIQMF.js}

@@ -1,9 +1,9 @@
 import {
   parseFilesContent
-} from "./chunk-KHUCKLOR.js";
+} from "./chunk-BJ5LXLKE.js";
 import {
   recordFilesystemRead
-} from "./chunk-ZKC5UNGD.js";
+} from "./chunk-OIFY4XNP.js";
 import {
   INDEXABLE_EXTENSIONS,
   LANG_FAMILY_ENTRIES,
@@ -75,6 +75,15 @@ var IndexCircuitBreaker = class {
       this.openedAt = this.now();
     }
   }
+  /**
+   * Release a probe that ended without a verdict (the caller aborted it).
+   * Neither success nor failure is recorded, but a half-open circuit must be
+   * able to admit the next probe — otherwise it refuses every request until a
+   * manual reset.
+   */
+  abandonProbe() {
+    this.probeInFlight = false;
+  }
   /** Force-close the circuit (manual recovery: `/codebase-reindex`). */
   reset() {
     this.state = "closed";
@@ -139,7 +148,8 @@ function buildWiringGraph(refs, options = {}) {
       const targetFile = fileOf.get(ref.toId);
       if (sourceFile !== void 0 && targetFile !== void 0 && sourceFile !== targetFile) {
         const imports = importsOf.get(sourceFile);
-        if (imports === void 0) {
+        if (options.implicitlyVisible?.(sourceFile, targetFile, imports)) {
+        } else if (imports === void 0) {
           w *= UNVERIFIED_VISIBILITY_WEIGHT;
         } else if (!imports.has(targetFile)) {
           w *= CONTRADICTED_VISIBILITY_WEIGHT;
@@ -309,6 +319,71 @@ function aggregateFileRank(rows, fileOf) {
   return out;
 }
 
+// src/codebase-index/graph-rank-pass.ts
+import * as path from "node:path";
+var DIRECTORY_SCOPED_FAMILIES = /* @__PURE__ */ new Set(["go", "jvm", "dotnet", "swift"]);
+var DIRECTORY_IMPORT_FAMILIES = /* @__PURE__ */ new Set(["go", "jvm"]);
+function familyOf(file) {
+  const lang = detectLang(file);
+  return lang ? languageFamily(lang) : void 0;
+}
+function createImplicitVisibility() {
+  const importedDirs = /* @__PURE__ */ new WeakMap();
+  return (sourceFile, targetFile, imports) => {
+    const family = familyOf(targetFile);
+    if (family === void 0) return false;
+    const targetDir = path.dirname(targetFile);
+    if (DIRECTORY_SCOPED_FAMILIES.has(family) && path.dirname(sourceFile) === targetDir && familyOf(sourceFile) === family) {
+      return true;
+    }
+    if (imports === void 0 || !DIRECTORY_IMPORT_FAMILIES.has(family)) return false;
+    let dirs = importedDirs.get(imports);
+    if (dirs === void 0) {
+      dirs = new Set([...imports].map((file) => path.dirname(file)));
+      importedDirs.set(imports, dirs);
+    }
+    return dirs.has(targetDir);
+  };
+}
+var RANK_VERSION = "1";
+var RANK_VERSION_KEY = "rank_version";
+var RANK_REFRESH_FILE_THRESHOLD = 25;
+function shouldRefreshRanks(store, opts) {
+  if (opts.force) return true;
+  if (!opts.files) return true;
+  if (store.getMetadata(RANK_VERSION_KEY) !== RANK_VERSION) return true;
+  if (store.getRankCounts().symbols === 0) return true;
+  return opts.files.length >= RANK_REFRESH_FILE_THRESHOLD;
+}
+function runGraphRankPass(store, errors) {
+  const startMs = Date.now();
+  try {
+    const refs = store.getAllResolvedRefs();
+    const fileOf = /* @__PURE__ */ new Map();
+    for (const symbol of store.getAllSymbols()) fileOf.set(symbol.id, symbol.file);
+    const graph = buildWiringGraph(refs, {
+      candidates: store.getSymbolNameCandidates(),
+      fileOf,
+      importsOf: store.getImportVisibility(),
+      implicitlyVisible: createImplicitVisibility()
+    });
+    const scores = pageRank(graph);
+    const symbolRows = toSymbolRankRows(graph, scores);
+    const fileRows = aggregateFileRank(symbolRows, fileOf);
+    store.replaceRanks(symbolRows, fileRows);
+    store.setMetadata(RANK_VERSION_KEY, RANK_VERSION);
+    return {
+      computed: true,
+      symbols: symbolRows.length,
+      files: fileRows.length,
+      durationMs: Date.now() - startMs
+    };
+  } catch (error) {
+    errors.push(`graph rank: ${error instanceof Error ? error.message : String(error)}`);
+    return { computed: false, symbols: 0, files: 0, durationMs: Date.now() - startMs };
+  }
+}
+
 // src/codebase-index/graph-adjacency-cache.ts
 var cached = null;
 function cacheKey(projectRoot, indexDir) {
@@ -334,7 +409,8 @@ function getWiringSnapshot(store, projectRoot, indexDir) {
   const graph = buildWiringGraph(store.getAllResolvedRefs(), {
     candidates: store.getSymbolNameCandidates(),
     fileOf,
-    importsOf: store.getImportVisibility()
+    importsOf: store.getImportVisibility(),
+    implicitlyVisible: createImplicitVisibility()
   });
   cached = { key, stamp, graph, fileOf };
   return { graph, fileOf };
@@ -560,6 +636,17 @@ function retrieveContext(store, projectRoot, indexDir, options, relativeOf) {
     score: scoreBySymbolId.get(row.id) ?? 0,
     snippet: ""
   }));
+  let floor = Number.POSITIVE_INFINITY;
+  for (const score of scoreBySymbolId.values()) if (score < floor) floor = score;
+  if (!Number.isFinite(floor) || floor <= 0) floor = 1;
+  const unwired = search.results.filter((hit) => !scoreBySymbolId.has(hit.id));
+  const maxLexical = Math.max(0, ...unwired.map((hit) => hit.score));
+  for (const hit of unwired) {
+    const lexical = maxLexical > 0 && hit.score > 0 ? hit.score / maxLexical : 1;
+    const score = floor * 0.5 * lexical;
+    scoreBySymbolId.set(hit.id, score);
+    walked.push({ ...hit, score });
+  }
   const grouped = groupIntoEntries(
     walked,
     scoreBySymbolId,
@@ -619,45 +706,6 @@ function groupIntoEntries(symbols, scoreBySymbolId, fileOf, limit, symbolsPerFil
   return { entries, totalCandidates };
 }
 
-// src/codebase-index/graph-rank-pass.ts
-var RANK_VERSION = "1";
-var RANK_VERSION_KEY = "rank_version";
-var RANK_REFRESH_FILE_THRESHOLD = 25;
-function shouldRefreshRanks(store, opts) {
-  if (opts.force) return true;
-  if (!opts.files) return true;
-  if (store.getMetadata(RANK_VERSION_KEY) !== RANK_VERSION) return true;
-  if (store.getRankCounts().symbols === 0) return true;
-  return opts.files.length >= RANK_REFRESH_FILE_THRESHOLD;
-}
-function runGraphRankPass(store, errors) {
-  const startMs = Date.now();
-  try {
-    const refs = store.getAllResolvedRefs();
-    const fileOf = /* @__PURE__ */ new Map();
-    for (const symbol of store.getAllSymbols()) fileOf.set(symbol.id, symbol.file);
-    const graph = buildWiringGraph(refs, {
-      candidates: store.getSymbolNameCandidates(),
-      fileOf,
-      importsOf: store.getImportVisibility()
-    });
-    const scores = pageRank(graph);
-    const symbolRows = toSymbolRankRows(graph, scores);
-    const fileRows = aggregateFileRank(symbolRows, fileOf);
-    store.replaceRanks(symbolRows, fileRows);
-    store.setMetadata(RANK_VERSION_KEY, RANK_VERSION);
-    return {
-      computed: true,
-      symbols: symbolRows.length,
-      files: fileRows.length,
-      durationMs: Date.now() - startMs
-    };
-  } catch (error) {
-    errors.push(`graph rank: ${error instanceof Error ? error.message : String(error)}`);
-    return { computed: false, symbols: 0, files: 0, durationMs: Date.now() - startMs };
-  }
-}
-
 // src/codebase-index/bm25.ts
 var K1 = 1.5;
 var B = 0.75;
@@ -1037,36 +1085,27 @@ function decorateGraphNodes(stmt, nodes, packageOf) {
 }
 
 // src/codebase-index/lsp-kind.ts
+var LSP_TO_INTERNAL_KINDS = {
+  [2 /* Module */]: ["mod"],
+  [3 /* Namespace */]: ["namespace"],
+  [5 /* Class */]: ["class"],
+  [6 /* Method */]: ["method"],
+  [7 /* Property */]: ["property"],
+  [8 /* Field */]: ["property"],
+  [10 /* Enum */]: ["enum"],
+  [11 /* Interface */]: ["interface", "trait"],
+  [12 /* Function */]: ["function"],
+  [13 /* Variable */]: ["var", "let"],
+  [14 /* Constant */]: ["const", "static"],
+  [19 /* Object */]: ["object"],
+  [23 /* Struct */]: ["struct"],
+  [26 /* TypeParameter */]: ["type"]
+};
+function lspKindToInternalKinds(k) {
+  return LSP_TO_INTERNAL_KINDS[k] ?? [];
+}
 function lspKindToInternalKind(k) {
-  switch (k) {
-    case 5 /* Class */:
-      return "class";
-    case 6 /* Method */:
-      return "method";
-    case 7 /* Property */:
-    case 8 /* Field */:
-      return "property";
-    case 9 /* Constructor */:
-      return "class";
-    case 10 /* Enum */:
-      return "enum";
-    case 11 /* Interface */:
-      return "interface";
-    case 12 /* Function */:
-      return "function";
-    case 13 /* Variable */:
-      return "var";
-    case 14 /* Constant */:
-      return "const";
-    case 22 /* EnumMember */:
-      return "enum";
-    case 26 /* TypeParameter */:
-      return "type";
-    case 3 /* Namespace */:
-      return "namespace";
-    default:
-      return null;
-  }
+  return LSP_TO_INTERNAL_KINDS[k]?.[0] ?? null;
 }
 function internalKindToLspKind(k) {
   switch (k) {
@@ -1092,7 +1131,17 @@ function internalKindToLspKind(k) {
       return 3 /* Namespace */;
     case "type":
       return 26 /* TypeParameter */;
-    // parameter and other internal-only kinds have no LSP equivalent
+    case "struct":
+      return 23 /* Struct */;
+    case "trait":
+      return 11 /* Interface */;
+    case "mod":
+      return 2 /* Module */;
+    case "object":
+      return 19 /* Object */;
+    case "static":
+      return 14 /* Constant */;
+    // parameter, impl, literal, schema have no LSP equivalent
     default:
       return null;
   }
@@ -1217,8 +1266,16 @@ function countFileVectorsWithStatement(stmt) {
     stmt("SELECT COUNT(*) AS n FROM file_vectors").get()?.n ?? 0
   );
 }
+function l2Norm(vector) {
+  let sum = 0;
+  for (let i = 0; i < vector.length; i++) sum += vector[i] * vector[i];
+  return Math.sqrt(sum);
+}
 function searchFileVectorsWithStatement(stmt, query, limit, minScore) {
-  if (limit <= 0 || query.length === 0) return [];
+  if (!(limit > 0) || query.length === 0) return [];
+  const queryNorm = l2Norm(query);
+  if (!(queryNorm > 0)) return [];
+  const floor = Number.isFinite(minScore) ? minScore : Number.NEGATIVE_INFINITY;
   const rows = stmt("SELECT file, vector FROM file_vectors").all();
   const hits = [];
   for (const row of rows) {
@@ -1229,9 +1286,12 @@ function searchFileVectorsWithStatement(stmt, query, limit, minScore) {
       continue;
     }
     if (vector.length !== query.length) continue;
+    const vectorNorm = l2Norm(vector);
+    if (!(vectorNorm > 0)) continue;
     let dot = 0;
     for (let i = 0; i < query.length; i++) dot += query[i] * vector[i];
-    if (dot >= minScore) hits.push({ file: row.file, score: dot });
+    const score = dot / (queryNorm * vectorNorm);
+    if (score >= floor) hits.push({ file: row.file, score });
   }
   hits.sort((a, b) => b.score - a.score || a.file.localeCompare(b.file));
   return hits.slice(0, limit);
@@ -1239,7 +1299,7 @@ function searchFileVectorsWithStatement(stmt, query, limit, minScore) {
 
 // src/codebase-index/writer.ts
 import * as fs3 from "node:fs";
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 
 // src/codebase-index/sqlite-runtime.ts
 import { toErrorMessage } from "@wrongstack/core/utils";
@@ -1311,7 +1371,7 @@ function runSqliteWithRetry(fn) {
 
 // src/codebase-index/writer-admin.ts
 import * as fs from "node:fs";
-import * as path from "node:path";
+import * as path2 from "node:path";
 var DB_FILE = "index.db";
 function getAllIndexableWithStatement(stmt) {
   const rows = stmt("SELECT id, name, signature, doc_comment FROM symbols").all();
@@ -1386,7 +1446,7 @@ function getAllFileMetasWithStatement(stmt) {
 }
 function getIndexDbSizeBytes(indexDir) {
   try {
-    return fs.statSync(path.join(indexDir, DB_FILE)).size;
+    return fs.statSync(path2.join(indexDir, DB_FILE)).size;
   } catch {
     return 0;
   }
@@ -1492,7 +1552,7 @@ function bulkInsertRefsWithStatement(stmt, maxSqlVars, refs) {
 
 // src/codebase-index/module-roots.ts
 import * as fs2 from "node:fs/promises";
-import * as path2 from "node:path";
+import * as path3 from "node:path";
 function toPortablePath(file) {
   return file.includes("\\") ? file.replace(/\\/g, "/") : file;
 }
@@ -1557,7 +1617,7 @@ function ancestorsOf(dir, stopAt) {
   for (; ; ) {
     out.push(current);
     if (current === stopAt || current.length <= stopAt.length) break;
-    const parent = path2.posix.dirname(current);
+    const parent = path3.posix.dirname(current);
     if (parent === current) break;
     current = parent;
   }
@@ -1568,8 +1628,12 @@ var MARKER_PROBES = [
     kind: "npm",
     file: "package.json",
     build: (dir, source) => {
-      const name = parsePackageJsonName(source) ?? path2.posix.basename(dir);
-      return { name, importPath: name, sourceRoots: [dir] };
+      const declared = parsePackageJsonName(source);
+      return {
+        name: declared ?? path3.posix.basename(dir),
+        importPath: declared,
+        sourceRoots: [dir]
+      };
     }
   },
   {
@@ -1582,7 +1646,7 @@ var MARKER_PROBES = [
         name: `crate:${name}`,
         // Rust paths use underscores where crate names often use dashes.
         importPath: name.replace(/-/g, "_"),
-        sourceRoots: [path2.posix.join(dir, "src")]
+        sourceRoots: [path3.posix.join(dir, "src")]
       };
     }
   },
@@ -1599,13 +1663,13 @@ var MARKER_PROBES = [
     kind: "python",
     file: "pyproject.toml",
     build: (dir, source) => {
-      const name = parseTomlTableName(source, ["project", "tool.poetry"]) ?? path2.posix.basename(dir);
+      const name = parseTomlTableName(source, ["project", "tool.poetry"]) ?? path3.posix.basename(dir);
       return {
         name: `py:${name}`,
         importPath: void 0,
         // `src/` layout is the packaging-guide default; the root itself covers
         // the flat layout. Both are probed, missing ones simply never match.
-        sourceRoots: [path2.posix.join(dir, "src"), dir]
+        sourceRoots: [path3.posix.join(dir, "src"), dir]
       };
     }
   },
@@ -1613,24 +1677,24 @@ var MARKER_PROBES = [
     kind: "python",
     file: "setup.py",
     build: (dir) => ({
-      name: `py:${path2.posix.basename(dir)}`,
+      name: `py:${path3.posix.basename(dir)}`,
       importPath: void 0,
-      sourceRoots: [path2.posix.join(dir, "src"), dir]
+      sourceRoots: [path3.posix.join(dir, "src"), dir]
     })
   },
   {
     kind: "maven",
     file: "pom.xml",
     build: (dir, source) => {
-      const artifactId = parsePomArtifactId(source) ?? path2.posix.basename(dir);
+      const artifactId = parsePomArtifactId(source) ?? path3.posix.basename(dir);
       return {
         name: `mvn:${artifactId}`,
         importPath: void 0,
         sourceRoots: [
-          path2.posix.join(dir, "src/main/java"),
-          path2.posix.join(dir, "src/main/kotlin"),
-          path2.posix.join(dir, "src/main/scala"),
-          path2.posix.join(dir, "src/test/java")
+          path3.posix.join(dir, "src/main/java"),
+          path3.posix.join(dir, "src/main/kotlin"),
+          path3.posix.join(dir, "src/main/scala"),
+          path3.posix.join(dir, "src/test/java")
         ]
       };
     }
@@ -1648,12 +1712,12 @@ var MARKER_PROBES = [
 ];
 function buildGradleRoot(dir) {
   return {
-    name: `gradle:${path2.posix.basename(dir)}`,
+    name: `gradle:${path3.posix.basename(dir)}`,
     importPath: void 0,
     sourceRoots: [
-      path2.posix.join(dir, "src/main/java"),
-      path2.posix.join(dir, "src/main/kotlin"),
-      path2.posix.join(dir, "src/main/scala")
+      path3.posix.join(dir, "src/main/java"),
+      path3.posix.join(dir, "src/main/kotlin"),
+      path3.posix.join(dir, "src/main/scala")
     ]
   };
 }
@@ -1675,6 +1739,17 @@ async function probeDotnetRoot(dir) {
     sourceRoots: [dir]
   };
 }
+var MARKER_PROBE_CONCURRENCY = 16;
+async function forEachLimited(items, limit, fn) {
+  let next = 0;
+  const worker = async () => {
+    while (next < items.length) {
+      const item = items[next++];
+      await fn(item);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+}
 async function detectModuleRoots(projectRoot, files) {
   const root = toPortablePath(projectRoot).replace(/\/+$/, "");
   const langsByDir = /* @__PURE__ */ new Map();
@@ -1682,7 +1757,7 @@ async function detectModuleRoots(projectRoot, files) {
     const portable = toPortablePath(file);
     const lang = detectLang(portable);
     if (!lang) continue;
-    const dir = path2.posix.dirname(portable);
+    const dir = path3.posix.dirname(portable);
     let langs = langsByDir.get(dir);
     if (!langs) {
       langs = /* @__PURE__ */ new Set();
@@ -1702,21 +1777,19 @@ async function detectModuleRoots(projectRoot, files) {
     }
   }
   const roots = [];
-  await Promise.all(
-    [...candidates].map(async ([dir, langs]) => {
-      for (const probe of MARKER_PROBES) {
-        if (!LANGS_BY_KIND[probe.kind].some((lang) => langs.has(lang))) continue;
-        const source = await readTextIfPresent(path2.posix.join(dir, probe.file));
-        if (source === void 0) continue;
-        const built = probe.build(dir, source);
-        if (built) roots.push({ dir, kind: probe.kind, ...built });
-      }
-      if (LANGS_BY_KIND.dotnet.some((lang) => langs.has(lang))) {
-        const dotnet = await probeDotnetRoot(dir);
-        if (dotnet) roots.push(dotnet);
-      }
-    })
-  );
+  await forEachLimited([...candidates], MARKER_PROBE_CONCURRENCY, async ([dir, langs]) => {
+    for (const probe of MARKER_PROBES) {
+      if (!LANGS_BY_KIND[probe.kind].some((lang) => langs.has(lang))) continue;
+      const source = await readTextIfPresent(path3.posix.join(dir, probe.file));
+      if (source === void 0) continue;
+      const built = probe.build(dir, source);
+      if (built) roots.push({ dir, kind: probe.kind, ...built });
+    }
+    if (LANGS_BY_KIND.dotnet.some((lang) => langs.has(lang))) {
+      const dotnet = await probeDotnetRoot(dir);
+      if (dotnet) roots.push(dotnet);
+    }
+  });
   roots.sort((a, b) => b.dir.length - a.dir.length || a.dir.localeCompare(b.dir));
   return { projectRoot: root, roots };
 }
@@ -1744,13 +1817,13 @@ function derivePackageFromLayout(filePath) {
 }
 function pythonPackageLabel(structure, file, initDirs) {
   const portable = toPortablePath(file);
-  const dir = path2.posix.dirname(portable);
+  const dir = path3.posix.dirname(portable);
   if (!initDirs.has(dir)) return void 0;
   const segments = [];
   let current = dir;
   while (initDirs.has(current) && current.length > structure.projectRoot.length) {
-    segments.unshift(path2.posix.basename(current));
-    current = path2.posix.dirname(current);
+    segments.unshift(path3.posix.basename(current));
+    current = path3.posix.dirname(current);
   }
   return segments.length > 0 ? `py:${segments.join(".")}` : void 0;
 }
@@ -1758,8 +1831,8 @@ function assignPackageLabels(structure, files) {
   const initDirs = /* @__PURE__ */ new Set();
   for (const file of files) {
     const portable = toPortablePath(file);
-    if (path2.posix.basename(portable) === "__init__.py") {
-      initDirs.add(path2.posix.dirname(portable));
+    if (path3.posix.basename(portable) === "__init__.py") {
+      initDirs.add(path3.posix.dirname(portable));
     }
   }
   const labels = /* @__PURE__ */ new Map();
@@ -1768,12 +1841,12 @@ function assignPackageLabels(structure, files) {
     const lang = detectLang(portable);
     if (lang === "go") {
       const owner2 = findOwningRoot(structure, portable, ["go"]);
-      const dir = path2.posix.dirname(portable);
+      const dir = path3.posix.dirname(portable);
       if (owner2?.importPath) {
-        const relative3 = path2.posix.relative(owner2.dir, dir);
+        const relative3 = path3.posix.relative(owner2.dir, dir);
         labels.set(file, relative3 ? `${owner2.importPath}/${relative3}` : owner2.importPath);
       } else {
-        labels.set(file, `go:${path2.posix.relative(structure.projectRoot, dir) || "."}`);
+        labels.set(file, `go:${path3.posix.relative(structure.projectRoot, dir) || "."}`);
       }
       continue;
     }
@@ -1969,6 +2042,34 @@ function chunkedIdQuery(stmt, ids, buildSql, extraArgs = []) {
   }
   return results;
 }
+function chunkedValueQuery(stmt, values, buildSql) {
+  const results = [];
+  let cursor = 0;
+  for (const take of inListChunks(values.length, MAX_SQL_VARS2)) {
+    const chunk = padToInBucket(values.slice(cursor, cursor + take));
+    cursor += take;
+    results.push(...stmt(buildSql(placeholders(chunk.length))).all(...chunk));
+  }
+  return results;
+}
+function refCountsTouching(stmt, localIds) {
+  const local = new Set(localIds);
+  const outgoing = chunkedIdQuery(
+    stmt,
+    localIds,
+    (ph) => `SELECT from_id, to_id, call_type, COUNT(*) AS n FROM refs
+        WHERE from_id IN (${ph}) AND to_id IS NOT NULL
+        GROUP BY from_id, to_id, call_type`
+  );
+  const incoming = chunkedIdQuery(
+    stmt,
+    localIds,
+    (ph) => `SELECT from_id, to_id, call_type, COUNT(*) AS n FROM refs
+          WHERE to_id IN (${ph})
+          GROUP BY from_id, to_id, call_type`
+  ).filter((row) => !local.has(row.from_id));
+  return [...outgoing, ...incoming];
+}
 function getSymbolsByIdsWithStatement(stmt, ids) {
   if (ids.length === 0) return [];
   return chunkedIdQuery(
@@ -2010,6 +2111,9 @@ function mapCallSiteRow(row) {
     line: row.ref_line
   };
 }
+function compareCallSiteRows(a, b) {
+  return a.ref_line - b.ref_line || (a.sym_file < b.sym_file ? -1 : a.sym_file > b.sym_file ? 1 : 0) || a.sym_line - b.sym_line || a.sym_id - b.sym_id;
+}
 function resolveIndexedFiles(stmt, file) {
   const rows = stmt(
     `SELECT DISTINCT file FROM symbols WHERE ${indexedFileMatchSql("file")} ORDER BY length(file), file`
@@ -2037,21 +2141,22 @@ function resolveSymbolIds(stmt, symbolName, file) {
   }
   return ids;
 }
-function findIncomingCallsByName(stmt, symbolName, file, limit) {
-  const targetIds = resolveSymbolIds(stmt, symbolName, file);
-  if (targetIds.length === 0)
-    return { calls: [], symbolFound: false, ambiguous: false, totalMatches: 0 };
-  let matchIds = targetIds;
-  let ambiguous = false;
-  if (file !== void 0) {
-    const allNamedIds = resolveSymbolIds(stmt, symbolName, void 0);
-    if (allNamedIds.length > targetIds.length) {
-      matchIds = allNamedIds;
-      ambiguous = true;
-    }
-  }
-  const useFallback = !file;
-  const rows = chunkedIdQuery(
+var MAX_DISAMBIGUATION_FILES = 64;
+function directIncomingRows(stmt, matchIds, scopedTargetIds) {
+  const targetFiles = scopedTargetIds === null ? [] : chunkedIdQuery(
+    stmt,
+    scopedTargetIds,
+    (ph) => `SELECT DISTINCT file FROM symbols WHERE id IN (${ph})`
+  ).map((row) => row.file);
+  const refine = targetFiles.length > 0 && targetFiles.length <= MAX_DISAMBIGUATION_FILES;
+  const fph = refine ? targetFiles.map(() => "?").join(",") : "";
+  const evidenceFilter = refine ? `AND (r.to_file IS NULL OR r.to_file IN (${fph}))
+       AND NOT EXISTS (
+         SELECT 1 FROM refs ri JOIN symbols si ON si.id = ri.from_id
+         WHERE si.file = s.file AND ri.call_type = 'import' AND ri.to_name = r.to_name
+           AND ri.to_file IS NOT NULL AND ri.to_file NOT IN (${fph})
+       )` : "";
+  return chunkedIdQuery(
     stmt,
     matchIds,
     (ph) => `SELECT
@@ -2067,9 +2172,26 @@ function findIncomingCallsByName(stmt, symbolName, file, limit) {
        FROM refs r
        JOIN symbols s ON s.id = r.from_id
        WHERE r.to_id IN (${ph})
+       ${evidenceFilter}
        ORDER BY r.line, r.id`,
-    []
+    refine ? [...targetFiles, ...targetFiles] : []
   );
+}
+function findIncomingCallsByName(stmt, symbolName, file, limit) {
+  const targetIds = resolveSymbolIds(stmt, symbolName, file);
+  if (targetIds.length === 0)
+    return { calls: [], symbolFound: false, ambiguous: false, totalMatches: 0 };
+  let matchIds = targetIds;
+  let ambiguous = false;
+  if (file !== void 0) {
+    const allNamedIds = resolveSymbolIds(stmt, symbolName, void 0);
+    if (allNamedIds.length > targetIds.length) {
+      matchIds = allNamedIds;
+      ambiguous = true;
+    }
+  }
+  const useFallback = !file;
+  const rows = directIncomingRows(stmt, matchIds, ambiguous ? targetIds : null);
   if (useFallback) {
     const fallbackRows = stmt(
       `SELECT
@@ -2089,7 +2211,7 @@ function findIncomingCallsByName(stmt, symbolName, file, limit) {
     ).all(symbolName);
     rows.push(...fallbackRows);
   }
-  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  rows.sort(compareCallSiteRows);
   const allCalls = rows.map(mapCallSiteRow);
   return {
     calls: allCalls.slice(0, limit),
@@ -2127,7 +2249,7 @@ function findOutgoingCallsByName(stmt, symbolName, file, limit) {
        ORDER BY r.line, r.id`,
     []
   );
-  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  rows.sort(compareCallSiteRows);
   const calls = rows.map(mapCallSiteRow).slice(0, limit);
   return { calls, symbolFound: true, unresolvedCount, totalMatches: rows.length };
 }
@@ -2149,6 +2271,32 @@ function runCteWithSeeds(stmt, seedIds, buildSql) {
     stmt("DROP TABLE IF EXISTS _cte_seeds").run();
   }
 }
+function annotateDirectEdges(stmt, rows, seedIds, seedColumn, otherColumn) {
+  if (rows.length === 0) return;
+  const edges = chunkedIdQuery(
+    stmt,
+    [...seedIds],
+    (ph) => `SELECT ${otherColumn} AS sym_id, call_type, line
+       FROM refs
+       WHERE ${seedColumn} IN (${ph}) AND ${otherColumn} IS NOT NULL`,
+    []
+  );
+  const best = /* @__PURE__ */ new Map();
+  for (const edge of edges) {
+    const current = best.get(edge.sym_id);
+    const edgeIsImport = edge.call_type === "import";
+    const currentIsImport = current?.call_type === "import";
+    if (!current || currentIsImport && !edgeIsImport || currentIsImport === edgeIsImport && edge.line < current.line) {
+      best.set(edge.sym_id, { call_type: edge.call_type, line: edge.line });
+    }
+  }
+  for (const row of rows) {
+    const edge = best.get(row.sym_id);
+    if (!edge) continue;
+    row.call_type = edge.call_type;
+    row.ref_line = edge.line;
+  }
+}
 function findTransitiveIncomingCallsByName(stmt, symbolName, file, limit) {
   const targetIds = resolveSymbolIds(stmt, symbolName, file);
   if (targetIds.length === 0)
@@ -2162,10 +2310,11 @@ function findTransitiveIncomingCallsByName(stmt, symbolName, file, limit) {
       ambiguous = true;
     }
   }
+  const anchorCallerIds = ambiguous ? [...new Set(directIncomingRows(stmt, matchIds, targetIds).map((row) => row.sym_id))] : null;
   const cteSql = (seedSource) => `WITH RECURSIVE incoming_tree(from_id) AS (
-       SELECT r.from_id
+       ${anchorCallerIds === null ? `SELECT r.from_id
        FROM refs r
-       WHERE r.to_id IN (${seedSource})
+       WHERE r.to_id IN (${seedSource})` : `SELECT s0.id FROM symbols s0 WHERE s0.id IN (${seedSource})`}
 
        UNION
 
@@ -2187,7 +2336,8 @@ function findTransitiveIncomingCallsByName(stmt, symbolName, file, limit) {
      JOIN symbols s ON s.id = it.from_id
      GROUP BY s.id
      ORDER BY s.file, s.line`;
-  const rows = runCteWithSeeds(stmt, matchIds, cteSql);
+  const rows = anchorCallerIds !== null && anchorCallerIds.length === 0 ? [] : runCteWithSeeds(stmt, anchorCallerIds ?? matchIds, cteSql);
+  annotateDirectEdges(stmt, rows, matchIds, "to_id", "from_id");
   if (!file) {
     const fallbackRows = stmt(
       `SELECT
@@ -2207,7 +2357,7 @@ function findTransitiveIncomingCallsByName(stmt, symbolName, file, limit) {
     ).all(symbolName);
     rows.push(...fallbackRows);
   }
-  rows.sort((a, b) => a.ref_line - b.ref_line || a.sym_id - b.sym_id);
+  rows.sort(compareCallSiteRows);
   const allCalls = rows.map(mapCallSiteRow);
   return {
     calls: allCalls.slice(0, limit),
@@ -2252,6 +2402,7 @@ function findTransitiveOutgoingCallsByName(stmt, symbolName, file, limit) {
      GROUP BY s.id
      ORDER BY s.file, s.line`;
   const rows = runCteWithSeeds(stmt, sourceIds, cteSql);
+  annotateDirectEdges(stmt, rows, sourceIds, "from_id", "to_id");
   const calls = rows.map(mapCallSiteRow).slice(0, limit);
   return { calls, symbolFound: true, unresolvedCount, totalMatches: rows.length };
 }
@@ -2361,33 +2512,29 @@ function getFileGraphWithStatement(stmt, packageFilter) {
   const pkgFilePaths = allFiles.filter((f) => matchesIndexedPackageFilter(f.file, packageOf(f.file), packageFilter)).map((f) => f.file);
   const localFiles = new Set(pkgFilePaths);
   if (localFiles.size === 0) return { nodes: [], edges: [] };
-  const filePlaceholders = [...localFiles].map(() => "?").join(",");
-  const pkgSyms = stmt(
-    `SELECT file, id, name, kind, lang, line FROM symbols WHERE file IN (${filePlaceholders}) ORDER BY id`
-  ).all(...pkgFilePaths);
+  const pkgSyms = chunkedValueQuery(
+    stmt,
+    [...localFiles],
+    (ph) => `SELECT file, id, name, kind, lang, line FROM symbols WHERE file IN (${ph})`
+  ).sort((a, b) => a.id - b.id);
   const { fileNodes, symToFile, fileStats, ensureFileNode } = buildFileGraphNodeState(
     pkgSyms,
     localFiles,
     packageOf
   );
-  const refRows = stmt(
-    `SELECT r.from_id, r.to_id, r.call_type, COUNT(*) AS n
-       FROM refs r
-       WHERE (r.from_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders}))
-           OR r.to_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders})))
-         AND r.to_id IS NOT NULL
-       GROUP BY r.from_id, r.to_id, r.call_type`
-  ).all(...pkgFilePaths, ...pkgFilePaths);
-  const knownSymIds = new Set(pkgSyms.map((s) => s.id));
+  const localIds = pkgSyms.map((s) => s.id);
+  const refRows = refCountsTouching(stmt, localIds);
+  const knownSymIds = new Set(localIds);
   const crossRefIds = /* @__PURE__ */ new Set();
   for (const r of refRows) {
     if (!knownSymIds.has(r.from_id)) crossRefIds.add(r.from_id);
     if (!knownSymIds.has(r.to_id)) crossRefIds.add(r.to_id);
   }
   if (crossRefIds.size > 0) {
-    const crossPlaceholders = [...crossRefIds].map(() => "?").join(",");
-    const extras = stmt(`SELECT id, file FROM symbols WHERE id IN (${crossPlaceholders})`).all(
-      ...crossRefIds
+    const extras = chunkedIdQuery(
+      stmt,
+      [...crossRefIds],
+      (ph) => `SELECT id, file FROM symbols WHERE id IN (${ph})`
     );
     for (const x of extras) {
       symToFile.set(x.id, x.file);
@@ -2408,15 +2555,17 @@ function getFileGraphWithStatement(stmt, packageFilter) {
     const n = Number(r.n) || 0;
     addWeightedEdge(edgeMap, fromFile, toFile, r.call_type, n);
   }
-  const importRows = stmt(
-    `SELECT r.from_id, COALESCE(r.to_file, st.file) AS to_file, COUNT(*) AS n
-       FROM refs r
-       LEFT JOIN symbols st ON st.id = r.to_id
-       WHERE r.call_type = 'import'
-         AND COALESCE(r.to_file, st.file) IS NOT NULL
-         AND r.from_id IN (SELECT id FROM symbols WHERE file IN (${filePlaceholders}))
-       GROUP BY r.from_id, COALESCE(r.to_file, st.file)`
-  ).all(...pkgFilePaths);
+  const importRows = chunkedIdQuery(
+    stmt,
+    localIds,
+    (ph) => `SELECT r.from_id, COALESCE(r.to_file, st.file) AS to_file, COUNT(*) AS n
+         FROM refs r
+         LEFT JOIN symbols st ON st.id = r.to_id
+         WHERE r.call_type = 'import'
+           AND COALESCE(r.to_file, st.file) IS NOT NULL
+           AND r.from_id IN (${ph})
+         GROUP BY r.from_id, COALESCE(r.to_file, st.file)`
+  );
   for (const r of importRows) {
     const fromFile = symToFile.get(r.from_id);
     if (!fromFile || !localFiles.has(fromFile)) continue;
@@ -2438,29 +2587,18 @@ function getFileGraphWithStatement(stmt, packageFilter) {
 function getSymbolGraphWithStatement(stmt, fileFilter) {
   const indexedFiles = resolveIndexedFiles(stmt, fileFilter);
   if (indexedFiles.length === 0) return { nodes: [], edges: [] };
-  const filePlaceholders = indexedFiles.map(() => "?").join(",");
-  const syms = stmt(
-    `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE file IN (${filePlaceholders}) ORDER BY line, id`
-  ).all(...indexedFiles);
+  const syms = chunkedValueQuery(
+    stmt,
+    indexedFiles,
+    (ph) => `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE file IN (${ph})`
+  ).sort((a, b) => a.line - b.line || a.id - b.id);
   if (syms.length === 0) return { nodes: [], edges: [] };
   const symById = new Map(syms.map((symbol) => [symbol.id, symbol]));
   const relatedIds = new Set(syms.map((symbol) => symbol.id));
-  const refRows = stmt(
-    `SELECT from_id, to_id, call_type, COUNT(*) AS n
-         FROM (
-           SELECT r.from_id, r.to_id, r.call_type
-             FROM refs r
-             JOIN symbols s ON s.id = r.from_id
-            WHERE s.file IN (${filePlaceholders})
-            UNION ALL
-           SELECT r.from_id, r.to_id, r.call_type
-             FROM refs r
-             JOIN symbols s ON s.id = r.to_id
-            WHERE s.file IN (${filePlaceholders})
-         )
-         WHERE to_id IS NOT NULL
-         GROUP BY from_id, to_id, call_type`
-  ).all(...indexedFiles, ...indexedFiles);
+  const refRows = refCountsTouching(
+    stmt,
+    syms.map((symbol) => symbol.id)
+  );
   const edgeMap = /* @__PURE__ */ new Map();
   for (const r of refRows) {
     if (r.to_id == null) continue;
@@ -2473,11 +2611,7 @@ function getSymbolGraphWithStatement(stmt, fileFilter) {
   const loadedIds = new Set(syms.map((s) => s.id));
   const missingIds = [...relatedIds].filter((id) => !loadedIds.has(id));
   if (missingIds.length > 0) {
-    const placeholders2 = missingIds.map(() => "?").join(",");
-    const extras = stmt(
-      `SELECT id, name, kind, lang, file, line, signature, scope FROM symbols WHERE id IN (${placeholders2})`
-    ).all(...missingIds);
-    for (const s of extras) symById.set(s.id, s);
+    for (const s of getSymbolsByIdsWithStatement(stmt, missingIds)) symById.set(s.id, s);
   }
   const packageOf = readPackageLabeller(stmt);
   const nodes = buildSymbolGraphNodes(
@@ -2799,7 +2933,7 @@ function allocateSymbolIds(stmt, count, getMaxSymbolId) {
   if (count <= 0) return getMaxSymbolId() + 1;
   ensureNextSymbolIdSeeded(stmt);
   const row = stmt("SELECT value FROM metadata WHERE key = ?").get(NEXT_SYMBOL_ID_KEY);
-  const start = Math.max(1, Number(row?.value ?? 1) || 1);
+  const start = Math.max(1, Number(row?.value ?? 1) || 1, getMaxSymbolId() + 1);
   stmt("INSERT OR REPLACE INTO metadata(key, value) VALUES (?, ?)").run(
     NEXT_SYMBOL_ID_KEY,
     String(start + count)
@@ -2880,6 +3014,9 @@ function compactIfNeeded(db, stmt, runWithRetry, options = {}) {
 }
 
 // src/codebase-index/writer-mutations.ts
+function rankKey(file, name, kind, scope) {
+  return `${file}\0${name}\0${kind}\0${scope}`;
+}
 function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvailable, allocateSymbolIds2, invalidateIncomingRefsForFiles, resolveRefsForNamesUnsafe2, entries, options = {}) {
   if (entries.length === 0 && (options.deleteForFiles?.length ?? 0) === 0) {
     return [];
@@ -2889,6 +3026,7 @@ function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvail
     for (const symbol of entry.symbols) affectedNames.add(symbol.name);
     for (const ref of entry.refs) affectedNames.add(ref.toName);
   }
+  const carriedRanks = /* @__PURE__ */ new Map();
   if (options.deleteForFiles && options.deleteForFiles.length > 0) {
     for (const name of invalidateIncomingRefsForFiles(options.deleteForFiles)) {
       affectedNames.add(name);
@@ -2898,6 +3036,21 @@ function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvail
       const bucket = padToInBucket(options.deleteForFiles.slice(cursor, cursor + take));
       cursor += take;
       const ph = placeholders(bucket.length);
+      const rankRows = stmtFn(
+        `SELECT s.file AS file, s.name AS name, s.kind AS kind, s.scope AS scope,
+                r.rank AS rank, r.in_deg AS inDeg, r.out_deg AS outDeg
+           FROM symbol_rank r JOIN symbols s ON s.id = r.symbol_id
+          WHERE s.file IN (${ph})`
+      ).all(...bucket);
+      for (const row of rankRows) {
+        const key = rankKey(row.file, row.name, row.kind, row.scope);
+        if (!carriedRanks.has(key)) {
+          carriedRanks.set(key, { rank: row.rank, inDeg: row.inDeg, outDeg: row.outDeg });
+        }
+      }
+      stmtFn(
+        `DELETE FROM symbol_rank WHERE symbol_id IN (SELECT id FROM symbols WHERE file IN (${ph}))`
+      ).run(...bucket);
       if (ftsAvailable) {
         stmtFn(
           `DELETE FROM symbols_fts WHERE rowid IN (SELECT id FROM symbols WHERE file IN (${ph}))`
@@ -2961,6 +3114,24 @@ function commitBatchWithStatement(stmtFn, maxSqlVars, ftsAvailable, vectorsAvail
     bulkInsertVectorsWithStatement((sql) => stmtFn(sql), maxSqlVars, vectorRows);
   }
   bulkInsertRefsWithStatement((sql) => stmtFn(sql), maxSqlVars, refsToInsert);
+  if (carriedRanks.size > 0) {
+    const rankRows = [];
+    for (const symbol of allInserted) {
+      const carried = carriedRanks.get(
+        rankKey(symbol.file, symbol.name, symbol.kind, symbol.scope)
+      );
+      if (carried) rankRows.push([symbol.id, carried.rank, carried.inDeg, carried.outDeg]);
+    }
+    let cursor = 0;
+    for (const take of ladderChunkSizes(rankRows.length, Math.max(1, Math.floor(maxSqlVars / 4)))) {
+      const chunk = rankRows.slice(cursor, cursor + take);
+      cursor += take;
+      stmtFn(
+        `INSERT OR REPLACE INTO symbol_rank(symbol_id, rank, in_deg, out_deg)
+         VALUES ${chunk.map(() => "(?, ?, ?, ?)").join(", ")}`
+      ).run(...chunk.flat());
+    }
+  }
   const upsertStmt = stmtFn(
     `INSERT INTO files(file, lang, mtime_ms, content_hash, symbol_count, last_indexed)
      VALUES (?, ?, ?, ?, ?, ?)
@@ -3289,6 +3460,16 @@ function resolveRefsWithStatement(stmtFn) {
     return result.changes ?? 0;
   }
 }
+function getFilesWithDanglingImportsWithStatement(stmtFn) {
+  return stmtFn(
+    `SELECT DISTINCT s.file AS file
+         FROM refs r
+         JOIN symbols s ON s.id = r.from_id
+        WHERE r.call_type = 'import'
+          AND r.to_file IS NOT NULL
+          AND NOT EXISTS (SELECT 1 FROM files f WHERE f.file = r.to_file)`
+  ).all().map((row) => row.file);
+}
 function applyImportResolutionsWithStatement(db, stmtFn, runWithRetry, maxSqlVars, resolutions) {
   if (resolutions.length === 0) return 0;
   return runWithRetry(() => {
@@ -3298,7 +3479,7 @@ function applyImportResolutionsWithStatement(db, stmtFn, runWithRetry, maxSqlVar
          from_file TEXT NOT NULL,
          lang TEXT NOT NULL,
          module TEXT NOT NULL,
-         to_file TEXT NOT NULL
+         to_file TEXT
        )`
     );
     const chunkSize = Math.max(1, Math.floor(maxSqlVars / 4));
@@ -3404,21 +3585,23 @@ var SEARCH_CANDIDATE_SCAN_CAP = 5e3;
 function normalizeSearchLimit(limit) {
   return typeof limit === "number" && Number.isFinite(limit) ? Math.max(0, Math.trunc(limit)) : void 0;
 }
+function resolveKindFilter(filter) {
+  const lspKinds = filter?.lspKind != null ? lspKindToInternalKinds(filter.lspKind) : void 0;
+  if (lspKinds !== void 0 && lspKinds.length === 0) return null;
+  if (filter?.kind) {
+    if (lspKinds !== void 0 && !lspKinds.includes(filter.kind)) return null;
+    return [filter.kind];
+  }
+  return lspKinds;
+}
 function buildWriterSearchWhere(query, filter) {
   const conditions = [];
   const values = [];
-  let effectiveKind = filter?.kind;
-  if (filter?.lspKind != null) {
-    const mapped = lspKindToInternalKind(filter.lspKind);
-    if (mapped !== null) {
-      effectiveKind = mapped;
-    } else {
-      return null;
-    }
-  }
-  if (effectiveKind) {
-    conditions.push("kind = ?");
-    values.push(effectiveKind);
+  const kinds = resolveKindFilter(filter);
+  if (kinds === null) return null;
+  if (kinds !== void 0) {
+    conditions.push(`kind IN (${kinds.map(() => "?").join(", ")})`);
+    values.push(...kinds);
   }
   if (filter?.lang) {
     conditions.push("lang = ?");
@@ -3493,12 +3676,8 @@ function searchRankedWithStatement(stmtFn, searchFn, ftsAvailable, vectorsAvaila
       safeLimit
     );
   }
-  let effectiveKind = filter?.kind;
-  if (filter?.lspKind != null) {
-    const mapped = lspKindToInternalKind(filter.lspKind);
-    if (mapped === null) return { results: [], total: 0 };
-    effectiveKind = mapped;
-  }
+  const kinds = resolveKindFilter(filter);
+  if (kinds === null) return { results: [], total: 0 };
   const longTokens = tokens.filter((t) => t.length >= 3);
   const shortTokens = tokens.filter((t) => t.length < 3);
   if (longTokens.length === 0) {
@@ -3521,9 +3700,9 @@ function searchRankedWithStatement(stmtFn, searchFn, ftsAvailable, vectorsAvaila
     );
     values.push(like, like, like);
   }
-  if (effectiveKind) {
-    conditions.push("s.kind = ?");
-    values.push(effectiveKind);
+  if (kinds !== void 0) {
+    conditions.push(`s.kind IN (${kinds.map(() => "?").join(", ")})`);
+    values.push(...kinds);
   }
   if (filter?.lang) {
     conditions.push("s.lang = ?");
@@ -3560,10 +3739,17 @@ function searchRankedWithStatement(stmtFn, searchFn, ftsAvailable, vectorsAvaila
     const vecRows = stmtFn(
       `SELECT sv.symbol_id, sv.vector FROM symbol_vectors sv WHERE sv.symbol_id IN (${placeholders2})`
     ).all(...candidateIds);
-    const vecScores = vecRows.map((r) => ({
-      id: r.symbol_id,
-      sim: cosineSimilarity(queryVec, decodeVector(r.vector))
-    })).sort((a, b) => b.sim - a.sim);
+    const vecScores = [];
+    for (const r of vecRows) {
+      try {
+        vecScores.push({
+          id: r.symbol_id,
+          sim: cosineSimilarity(queryVec, decodeVector(r.vector))
+        });
+      } catch {
+      }
+    }
+    vecScores.sort((a, b) => b.sim - a.sim);
     const bm25Rank = /* @__PURE__ */ new Map();
     bm25Rows.forEach((r, i) => {
       bm25Rank.set(r.id, i);
@@ -3667,7 +3853,7 @@ var StorePool = class {
   release(store) {
     const k = this.keyByStore.get(store);
     const entry = k === void 0 ? void 0 : this.stores.get(k);
-    if (entry && entry.refs > 0) entry.refs--;
+    if (entry && entry.store === store && entry.refs > 0) entry.refs--;
     this.trim();
   }
   trim() {
@@ -3729,6 +3915,8 @@ var IndexStore = class _IndexStore {
   stmtCache = /* @__PURE__ */ new Map();
   bm25Cache = null;
   bm25Dirty = true;
+  /** `PRAGMA data_version` the BM25 cache was built at. */
+  bm25DataVersion = -1;
   stmt(sql) {
     const cached2 = this.stmtCache.get(sql);
     if (cached2 !== void 0) {
@@ -3748,7 +3936,7 @@ var IndexStore = class _IndexStore {
     this.indexDir = resolveIndexDir(projectRoot, opts.indexDir);
     fs3.mkdirSync(this.indexDir, { recursive: true });
     const Database = loadDatabaseSync();
-    this.db = new Database(path3.join(this.indexDir, DB_FILE2));
+    this.db = new Database(path4.join(this.indexDir, DB_FILE2));
     applyIndexStorePragmas(this.db);
     this.initSchema();
   }
@@ -3768,6 +3956,7 @@ var IndexStore = class _IndexStore {
         this.db.exec("ROLLBACK");
       } catch {
       }
+      this.invalidateBm25();
       throw error;
     } finally {
       this.atomicIndexUpdateActive = false;
@@ -3786,12 +3975,22 @@ var IndexStore = class _IndexStore {
     if (savepoint) this.db.exec(`RELEASE SAVEPOINT ${savepoint}`);
     else this.db.exec("COMMIT");
   }
+  /**
+   * Never throws: every caller is already propagating the failure that caused
+   * the rollback. When SQLite has rolled the transaction back itself (disk
+   * full, I/O error) the ROLLBACK fails with "no transaction is active", and
+   * that message used to replace the real error.
+   */
   rollbackWriteTransaction(savepoint) {
-    if (savepoint) {
-      this.db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
-      this.db.exec(`RELEASE SAVEPOINT ${savepoint}`);
-    } else {
-      this.db.exec("ROLLBACK");
+    this.invalidateBm25();
+    try {
+      if (savepoint) {
+        this.db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        this.db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+      } else {
+        this.db.exec("ROLLBACK");
+      }
+    } catch {
     }
   }
   initSchema() {
@@ -3876,6 +4075,9 @@ var IndexStore = class _IndexStore {
             "DELETE FROM symbol_vectors WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
           ).run(file);
         }
+        this.stmt(
+          "DELETE FROM symbol_rank WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
+        ).run(file);
         const deletedChanges = Number(
           this.stmt("DELETE FROM symbols WHERE file = ?").run(file).changes
         );
@@ -3907,6 +4109,10 @@ var IndexStore = class _IndexStore {
         this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(
           file
         );
+        this.stmt(
+          "DELETE FROM symbol_rank WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
+        ).run(file);
+        this.stmt("DELETE FROM file_rank WHERE file = ?").run(file);
         const deletedChanges = Number(
           this.stmt("DELETE FROM symbols WHERE file = ?").run(file).changes
         );
@@ -3945,6 +4151,9 @@ var IndexStore = class _IndexStore {
       onlyFiles
     );
   }
+  getFilesWithDanglingImports() {
+    return getFilesWithDanglingImportsWithStatement((sql) => this.stmt(sql));
+  }
   applyImportResolutions(resolutions) {
     return applyImportResolutionsWithStatement(
       this.db,
@@ -3976,13 +4185,33 @@ var IndexStore = class _IndexStore {
     this.bm25Dirty = true;
     this.bm25Cache = null;
   }
+  /**
+   * The corpus is rebuilt when this connection wrote (bm25Dirty) OR another
+   * connection committed since it was built. Pooled stores stay open for the
+   * life of the host while the project daemon, an inline indexer or another
+   * process writes the same database; the dirty flag alone never saw those
+   * writes, so short-query results silently dropped every symbol added since.
+   */
   getOrBuildBm25() {
-    if (this.bm25Cache && !this.bm25Dirty) return this.bm25Cache;
+    const version = this.dataVersion();
+    if (this.bm25Cache && !this.bm25Dirty && version === this.bm25DataVersion) {
+      return this.bm25Cache;
+    }
     const docs = this.getAllIndexable();
     this.bm25Cache = buildBm25Index(docs);
     this.bm25Dirty = false;
+    this.bm25DataVersion = version;
     return this.bm25Cache;
   }
+  /** Changes whenever ANOTHER connection commits to this database. */
+  dataVersion() {
+    try {
+      const row = this.stmt("PRAGMA data_version").get();
+      return Number(row?.data_version ?? -1);
+    } catch {
+      return -1;
+    }
+  }
   getAllIndexable() {
     return getAllIndexableWithStatement((sql) => this.stmt(sql));
   }
@@ -4128,6 +4357,9 @@ var IndexStore = class _IndexStore {
         this.stmt("DELETE FROM refs WHERE from_id IN (SELECT id FROM symbols WHERE file = ?)").run(
           meta.file
         );
+        this.stmt(
+          "DELETE FROM symbol_rank WHERE symbol_id IN (SELECT id FROM symbols WHERE file = ?)"
+        ).run(meta.file);
         const deletedChanges = Number(
           this.stmt("DELETE FROM symbols WHERE file = ?").run(meta.file).changes
         );
@@ -4252,7 +4484,9 @@ var IndexStore = class _IndexStore {
     return getSymbolGraphWithStatement((sql) => this.stmt(sql), fileFilter);
   }
   getAllSymbols() {
-    return this.stmt("SELECT id, name, file, kind, line FROM symbols ORDER BY id").all().map((r) => ({ ...r, kind: r.kind }));
+    return this.stmt(
+      "SELECT id, name, file, kind, line, scope FROM symbols ORDER BY id"
+    ).all().map((r) => ({ ...r, kind: r.kind }));
   }
   /** Declarations in one file, in source order. */
   getFileSymbols(file, limit) {
@@ -4422,7 +4656,7 @@ import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 import * as fs5 from "node:fs/promises";
 import { availableParallelism } from "node:os";
-import * as path5 from "node:path";
+import * as path6 from "node:path";
 import {
   DEFAULT_WALK_IGNORE_DIRS,
   indexParallelBatchSize,
@@ -4507,7 +4741,7 @@ function xxhash64String(content) {
 }
 
 // src/codebase-index/module-resolver.ts
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 var EXTENSIONS = {
   js: [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs", ".vue", ".svelte"],
   py: [".py", ".pyi"],
@@ -4526,6 +4760,13 @@ var DIRECTORY_ENTRIES = {
 function normalizeNamespace(value) {
   return value.replace(/::|[\\/]/g, ".").replace(/^\.+|\.+$/g, "").toLowerCase();
 }
+function rustModuleDir(file) {
+  const base = path5.posix.basename(file);
+  if (base === "mod.rs" || base === "lib.rs" || base === "main.rs") {
+    return path5.posix.dirname(file);
+  }
+  return file.replace(/\.rs$/i, "");
+}
 var ModuleResolver = class {
   structure;
   /** Lowercased portable path → the path as indexed (case is preserved). */
@@ -4540,14 +4781,23 @@ var ModuleResolver = class {
     this.byDir = /* @__PURE__ */ new Map();
     this.byNamespace = /* @__PURE__ */ new Map();
     const dirsByKey = /* @__PURE__ */ new Map();
+    const collidedPaths = /* @__PURE__ */ new Set();
+    const collidedDirs = /* @__PURE__ */ new Set();
     for (const file of files) {
       const portable = toPortablePath(file);
       const pathKey = portable.toLowerCase();
-      const priorPath = this.byPath.get(pathKey);
-      if (priorPath !== void 0 && priorPath !== file) this.byPath.delete(pathKey);
-      else this.byPath.set(pathKey, file);
-      const dir = path4.posix.dirname(portable);
+      if (!collidedPaths.has(pathKey)) {
+        const priorPath = this.byPath.get(pathKey);
+        if (priorPath !== void 0 && priorPath !== file) {
+          this.byPath.delete(pathKey);
+          collidedPaths.add(pathKey);
+        } else {
+          this.byPath.set(pathKey, file);
+        }
+      }
+      const dir = path5.posix.dirname(portable);
       const dirKey = dir.toLowerCase();
+      if (collidedDirs.has(dirKey)) continue;
       const knownDir = dirsByKey.get(dirKey);
       if (knownDir === void 0) {
         dirsByKey.set(dirKey, dir);
@@ -4557,6 +4807,7 @@ var ModuleResolver = class {
       } else {
         dirsByKey.delete(dirKey);
         this.byDir.delete(dirKey);
+        collidedDirs.add(dirKey);
       }
     }
     for (const { name, file } of namespaces) {
@@ -4621,7 +4872,7 @@ var ModuleResolver = class {
   }
   // ─── Lookup primitives ──────────────────────────────────────────────────────
   lookup(candidate) {
-    return this.byPath.get(path4.posix.normalize(candidate).toLowerCase());
+    return this.byPath.get(path5.posix.normalize(candidate).toLowerCase());
   }
   /**
    * Try `base` verbatim, then `base` + each extension, then each directory
@@ -4631,7 +4882,7 @@ var ModuleResolver = class {
     const direct = this.lookup(base);
     if (direct) return direct;
     const extensions = EXTENSIONS[family] ?? [];
-    const suffix = path4.posix.extname(base);
+    const suffix = path5.posix.extname(base);
     const stem = suffix && extensions.includes(suffix) ? base.slice(0, -suffix.length) : base;
     for (const ext of extensions) {
       const hit = this.lookup(`${stem}${ext}`);
@@ -4639,7 +4890,7 @@ var ModuleResolver = class {
     }
     for (const entry of DIRECTORY_ENTRIES[family] ?? []) {
       for (const ext of extensions) {
-        const hit = this.lookup(path4.posix.join(base, `${entry}${ext}`));
+        const hit = this.lookup(path5.posix.join(base, `${entry}${ext}`));
         if (hit) return hit;
       }
     }
@@ -4656,14 +4907,14 @@ var ModuleResolver = class {
    * member represents it.
    */
   representativeIn(dir, family) {
-    const members = this.byDir.get(path4.posix.normalize(dir).toLowerCase());
+    const members = this.byDir.get(path5.posix.normalize(dir).toLowerCase());
     if (!members?.length) return void 0;
     const extensions = EXTENSIONS[family] ?? [];
-    const eligible = members.filter((file) => extensions.includes(path4.posix.extname(toPortablePath(file)).toLowerCase())).sort((a, b) => toPortablePath(a).localeCompare(toPortablePath(b)));
+    const eligible = members.filter((file) => extensions.includes(path5.posix.extname(toPortablePath(file)).toLowerCase())).sort((a, b) => toPortablePath(a).localeCompare(toPortablePath(b)));
     if (eligible.length === 0) return void 0;
-    const base = path4.posix.basename(path4.posix.normalize(dir)).toLowerCase();
+    const base = path5.posix.basename(path5.posix.normalize(dir)).toLowerCase();
     const named = eligible.find(
-      (file) => path4.posix.basename(toPortablePath(file)).split(".")[0]?.toLowerCase() === base
+      (file) => path5.posix.basename(toPortablePath(file)).split(".")[0]?.toLowerCase() === base
     );
     return named ?? eligible[0];
   }
@@ -4671,7 +4922,7 @@ var ModuleResolver = class {
   /** Relative specifiers, then workspace package names and their subpaths. */
   resolveJs(fromFile, spec) {
     if (spec.startsWith(".")) {
-      const absolute = path4.posix.join(path4.posix.dirname(fromFile), spec);
+      const absolute = path5.posix.join(path5.posix.dirname(fromFile), spec);
       return this.lookupWithExtensions(absolute, "js");
     }
     const owner = this.structure.roots.find(
@@ -4680,9 +4931,9 @@ var ModuleResolver = class {
     if (!owner?.importPath) return void 0;
     const subpath = spec.slice(owner.importPath.length).replace(/^\//, "");
     if (!subpath) {
-      return this.lookupWithExtensions(path4.posix.join(owner.dir, "src/index"), "js") ?? this.lookupWithExtensions(path4.posix.join(owner.dir, "index"), "js");
+      return this.lookupWithExtensions(path5.posix.join(owner.dir, "src/index"), "js") ?? this.lookupWithExtensions(path5.posix.join(owner.dir, "index"), "js");
     }
-    return this.lookupWithExtensions(path4.posix.join(owner.dir, subpath), "js") ?? this.lookupWithExtensions(path4.posix.join(owner.dir, "src", subpath), "js");
+    return this.lookupWithExtensions(path5.posix.join(owner.dir, subpath), "js") ?? this.lookupWithExtensions(path5.posix.join(owner.dir, "src", subpath), "js");
   }
   /** Go import paths are absolute module paths; a package is a directory. */
   resolveGo(spec) {
@@ -4691,7 +4942,7 @@ var ModuleResolver = class {
     );
     if (!owner?.importPath) return void 0;
     const subpath = spec.slice(owner.importPath.length).replace(/^\//, "");
-    return this.representativeIn(path4.posix.join(owner.dir, subpath), "go");
+    return this.representativeIn(path5.posix.join(owner.dir, subpath), "go");
   }
   /**
    * `import a.b.c` / `from a.b import c`, plus PEP 328 relative imports whose
@@ -4700,20 +4951,20 @@ var ModuleResolver = class {
   resolvePython(fromFile, spec) {
     const leadingDots = /^\.*/.exec(spec)?.[0].length ?? 0;
     if (leadingDots > 0) {
-      let base = path4.posix.dirname(fromFile);
-      for (let i = 1; i < leadingDots; i++) base = path4.posix.dirname(base);
+      let base = path5.posix.dirname(fromFile);
+      for (let i = 1; i < leadingDots; i++) base = path5.posix.dirname(base);
       const rest = spec.slice(leadingDots).split(".").filter(Boolean);
-      return this.lookupWithExtensions(path4.posix.join(base, ...rest), "py");
+      return this.lookupWithExtensions(path5.posix.join(base, ...rest), "py");
     }
     const segments = spec.split(".").filter(Boolean);
     if (segments.length === 0) return void 0;
     const sourceRoots = this.structure.roots.filter((root) => root.kind === "python").flatMap((root) => root.sourceRoots);
     for (const base of [...sourceRoots, this.structure.projectRoot]) {
-      const hit = this.lookupWithExtensions(path4.posix.join(base, ...segments), "py");
+      const hit = this.lookupWithExtensions(path5.posix.join(base, ...segments), "py");
       if (hit) return hit;
       if (segments.length > 1) {
         const parent = this.lookupWithExtensions(
-          path4.posix.join(base, ...segments.slice(0, -1)),
+          path5.posix.join(base, ...segments.slice(0, -1)),
           "py"
         );
         if (parent) return parent;
@@ -4721,39 +4972,64 @@ var ModuleResolver = class {
     }
     return void 0;
   }
-  /** `use crate::a::b`, `use super::x`, `use self::y`, `use other_crate::z`. */
+  /**
+   * `use crate::a::b`, `use super::x`, `use self::y`, `use other_crate::z`,
+   * and `mod x;` declarations.
+   *
+   * Paths are resolved from the declaring file's MODULE directory, which is
+   * only its filesystem directory for `mod.rs`/`lib.rs`/`main.rs`. A plain
+   * `src/net.rs` owns `src/net/`: its `mod http;` is `src/net/http.rs`, its
+   * `super` is the crate root. Using the file's directory put every
+   * `self::`/`super::`/`mod` path from such a file one level too high, so
+   * those edges silently resolved to nothing (or to an unrelated file).
+   */
   resolveRust(fromFile, spec) {
     const segments = spec.split("::").filter(Boolean);
     if (segments.length === 0) return void 0;
     const head = segments[0];
     if (head === "self" || head === "super") {
-      let base = path4.posix.dirname(fromFile);
+      let base = rustModuleDir(fromFile);
+      let consumed = 0;
       for (const segment of segments) {
-        if (segment === "super") base = path4.posix.dirname(base);
+        if (segment === "super") base = path5.posix.dirname(base);
         else if (segment !== "self") break;
+        consumed++;
       }
-      const rest2 = segments.filter((segment) => segment !== "self" && segment !== "super");
-      return this.lookupWithExtensions(path4.posix.join(base, ...rest2), "rs");
+      return this.lookupRustPath(base, segments.slice(consumed)) ?? this.lookupRustModuleFile(base);
     }
-    const owningCrate = findOwningRoot(this.structure, fromFile, ["cargo"]);
-    const crate = head === "crate" ? owningCrate : this.structure.roots.find(
+    const crate = head === "crate" ? findOwningRoot(this.structure, fromFile, ["cargo"]) : this.structure.roots.find(
       (root) => root.kind === "cargo" && root.importPath === head?.replace(/-/g, "_")
     );
     if (!crate) {
-      return this.lookupWithExtensions(
-        path4.posix.join(path4.posix.dirname(fromFile), ...segments),
-        "rs"
-      );
+      return this.lookupRustPath(rustModuleDir(fromFile), segments);
     }
     const rest = segments.slice(1);
     for (const base of crate.sourceRoots) {
-      const parent = rest.length > 1 ? this.lookupWithExtensions(path4.posix.join(base, ...rest.slice(0, -1)), "rs") : void 0;
-      const exact = this.lookupWithExtensions(path4.posix.join(base, ...rest), "rs");
-      const hit = exact ?? parent ?? this.lookupWithExtensions(path4.posix.join(base, "lib"), "rs");
+      const hit = this.lookupRustPath(base, rest) ?? this.lookupRustCrateRoot(base);
+      if (hit) return hit;
+    }
+    return void 0;
+  }
+  /**
+   * Longest module prefix of `segments` under `base` that is an indexed file.
+   * The trailing segments of a `use` are usually items (`net::http::Client::new`),
+   * so each is dropped in turn until a module file matches.
+   */
+  lookupRustPath(base, segments) {
+    for (let end = segments.length; end > 0; end--) {
+      const hit = this.lookupWithExtensions(path5.posix.join(base, ...segments.slice(0, end)), "rs");
       if (hit) return hit;
     }
     return void 0;
   }
+  /** The file defining the module whose children live in `dir`. */
+  lookupRustModuleFile(dir) {
+    return this.lookupWithExtensions(dir, "rs") ?? this.lookupRustCrateRoot(dir);
+  }
+  /** A crate's root file: the library root, else the binary root. */
+  lookupRustCrateRoot(sourceRoot) {
+    return this.lookup(path5.posix.join(sourceRoot, "lib.rs")) ?? this.lookup(path5.posix.join(sourceRoot, "main.rs"));
+  }
   /** `com.example.Thing` and `com.example.*` against JVM source roots. */
   resolveJvm(spec) {
     const segments = spec.split(".").filter(Boolean);
@@ -4762,24 +5038,31 @@ var ModuleResolver = class {
     const wildcard = segments[segments.length - 1] === "*";
     const parts = wildcard ? segments.slice(0, -1) : segments;
     for (const base of [...sourceRoots, this.structure.projectRoot]) {
-      const target = path4.posix.join(base, ...parts);
-      const hit = wildcard ? this.representativeIn(target, "jvm") : this.lookupWithExtensions(target, "jvm");
-      if (hit) return hit;
+      const target = path5.posix.join(base, ...parts);
+      if (wildcard) {
+        const hit = this.representativeIn(target, "jvm") ?? this.lookupWithExtensions(target, "jvm");
+        if (hit) return hit;
+        continue;
+      }
+      for (let end = parts.length; end >= Math.max(2, parts.length - 2); end--) {
+        const hit = this.lookupWithExtensions(path5.posix.join(base, ...parts.slice(0, end)), "jvm");
+        if (hit) return hit;
+      }
     }
     return void 0;
   }
   /** `#include "foo/bar.h"` — quoted form only; `<…>` is a system header. */
   resolveInclude(fromFile, spec) {
     const relative3 = this.lookupWithExtensions(
-      path4.posix.join(path4.posix.dirname(fromFile), spec),
+      path5.posix.join(path5.posix.dirname(fromFile), spec),
       "c"
     );
     if (relative3) return relative3;
     for (const base of [
-      path4.posix.join(this.structure.projectRoot, "include"),
+      path5.posix.join(this.structure.projectRoot, "include"),
       this.structure.projectRoot
     ]) {
-      const hit = this.lookupWithExtensions(path4.posix.join(base, spec), "c");
+      const hit = this.lookupWithExtensions(path5.posix.join(base, spec), "c");
       if (hit) return hit;
     }
     return void 0;
@@ -4787,15 +5070,15 @@ var ModuleResolver = class {
   /** `require_relative 'x'` is relative; `require 'x'` is looked up under lib/. */
   resolveRuby(fromFile, spec) {
     const relative3 = this.lookupWithExtensions(
-      path4.posix.join(path4.posix.dirname(fromFile), spec),
+      path5.posix.join(path5.posix.dirname(fromFile), spec),
       "ruby"
     );
     if (relative3) return relative3;
     for (const base of [
-      path4.posix.join(this.structure.projectRoot, "lib"),
+      path5.posix.join(this.structure.projectRoot, "lib"),
       this.structure.projectRoot
     ]) {
-      const hit = this.lookupWithExtensions(path4.posix.join(base, spec), "ruby");
+      const hit = this.lookupWithExtensions(path5.posix.join(base, spec), "ruby");
       if (hit) return hit;
     }
     return void 0;
@@ -4993,7 +5276,7 @@ var ParserWorkerPool = class {
    */
   async reparseInline(batch, orphaned, workerId) {
     try {
-      const { parseFileContent } = await import("./parser-dispatch-WG4DNBHH.js");
+      const { parseFileContent } = await import("./parser-dispatch-ZSWCQB6M.js");
       for (const item of orphaned) {
         if (batch.settled) return;
         try {
@@ -5098,15 +5381,15 @@ var IndexSourceChangedError = class extends Error {
   name = "IndexSourceChangedError";
 };
 function isWithinProject(projectRoot, file) {
-  const rel = path5.relative(projectRoot, file);
-  return rel !== "" && !rel.startsWith(`..${path5.sep}`) && rel !== ".." && !path5.isAbsolute(rel);
+  const rel = path6.relative(projectRoot, file);
+  return rel !== "" && !rel.startsWith(`..${path6.sep}`) && rel !== ".." && !path6.isAbsolute(rel);
 }
 function isMissingPathError(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
 function normalizeComparablePath(value) {
-  const resolved = path5.resolve(value);
+  const resolved = path6.resolve(value);
   return process.platform === "win32" ? resolved.toLowerCase() : resolved;
 }
 function gitOutput(projectRoot, args) {
@@ -5152,24 +5435,24 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
       const record = statusRecords[i];
       if (!record) continue;
       const status = record.slice(0, 2);
-      const changedPath = path5.resolve(projectRoot, record.slice(3));
+      const changedPath = path6.resolve(projectRoot, record.slice(3));
       dirty.add(changedPath);
       if (status.includes("D")) deleted.add(changedPath);
       if (status.includes("R") || status.includes("C")) {
         const source = statusRecords[++i];
-        if (source) dirty.add(path5.resolve(projectRoot, source));
+        if (source) dirty.add(path6.resolve(projectRoot, source));
       }
     }
     const files = [];
     for (const relative3 of output.toString("utf8").split("\0")) {
       if (!relative3) continue;
       const portable = relative3.replace(/\\/g, "/");
-      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path5.posix.basename(portable)) || isAtlasProjection(portable)) {
+      if (portable.split("/").some((segment) => ignoreSet.has(segment)) || DEFAULT_IGNORE_FILES.has(path6.posix.basename(portable)) || isAtlasProjection(portable)) {
         continue;
       }
-      const full = path5.resolve(projectRoot, relative3);
+      const full = path6.resolve(projectRoot, relative3);
       if (deleted.has(full)) continue;
-      const ext = path5.extname(relative3).toLowerCase();
+      const ext = path6.extname(relative3).toLowerCase();
       if (INDEXABLE_EXTENSION_SET.has(ext) || detectLang(full) !== null) files.push(full);
     }
     const snapshot = createHash("sha256").update(stagedOutput).update("\0").update(statusOutput);
@@ -5188,6 +5471,57 @@ async function findGitSourceFiles(projectRoot, ignore, signal) {
     return null;
   }
 }
+async function expandTargetedDirectories(store, projectRoot, targets, isGitIgnored, signal) {
+  const isIndexableName = (file) => INDEXABLE_EXTENSION_SET.has(path6.extname(file).toLowerCase()) || detectLang(file) !== null;
+  const expanded = /* @__PURE__ */ new Set();
+  let indexedFiles;
+  for (const target of targets) {
+    if (isIndexableName(target) || !isWithinProject(projectRoot, target)) {
+      expanded.add(target);
+      continue;
+    }
+    let stats;
+    try {
+      stats = await fs5.stat(target);
+    } catch (err) {
+      if (!isMissingPathError(err)) {
+        expanded.add(target);
+        continue;
+      }
+    }
+    if (stats && !stats.isDirectory()) {
+      expanded.add(target);
+      continue;
+    }
+    indexedFiles ??= store.getAllFileMetas().map((meta) => meta.file);
+    const prefix = normalizeComparablePath(target) + path6.sep;
+    for (const file of indexedFiles) {
+      if (normalizeComparablePath(file).startsWith(prefix)) expanded.add(file);
+    }
+    if (!stats) continue;
+    const walk = async (dir) => {
+      throwIfAborted(signal);
+      let entries;
+      try {
+        entries = await fs5.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (DEFAULT_IGNORE.includes(entry.name)) continue;
+        const full = path6.join(dir, entry.name);
+        const rel = path6.relative(projectRoot, full).replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+          if (!isGitIgnored(rel, true)) await walk(full);
+        } else if (entry.isFile() && isIndexableName(full)) {
+          expanded.add(full);
+        }
+      }
+    };
+    await walk(target);
+  }
+  return [...expanded];
+}
 async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
   const gitFiles = await findGitSourceFiles(projectRoot, ignore, signal);
   if (gitFiles) {
@@ -5222,15 +5556,15 @@ async function findSourceFiles(projectRoot, ignore, isGitIgnored, signal) {
     dirCount++;
     for (const e of entries) {
       if (ignoreSet.has(e.name)) continue;
-      const full = path5.join(dir, e.name);
-      const rel = path5.relative(projectRoot, full).replace(/\\/g, "/");
+      const full = path6.join(dir, e.name);
+      const rel = path6.relative(projectRoot, full).replace(/\\/g, "/");
       if (e.isDirectory()) {
         if (isGitIgnored(rel, true)) continue;
         await walk(full);
       } else if (e.isFile()) {
         if (DEFAULT_IGNORE_FILES.has(e.name) || isGitIgnored(rel, false)) continue;
         if (isAtlasProjection(rel)) continue;
-        const ext = path5.extname(e.name).toLowerCase();
+        const ext = path6.extname(e.name).toLowerCase();
         if (indexableExts.has(ext) || detectLang(full) !== null) {
           results.push(full);
         }
@@ -5269,13 +5603,15 @@ async function resolveProjectRelations(store, projectRoot, opts) {
     if (opts.signal?.aborted) return;
     store.setFilePackages(assignPackageLabels(structure, indexedFiles));
     const resolver = new ModuleResolver(structure, indexedFiles, store.getNamespaceDeclarations());
-    const pending = store.getUnresolvedImports(opts.onlyFiles);
+    const scope = opts.onlyFiles ? [.../* @__PURE__ */ new Set([...opts.onlyFiles, ...store.getFilesWithDanglingImports()])] : void 0;
+    const pending = store.getUnresolvedImports(scope);
     const resolutions = [];
     for (const entry of pending) {
       const toFile = resolver.resolve(entry.fromFile, entry.lang, entry.module);
-      if (toFile && toFile !== entry.fromFile) {
-        resolutions.push({ ...entry, toFile });
-      }
+      resolutions.push({
+        ...entry,
+        toFile: toFile && toFile !== entry.fromFile ? toFile : null
+      });
     }
     if (opts.signal?.aborted) return;
     store.applyImportResolutions(resolutions);
@@ -5309,7 +5645,8 @@ async function runIndexerAtomic(store, opts) {
   const { projectRoot, langs, ignore = [], signal } = opts;
   const relationGraphVersion = "2";
   const refResolutionVersion = "2";
-  const force = (opts.force ?? false) || store.getMetadata("relation_graph_version") !== relationGraphVersion;
+  const graphVersionStale = store.getMetadata("relation_graph_version") !== relationGraphVersion;
+  const force = (opts.force ?? false) || graphVersionStale;
   const needsFullRefResolution = force || store.getMetadata("ref_resolution_version") !== refResolutionVersion;
   const startMs = Date.now();
   const errors = [];
@@ -5327,10 +5664,17 @@ async function runIndexerAtomic(store, opts) {
   let trustedUnchanged;
   let discoverySnapshotKey;
   if (opts.files && opts.files.length > 0) {
-    files = opts.files.map((f) => path5.resolve(projectRoot, f)).filter((f) => {
+    const targeted = await expandTargetedDirectories(
+      store,
+      projectRoot,
+      opts.files.map((f) => path6.resolve(projectRoot, f)),
+      isGitIgnored,
+      signal
+    );
+    files = targeted.filter((f) => {
       if (!isWithinProject(projectRoot, f)) return false;
-      const rel = path5.relative(projectRoot, f).replace(/\\/g, "/");
-      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path5.basename(f)) && !isAtlasProjection(rel) && !isGitIgnored(rel, false);
+      const rel = path6.relative(projectRoot, f).replace(/\\/g, "/");
+      return !rel.split("/").some((seg) => DEFAULT_IGNORE.includes(seg)) && !DEFAULT_IGNORE_FILES.has(path6.basename(f)) && !isAtlasProjection(rel) && !isGitIgnored(rel, false);
     });
   } else {
     const discovery = await findSourceFiles(projectRoot, ignore, isGitIgnored, signal);
@@ -5348,7 +5692,8 @@ async function runIndexerAtomic(store, opts) {
       return lang ? langSet.has(lang) : false;
     });
   }
-  if (force) store.clearAll();
+  const scopedRun = (langs?.length ?? 0) > 0 || (opts.files?.length ?? 0) > 0;
+  if (force && (graphVersionStale || !scopedRun)) store.clearAll();
   const existingMeta = /* @__PURE__ */ new Map();
   if (!force) {
     for (const meta of store.getAllFileMetas()) existingMeta.set(meta.file, meta);
@@ -5513,7 +5858,10 @@ async function runIndexerAtomic(store, opts) {
       }
       const result = settled.value;
       if (result.error) {
-        if (result.missing) store.deleteFile(file);
+        if (result.missing) {
+          store.deleteFile(file);
+          continue;
+        }
         errors.push(`${file}: ${result.error}`);
         filesFailed++;
         continue;
@@ -5671,7 +6019,7 @@ async function runIndexerAtomic(store, opts) {
 }
 
 // src/codebase-index/index-service.ts
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 async function indexService(args, hooks = {}) {
   const store = indexStorePool.acquire(args.projectRoot, { indexDir: args.indexDir });
   try {
@@ -5725,7 +6073,7 @@ function contextService(args) {
         pathPrefix: args.pathPrefix
       },
       (file) => {
-        const relative3 = path6.relative(args.projectRoot, file);
+        const relative3 = path7.relative(args.projectRoot, file);
         if (!relative3 || relative3.startsWith("..")) return posixIndexPath(file);
         return posixIndexPath(relative3);
       }
@@ -5817,6 +6165,11 @@ export {
   pageRank,
   toSymbolRankRows,
   aggregateFileRank,
+  RANK_VERSION,
+  RANK_VERSION_KEY,
+  RANK_REFRESH_FILE_THRESHOLD,
+  shouldRefreshRanks,
+  runGraphRankPass,
   getWiringSnapshot,
   clearWiringSnapshot,
   posixIndexPath,
@@ -5827,11 +6180,6 @@ export {
   DEFAULT_SYMBOLS_PER_FILE,
   retrieveContext,
   xxhash64String,
-  RANK_VERSION,
-  RANK_VERSION_KEY,
-  RANK_REFRESH_FILE_THRESHOLD,
-  shouldRefreshRanks,
-  runGraphRankPass,
   tokenise,
   buildIndexableText,
   buildBm25Index,
@@ -5856,4 +6204,4 @@ export {
   incomingCallsService,
   outgoingCallsService
 };
-//# sourceMappingURL=chunk-NEYUPZL6.js.map
+//# sourceMappingURL=chunk-6D3UIQMF.js.map