@lzehrung/codegraph 2.1.1 → 2.2.0

package/dist/bin/queryIndexWorker.js

@@ -3,7 +3,7 @@ const require = __codegraphCreateRequire(import.meta.url);
 
 
 // dist/agent/query-index/content.js
-import fs4 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
 
 // dist/languages/queryGenerator.js
@@ -75,17 +75,6 @@ function getLanguageById(id) {
   return registry.get(id);
 }
 
-// dist/parserBackend.js
-function loadTreeSitterLanguage(packageName) {
-  return { name: packageName };
-}
-function loadTypeScriptGrammars() {
-  return {
-    typescript: { name: "tree-sitter-typescript/typescript" },
-    tsx: { name: "tree-sitter-typescript/tsx" }
-  };
-}
-
 // dist/languages/definitions/jsFamily.js
 var ECMASCRIPT_CONTROL_SPLIT_POINTS = [
   "if_statement",
@@ -331,7 +320,6 @@ var BASE_HELPERS = {
 var TYPESCRIPT_DEF = {
   id: "ts",
   extensions: [".ts", ".mts", ".cts"],
-  grammar: () => loadTypeScriptGrammars().typescript,
   structure: BASE_STRUCTURE,
   graph: BASE_GRAPH,
   ...BASE_HELPERS,
@@ -346,7 +334,6 @@ registerLanguage(TYPESCRIPT_DEF);
 var TSX_DEF = {
   id: "tsx",
   extensions: [".tsx"],
-  grammar: () => loadTypeScriptGrammars().tsx,
   structure: {
     ...BASE_STRUCTURE,
     blocks: [
@@ -384,7 +371,6 @@ var JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN = `
 var JAVASCRIPT_DEF = {
   id: "js",
   extensions: [".js", ".jsx", ".mjs", ".cjs"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-javascript"),
   structure: {
     blocks: [...ECMASCRIPT_CORE_FUNCTION_BLOCKS, ...ECMASCRIPT_MODULE_VAR_BLOCKS],
     splitPoints: [...ECMASCRIPT_CONTROL_SPLIT_POINTS],
@@ -553,7 +539,6 @@ var KOTLIN_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
 var PYTHON_DEF = {
   id: "python",
   extensions: [".py", ".pyi"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-python"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -684,7 +669,6 @@ registerLanguage(PYTHON_DEF);
 var PHP_DEF = {
   id: "php",
   extensions: [".php"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-php"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -839,7 +823,6 @@ registerLanguage(PHP_DEF);
 var HTML_DEF = {
   id: "html",
   extensions: [".html", ".htm"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-html"),
   structure: {
     blocks: [
       {
@@ -884,7 +867,6 @@ function htmlStubLanguage(id, extensions) {
   return {
     id,
     extensions,
-    grammar: () => loadTreeSitterLanguage("tree-sitter-html"),
     structure: {
       blocks: [],
       splitPoints: [],
@@ -963,7 +945,6 @@ function cssLikeNodeTypes() {
 var CSS_DEF = {
   id: "css",
   extensions: [".css"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-css"),
   structure: cssLikeStructure(),
   graph: cssLikeGraph(),
   nodeTypes: cssLikeNodeTypes()
@@ -981,7 +962,6 @@ var SCSS_SYMBOL_QUERY_PATTERNS = [
 var SCSS_DEF = {
   id: "scss",
   extensions: [".scss"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-scss"),
   structure: {
     blocks: [
       { type: "rule_set", captureId: "rule" },
@@ -1031,7 +1011,6 @@ registerLanguage(SCSS_DEF);
 var LESS_DEF = {
   id: "less",
   extensions: [".less"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-css"),
   structure: cssLikeStructure(),
   graph: cssLikeGraph(),
   nodeTypes: cssLikeNodeTypes()
@@ -1042,7 +1021,6 @@ registerLanguage(LESS_DEF);
 var VUE_DEF = {
   id: "vue",
   extensions: [".vue"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-vue"),
   structure: {
     blocks: [
       { type: "template_element", captureId: "template" },
@@ -1072,7 +1050,6 @@ registerLanguage(VUE_DEF);
 var SVELTE_DEF = {
   id: "svelte",
   extensions: [".svelte"],
-  grammar: () => loadTreeSitterLanguage("@tree-sitter-grammars/tree-sitter-svelte"),
   structure: {
     blocks: [
       { type: "script_element", captureId: "script" },
@@ -1102,7 +1079,6 @@ registerLanguage(SVELTE_DEF);
 var RUBY_DEF = {
   id: "ruby",
   extensions: [".rb"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-ruby"),
   structure: {
     blocks: [
       {
@@ -1189,7 +1165,6 @@ registerLanguage(RUBY_DEF);
 var GO_DEF = {
   id: "go",
   extensions: [".go"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-go"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -1298,7 +1273,6 @@ var JAVA_IDENTIFIER_IGNORABLE_PATTERN = new RegExp(`[${JAVA_IDENTIFIER_IGNORABLE
 var JAVA_DEF = {
   id: "java",
   extensions: [".java"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-java"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -1423,7 +1397,6 @@ var CSHARP_IDENTIFIER_FORMAT_PATTERN = new RegExp(`[${CSHARP_IDENTIFIER_FORMAT_S
 var CSHARP_DEF = {
   id: "csharp",
   extensions: [".cs"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-c-sharp"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -1552,7 +1525,6 @@ registerLanguage(CSHARP_DEF);
 var RUST_DEF = {
   id: "rust",
   extensions: [".rs"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-rust"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -1784,7 +1756,6 @@ function createCFamilyLanguageDefinition(options) {
   return {
     id: options.id,
     extensions: [...options.extensions],
-    grammar: () => loadTreeSitterLanguage(options.grammarPackage),
     structure: {
       blocks: options.blocks(functionNameQuery),
       splitPoints: [...options.splitPoints ?? cFamilyControlSplitPoints],
@@ -1877,7 +1848,6 @@ function isFunctionDeclarator(node) {
 var C_DEF = createCFamilyLanguageDefinition({
   id: "c",
   extensions: [".c", ".h", ".i"],
-  grammarPackage: "tree-sitter-c",
   includeFieldIdentifier: false,
   blocks: (functionNameQuery) => [
     cFamilyFunctionBlock(functionNameQuery),
@@ -1950,7 +1920,6 @@ registerLanguage(C_DEF);
 var CPP_DEF = createCFamilyLanguageDefinition({
   id: "cpp",
   extensions: [".cc", ".cpp", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".ipp", ".tpp", ".inl"],
-  grammarPackage: "tree-sitter-cpp",
   includeFieldIdentifier: true,
   usesQueryDrivenLocals: true,
   blocks: (functionNameQuery) => [
@@ -2044,7 +2013,6 @@ function normalizeKotlinNativeQuery(kind, query) {
 var KOTLIN_DEF = {
   id: "kotlin",
   extensions: [".kt", ".kts"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-kotlin"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -2172,7 +2140,6 @@ registerLanguage(KOTLIN_DEF);
 var SWIFT_DEF = {
   id: "swift",
   extensions: [".swift"],
-  grammar: () => loadTreeSitterLanguage("tree-sitter-swift"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -2345,7 +2312,6 @@ registerLanguage(SWIFT_DEF);
 var SQL_DEF = {
   id: "sql",
   extensions: [".sql"],
-  grammar: () => loadTreeSitterLanguage("@derekstride/tree-sitter-sql"),
   structure: {
     blocks: [
       { type: "statement", nameQuery: "(create_table)", captureId: "create" },
@@ -2388,7 +2354,6 @@ var ZIG_TYPE_INITIALIZER_TYPES = /* @__PURE__ */ new Set([
 var ZIG_DEF = {
   id: "zig",
   extensions: [".zig"],
-  grammar: () => loadTreeSitterLanguage("@tree-sitter-grammars/tree-sitter-zig"),
   usesQueryDrivenLocals: true,
   structure: {
     blocks: [
@@ -2552,7 +2517,6 @@ function adaptDefinition(def) {
   return {
     id: def.id,
     matchExts: def.extensions,
-    language: (filename) => def.grammar(filename),
     nodeTypes: def.nodeTypes || { identifier: ["identifier"] },
     queries: def.graph,
     classifyDefinition: def.classifyDefinition || (() => "variable"),
@@ -2646,6 +2610,7 @@ function isLikelyCppHeader(sample) {
 }
 
 // dist/native/runtime.js
+import fs5 from "node:fs";
 import path5 from "node:path";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
@@ -2678,10 +2643,11 @@ function stringifyUnknown(value) {
 }
 
 // dist/native/bindingLoader.js
-import fs3 from "node:fs";
+import fs4 from "node:fs";
 import path4 from "node:path";
 
 // dist/util/paths.js
+import fs2, {} from "node:fs";
 import fsp from "node:fs/promises";
 import path2 from "node:path";
 
@@ -2689,6 +2655,19 @@ import path2 from "node:path";
 function errorMessage(error) {
   if (error instanceof Error)
     return error.message;
+  if (typeof error === "string")
+    return error;
+  if (error === null || error === void 0)
+    return String(error);
+  if (typeof error === "object") {
+    try {
+      const serialized = JSON.stringify(error);
+      if (serialized)
+        return serialized;
+    } catch {
+      return String(error);
+    }
+  }
   return String(error);
 }
 
@@ -2765,7 +2744,9 @@ function isRelativeToRoot(normalizedRoot, normalizedFile) {
 function isFilePathWithinRoot(projectRoot, filePath) {
   const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
   const normalizedFile = normalizePath(resolveFilePathFromRoot(normalizedRoot, filePath));
-  return isRelativeToRoot(normalizedRoot, normalizedFile);
+  if (isRelativeToRoot(normalizedRoot, normalizedFile))
+    return true;
+  return windowsAliasRelativePath(normalizedRoot, normalizedFile) !== null;
 }
 function assertFilePathWithinRoot(projectRoot, filePath, label = "File") {
   const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
@@ -2775,13 +2756,50 @@ function assertFilePathWithinRoot(projectRoot, filePath, label = "File") {
   }
   return normalizedFile;
 }
+function windowsAliasRelativePath(normalizedRoot, normalizedFile) {
+  if (process.platform !== "win32")
+    return null;
+  if (!isWindowsQualifiedAbsolutePath(normalizedRoot) || !isWindowsQualifiedAbsolutePath(normalizedFile)) {
+    return null;
+  }
+  try {
+    const realRoot = fs2.realpathSync.native(normalizedRoot);
+    const realFile = fs2.realpathSync.native(normalizedFile);
+    const directRelativePath = path2.win32.relative(realRoot, realFile);
+    if (!directRelativePath.startsWith("..") && !path2.win32.isAbsolute(directRelativePath)) {
+      return normalizePath(directRelativePath);
+    }
+    const rootStat = fs2.statSync(realRoot, { bigint: true });
+    let ancestorPath = realFile;
+    while (true) {
+      const ancestorStat = fs2.statSync(ancestorPath, { bigint: true });
+      if (sameWindowsDirectoryIdentity(rootStat, ancestorStat)) {
+        return normalizePath(path2.win32.relative(ancestorPath, realFile));
+      }
+      const parentPath = path2.dirname(ancestorPath);
+      if (parentPath === ancestorPath)
+        return null;
+      ancestorPath = parentPath;
+    }
+  } catch {
+    return null;
+  }
+}
+function sameWindowsDirectoryIdentity(left, right) {
+  return left.ino !== 0n && left.dev === right.dev && left.ino === right.ino && left.birthtimeNs === right.birthtimeNs;
+}
 
 // dist/native/runtimeCache.js
 import { createHash, randomBytes } from "node:crypto";
-import fs2 from "node:fs";
+import fs3 from "node:fs";
 import path3 from "node:path";
 var CACHE_SCHEMA_VERSION = 1;
 var HASH_BUFFER_SIZE = 1024 * 1024;
+var IDENTITY_FILE_PREFIX = "identity-";
+var IDENTITY_FILE_SUFFIX = ".json";
+var IDENTITY_VERSION = 1;
+var IDENTITY_REVERIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var ABANDONED_ENTRY_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
 function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
@@ -2798,12 +2816,12 @@ function assertSafeCacheSegment(value, label) {
   }
 }
 function assertSafePathComponent(componentPath) {
-  const stats = fs2.lstatSync(componentPath);
+  const stats = fs3.lstatSync(componentPath);
   if (!stats.isDirectory() || stats.isSymbolicLink()) {
     throw new Error(`unsafe native cache path component: ${componentPath}`);
   }
 }
-function prepareSafeDirectory(directoryPath) {
+function prepareSafeDirectory(directoryPath, create = true) {
   const absolute = path3.resolve(directoryPath);
   const parsed = path3.parse(absolute);
   let current = parsed.root;
@@ -2814,11 +2832,11 @@ function prepareSafeDirectory(directoryPath) {
     try {
       assertSafePathComponent(current);
     } catch (error) {
-      if (error.code !== "ENOENT") {
+      if (error.code !== "ENOENT" || !create) {
         throw error;
       }
       try {
-        fs2.mkdirSync(current);
+        fs3.mkdirSync(current);
       } catch (mkdirError) {
         if (mkdirError.code !== "EEXIST")
           throw mkdirError;
@@ -2826,27 +2844,33 @@ function prepareSafeDirectory(directoryPath) {
       assertSafePathComponent(current);
     }
   }
-  return fs2.realpathSync.native(absolute);
+  return fs3.realpathSync.native(absolute);
 }
-function resolveProductionCacheRoot() {
+function findProductionCacheRoot() {
   const localAppData = process.env.LOCALAPPDATA;
-  if (!localAppData) {
+  if (!localAppData)
+    return null;
+  return path3.join(localAppData, "codegraph", "native-cache", `v${CACHE_SCHEMA_VERSION}`);
+}
+function resolveProductionCacheRoot() {
+  const cacheRoot = findProductionCacheRoot();
+  if (!cacheRoot) {
     throw new Error("LOCALAPPDATA is unavailable; cannot prepare the Windows native runtime cache");
   }
-  return path3.join(localAppData, "codegraph", "native-cache", `v${CACHE_SCHEMA_VERSION}`);
+  return cacheRoot;
 }
 function hashFileStreaming(filePath, onChunk) {
-  const before = fs2.statSync(filePath);
+  const before = fs3.statSync(filePath);
   if (!before.isFile() || before.size <= 0) {
     throw new Error(`native binary is not a non-empty regular file: ${filePath}`);
   }
   const hash = createHash("sha256");
   const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
-  const descriptor = fs2.openSync(filePath, "r");
+  const descriptor = fs3.openSync(filePath, "r");
   let size = 0;
   try {
     while (true) {
-      const bytesRead = fs2.readSync(descriptor, buffer, 0, buffer.length, null);
+      const bytesRead = fs3.readSync(descriptor, buffer, 0, buffer.length, null);
       if (!bytesRead)
         break;
       hash.update(buffer.subarray(0, bytesRead));
@@ -2854,57 +2878,58 @@ function hashFileStreaming(filePath, onChunk) {
       onChunk?.(bytesRead);
     }
   } finally {
-    fs2.closeSync(descriptor);
+    fs3.closeSync(descriptor);
   }
-  if (size !== before.size) {
+  const after = fs3.statSync(filePath);
+  if (!after.isFile() || size !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
     throw new Error(`native binary changed while hashing: ${filePath}`);
   }
-  return { sha256: hash.digest("hex"), size };
+  return { sha256: hash.digest("hex"), size, mtimeMs: before.mtimeMs };
 }
 function randomSuffix() {
   return `${process.pid}.${randomBytes(8).toString("hex")}`;
 }
 function copyFileExclusive(sourcePath, destinationPath) {
-  const source = fs2.openSync(sourcePath, "r");
+  const source = fs3.openSync(sourcePath, "r");
   let destination;
   const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
   try {
-    destination = fs2.openSync(destinationPath, "wx");
+    destination = fs3.openSync(destinationPath, "wx");
     while (true) {
-      const bytesRead = fs2.readSync(source, buffer, 0, buffer.length, null);
+      const bytesRead = fs3.readSync(source, buffer, 0, buffer.length, null);
       if (!bytesRead)
         break;
       let written = 0;
       while (written < bytesRead) {
-        written += fs2.writeSync(destination, buffer, written, bytesRead - written);
+        written += fs3.writeSync(destination, buffer, written, bytesRead - written);
       }
     }
-    fs2.fsyncSync(destination);
+    fs3.fsyncSync(destination);
   } finally {
     if (destination !== void 0)
-      fs2.closeSync(destination);
-    fs2.closeSync(source);
+      fs3.closeSync(destination);
+    fs3.closeSync(source);
   }
 }
 function removeRegularTemporaryFile(filePath) {
   try {
-    const stats = fs2.lstatSync(filePath);
+    const stats = fs3.lstatSync(filePath);
     if (stats.isFile() && !stats.isSymbolicLink())
-      fs2.unlinkSync(filePath);
+      fs3.unlinkSync(filePath);
   } catch {
   }
 }
 function verifyFile(filePath, expected) {
   try {
     const actual = hashFileStreaming(filePath);
-    return actual.size === expected.size && actual.sha256 === expected.sha256;
+    return actual.size === expected.size && actual.sha256 === expected.sha256 ? actual : null;
   } catch {
-    return false;
+    return null;
   }
 }
 function publishExclusive(temporaryPath, finalPath) {
   try {
-    fs2.linkSync(temporaryPath, finalPath);
+    fs3.linkSync(temporaryPath, finalPath);
     return true;
   } catch (error) {
     if (error.code === "EEXIST")
@@ -2929,21 +2954,21 @@ function populateBinary(sourcePath, finalPath, expected) {
 }
 function recoverCorruptFinal(finalPath) {
   const recoveryPath = `${finalPath}.corrupt.${randomSuffix()}`;
-  fs2.renameSync(finalPath, recoveryPath);
+  fs3.renameSync(finalPath, recoveryPath);
 }
 function writeManifest(entryPath, manifest) {
   const finalPath = path3.join(entryPath, "manifest.json");
-  if (fs2.existsSync(finalPath))
+  if (fs3.existsSync(finalPath))
     return;
   const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
   try {
-    const descriptor = fs2.openSync(temporaryPath, "wx");
+    const descriptor = fs3.openSync(temporaryPath, "wx");
     try {
-      fs2.writeFileSync(descriptor, `${JSON.stringify(manifest, null, 2)}
+      fs3.writeFileSync(descriptor, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
-      fs2.fsyncSync(descriptor);
+      fs3.fsyncSync(descriptor);
     } finally {
-      fs2.closeSync(descriptor);
+      fs3.closeSync(descriptor);
     }
     publishExclusive(temporaryPath, finalPath);
   } catch (error) {
@@ -2951,12 +2976,302 @@ function writeManifest(entryPath, manifest) {
     throw error;
   }
 }
+function currentRuntimeStamp() {
+  return { abi: process.versions.modules, platform: process.platform, arch: process.arch };
+}
+function identityFilePath(entryPath, sourcePath) {
+  const sourceKey = createHash("sha256").update(sourcePath).digest("hex");
+  return path3.join(entryPath, `${IDENTITY_FILE_PREFIX}${sourceKey}${IDENTITY_FILE_SUFFIX}`);
+}
+function isIdentityFileName(fileName) {
+  return /^identity-[a-f0-9]{64}\.json$/.test(fileName);
+}
+function readCacheIdentityFile(filePath) {
+  let parsed;
+  try {
+    parsed = JSON.parse(fs3.readFileSync(filePath, "utf8"));
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object")
+    return null;
+  const candidate = parsed;
+  if (candidate.version !== IDENTITY_VERSION)
+    return null;
+  const numbers = [candidate.sourceSize, candidate.sourceMtimeMs, candidate.cachedSize, candidate.cachedMtimeMs];
+  if (numbers.some((value) => typeof value !== "number" || !Number.isFinite(value)))
+    return null;
+  const strings = [
+    candidate.sha256,
+    candidate.cacheKey,
+    candidate.sourcePath,
+    candidate.loadedPath,
+    candidate.verifiedAt
+  ];
+  if (strings.some((value) => typeof value !== "string" || !value))
+    return null;
+  if (!Array.isArray(candidate.supportedLanguageIds))
+    return null;
+  if (candidate.supportedLanguageIds.some((value) => typeof value !== "string"))
+    return null;
+  const origin = candidate.origin;
+  if (!origin || typeof origin !== "object" || origin.mode !== "cache" || typeof origin.packageName !== "string") {
+    return null;
+  }
+  const runtime = candidate.runtime;
+  if (!runtime || typeof runtime !== "object")
+    return null;
+  if (typeof runtime.abi !== "string" || typeof runtime.platform !== "string" || typeof runtime.arch !== "string") {
+    return null;
+  }
+  return candidate;
+}
+function readCacheIdentity(entryPath, sourcePath) {
+  return readCacheIdentityFile(identityFilePath(entryPath, sourcePath));
+}
+function latestCacheIdentityVerifiedAt(entryPath, now) {
+  let fileNames;
+  try {
+    fileNames = fs3.readdirSync(entryPath);
+  } catch {
+    return Number.NaN;
+  }
+  let latest = Number.NaN;
+  for (const fileName of fileNames) {
+    if (!isIdentityFileName(fileName))
+      continue;
+    const identity = readCacheIdentityFile(path3.join(entryPath, fileName));
+    const verifiedAt = identity ? Date.parse(identity.verifiedAt) : Number.NaN;
+    if (!Number.isFinite(verifiedAt) || verifiedAt > now)
+      continue;
+    if (!Number.isFinite(latest) || verifiedAt > latest)
+      latest = verifiedAt;
+  }
+  return latest;
+}
+function statOrNull(filePath) {
+  try {
+    const stats = fs3.statSync(filePath);
+    return stats.isFile() ? stats : null;
+  } catch {
+    return null;
+  }
+}
+function lstatRegularFileOrNull(filePath) {
+  try {
+    const stats = fs3.lstatSync(filePath);
+    return stats.isFile() && !stats.isSymbolicLink() ? stats : null;
+  } catch {
+    return null;
+  }
+}
+function isSafeExistingDirectory(directoryPath) {
+  try {
+    prepareSafeDirectory(directoryPath, false);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function pathsResolveEqual(left, right) {
+  return path3.resolve(left) === path3.resolve(right);
+}
+function lookupNativeRuntimeCacheEntry(request) {
+  try {
+    assertSafeCacheSegment(request.target, "target");
+    assertSafeCacheSegment(request.packageVersion, "package version");
+    const cacheRoot = request.cacheRoot ?? findProductionCacheRoot();
+    if (!cacheRoot)
+      return null;
+    const sourceRealPath = fs3.realpathSync.native(request.sourcePath);
+    const sourceStats = statOrNull(sourceRealPath);
+    if (!sourceStats)
+      return null;
+    const runtime = currentRuntimeStamp();
+    const resolvedCacheRoot = path3.resolve(cacheRoot);
+    const targetPath = path3.join(resolvedCacheRoot, request.target);
+    if (!isSafeExistingDirectory(resolvedCacheRoot) || !isSafeExistingDirectory(targetPath))
+      return null;
+    const prefix = `${request.packageVersion}-`;
+    let entryNames;
+    try {
+      entryNames = fs3.readdirSync(targetPath);
+    } catch {
+      return null;
+    }
+    const now = request.now ?? Date.now();
+    for (const entryName of entryNames) {
+      if (!entryName.startsWith(prefix))
+        continue;
+      const entryPath = path3.join(targetPath, entryName);
+      if (!isSafeExistingDirectory(entryPath))
+        continue;
+      const identity = readCacheIdentity(entryPath, sourceRealPath);
+      if (!identity)
+        continue;
+      const expectedEntryName = `${request.packageVersion}-${identity.sha256}`;
+      const expectedCacheKey = `${request.packageName}@${request.packageVersion}:${request.target}:${identity.sha256}`;
+      const loadedPath = path3.resolve(identity.loadedPath);
+      if (entryName !== expectedEntryName || identity.cacheKey !== expectedCacheKey || identity.loadedPath !== loadedPath || path3.dirname(loadedPath) !== entryPath || path3.basename(loadedPath) !== path3.basename(sourceRealPath)) {
+        continue;
+      }
+      if (identity.sourcePath !== sourceRealPath)
+        continue;
+      if (identity.sourceSize !== sourceStats.size || identity.sourceMtimeMs !== sourceStats.mtimeMs)
+        continue;
+      if (identity.origin.packageName !== request.packageName || identity.origin.packageVersion !== request.packageVersion || identity.origin.target !== request.target || identity.origin.sourcePath === void 0 || identity.origin.loadedPath === void 0 || !pathsResolveEqual(identity.origin.sourcePath, sourceRealPath) || !pathsResolveEqual(identity.origin.loadedPath, identity.loadedPath) || identity.origin.cacheKey !== identity.cacheKey || identity.origin.sha256 !== identity.sha256) {
+        continue;
+      }
+      if (identity.runtime.abi !== runtime.abi || identity.runtime.platform !== runtime.platform || identity.runtime.arch !== runtime.arch) {
+        continue;
+      }
+      const cachedStats = lstatRegularFileOrNull(identity.loadedPath);
+      if (!cachedStats)
+        continue;
+      if (identity.cachedSize !== cachedStats.size || identity.cachedMtimeMs !== cachedStats.mtimeMs)
+        continue;
+      const verifiedAt = Date.parse(identity.verifiedAt);
+      if (!Number.isFinite(verifiedAt) || verifiedAt > now || now - verifiedAt >= IDENTITY_REVERIFY_INTERVAL_MS) {
+        continue;
+      }
+      if (!isWithinDirectory(identity.loadedPath, resolvedCacheRoot))
+        continue;
+      return { entryPath, identity, revalidateAt: verifiedAt + IDENTITY_REVERIFY_INTERVAL_MS };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function recordNativeRuntimeCacheIdentity(identity) {
+  try {
+    const sourceStats = statOrNull(identity.sourcePath);
+    const cachedStats = lstatRegularFileOrNull(identity.loadedPath);
+    if (!sourceStats || !cachedStats || sourceStats.size !== identity.sourceSize || sourceStats.mtimeMs !== identity.sourceMtimeMs || cachedStats.size !== identity.cachedSize || cachedStats.mtimeMs !== identity.cachedMtimeMs) {
+      return;
+    }
+    const entryPath = path3.dirname(identity.loadedPath);
+    const record = {
+      version: IDENTITY_VERSION,
+      runtime: currentRuntimeStamp(),
+      ...identity
+    };
+    const finalPath = identityFilePath(entryPath, identity.sourcePath);
+    const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
+    try {
+      const descriptor = fs3.openSync(temporaryPath, "wx");
+      try {
+        fs3.writeFileSync(descriptor, `${JSON.stringify(record, null, 2)}
+`, "utf8");
+        fs3.fsyncSync(descriptor);
+      } finally {
+        fs3.closeSync(descriptor);
+      }
+      fs3.renameSync(temporaryPath, finalPath);
+    } catch {
+      removeRegularTemporaryFile(temporaryPath);
+    }
+  } catch {
+  }
+}
+function readEntrySummary(entryPath, now) {
+  let packageVersion = null;
+  let sourceFileName = null;
+  let cachedAtMs = null;
+  try {
+    const parsed = JSON.parse(fs3.readFileSync(path3.join(entryPath, "manifest.json"), "utf8"));
+    if (parsed && typeof parsed === "object") {
+      const manifest = parsed;
+      if (typeof manifest.packageVersion === "string" && manifest.packageVersion) {
+        packageVersion = manifest.packageVersion;
+      }
+      if (typeof manifest.sourceFileName === "string" && manifest.sourceFileName && path3.basename(manifest.sourceFileName) === manifest.sourceFileName) {
+        sourceFileName = manifest.sourceFileName;
+      }
+      const cachedAt = typeof manifest.cachedAt === "string" ? Date.parse(manifest.cachedAt) : Number.NaN;
+      if (Number.isFinite(cachedAt))
+        cachedAtMs = cachedAt;
+    }
+  } catch {
+    return null;
+  }
+  if (!packageVersion || !sourceFileName)
+    return null;
+  const verifiedAt = latestCacheIdentityVerifiedAt(entryPath, now);
+  const lastUsedMs = Number.isFinite(verifiedAt) ? verifiedAt : cachedAtMs;
+  if (lastUsedMs === null)
+    return null;
+  return { packageVersion, lastUsedMs, sourceFileName };
+}
+function removeAbandonedEntry(entryPath, sourceFileName) {
+  const cachedBinaryPath = path3.join(entryPath, sourceFileName);
+  if (!isWithinDirectory(cachedBinaryPath, entryPath) || path3.dirname(cachedBinaryPath) !== entryPath) {
+    throw new Error("invalid native cache binary path");
+  }
+  const stats = fs3.lstatSync(cachedBinaryPath);
+  if (!stats.isFile() || stats.isSymbolicLink())
+    throw new Error("unsafe native cache binary");
+  fs3.unlinkSync(cachedBinaryPath);
+  fs3.rmSync(entryPath, { recursive: true, force: true });
+}
+function pruneAbandonedEntries(targetPath, cacheRoot, keepEntryPath, keepVersion, now) {
+  let entryNames;
+  try {
+    entryNames = fs3.readdirSync(targetPath);
+  } catch {
+    return;
+  }
+  for (const entryName of entryNames) {
+    const entryPath = path3.join(targetPath, entryName);
+    if (entryPath === keepEntryPath)
+      continue;
+    if (!isWithinDirectory(entryPath, cacheRoot))
+      continue;
+    try {
+      if (!fs3.lstatSync(entryPath).isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    const summary = readEntrySummary(entryPath, now);
+    if (!summary || summary.packageVersion === keepVersion)
+      continue;
+    if (now - summary.lastUsedMs < ABANDONED_ENTRY_RETENTION_MS)
+      continue;
+    try {
+      removeAbandonedEntry(entryPath, summary.sourceFileName);
+    } catch {
+    }
+  }
+}
 function prepareNativeRuntimeCache(request) {
   const sourcePath = path3.resolve(request.sourcePath);
   try {
     assertSafeCacheSegment(request.target, "target");
     assertSafeCacheSegment(request.packageVersion, "package version");
-    const sourceRealPath = fs2.realpathSync.native(sourcePath);
+    const hit = lookupNativeRuntimeCacheEntry({
+      sourcePath,
+      packageName: request.packageName,
+      packageVersion: request.packageVersion,
+      target: request.target,
+      ...request.cacheRoot !== void 0 ? { cacheRoot: request.cacheRoot } : {},
+      ...request.now !== void 0 ? { now: request.now } : {}
+    });
+    if (hit) {
+      return {
+        status: "reused",
+        sourcePath: hit.identity.sourcePath,
+        loadedPath: hit.identity.loadedPath,
+        cacheKey: hit.identity.cacheKey,
+        sha256: hit.identity.sha256,
+        sourceSize: hit.identity.sourceSize,
+        sourceMtimeMs: hit.identity.sourceMtimeMs,
+        cachedSize: hit.identity.cachedSize,
+        cachedMtimeMs: hit.identity.cachedMtimeMs,
+        verified: false
+      };
+    }
+    const sourceRealPath = fs3.realpathSync.native(sourcePath);
     const source = hashFileStreaming(sourceRealPath);
     const cacheRoot = prepareSafeDirectory(request.cacheRoot ?? resolveProductionCacheRoot());
     const targetPath = prepareSafeDirectory(path3.join(cacheRoot, request.target));
@@ -2971,12 +3286,13 @@ function prepareNativeRuntimeCache(request) {
     const sourceFileName = path3.basename(sourceRealPath);
     const finalPath = path3.join(entryPath, sourceFileName);
     let status = "reused";
-    const finalExists = fs2.existsSync(finalPath);
-    if (!finalExists || !verifyFile(finalPath, source)) {
-      if (finalExists)
+    let cached = fs3.existsSync(finalPath) ? verifyFile(finalPath, source) : null;
+    if (!cached) {
+      if (fs3.existsSync(finalPath))
         recoverCorruptFinal(finalPath);
       status = populateBinary(sourceRealPath, finalPath, source) ? "cached" : "reused";
-      if (!verifyFile(finalPath, source)) {
+      cached = verifyFile(finalPath, source);
+      if (!cached) {
         throw new Error("native cache winner failed integrity verification");
       }
     }
@@ -2990,12 +3306,18 @@ function prepareNativeRuntimeCache(request) {
       sourceSha256: source.sha256,
       cachedAt: (/* @__PURE__ */ new Date()).toISOString()
     });
+    pruneAbandonedEntries(targetPath, cacheRoot, entryPath, request.packageVersion, request.now ?? Date.now());
     return {
       status,
       sourcePath: sourceRealPath,
       loadedPath: finalPath,
       cacheKey,
-      sha256: source.sha256
+      sha256: source.sha256,
+      sourceSize: source.size,
+      sourceMtimeMs: source.mtimeMs,
+      cachedSize: cached.size,
+      cachedMtimeMs: cached.mtimeMs,
+      verified: true
     };
   } catch (error) {
     return { status: "unavailable", sourcePath, error: asError(error) };
@@ -3054,7 +3376,7 @@ function findLocalNativeBinary(packageRoot) {
   }
   const expectedName = `index.${suffix}.node`;
   try {
-    const entries = fs3.readdirSync(packageRoot, { withFileTypes: true });
+    const entries = fs4.readdirSync(packageRoot, { withFileTypes: true });
     const binary = entries.find((entry) => entry.isFile() && entry.name === expectedName);
     return binary ? path4.join(packageRoot, binary.name) : null;
   } catch {
@@ -3068,13 +3390,13 @@ function readPlatformPackage(packageName, target, resolveFn) {
   if (path4.basename(resolvedEntry) !== expectedFileName) {
     throw new Error(`unexpected native platform entry for ${platformPackageName}: ${resolvedEntry}`);
   }
-  const sourcePath = fs3.realpathSync.native(resolvedEntry);
-  const stats = fs3.statSync(sourcePath);
+  const sourcePath = fs4.realpathSync.native(resolvedEntry);
+  const stats = fs4.statSync(sourcePath);
   if (!stats.isFile() || stats.size <= 0) {
     throw new Error(`native platform entry is not a non-empty regular file: ${sourcePath}`);
   }
   const packageJsonPath = path4.join(path4.dirname(sourcePath), "package.json");
-  const parsed = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+  const parsed = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
   if (parsed.name !== platformPackageName || !parsed.version) {
     throw new Error(`invalid native platform package metadata: ${packageJsonPath}`);
   }
@@ -3160,6 +3482,17 @@ function loadNativeBinding(options) {
             loadedPath: normalizePath(cached.loadedPath),
             cacheKey: cached.cacheKey,
             sha256: cached.sha256
+          },
+          cacheEntry: {
+            sourcePath: cached.sourcePath,
+            loadedPath: cached.loadedPath,
+            cacheKey: cached.cacheKey,
+            sha256: cached.sha256,
+            sourceSize: cached.sourceSize,
+            sourceMtimeMs: cached.sourceMtimeMs,
+            cachedSize: cached.cachedSize,
+            cachedMtimeMs: cached.cachedMtimeMs,
+            verified: cached.verified
           }
         };
       } catch (error) {
@@ -3202,6 +3535,7 @@ var require2 = createRequire(import.meta.url);
 var localNativePackageRoot = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "../../packages/codegraph-native");
 var NATIVE_REQUIRED_ERROR_PREFIX = "native tree-sitter required by explicit option but unavailable";
 var bindingState;
+var cachedRuntimeFingerprints = /* @__PURE__ */ new Map();
 function isNativeTreeSitterDisabledByEnv(env = process.env) {
   const rawValue = env.CODEGRAPH_DISABLE_NATIVE;
   if (typeof rawValue !== "string") {
@@ -3216,6 +3550,7 @@ function normalizeNativeRuntimeMode(mode) {
 function loadBinding() {
   if (bindingState)
     return bindingState;
+  cachedRuntimeFingerprints.clear();
   const loaded = loadNativeBinding({
     packageName: "@lzehrung/codegraph-native",
     localPackageRoot: localNativePackageRoot,
@@ -3223,12 +3558,28 @@ function loadBinding() {
     resolveFn: require2.resolve
   });
   if (loaded.binding) {
+    const supportedLanguageIds = new Set(loaded.binding.supportedLanguageIds());
     bindingState = {
       loaded: true,
       binding: loaded.binding,
-      supportedLanguageIds: new Set(loaded.binding.supportedLanguageIds()),
+      supportedLanguageIds,
       origin: loaded.origin
     };
+    if (loaded.cacheEntry?.verified) {
+      recordNativeRuntimeCacheIdentity({
+        sourcePath: loaded.cacheEntry.sourcePath,
+        loadedPath: loaded.cacheEntry.loadedPath,
+        cacheKey: loaded.cacheEntry.cacheKey,
+        sha256: loaded.cacheEntry.sha256,
+        sourceSize: loaded.cacheEntry.sourceSize,
+        sourceMtimeMs: loaded.cacheEntry.sourceMtimeMs,
+        cachedSize: loaded.cacheEntry.cachedSize,
+        cachedMtimeMs: loaded.cacheEntry.cachedMtimeMs,
+        verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        supportedLanguageIds: Array.from(supportedLanguageIds).sort(),
+        origin: loaded.origin
+      });
+    }
     return bindingState;
   }
   bindingState = {
@@ -3841,7 +4192,7 @@ function compressQueryText(text) {
   });
 }
 function normalizeQuerySearchText(input) {
-  return input.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  return input.replace(/([\p{Ll}\p{Nd}])(\p{Lu})/gu, "$1 $2").replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, "$1 $2").toLowerCase().replace(/[^\p{L}\p{N}\p{M}_]+/gu, " ").trim();
 }
 function detectQueryIndexSurface(relativePath) {
   const lower = relativePath.toLowerCase();
@@ -3891,7 +4242,7 @@ function buildQueryTextChunks(file, text) {
 }
 async function prepareQueryIndexFile(input) {
   try {
-    const stat = await fs4.stat(input.absolutePath);
+    const stat = await fs6.stat(input.absolutePath);
     const support = supportForFile(input.absolutePath);
     if (stat.size > MAX_QUERY_INDEX_TEXT_BYTES) {
       return {
@@ -3906,7 +4257,7 @@ async function prepareQueryIndexFile(input) {
         sourceRead: false
       };
     }
-    const text = await fs4.readFile(input.absolutePath, "utf8");
+    const text = await fs6.readFile(input.absolutePath, "utf8");
     return {
       path: input.path,
       sourceIdentity: input.sourceIdentity,