@lzehrung/codegraph 2.3.2 → 2.3.4

package/dist/bin/cli.js

@@ -1179,6 +1179,7 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
   let current = 0;
   let total = 0;
   let mode = "build";
+  let activity = progressAction(mode);
   let interval;
   let delay;
   const clear = () => {
@@ -1190,11 +1191,10 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
   const render = () => {
     if (!active)
       return;
-    const action = progressAction(mode);
     const frame = SPINNER_FRAMES[frameIndex % SPINNER_FRAMES.length];
     frameIndex += 1;
-    const count = formatProgressCount(current, total);
-    write(`${CLEAR_LINE}${action} project index... ${frame}${count}`);
+    const count = hasProgressCount(mode, current, total) ? formatProgressCount(current, total) : "";
+    write(`${CLEAR_LINE}${activity}... ${frame}${count}`);
     rendered = true;
   };
   const stopInterval = () => {
@@ -1216,6 +1216,7 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
     current = update.current;
     total = update.total;
     mode = update.mode ?? "build";
+    activity = update.activity ?? `${progressAction(mode)} project index`;
     const beginRendering = () => {
       if (!active)
         return;
@@ -1262,6 +1263,8 @@ function createInteractiveProgressDisplay(write, delayMs = 0) {
       current = update.current;
       total = update.total;
       mode = update.mode ?? mode;
+      if (update.activity !== void 0)
+        activity = update.activity;
     },
     clear,
     dispose: () => {
@@ -1281,12 +1284,16 @@ function formatProgressCount(current, total) {
     return ` ${current}/${formatFileCount(total)}`;
   return ` ${formatFileCount(current)} processed`;
 }
+function hasProgressCount(mode, current, total) {
+  return mode !== "check" || current > 0 || total > 0;
+}
 function createLogProgressDisplay(write, delayMs = 0) {
   let active = false;
   let rendered = false;
   let current = 0;
   let total = 0;
   let mode = "build";
+  let activity = progressAction(mode);
   let delay;
   let heartbeat;
   const stopTimers = () => {
@@ -1303,12 +1310,13 @@ function createLogProgressDisplay(write, delayMs = 0) {
     if (!active || rendered)
       return;
     rendered = true;
-    write(`[Progress] ${progressAction(mode)} project index.
+    write(`[Progress] ${activity}.
 `);
     heartbeat = setInterval(() => {
       if (!active)
         return;
-      write(`[Progress] ${progressAction(mode)} project index:${formatProgressCount(current, total)}.
+      const count = hasProgressCount(mode, current, total) ? `:${formatProgressCount(current, total)}` : "";
+      write(`[Progress] ${activity}${count}.
 `);
     }, 1e3);
     heartbeat.unref();
@@ -1320,6 +1328,7 @@ function createLogProgressDisplay(write, delayMs = 0) {
     current = update.current;
     total = update.total;
     mode = update.mode ?? "build";
+    activity = update.activity ?? `${progressAction(mode)} project index`;
     if (delayMs) {
       delay = setTimeout(renderStart, delayMs);
       delay.unref();
@@ -1351,13 +1360,25 @@ function createLogProgressDisplay(write, delayMs = 0) {
           return;
         start(update);
       }
+      const previousActivity = activity;
       current = update.current;
       total = update.total;
       mode = update.mode ?? mode;
+      if (update.activity !== void 0)
+        activity = update.activity;
+      if (rendered && activity !== previousActivity) {
+        write(`[Progress] ${activity}.
+`);
+      }
       const isComplete = update.total > 0 && update.current >= update.total;
-      if (rendered && (update.current === 1 || isComplete || update.current % 100 === 0)) {
-        write(`[Progress] ${formatFileCount(update.current)} processed.
+      if (rendered && (update.current === 1 || isComplete || update.current > 0 && update.current % 100 === 0)) {
+        if (update.activity !== void 0) {
+          write(`[Progress] ${activity}:${formatProgressCount(update.current, update.total)}.
+`);
+        } else {
+          write(`[Progress] ${formatFileCount(update.current)} processed.
 `);
+        }
       }
     },
     clear: () => {
@@ -2395,12 +2416,11 @@ function hasNonAsciiCodePoint(value, includeC0Controls = false) {
   }
   return false;
 }
-var ECMASCRIPT_IDENTIFIER_SOURCE, DUPLICATE_TOKENIZER_IDENTIFIER_SOURCE, BLOOM_FILTER_IDENTIFIER_SOURCE, XID_IDENTIFIER_SOURCE, PYTHON_IDENTIFIER_SOURCE, PHP_IDENTIFIER_SOURCE, JAVA_IDENTIFIER_IGNORABLE_SOURCE, CSHARP_IDENTIFIER_FORMAT_SOURCE, JAVA_IDENTIFIER_SOURCE, CSHARP_IDENTIFIER_SOURCE, GO_IDENTIFIER_SOURCE, KOTLIN_IDENTIFIER_SOURCE;
+var ECMASCRIPT_IDENTIFIER_SOURCE, BLOOM_FILTER_IDENTIFIER_SOURCE, XID_IDENTIFIER_SOURCE, PYTHON_IDENTIFIER_SOURCE, PHP_IDENTIFIER_SOURCE, JAVA_IDENTIFIER_IGNORABLE_SOURCE, CSHARP_IDENTIFIER_FORMAT_SOURCE, JAVA_IDENTIFIER_SOURCE, CSHARP_IDENTIFIER_SOURCE, GO_IDENTIFIER_SOURCE, KOTLIN_IDENTIFIER_SOURCE;
 var init_identifiers = __esm({
   "dist/util/identifiers.js"() {
     "use strict";
     ECMASCRIPT_IDENTIFIER_SOURCE = String.raw`[$_\p{ID_Start}](?:[$_\p{ID_Continue}]|\u200c|\u200d)*`;
-    DUPLICATE_TOKENIZER_IDENTIFIER_SOURCE = String.raw`[$_\p{XID_Start}\u1885\u1886\u2118\u212E\u309B\u309C](?:[$_\p{XID_Continue}\u00B7\u0387\u1369-\u1371\u19DA\u200C\u200D\u1885\u1886\u2118\u212E\u309B\u309C])*`;
     BLOOM_FILTER_IDENTIFIER_SOURCE = String.raw`[A-Za-z0-9_$\u0000-\u0008\u000E-\u001B\u007F-\u009F\u200C\u200D\u0080-\u{10FFFF}]+`;
     XID_IDENTIFIER_SOURCE = String.raw`[_\p{XID_Start}][_\p{XID_Continue}]*`;
     PYTHON_IDENTIFIER_SOURCE = XID_IDENTIFIER_SOURCE;
@@ -4761,9 +4781,9 @@ var require_path = __commonJS({
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
-    var os12 = __require("os");
+    var os13 = __require("os");
     var path99 = __require("path");
-    var IS_WINDOWS_PLATFORM = os12.platform() === "win32";
+    var IS_WINDOWS_PLATFORM = os13.platform() === "win32";
     var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
     var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
     var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
@@ -10281,8 +10301,8 @@ var require_settings4 = __commonJS({
     Object.defineProperty(exports, "__esModule", { value: true });
     exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
     var fs49 = __require("fs");
-    var os12 = __require("os");
-    var CPU_COUNT = Math.max(os12.cpus().length, 1);
+    var os13 = __require("os");
+    var CPU_COUNT = Math.max(os13.cpus().length, 1);
     exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
       lstat: fs49.lstat,
       lstatSync: fs49.lstatSync,
@@ -13503,6 +13523,7 @@ __export(git_exports, {
   decodeGitPath: () => decodeGitPath,
   getGitBlobHashes: () => getGitBlobHashes,
   getGitHead: () => getGitHead,
+  getGitRepositoryRoot: () => getGitRepositoryRoot,
   getUnifiedDiff: () => getUnifiedDiff,
   gitDiffArgs: () => gitDiffArgs,
   isGitIndexSentinel: () => isGitIndexSentinel,
@@ -13796,6 +13817,15 @@ async function isGitRepo(projectRoot) {
   gitRepositoryChecks.set(resolvedRoot, check2);
   return await check2;
 }
+async function getGitRepositoryRoot(projectRoot) {
+  try {
+    const { stdout } = await runGit(projectRoot, ["rev-parse", "--show-toplevel"]);
+    const root = normalizePath(stdout.trim());
+    return root || null;
+  } catch {
+    return null;
+  }
+}
 async function isGitPathTracked(projectRoot, file2) {
   return await runGitPathPredicate(projectRoot, ["ls-files", "--error-unmatch", "--", normalizePath(file2)]);
 }
@@ -13917,6 +13947,9 @@ async function listChangedFiles(projectRoot, opts) {
     throw createGitError(projectRoot, args, error51);
   }
 }
+function resolveGitListedPath(projectRoot, listedPath) {
+  return normalizePath(path8.isAbsolute(listedPath) ? listedPath : path8.resolve(projectRoot, listedPath));
+}
 async function listTrackedFiles(projectRoot, opts) {
   if (!(opts?.gitAvailable ?? true))
     return [];
@@ -13927,7 +13960,7 @@ async function listTrackedFiles(projectRoot, opts) {
     const { stdout } = await runGit(projectRoot, args, { maxBuffer: 64 * 1024 * 1024 });
     const out = [];
     for (const rel of stdout.split("\0").filter(Boolean)) {
-      const abs = normalizePath(path8.resolve(projectRoot, rel));
+      const abs = resolveGitListedPath(projectRoot, rel);
       if (abs)
         out.push(abs);
     }
@@ -13987,7 +14020,7 @@ async function listGitExcludeFilesUncached(projectRoot) {
     const { stdout } = await runGit(projectRoot, ["rev-parse", "--git-path", "info/exclude"]);
     const resolved = stdout.trim();
     if (resolved)
-      candidates.push(normalizePath(path8.resolve(projectRoot, resolved)));
+      candidates.push({ file: normalizePath(path8.resolve(projectRoot, resolved)), priority: 1 });
   } catch {
   }
   try {
@@ -13995,15 +14028,19 @@ async function listGitExcludeFilesUncached(projectRoot) {
     const configured = stdout.trim();
     if (configured) {
       const expanded = configured.startsWith("~") ? path8.join(os2.homedir(), configured.slice(1)) : path8.resolve(projectRoot, configured);
-      candidates.push(normalizePath(expanded));
+      candidates.push({ file: normalizePath(expanded), priority: 0 });
     }
   } catch {
   }
   const sources = [];
-  for (const file2 of Array.from(new Set(candidates))) {
+  const uniqueCandidates = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    uniqueCandidates.set(candidate.file, Math.max(uniqueCandidates.get(candidate.file) ?? candidate.priority, candidate.priority));
+  }
+  for (const [file2, priority] of uniqueCandidates) {
     try {
       if ((await fsp4.stat(file2)).isFile())
-        sources.push({ file: file2, baseDir });
+        sources.push({ file: file2, baseDir, priority });
     } catch {
     }
   }
@@ -14021,7 +14058,7 @@ async function listUntrackedFiles(projectRoot, opts) {
     const relFiles = stdout.toString().split("\0").filter(Boolean);
     const out = [];
     for (const rel of relFiles) {
-      const abs = normalizePath(path8.resolve(projectRoot, rel));
+      const abs = resolveGitListedPath(projectRoot, rel);
       if (abs)
         out.push(abs);
     }
@@ -14098,15 +14135,26 @@ __export(projectFiles_exports, {
   DEFAULT_PROJECT_PATTERNS: () => DEFAULT_PROJECT_PATTERNS,
   createDiscoveredFileMatcher: () => createDiscoveredFileMatcher,
   discoverProjectFiles: () => discoverProjectFiles,
+  discoverProjectFilesWithGitCandidates: () => discoverProjectFilesWithGitCandidates,
   filterRealPathsWithinRoot: () => filterRealPathsWithinRoot,
   isRelativePathInside: () => isRelativePathInside,
   listProjectFiles: () => listProjectFiles,
+  listProjectFilesWithGitCandidates: () => listProjectFilesWithGitCandidates,
   matchesDiscoveryGlob: () => matchesDiscoveryGlob,
   translateGlobRootIgnoreGlobsForScanRoot: () => translateGlobRootIgnoreGlobsForScanRoot
 });
 import fs6 from "node:fs";
 import fsp5 from "node:fs/promises";
 import path9 from "node:path";
+function createPathCheckProgressReporter(total, onProgress) {
+  onProgress?.(0, total);
+  let completed = 0;
+  return () => {
+    completed += 1;
+    if (completed === total || completed % 100 === 0)
+      onProgress?.(completed, total);
+  };
+}
 function isPresent(value) {
   return value !== void 0;
 }
@@ -14187,20 +14235,34 @@ function parseGitignoreRule(baseDir, rawLine) {
     matches
   };
 }
-async function buildGitignoreIndex(sources) {
-  const sorted = [...sources].map(({ file: file2, baseDir }) => ({ file: normalizePath(file2), baseDir: normalizePath(baseDir) })).sort((left, right) => {
-    const leftFile = left.file;
-    const rightFile = right.file;
-    const depthDelta = leftFile.split("/").length - rightFile.split("/").length;
-    if (depthDelta !== 0)
-      return depthDelta;
-    if (leftFile < rightFile)
+async function buildGitignoreIndex(sources, repositoryRoots = [], repositoryAliases = []) {
+  const sorted = [...sources].map(({ file: file2, baseDir, repositoryRoot, priority }) => ({
+    file: normalizePath(file2),
+    baseDir: normalizePath(baseDir),
+    priority: priority ?? 2,
+    ...repositoryRoot === void 0 ? {} : { repositoryRoot: normalizePath(repositoryRoot) }
+  })).sort((left, right) => {
+    const baseDepthDelta = left.baseDir.split("/").length - right.baseDir.split("/").length;
+    if (baseDepthDelta !== 0)
+      return baseDepthDelta;
+    const priorityDelta = left.priority - right.priority;
+    if (priorityDelta !== 0)
+      return priorityDelta;
+    if (left.file < right.file)
       return -1;
-    return leftFile > rightFile ? 1 : 0;
+    return left.file > right.file ? 1 : 0;
   });
-  const gitignoreIndex = { hasRules: false, byBaseDir: /* @__PURE__ */ new Map() };
-  for (const { file: file2, baseDir } of sorted) {
-    if (isIgnoredByGitignore(file2, gitignoreIndex)) {
+  const gitignoreIndex = {
+    hasRules: false,
+    repositoryRoots: Array.from(new Set(repositoryRoots.map(normalizePath))).sort((left, right) => right.length - left.length),
+    repositoryAliases: Array.from(new Map(repositoryAliases.map(({ path: aliasPath, repositoryRoot }) => [
+      fileIdentityKey(aliasPath),
+      { path: normalizePath(aliasPath), repositoryRoot: normalizePath(repositoryRoot) }
+    ])).values()).sort((left, right) => right.path.length - left.path.length),
+    byBaseDir: /* @__PURE__ */ new Map()
+  };
+  for (const { file: file2, baseDir, repositoryRoot } of sorted) {
+    if (isIgnoredByGitignore(path9.dirname(file2), gitignoreIndex, true)) {
       continue;
     }
     let raw;
@@ -14218,7 +14280,7 @@ async function buildGitignoreIndex(sources) {
       if (existing)
         existing.rules.push(rule);
       else
-        gitignoreIndex.byBaseDir.set(baseKey, { baseDir, rules: [rule] });
+        gitignoreIndex.byBaseDir.set(baseKey, { baseDir, repositoryRoot, rules: [rule] });
       gitignoreIndex.hasRules = true;
     }
   }
@@ -14247,9 +14309,10 @@ async function loadGitignoreIndexForRootAliases(projectRoot) {
   }
   return await buildGitignoreIndex(sources);
 }
-function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
+function isIgnoredByGitignore(absolutePath, gitignoreIndex, isDirectory2 = false) {
   if (!gitignoreIndex.hasRules)
     return false;
+  const owningRepositoryRoot = gitignoreIndex.repositoryRoots.find((root) => isFilePathWithinRoot(root, absolutePath)) ?? gitignoreIndex.repositoryAliases.find(({ path: aliasPath }) => isFilePathWithinRoot(aliasPath, absolutePath))?.repositoryRoot;
   const chain = [];
   let current = normalizePath(path9.dirname(absolutePath));
   for (; ; ) {
@@ -14264,6 +14327,9 @@ function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
   let ignored = false;
   for (let depth = chain.length - 1; depth >= 0; depth -= 1) {
     const group = chain[depth];
+    if (group.repositoryRoot !== void 0 && owningRepositoryRoot !== void 0 && fileIdentityKey(group.repositoryRoot) !== fileIdentityKey(owningRepositoryRoot)) {
+      continue;
+    }
     const relativePath3 = path9.relative(group.baseDir, absolutePath);
     if (!isRelativePathInside(relativePath3)) {
       continue;
@@ -14271,10 +14337,11 @@ function isIgnoredByGitignore(absolutePath, gitignoreIndex) {
     const normalizedRelativePath2 = normalizePath(relativePath3);
     const hasSeparator = normalizedRelativePath2.includes("/");
     for (const rule of group.rules) {
-      if (rule.dirOnly && !hasSeparator) {
+      if (rule.dirOnly && !hasSeparator && !isDirectory2) {
         continue;
       }
-      if (rule.matches(normalizedRelativePath2)) {
+      const matchesDirectory = isDirectory2 && rule.dirOnly && rule.matches(`${normalizedRelativePath2}/.directory`);
+      if (rule.matches(normalizedRelativePath2) || matchesDirectory) {
         ignored = !rule.negated;
       }
     }
@@ -14313,40 +14380,89 @@ function collectCandidateAncestorDirectories(root, files) {
   }
   return directories;
 }
-async function findGitIgnoreSources(root, files) {
-  const directories = collectCandidateAncestorDirectories(root, files);
-  const present = await mapLimitSemaphore(directories, REALPATH_FILTER_CONCURRENCY, async (directory) => {
-    const candidate = normalizePath(path9.join(directory, ".gitignore"));
-    try {
-      return (await fsp5.stat(candidate)).isFile() ? { file: candidate, baseDir: directory } : null;
-    } catch {
-      return null;
-    }
-  });
-  const sources = present.filter((entry) => entry !== null);
-  sources.push(...await listGitExcludeFiles(root));
+async function findGitIgnoreSources(sourceRoots, files) {
+  const roots = Array.from(new Map(sourceRoots.map(({ path: sourceRoot, repositoryRoot }) => [
+    fileIdentityKey(sourceRoot),
+    { path: normalizePath(sourceRoot), repositoryRoot: normalizePath(repositoryRoot) }
+  ])).values());
+  const sources = [];
+  for (const { path: sourceRoot, repositoryRoot } of roots) {
+    const directories = collectCandidateAncestorDirectories(sourceRoot, files.filter((file2) => isFilePathWithinRoot(sourceRoot, file2)));
+    const present = await mapLimitSemaphore(directories, REALPATH_FILTER_CONCURRENCY, async (directory) => {
+      const candidate = normalizePath(path9.join(directory, ".gitignore"));
+      try {
+        return (await fsp5.stat(candidate)).isFile() ? { file: candidate, baseDir: directory, repositoryRoot, priority: 2 } : null;
+      } catch {
+        return null;
+      }
+    });
+    sources.push(...present.filter((entry) => entry !== null));
+    sources.push(...(await listGitExcludeFiles(sourceRoot)).map((source) => ({
+      ...source,
+      repositoryRoot: source.baseDir
+    })));
+  }
   return sources;
 }
 async function listGitCandidateFiles(root, logLevel) {
   try {
-    if (!await isGitRepo(root))
+    const realRoot = normalizePath(await fsp5.realpath(root));
+    const gitRoot = await isGitRepo(root) ? root : realRoot;
+    if (!await isGitRepo(gitRoot))
+      return null;
+    if (await isGitProjectRootIgnored(realRoot))
       return null;
-    if (await isGitProjectRootIgnored(root))
+    const gitRepositoryRoot = await getGitRepositoryRoot(gitRoot);
+    if (!gitRepositoryRoot)
       return null;
     const [tracked, untracked, submoduleDirectories] = await Promise.all([
-      listTrackedFiles(root, { recurseSubmodules: true, ...logLevel === void 0 ? {} : { logLevel } }),
-      listUntrackedFiles(root, { respectGitignore: true }),
-      listGitSubmoduleDirectories(root, { recurse: true })
+      listTrackedFiles(gitRoot, { recurseSubmodules: true, ...logLevel === void 0 ? {} : { logLevel } }),
+      listUntrackedFiles(gitRoot, { respectGitignore: true }),
+      listGitSubmoduleDirectories(gitRoot, { recurse: true })
     ]);
-    const submoduleUntracked = await Promise.all(submoduleDirectories.map(async (directory) => await listUntrackedFiles(directory, { respectGitignore: true })));
-    const files = Array.from(/* @__PURE__ */ new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
-    return { files, gitignoreFiles: await findGitIgnoreSources(root, files) };
+    const submoduleRoots = await Promise.all(submoduleDirectories.map(async (logicalPath) => ({
+      logicalPath: normalizePath(logicalPath),
+      physicalPath: normalizePath(await fsp5.realpath(logicalPath).catch(() => logicalPath))
+    })));
+    const submoduleUntracked = await Promise.all(submoduleRoots.map(async ({ physicalPath }) => await listUntrackedFiles(physicalPath, { respectGitignore: true })));
+    const rawFiles = Array.from(/* @__PURE__ */ new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
+    const needsLogicalRemap = normalizePath(gitRoot) !== normalizePath(root);
+    const files = Array.from(new Set(rawFiles.map((file2) => needsLogicalRemap && isFilePathWithinRoot(realRoot, file2) ? normalizePath(path9.resolve(root, path9.relative(realRoot, file2))) : normalizePath(file2)))).sort();
+    const physicalFiles = normalizePath(root) === realRoot ? [] : (await mapLimitSemaphore(files, REALPATH_FILTER_CONCURRENCY, async (file2) => {
+      try {
+        return normalizePath(await fsp5.realpath(file2));
+      } catch {
+        return null;
+      }
+    })).filter((file2) => file2 !== null);
+    const gitignoreRoots = [gitRepositoryRoot, ...submoduleRoots.map(({ physicalPath }) => physicalPath)].map(normalizePath);
+    const sourceRoots = [
+      { path: root, repositoryRoot: gitRepositoryRoot },
+      { path: realRoot, repositoryRoot: gitRepositoryRoot },
+      { path: gitRepositoryRoot, repositoryRoot: gitRepositoryRoot },
+      ...submoduleRoots.flatMap(({ logicalPath, physicalPath }) => [
+        { path: logicalPath, repositoryRoot: physicalPath },
+        { path: physicalPath, repositoryRoot: physicalPath }
+      ])
+    ];
+    return {
+      files,
+      gitignoreFiles: await findGitIgnoreSources(sourceRoots, [...rawFiles, ...files, ...physicalFiles]),
+      gitignoreRoots,
+      gitignoreAliases: sourceRoots
+    };
   } catch (error51) {
     logWithLevel(logLevel, "debug", `Git discovery unavailable for ${root}: ${stringifyUnknown(error51)}`);
     return null;
   }
 }
 async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
+  return await listProjectFilesInternal(projectRoot, patterns, options);
+}
+async function listProjectFilesWithGitCandidates(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
+  return await listProjectFilesInternal(projectRoot, patterns, options);
+}
+async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS, options) {
   const root = await ensureDirectoryReadable(projectRoot, "Project root");
   const globRoot = options?.globRoot ? await ensureDirectoryReadable(options.globRoot, "Glob root") : root;
   const includeGlobs = (options?.includeGlobs ?? []).map(normalizeGlobPattern).filter(Boolean);
@@ -14364,10 +14480,14 @@ async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS
   try {
     const useGitignore = options?.useGitignore ?? true;
     const realRoot = await fsp5.realpath(root);
-    const gitCandidates = useGitignore && options?.gitignoreRoot === void 0 && normalizePath(realRoot) === normalizePath(root) ? await listGitCandidateFiles(root, options?.logLevel) : null;
+    const attemptedGitCandidates = useGitignore && options?.gitignoreRoot === void 0 && normalizePath(realRoot) === normalizePath(root);
+    const gitCandidates = attemptedGitCandidates ? await listGitCandidateFiles(root, options?.logLevel) : null;
+    if (attemptedGitCandidates) {
+      options?.onGitCandidatesDiscovered?.(gitCandidates);
+    }
     let gitignoreIndex = EMPTY_GITIGNORE_INDEX;
     if (useGitignore && gitCandidates) {
-      gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles);
+      gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases);
     } else if (useGitignore) {
       const gitignoreRoot = options?.gitignoreRoot ? await ensureDirectoryReadable(options.gitignoreRoot, "Gitignore root") : root;
       gitignoreIndex = await loadGitignoreIndexForRootAliases(gitignoreRoot);
@@ -14386,11 +14506,14 @@ async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS
       followSymbolicLinks: false,
       ignore: translatedUserIgnoreGlobs
     }) : [];
+    const reportSourceSymlinkChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking source symlinks", current, total }) : void 0;
+    const reportSourcePathChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking source file paths", current, total }) : void 0;
     const symlinkOptions = {
       globRoot,
       ...gitCandidates ? { candidatePaths: gitCandidates.files } : {},
       ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
-      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {}
+      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {},
+      ...reportSourceSymlinkChecks ? { onPathCheckProgress: reportSourceSymlinkChecks } : {}
     };
     const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, symlinkProbeIgnoreGlobs, symlinkOptions);
     const linkedFiles = await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, fastGlobIgnoreGlobs, {
@@ -14403,7 +14526,7 @@ async function listProjectFiles(projectRoot, patterns = DEFAULT_PROJECT_PATTERNS
       filterIgnoreGlobs: userIgnoreGlobs,
       resolvedSafeSymlinkDirectories: safeSymlinkDirectories
     });
-    const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot);
+    const rootSafeFiles = await filterRealPathsWithinRootEntries([...files, ...includedOverrideFiles, ...linkedFiles, ...linkedOverrideFiles], realRoot, reportSourcePathChecks);
     const seen = /* @__PURE__ */ new Set();
     return rootSafeFiles.map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath })).filter(({ filePath, realPath }) => {
       if (seen.has(filePath))
@@ -14471,10 +14594,20 @@ async function isSafeSymlinkDirectory(root, linkPath, realRoot) {
     return false;
   }
 }
+async function verifySafeSymlinkDirectories(root, realRoot, paths, onPathCheckProgress) {
+  const reportPathCheck = createPathCheckProgressReporter(paths.length, onPathCheckProgress);
+  const verified = await mapLimitSemaphore(Array.from(paths), REALPATH_FILTER_CONCURRENCY, async (linkPath) => {
+    try {
+      return await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null;
+    } finally {
+      reportPathCheck();
+    }
+  });
+  return verified.filter((entry) => entry !== null);
+}
 async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
   if (options.knownSymlinkDirectories !== void 0) {
-    const verified = await mapLimitSemaphore(Array.from(new Set(options.knownSymlinkDirectories)), REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
-    const resolved = verified.filter((entry) => entry !== null);
+    const resolved = await verifySafeSymlinkDirectories(root, realRoot, Array.from(new Set(options.knownSymlinkDirectories)), options.onPathCheckProgress);
     options.onSymlinkDirectoriesDiscovered?.(resolved, "known");
     return resolved;
   }
@@ -14486,8 +14619,7 @@ async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
         return false;
       return !ignoreMatchers.some((matcher) => matcher(relativePath3));
     });
-    const verified = await mapLimitSemaphore(candidatePaths, REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
-    const discovered2 = verified.filter((entry) => entry !== null);
+    const discovered2 = await verifySafeSymlinkDirectories(root, realRoot, candidatePaths, options.onPathCheckProgress);
     options.onSymlinkDirectoriesDiscovered?.(discovered2, "git-candidates");
     return discovered2;
   }
@@ -14500,8 +14632,7 @@ async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
     objectMode: true,
     ignore
   });
-  const candidates = await mapLimitSemaphore(entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), REALPATH_FILTER_CONCURRENCY, async (linkPath) => await isSafeSymlinkDirectory(root, linkPath, realRoot) ? linkPath : null);
-  const discovered = candidates.filter((entry) => entry !== null);
+  const discovered = await verifySafeSymlinkDirectories(root, realRoot, entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), options.onPathCheckProgress);
   options.onSymlinkDirectoriesDiscovered?.(discovered, "filesystem");
   return discovered;
 }
@@ -14533,19 +14664,22 @@ async function listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, i
   }
   return [...filesByPath.values()];
 }
-async function filterRealPathsWithinRootEntries(paths, realRoot) {
+async function filterRealPathsWithinRootEntries(paths, realRoot, onPathCheckProgress) {
+  const reportPathCheck = createPathCheckProgressReporter(paths.length, onPathCheckProgress);
   const filtered = await mapLimitSemaphore(paths, REALPATH_FILTER_CONCURRENCY, async (filePath) => {
     try {
       const realPath = await fsp5.realpath(filePath);
       return isFilePathWithinRoot(realRoot, realPath) ? { path: filePath, realPath } : null;
     } catch {
       return null;
+    } finally {
+      reportPathCheck();
     }
   });
   return filtered.filter((entry) => entry !== null);
 }
-async function filterRealPathsWithinRoot(paths, realRoot) {
-  const entries = await filterRealPathsWithinRootEntries(paths, realRoot);
+async function filterRealPathsWithinRoot(paths, realRoot, onPathCheckProgress) {
+  const entries = await filterRealPathsWithinRootEntries(paths, realRoot, onPathCheckProgress);
   return entries.map((entry) => entry.path);
 }
 function toProjectGlob(pattern) {
@@ -14580,27 +14714,94 @@ async function buildProjectFileInfo(def, filePath) {
   };
 }
 async function discoverProjectFiles(projectRoot, options) {
+  return await discoverProjectFilesInternal(projectRoot, options);
+}
+async function discoverProjectFilesWithGitCandidates(projectRoot, options) {
+  return await discoverProjectFilesInternal(projectRoot, options);
+}
+async function discoverProjectFilesInternal(projectRoot, options) {
   const root = await ensureDirectoryReadable(projectRoot, "Project root");
   try {
     const realRoot = await fsp5.realpath(root);
-    const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((def) => def.patterns.map(toProjectGlob));
-    const matches = await (0, import_fast_glob2.default)(allPatterns, {
-      cwd: root,
-      absolute: true,
-      dot: true,
-      followSymbolicLinks: false,
-      ignore: DEFAULT_PROJECT_FILE_IGNORES,
-      markDirectories: true,
-      onlyFiles: false
-    });
-    const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
-      markDirectories: true,
-      onlyFiles: false,
-      ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
-      ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {}
-    });
-    const rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => match.endsWith("/") ? match.slice(0, -1) : match), realRoot);
     const projectFileDefinitionMatchers = PROJECT_FILE_DEFINITIONS.map((definition) => definition.patterns.map((pattern) => pattern.includes("*") || pattern.includes("?") ? new RegExp("^" + pattern.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$") : void 0));
+    const matchesDefinition = (fileName, definitionIndex) => {
+      const definition = PROJECT_FILE_DEFINITIONS[definitionIndex];
+      return definition.patterns.some((pattern, patternIndex) => {
+        const matcher = projectFileDefinitionMatchers[definitionIndex][patternIndex];
+        return matcher ? matcher.test(fileName) : pattern === fileName;
+      });
+    };
+    let gitCandidates;
+    if (options?.knownGitCandidates !== void 0) {
+      gitCandidates = options.knownGitCandidates;
+    } else {
+      gitCandidates = await listGitCandidateFiles(root, options?.logLevel);
+    }
+    options?.onGitCandidatesDiscovered?.(gitCandidates);
+    const reportMetadataSymlinkChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata symlinks", current, total }) : void 0;
+    const reportMetadataFileChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata files", current, total }) : void 0;
+    const reportMetadataDirectoryChecks = options?.onDiscoveryProgress ? (current, total) => options.onDiscoveryProgress?.({ activity: "Checking project metadata directories", current, total }) : void 0;
+    let rootSafeMatches;
+    if (gitCandidates) {
+      const gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases);
+      const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((globPattern) => (0, import_picomatch.default)(globPattern, { dot: true }));
+      const filterGitIgnoredEntries = (entries2, directoryKeys = /* @__PURE__ */ new Set()) => entries2.map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath })).filter(({ filePath, realPath }) => {
+        const isDirectory2 = directoryKeys.has(fileIdentityKey(filePath));
+        const rootRelative = normalizePath(path9.relative(root, filePath));
+        if (!isRelativePathInside(rootRelative))
+          return false;
+        if (defaultIgnoreMatchers.some((matcher) => matcher(rootRelative)))
+          return false;
+        if (isIgnoredByGitignore(filePath, gitignoreIndex, isDirectory2))
+          return false;
+        return normalizePath(realPath) === filePath || !isIgnoredByGitignore(realPath, gitignoreIndex, isDirectory2);
+      }).map(({ filePath }) => filePath);
+      const symlinkOptions = {
+        candidatePaths: gitCandidates.files,
+        ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
+        ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {},
+        ...reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}
+      };
+      const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, DEFAULT_PROJECT_FILE_IGNORES, symlinkOptions);
+      const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((definition) => definition.patterns.map(toProjectGlob));
+      const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
+        markDirectories: true,
+        onlyFiles: false,
+        resolvedSafeSymlinkDirectories: safeSymlinkDirectories
+      });
+      const rootSafeCandidateEntries = await filterRealPathsWithinRootEntries(gitCandidates.files, realRoot, reportMetadataFileChecks);
+      const filteredFiles = filterGitIgnoredEntries(rootSafeCandidateEntries);
+      const fileMatches = filteredFiles.filter((file2) => PROJECT_FILE_DEFINITIONS.some((definition, definitionIndex) => definition.kind === "file" && matchesDefinition(path9.basename(file2), definitionIndex)));
+      const rawCandidateDirectories = collectCandidateAncestorDirectories(root, rootSafeCandidateEntries.map(({ path: filePath }) => filePath));
+      const candidateDirectoryKeys = new Set(rawCandidateDirectories.map(fileIdentityKey));
+      const safeSymlinkDirectoryKeys = new Set(safeSymlinkDirectories.map(fileIdentityKey));
+      const directoryMatches = [
+        ...filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(rawCandidateDirectories, realRoot, reportMetadataDirectoryChecks), candidateDirectoryKeys),
+        ...filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(safeSymlinkDirectories, realRoot, reportMetadataDirectoryChecks), safeSymlinkDirectoryKeys)
+      ].filter((directory) => PROJECT_FILE_DEFINITIONS.some((definition, definitionIndex) => definition.kind === "dir" && matchesDefinition(path9.basename(directory), definitionIndex)));
+      const linkedDirectoryKeys = new Set(linkedMatches.filter((match) => match.endsWith("/")).map((match) => fileIdentityKey(match.slice(0, -1))));
+      const rootSafeLinked = filterGitIgnoredEntries(await filterRealPathsWithinRootEntries(linkedMatches.map((match) => match.endsWith("/") ? match.slice(0, -1) : match), realRoot, reportMetadataFileChecks), linkedDirectoryKeys);
+      rootSafeMatches = [...fileMatches, ...directoryMatches, ...rootSafeLinked];
+    } else {
+      const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((definition) => definition.patterns.map(toProjectGlob));
+      const matches = await (0, import_fast_glob2.default)(allPatterns, {
+        cwd: root,
+        absolute: true,
+        dot: true,
+        followSymbolicLinks: false,
+        ignore: DEFAULT_PROJECT_FILE_IGNORES,
+        markDirectories: true,
+        onlyFiles: false
+      });
+      const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
+        markDirectories: true,
+        onlyFiles: false,
+        ...options?.knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: options.knownSymlinkDirectories } : {},
+        ...options?.onSymlinkDirectoriesDiscovered ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered } : {},
+        ...reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}
+      });
+      rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => match.endsWith("/") ? match.slice(0, -1) : match), realRoot, reportMetadataFileChecks);
+    }
     const entries = [];
     const matchTasks = rootSafeMatches.map(async (cleanMatch) => {
       const stats = await fsp5.stat(cleanMatch);
@@ -14612,10 +14813,7 @@ async function discoverProjectFiles(projectRoot, options) {
           continue;
         if (!isDir && def.kind !== "file")
           continue;
-        const matchesPattern = def.patterns.some((pattern, patternIndex) => {
-          const matcher = projectFileDefinitionMatchers[definitionIndex][patternIndex];
-          return matcher ? matcher.test(fileName) : pattern === fileName;
-        });
+        const matchesPattern = matchesDefinition(fileName, definitionIndex);
         if (matchesPattern) {
           entries.push(await buildProjectFileInfo(def, cleanMatch));
         }
@@ -14742,7 +14940,12 @@ var init_projectFiles = __esm({
       ...DEFAULT_PROJECT_MANIFESTS.map((name) => `**/${name}`)
     ];
     REALPATH_FILTER_CONCURRENCY = 64;
-    EMPTY_GITIGNORE_INDEX = { hasRules: false, byBaseDir: /* @__PURE__ */ new Map() };
+    EMPTY_GITIGNORE_INDEX = {
+      hasRules: false,
+      repositoryRoots: [],
+      repositoryAliases: [],
+      byBaseDir: /* @__PURE__ */ new Map()
+    };
   }
 });
 
@@ -25606,12 +25809,210 @@ var init_adjacency = __esm({
   }
 });
 
+// dist/util/bloomFilter.js
+var bloomFilter_exports = {};
+__export(bloomFilter_exports, {
+  BloomFilter: () => BloomFilter,
+  BloomFilterCache: () => BloomFilterCache,
+  buildBloomFilterFromSource: () => buildBloomFilterFromSource,
+  calculateOptimalBloomParams: () => calculateOptimalBloomParams
+});
+import crypto3 from "node:crypto";
+function calculateOptimalBloomParams(expectedItems, falsePositiveRate = 0.01) {
+  const n = Math.max(1, expectedItems);
+  const p = Math.max(1e-4, Math.min(0.5, falsePositiveRate));
+  const ln2 = Math.LN2;
+  const ln2Squared = ln2 * ln2;
+  const optimalSize = Math.ceil(-n * Math.log(p) / ln2Squared);
+  const optimalHashCount = Math.max(1, Math.round(optimalSize / n * ln2));
+  const size = Math.max(1e3, Math.min(1e6, optimalSize));
+  const hashCount = Math.max(1, Math.min(10, optimalHashCount));
+  return { size, hashCount };
+}
+function buildBloomFilterFromSource(source, support, falsePositiveRate = 0.01) {
+  const identifierPattern = new RegExp(BLOOM_FILTER_IDENTIFIER_SOURCE, "gu");
+  const matches = source.match(identifierPattern);
+  const unique = /* @__PURE__ */ new Set();
+  for (const identifier of matches ?? []) {
+    unique.add(support.normalizeIdentifier(identifier));
+  }
+  const filter = BloomFilter.createOptimal(unique.size || 100, falsePositiveRate);
+  for (const identifier of unique) {
+    filter.add(identifier);
+  }
+  return filter;
+}
+var BloomFilter, BloomFilterCache;
+var init_bloomFilter = __esm({
+  "dist/util/bloomFilter.js"() {
+    "use strict";
+    init_identifiers();
+    init_paths();
+    BloomFilter = class _BloomFilter {
+      bits;
+      size;
+      hashCount;
+      itemCount = 0;
+      /**
+       * Create a bloom filter
+       * @param size - Number of bits in the filter (default: 10000)
+       * @param hashCount - Number of hash functions to use (default: 3)
+       */
+      constructor(size = 1e4, hashCount = 3) {
+        this.size = size;
+        this.hashCount = hashCount;
+        this.bits = new Uint8Array(Math.ceil(size / 8));
+      }
+      /**
+       * Create an optimally-sized bloom filter for the expected number of items.
+       * @param expectedItems - Expected number of items to be added
+       * @param falsePositiveRate - Target false positive rate (default: 0.01 = 1%)
+       */
+      static createOptimal(expectedItems, falsePositiveRate = 0.01) {
+        const { size, hashCount } = calculateOptimalBloomParams(expectedItems, falsePositiveRate);
+        return new _BloomFilter(size, hashCount);
+      }
+      /**
+       * Add an item to the bloom filter
+       */
+      add(item) {
+        for (const hash2 of this.getHashes(item)) {
+          const byteIndex = Math.floor(hash2 / 8);
+          const bitIndex = hash2 % 8;
+          if (byteIndex < 0 || byteIndex >= this.bits.length)
+            return;
+          const currentByte = this.bits[byteIndex];
+          if (currentByte !== void 0) {
+            this.bits[byteIndex] = currentByte | 1 << bitIndex;
+          }
+        }
+        this.itemCount++;
+      }
+      /**
+       * Get the number of items added to the filter
+       */
+      getItemCount() {
+        return this.itemCount;
+      }
+      /**
+       * Get the current estimated false positive rate based on items added
+       */
+      getCurrentFalsePositiveRate() {
+        return this.getFalsePositiveRate(this.itemCount);
+      }
+      /**
+       * Check if an item might be in the set
+       * Returns false if definitely not present, true if might be present
+       */
+      mightContain(item) {
+        for (const hash2 of this.getHashes(item)) {
+          const byteIndex = Math.floor(hash2 / 8);
+          const bitIndex = hash2 % 8;
+          if (byteIndex < 0 || byteIndex >= this.bits.length)
+            return false;
+          const currentByte = this.bits[byteIndex];
+          if (currentByte === void 0 || (currentByte & 1 << bitIndex) === 0) {
+            return false;
+          }
+        }
+        return true;
+      }
+      /**
+       * Generate multiple hash values for an item
+       */
+      *getHashes(item) {
+        const hash2 = crypto3.createHash("sha256").update(item).digest();
+        for (let i = 0; i < this.hashCount; i++) {
+          const offset = i * 4 % (hash2.length - 4);
+          const value = hash2.readUInt32LE(offset);
+          yield value % this.size;
+        }
+      }
+      /**
+       * Get the approximate false positive rate
+       */
+      getFalsePositiveRate(itemCount) {
+        const exp = Math.exp(-this.hashCount * itemCount / this.size);
+        return Math.pow(1 - exp, this.hashCount);
+      }
+      /**
+       * Serialize to buffer for caching
+       */
+      toBuffer() {
+        return Buffer.from(this.bits);
+      }
+      /**
+       * Deserialize from buffer
+       */
+      static fromBuffer(buffer, size, hashCount, itemCount = 0) {
+        const filter = new _BloomFilter(size, hashCount);
+        filter.bits = new Uint8Array(buffer);
+        filter.itemCount = itemCount;
+        return filter;
+      }
+      /**
+       * Get metadata for serialization
+       */
+      getMetadata() {
+        return { size: this.size, hashCount: this.hashCount };
+      }
+    };
+    BloomFilterCache = class {
+      filters = /* @__PURE__ */ new Map();
+      set(file2, filter) {
+        this.filters.set(fileIdentityKey(file2), filter);
+      }
+      get(file2) {
+        return this.filters.get(fileIdentityKey(file2));
+      }
+      has(file2) {
+        return this.filters.has(fileIdentityKey(file2));
+      }
+      /**
+       * Check if a symbol might be in any of the provided files
+       * Returns only files that might contain the symbol
+       */
+      filterFiles(symbol2, files) {
+        const candidates = [];
+        for (const file2 of files) {
+          const filter = this.filters.get(fileIdentityKey(file2));
+          if (!filter) {
+            candidates.push(file2);
+          } else if (filter.mightContain(symbol2)) {
+            candidates.push(file2);
+          }
+        }
+        return candidates;
+      }
+      clear() {
+        this.filters.clear();
+      }
+      size() {
+        return this.filters.size;
+      }
+    };
+  }
+});
+
 // dist/worker/nativeExtractWorker.js
 import fsp17 from "node:fs/promises";
 import { createRequire as createRequire3 } from "node:module";
 import path32 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 import { isMainThread, workerData } from "node:worker_threads";
+function buildBloomFilterPayload(source, languageId) {
+  const support = supportById(languageId);
+  if (!support)
+    return void 0;
+  const filter = buildBloomFilterFromSource(source, support);
+  const { size, hashCount } = filter.getMetadata();
+  return {
+    bits: filter.toBuffer(),
+    size,
+    hashCount,
+    itemCount: filter.getItemCount()
+  };
+}
 function readWorkerBindingHandoff(source = isMainThread ? void 0 : workerData) {
   if (!source || typeof source !== "object")
     return null;
@@ -25647,7 +26048,7 @@ function resolveSourceMaxBytes(task) {
   }
   return DEFAULT_NATIVE_SOURCE_MAX_BYTES;
 }
-function resourceLimitFallback(task, source, error51) {
+function resourceLimitFallback(task, source, error51, bloomFilter) {
   const includeSource = task.includeSourceInResult ?? true;
   return {
     filePath: task.filePath,
@@ -25656,6 +26057,7 @@ function resourceLimitFallback(task, source, error51) {
     nativeResults: null,
     compactResults: null,
     syntaxTree: null,
+    ...bloomFilter ? { bloomFilter } : {},
     fallbackReason: "queryFailure",
     error: error51
   };
@@ -25721,6 +26123,7 @@ function createNativeExtractor(deps) {
     }
     const includeSource = task.includeSourceInResult ?? true;
     const source = loaded.source;
+    const bloomFilter = task.includeBloomFilter ? buildBloomFilterPayload(source, task.languageId) : void 0;
     if (!binding || !supportedIds) {
       return {
         filePath: task.filePath,
@@ -25729,6 +26132,7 @@ function createNativeExtractor(deps) {
         nativeResults: null,
         compactResults: null,
         syntaxTree: null,
+        ...bloomFilter ? { bloomFilter } : {},
         fallbackReason: "unavailable",
         ...loadError ? { error: loadError } : {}
       };
@@ -25741,6 +26145,7 @@ function createNativeExtractor(deps) {
         nativeResults: null,
         compactResults: null,
         syntaxTree: null,
+        ...bloomFilter ? { bloomFilter } : {},
         fallbackReason: "unsupportedLanguage"
       };
     }
@@ -25753,7 +26158,8 @@ function createNativeExtractor(deps) {
           ...includeSource ? { source } : {},
           nativeResults: null,
           compactResults,
-          syntaxTree: null
+          syntaxTree: null,
+          ...bloomFilter ? { bloomFilter } : {}
         };
       }
       const extraction = binding.extractLanguage(source, task.languageId, task.importsQuery, task.exportsQuery, task.localsQuery, task.importBindingsQuery);
@@ -25767,6 +26173,7 @@ function createNativeExtractor(deps) {
           nativeResults: extraction.results,
           compactResults: null,
           syntaxTree: null,
+          ...bloomFilter ? { bloomFilter } : {},
           fallbackReason: "unavailable",
           error: loadError
         };
@@ -25777,12 +26184,13 @@ function createNativeExtractor(deps) {
         ...includeSource ? { source } : {},
         nativeResults: extraction.results,
         compactResults: null,
-        syntaxTree
+        syntaxTree,
+        ...bloomFilter ? { bloomFilter } : {}
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       if (/max (node|depth) limit/i.test(message)) {
-        return resourceLimitFallback(task, source, message);
+        return resourceLimitFallback(task, source, message, bloomFilter);
       }
       return {
         filePath: task.filePath,
@@ -25791,6 +26199,7 @@ function createNativeExtractor(deps) {
         nativeResults: null,
         compactResults: null,
         syntaxTree: null,
+        ...bloomFilter ? { bloomFilter } : {},
         fallbackReason: "queryFailure",
         error: message
       };
@@ -25803,6 +26212,8 @@ var init_nativeExtractWorker = __esm({
     "use strict";
     init_bindingLoader();
     init_treeShape();
+    init_languages();
+    init_bloomFilter();
     init_treeShape();
     NATIVE_WORKER_BATCH_SIZE = 32;
     DEFAULT_NATIVE_SOURCE_MAX_BYTES = 8 * 1024 * 1024;
@@ -28504,190 +28915,6 @@ var init_locals_and_exports = __esm({
   }
 });
 
-// dist/util/bloomFilter.js
-var bloomFilter_exports = {};
-__export(bloomFilter_exports, {
-  BloomFilter: () => BloomFilter,
-  BloomFilterCache: () => BloomFilterCache,
-  buildBloomFilterFromSource: () => buildBloomFilterFromSource,
-  calculateOptimalBloomParams: () => calculateOptimalBloomParams
-});
-import crypto3 from "node:crypto";
-function calculateOptimalBloomParams(expectedItems, falsePositiveRate = 0.01) {
-  const n = Math.max(1, expectedItems);
-  const p = Math.max(1e-4, Math.min(0.5, falsePositiveRate));
-  const ln2 = Math.LN2;
-  const ln2Squared = ln2 * ln2;
-  const optimalSize = Math.ceil(-n * Math.log(p) / ln2Squared);
-  const optimalHashCount = Math.max(1, Math.round(optimalSize / n * ln2));
-  const size = Math.max(1e3, Math.min(1e6, optimalSize));
-  const hashCount = Math.max(1, Math.min(10, optimalHashCount));
-  return { size, hashCount };
-}
-function buildBloomFilterFromSource(source, support, falsePositiveRate = 0.01) {
-  const identifierPattern = new RegExp(BLOOM_FILTER_IDENTIFIER_SOURCE, "gu");
-  const matches = source.match(identifierPattern);
-  const unique = /* @__PURE__ */ new Set();
-  for (const identifier of matches ?? []) {
-    unique.add(support.normalizeIdentifier(identifier));
-  }
-  const filter = BloomFilter.createOptimal(unique.size || 100, falsePositiveRate);
-  for (const identifier of unique) {
-    filter.add(identifier);
-  }
-  return filter;
-}
-var BloomFilter, BloomFilterCache;
-var init_bloomFilter = __esm({
-  "dist/util/bloomFilter.js"() {
-    "use strict";
-    init_identifiers();
-    init_paths();
-    BloomFilter = class _BloomFilter {
-      bits;
-      size;
-      hashCount;
-      itemCount = 0;
-      /**
-       * Create a bloom filter
-       * @param size - Number of bits in the filter (default: 10000)
-       * @param hashCount - Number of hash functions to use (default: 3)
-       */
-      constructor(size = 1e4, hashCount = 3) {
-        this.size = size;
-        this.hashCount = hashCount;
-        this.bits = new Uint8Array(Math.ceil(size / 8));
-      }
-      /**
-       * Create an optimally-sized bloom filter for the expected number of items.
-       * @param expectedItems - Expected number of items to be added
-       * @param falsePositiveRate - Target false positive rate (default: 0.01 = 1%)
-       */
-      static createOptimal(expectedItems, falsePositiveRate = 0.01) {
-        const { size, hashCount } = calculateOptimalBloomParams(expectedItems, falsePositiveRate);
-        return new _BloomFilter(size, hashCount);
-      }
-      /**
-       * Add an item to the bloom filter
-       */
-      add(item) {
-        for (const hash2 of this.getHashes(item)) {
-          const byteIndex = Math.floor(hash2 / 8);
-          const bitIndex = hash2 % 8;
-          if (byteIndex < 0 || byteIndex >= this.bits.length)
-            return;
-          const currentByte = this.bits[byteIndex];
-          if (currentByte !== void 0) {
-            this.bits[byteIndex] = currentByte | 1 << bitIndex;
-          }
-        }
-        this.itemCount++;
-      }
-      /**
-       * Get the number of items added to the filter
-       */
-      getItemCount() {
-        return this.itemCount;
-      }
-      /**
-       * Get the current estimated false positive rate based on items added
-       */
-      getCurrentFalsePositiveRate() {
-        return this.getFalsePositiveRate(this.itemCount);
-      }
-      /**
-       * Check if an item might be in the set
-       * Returns false if definitely not present, true if might be present
-       */
-      mightContain(item) {
-        for (const hash2 of this.getHashes(item)) {
-          const byteIndex = Math.floor(hash2 / 8);
-          const bitIndex = hash2 % 8;
-          if (byteIndex < 0 || byteIndex >= this.bits.length)
-            return false;
-          const currentByte = this.bits[byteIndex];
-          if (currentByte === void 0 || (currentByte & 1 << bitIndex) === 0) {
-            return false;
-          }
-        }
-        return true;
-      }
-      /**
-       * Generate multiple hash values for an item
-       */
-      *getHashes(item) {
-        const hash2 = crypto3.createHash("sha256").update(item).digest();
-        for (let i = 0; i < this.hashCount; i++) {
-          const offset = i * 4 % (hash2.length - 4);
-          const value = hash2.readUInt32LE(offset);
-          yield value % this.size;
-        }
-      }
-      /**
-       * Get the approximate false positive rate
-       */
-      getFalsePositiveRate(itemCount) {
-        const exp = Math.exp(-this.hashCount * itemCount / this.size);
-        return Math.pow(1 - exp, this.hashCount);
-      }
-      /**
-       * Serialize to buffer for caching
-       */
-      toBuffer() {
-        return Buffer.from(this.bits);
-      }
-      /**
-       * Deserialize from buffer
-       */
-      static fromBuffer(buffer, size, hashCount) {
-        const filter = new _BloomFilter(size, hashCount);
-        filter.bits = new Uint8Array(buffer);
-        return filter;
-      }
-      /**
-       * Get metadata for serialization
-       */
-      getMetadata() {
-        return { size: this.size, hashCount: this.hashCount };
-      }
-    };
-    BloomFilterCache = class {
-      filters = /* @__PURE__ */ new Map();
-      set(file2, filter) {
-        this.filters.set(fileIdentityKey(file2), filter);
-      }
-      get(file2) {
-        return this.filters.get(fileIdentityKey(file2));
-      }
-      has(file2) {
-        return this.filters.has(fileIdentityKey(file2));
-      }
-      /**
-       * Check if a symbol might be in any of the provided files
-       * Returns only files that might contain the symbol
-       */
-      filterFiles(symbol2, files) {
-        const candidates = [];
-        for (const file2 of files) {
-          const filter = this.filters.get(fileIdentityKey(file2));
-          if (!filter) {
-            candidates.push(file2);
-          } else if (filter.mightContain(symbol2)) {
-            candidates.push(file2);
-          }
-        }
-        return candidates;
-      }
-      clear() {
-        this.filters.clear();
-      }
-      size() {
-        return this.filters.size;
-      }
-    };
-  }
-});
-
 // dist/languages/queryGenerator.js
 function generateChunkingQuery(def) {
   const parts = [];
@@ -29686,7 +29913,1509 @@ var init_duplicate_keywords = __esm({
   }
 });
 
+// dist/duplicate-identifier-ranges.js
+var DUPLICATE_IDENTIFIER_START_RANGES, DUPLICATE_IDENTIFIER_CONTINUE_RANGES;
+var init_duplicate_identifier_ranges = __esm({
+  "dist/duplicate-identifier-ranges.js"() {
+    "use strict";
+    DUPLICATE_IDENTIFIER_START_RANGES = [
+      [36, 36],
+      [65, 90],
+      [95, 95],
+      [97, 122],
+      [170, 170],
+      [181, 181],
+      [186, 186],
+      [192, 214],
+      [216, 246],
+      [248, 705],
+      [710, 721],
+      [736, 740],
+      [748, 748],
+      [750, 750],
+      [880, 884],
+      [886, 887],
+      [891, 893],
+      [895, 895],
+      [902, 902],
+      [904, 906],
+      [908, 908],
+      [910, 929],
+      [931, 1013],
+      [1015, 1153],
+      [1162, 1327],
+      [1329, 1366],
+      [1369, 1369],
+      [1376, 1416],
+      [1488, 1514],
+      [1519, 1522],
+      [1568, 1610],
+      [1646, 1647],
+      [1649, 1747],
+      [1749, 1749],
+      [1765, 1766],
+      [1774, 1775],
+      [1786, 1788],
+      [1791, 1791],
+      [1808, 1808],
+      [1810, 1839],
+      [1869, 1957],
+      [1969, 1969],
+      [1994, 2026],
+      [2036, 2037],
+      [2042, 2042],
+      [2048, 2069],
+      [2074, 2074],
+      [2084, 2084],
+      [2088, 2088],
+      [2112, 2136],
+      [2144, 2154],
+      [2160, 2183],
+      [2185, 2190],
+      [2208, 2249],
+      [2308, 2361],
+      [2365, 2365],
+      [2384, 2384],
+      [2392, 2401],
+      [2417, 2432],
+      [2437, 2444],
+      [2447, 2448],
+      [2451, 2472],
+      [2474, 2480],
+      [2482, 2482],
+      [2486, 2489],
+      [2493, 2493],
+      [2510, 2510],
+      [2524, 2525],
+      [2527, 2529],
+      [2544, 2545],
+      [2556, 2556],
+      [2565, 2570],
+      [2575, 2576],
+      [2579, 2600],
+      [2602, 2608],
+      [2610, 2611],
+      [2613, 2614],
+      [2616, 2617],
+      [2649, 2652],
+      [2654, 2654],
+      [2674, 2676],
+      [2693, 2701],
+      [2703, 2705],
+      [2707, 2728],
+      [2730, 2736],
+      [2738, 2739],
+      [2741, 2745],
+      [2749, 2749],
+      [2768, 2768],
+      [2784, 2785],
+      [2809, 2809],
+      [2821, 2828],
+      [2831, 2832],
+      [2835, 2856],
+      [2858, 2864],
+      [2866, 2867],
+      [2869, 2873],
+      [2877, 2877],
+      [2908, 2909],
+      [2911, 2913],
+      [2929, 2929],
+      [2947, 2947],
+      [2949, 2954],
+      [2958, 2960],
+      [2962, 2965],
+      [2969, 2970],
+      [2972, 2972],
+      [2974, 2975],
+      [2979, 2980],
+      [2984, 2986],
+      [2990, 3001],
+      [3024, 3024],
+      [3077, 3084],
+      [3086, 3088],
+      [3090, 3112],
+      [3114, 3129],
+      [3133, 3133],
+      [3160, 3162],
+      [3165, 3165],
+      [3168, 3169],
+      [3200, 3200],
+      [3205, 3212],
+      [3214, 3216],
+      [3218, 3240],
+      [3242, 3251],
+      [3253, 3257],
+      [3261, 3261],
+      [3293, 3294],
+      [3296, 3297],
+      [3313, 3314],
+      [3332, 3340],
+      [3342, 3344],
+      [3346, 3386],
+      [3389, 3389],
+      [3406, 3406],
+      [3412, 3414],
+      [3423, 3425],
+      [3450, 3455],
+      [3461, 3478],
+      [3482, 3505],
+      [3507, 3515],
+      [3517, 3517],
+      [3520, 3526],
+      [3585, 3632],
+      [3634, 3634],
+      [3648, 3654],
+      [3713, 3714],
+      [3716, 3716],
+      [3718, 3722],
+      [3724, 3747],
+      [3749, 3749],
+      [3751, 3760],
+      [3762, 3762],
+      [3773, 3773],
+      [3776, 3780],
+      [3782, 3782],
+      [3804, 3807],
+      [3840, 3840],
+      [3904, 3911],
+      [3913, 3948],
+      [3976, 3980],
+      [4096, 4138],
+      [4159, 4159],
+      [4176, 4181],
+      [4186, 4189],
+      [4193, 4193],
+      [4197, 4198],
+      [4206, 4208],
+      [4213, 4225],
+      [4238, 4238],
+      [4256, 4293],
+      [4295, 4295],
+      [4301, 4301],
+      [4304, 4346],
+      [4348, 4680],
+      [4682, 4685],
+      [4688, 4694],
+      [4696, 4696],
+      [4698, 4701],
+      [4704, 4744],
+      [4746, 4749],
+      [4752, 4784],
+      [4786, 4789],
+      [4792, 4798],
+      [4800, 4800],
+      [4802, 4805],
+      [4808, 4822],
+      [4824, 4880],
+      [4882, 4885],
+      [4888, 4954],
+      [4992, 5007],
+      [5024, 5109],
+      [5112, 5117],
+      [5121, 5740],
+      [5743, 5759],
+      [5761, 5786],
+      [5792, 5866],
+      [5870, 5880],
+      [5888, 5905],
+      [5919, 5937],
+      [5952, 5969],
+      [5984, 5996],
+      [5998, 6e3],
+      [6016, 6067],
+      [6103, 6103],
+      [6108, 6108],
+      [6176, 6264],
+      [6272, 6312],
+      [6314, 6314],
+      [6320, 6389],
+      [6400, 6430],
+      [6480, 6509],
+      [6512, 6516],
+      [6528, 6571],
+      [6576, 6601],
+      [6656, 6678],
+      [6688, 6740],
+      [6823, 6823],
+      [6917, 6963],
+      [6981, 6988],
+      [7043, 7072],
+      [7086, 7087],
+      [7098, 7141],
+      [7168, 7203],
+      [7245, 7247],
+      [7258, 7293],
+      [7296, 7306],
+      [7312, 7354],
+      [7357, 7359],
+      [7401, 7404],
+      [7406, 7411],
+      [7413, 7414],
+      [7418, 7418],
+      [7424, 7615],
+      [7680, 7957],
+      [7960, 7965],
+      [7968, 8005],
+      [8008, 8013],
+      [8016, 8023],
+      [8025, 8025],
+      [8027, 8027],
+      [8029, 8029],
+      [8031, 8061],
+      [8064, 8116],
+      [8118, 8124],
+      [8126, 8126],
+      [8130, 8132],
+      [8134, 8140],
+      [8144, 8147],
+      [8150, 8155],
+      [8160, 8172],
+      [8178, 8180],
+      [8182, 8188],
+      [8305, 8305],
+      [8319, 8319],
+      [8336, 8348],
+      [8450, 8450],
+      [8455, 8455],
+      [8458, 8467],
+      [8469, 8469],
+      [8472, 8477],
+      [8484, 8484],
+      [8486, 8486],
+      [8488, 8488],
+      [8490, 8505],
+      [8508, 8511],
+      [8517, 8521],
+      [8526, 8526],
+      [8544, 8584],
+      [11264, 11492],
+      [11499, 11502],
+      [11506, 11507],
+      [11520, 11557],
+      [11559, 11559],
+      [11565, 11565],
+      [11568, 11623],
+      [11631, 11631],
+      [11648, 11670],
+      [11680, 11686],
+      [11688, 11694],
+      [11696, 11702],
+      [11704, 11710],
+      [11712, 11718],
+      [11720, 11726],
+      [11728, 11734],
+      [11736, 11742],
+      [12293, 12295],
+      [12321, 12329],
+      [12337, 12341],
+      [12344, 12348],
+      [12353, 12438],
+      [12443, 12447],
+      [12449, 12538],
+      [12540, 12543],
+      [12549, 12591],
+      [12593, 12686],
+      [12704, 12735],
+      [12784, 12799],
+      [13312, 19903],
+      [19968, 42124],
+      [42192, 42237],
+      [42240, 42508],
+      [42512, 42527],
+      [42538, 42539],
+      [42560, 42606],
+      [42623, 42653],
+      [42656, 42735],
+      [42775, 42783],
+      [42786, 42888],
+      [42891, 42957],
+      [42960, 42961],
+      [42963, 42963],
+      [42965, 42972],
+      [42994, 43009],
+      [43011, 43013],
+      [43015, 43018],
+      [43020, 43042],
+      [43072, 43123],
+      [43138, 43187],
+      [43250, 43255],
+      [43259, 43259],
+      [43261, 43262],
+      [43274, 43301],
+      [43312, 43334],
+      [43360, 43388],
+      [43396, 43442],
+      [43471, 43471],
+      [43488, 43492],
+      [43494, 43503],
+      [43514, 43518],
+      [43520, 43560],
+      [43584, 43586],
+      [43588, 43595],
+      [43616, 43638],
+      [43642, 43642],
+      [43646, 43695],
+      [43697, 43697],
+      [43701, 43702],
+      [43705, 43709],
+      [43712, 43712],
+      [43714, 43714],
+      [43739, 43741],
+      [43744, 43754],
+      [43762, 43764],
+      [43777, 43782],
+      [43785, 43790],
+      [43793, 43798],
+      [43808, 43814],
+      [43816, 43822],
+      [43824, 43866],
+      [43868, 43881],
+      [43888, 44002],
+      [44032, 55203],
+      [55216, 55238],
+      [55243, 55291],
+      [63744, 64109],
+      [64112, 64217],
+      [64256, 64262],
+      [64275, 64279],
+      [64285, 64285],
+      [64287, 64296],
+      [64298, 64310],
+      [64312, 64316],
+      [64318, 64318],
+      [64320, 64321],
+      [64323, 64324],
+      [64326, 64433],
+      [64467, 64605],
+      [64612, 64829],
+      [64848, 64911],
+      [64914, 64967],
+      [65008, 65017],
+      [65137, 65137],
+      [65139, 65139],
+      [65143, 65143],
+      [65145, 65145],
+      [65147, 65147],
+      [65149, 65149],
+      [65151, 65276],
+      [65313, 65338],
+      [65345, 65370],
+      [65382, 65437],
+      [65440, 65470],
+      [65474, 65479],
+      [65482, 65487],
+      [65490, 65495],
+      [65498, 65500],
+      [65536, 65547],
+      [65549, 65574],
+      [65576, 65594],
+      [65596, 65597],
+      [65599, 65613],
+      [65616, 65629],
+      [65664, 65786],
+      [65856, 65908],
+      [66176, 66204],
+      [66208, 66256],
+      [66304, 66335],
+      [66349, 66378],
+      [66384, 66421],
+      [66432, 66461],
+      [66464, 66499],
+      [66504, 66511],
+      [66513, 66517],
+      [66560, 66717],
+      [66736, 66771],
+      [66776, 66811],
+      [66816, 66855],
+      [66864, 66915],
+      [66928, 66938],
+      [66940, 66954],
+      [66956, 66962],
+      [66964, 66965],
+      [66967, 66977],
+      [66979, 66993],
+      [66995, 67001],
+      [67003, 67004],
+      [67008, 67059],
+      [67072, 67382],
+      [67392, 67413],
+      [67424, 67431],
+      [67456, 67461],
+      [67463, 67504],
+      [67506, 67514],
+      [67584, 67589],
+      [67592, 67592],
+      [67594, 67637],
+      [67639, 67640],
+      [67644, 67644],
+      [67647, 67669],
+      [67680, 67702],
+      [67712, 67742],
+      [67808, 67826],
+      [67828, 67829],
+      [67840, 67861],
+      [67872, 67897],
+      [67968, 68023],
+      [68030, 68031],
+      [68096, 68096],
+      [68112, 68115],
+      [68117, 68119],
+      [68121, 68149],
+      [68192, 68220],
+      [68224, 68252],
+      [68288, 68295],
+      [68297, 68324],
+      [68352, 68405],
+      [68416, 68437],
+      [68448, 68466],
+      [68480, 68497],
+      [68608, 68680],
+      [68736, 68786],
+      [68800, 68850],
+      [68864, 68899],
+      [68938, 68965],
+      [68975, 68997],
+      [69248, 69289],
+      [69296, 69297],
+      [69314, 69316],
+      [69376, 69404],
+      [69415, 69415],
+      [69424, 69445],
+      [69488, 69505],
+      [69552, 69572],
+      [69600, 69622],
+      [69635, 69687],
+      [69745, 69746],
+      [69749, 69749],
+      [69763, 69807],
+      [69840, 69864],
+      [69891, 69926],
+      [69956, 69956],
+      [69959, 69959],
+      [69968, 70002],
+      [70006, 70006],
+      [70019, 70066],
+      [70081, 70084],
+      [70106, 70106],
+      [70108, 70108],
+      [70144, 70161],
+      [70163, 70187],
+      [70207, 70208],
+      [70272, 70278],
+      [70280, 70280],
+      [70282, 70285],
+      [70287, 70301],
+      [70303, 70312],
+      [70320, 70366],
+      [70405, 70412],
+      [70415, 70416],
+      [70419, 70440],
+      [70442, 70448],
+      [70450, 70451],
+      [70453, 70457],
+      [70461, 70461],
+      [70480, 70480],
+      [70493, 70497],
+      [70528, 70537],
+      [70539, 70539],
+      [70542, 70542],
+      [70544, 70581],
+      [70583, 70583],
+      [70609, 70609],
+      [70611, 70611],
+      [70656, 70708],
+      [70727, 70730],
+      [70751, 70753],
+      [70784, 70831],
+      [70852, 70853],
+      [70855, 70855],
+      [71040, 71086],
+      [71128, 71131],
+      [71168, 71215],
+      [71236, 71236],
+      [71296, 71338],
+      [71352, 71352],
+      [71424, 71450],
+      [71488, 71494],
+      [71680, 71723],
+      [71840, 71903],
+      [71935, 71942],
+      [71945, 71945],
+      [71948, 71955],
+      [71957, 71958],
+      [71960, 71983],
+      [71999, 71999],
+      [72001, 72001],
+      [72096, 72103],
+      [72106, 72144],
+      [72161, 72161],
+      [72163, 72163],
+      [72192, 72192],
+      [72203, 72242],
+      [72250, 72250],
+      [72272, 72272],
+      [72284, 72329],
+      [72349, 72349],
+      [72368, 72440],
+      [72640, 72672],
+      [72704, 72712],
+      [72714, 72750],
+      [72768, 72768],
+      [72818, 72847],
+      [72960, 72966],
+      [72968, 72969],
+      [72971, 73008],
+      [73030, 73030],
+      [73056, 73061],
+      [73063, 73064],
+      [73066, 73097],
+      [73112, 73112],
+      [73440, 73458],
+      [73474, 73474],
+      [73476, 73488],
+      [73490, 73523],
+      [73648, 73648],
+      [73728, 74649],
+      [74752, 74862],
+      [74880, 75075],
+      [77712, 77808],
+      [77824, 78895],
+      [78913, 78918],
+      [78944, 82938],
+      [82944, 83526],
+      [90368, 90397],
+      [92160, 92728],
+      [92736, 92766],
+      [92784, 92862],
+      [92880, 92909],
+      [92928, 92975],
+      [92992, 92995],
+      [93027, 93047],
+      [93053, 93071],
+      [93504, 93548],
+      [93760, 93823],
+      [93952, 94026],
+      [94032, 94032],
+      [94099, 94111],
+      [94176, 94177],
+      [94179, 94179],
+      [94208, 100343],
+      [100352, 101589],
+      [101631, 101640],
+      [110576, 110579],
+      [110581, 110587],
+      [110589, 110590],
+      [110592, 110882],
+      [110898, 110898],
+      [110928, 110930],
+      [110933, 110933],
+      [110948, 110951],
+      [110960, 111355],
+      [113664, 113770],
+      [113776, 113788],
+      [113792, 113800],
+      [113808, 113817],
+      [119808, 119892],
+      [119894, 119964],
+      [119966, 119967],
+      [119970, 119970],
+      [119973, 119974],
+      [119977, 119980],
+      [119982, 119993],
+      [119995, 119995],
+      [119997, 120003],
+      [120005, 120069],
+      [120071, 120074],
+      [120077, 120084],
+      [120086, 120092],
+      [120094, 120121],
+      [120123, 120126],
+      [120128, 120132],
+      [120134, 120134],
+      [120138, 120144],
+      [120146, 120485],
+      [120488, 120512],
+      [120514, 120538],
+      [120540, 120570],
+      [120572, 120596],
+      [120598, 120628],
+      [120630, 120654],
+      [120656, 120686],
+      [120688, 120712],
+      [120714, 120744],
+      [120746, 120770],
+      [120772, 120779],
+      [122624, 122654],
+      [122661, 122666],
+      [122928, 122989],
+      [123136, 123180],
+      [123191, 123197],
+      [123214, 123214],
+      [123536, 123565],
+      [123584, 123627],
+      [124112, 124139],
+      [124368, 124397],
+      [124400, 124400],
+      [124896, 124902],
+      [124904, 124907],
+      [124909, 124910],
+      [124912, 124926],
+      [124928, 125124],
+      [125184, 125251],
+      [125259, 125259],
+      [126464, 126467],
+      [126469, 126495],
+      [126497, 126498],
+      [126500, 126500],
+      [126503, 126503],
+      [126505, 126514],
+      [126516, 126519],
+      [126521, 126521],
+      [126523, 126523],
+      [126530, 126530],
+      [126535, 126535],
+      [126537, 126537],
+      [126539, 126539],
+      [126541, 126543],
+      [126545, 126546],
+      [126548, 126548],
+      [126551, 126551],
+      [126553, 126553],
+      [126555, 126555],
+      [126557, 126557],
+      [126559, 126559],
+      [126561, 126562],
+      [126564, 126564],
+      [126567, 126570],
+      [126572, 126578],
+      [126580, 126583],
+      [126585, 126588],
+      [126590, 126590],
+      [126592, 126601],
+      [126603, 126619],
+      [126625, 126627],
+      [126629, 126633],
+      [126635, 126651],
+      [131072, 173791],
+      [173824, 177977],
+      [177984, 178205],
+      [178208, 183969],
+      [183984, 191456],
+      [191472, 192093],
+      [194560, 195101],
+      [196608, 201546],
+      [201552, 205743]
+    ];
+    DUPLICATE_IDENTIFIER_CONTINUE_RANGES = [
+      [36, 36],
+      [48, 57],
+      [65, 90],
+      [95, 95],
+      [97, 122],
+      [170, 170],
+      [181, 181],
+      [183, 183],
+      [186, 186],
+      [192, 214],
+      [216, 246],
+      [248, 705],
+      [710, 721],
+      [736, 740],
+      [748, 748],
+      [750, 750],
+      [768, 884],
+      [886, 887],
+      [891, 893],
+      [895, 895],
+      [902, 906],
+      [908, 908],
+      [910, 929],
+      [931, 1013],
+      [1015, 1153],
+      [1155, 1159],
+      [1162, 1327],
+      [1329, 1366],
+      [1369, 1369],
+      [1376, 1416],
+      [1425, 1469],
+      [1471, 1471],
+      [1473, 1474],
+      [1476, 1477],
+      [1479, 1479],
+      [1488, 1514],
+      [1519, 1522],
+      [1552, 1562],
+      [1568, 1641],
+      [1646, 1747],
+      [1749, 1756],
+      [1759, 1768],
+      [1770, 1788],
+      [1791, 1791],
+      [1808, 1866],
+      [1869, 1969],
+      [1984, 2037],
+      [2042, 2042],
+      [2045, 2045],
+      [2048, 2093],
+      [2112, 2139],
+      [2144, 2154],
+      [2160, 2183],
+      [2185, 2190],
+      [2199, 2273],
+      [2275, 2403],
+      [2406, 2415],
+      [2417, 2435],
+      [2437, 2444],
+      [2447, 2448],
+      [2451, 2472],
+      [2474, 2480],
+      [2482, 2482],
+      [2486, 2489],
+      [2492, 2500],
+      [2503, 2504],
+      [2507, 2510],
+      [2519, 2519],
+      [2524, 2525],
+      [2527, 2531],
+      [2534, 2545],
+      [2556, 2556],
+      [2558, 2558],
+      [2561, 2563],
+      [2565, 2570],
+      [2575, 2576],
+      [2579, 2600],
+      [2602, 2608],
+      [2610, 2611],
+      [2613, 2614],
+      [2616, 2617],
+      [2620, 2620],
+      [2622, 2626],
+      [2631, 2632],
+      [2635, 2637],
+      [2641, 2641],
+      [2649, 2652],
+      [2654, 2654],
+      [2662, 2677],
+      [2689, 2691],
+      [2693, 2701],
+      [2703, 2705],
+      [2707, 2728],
+      [2730, 2736],
+      [2738, 2739],
+      [2741, 2745],
+      [2748, 2757],
+      [2759, 2761],
+      [2763, 2765],
+      [2768, 2768],
+      [2784, 2787],
+      [2790, 2799],
+      [2809, 2815],
+      [2817, 2819],
+      [2821, 2828],
+      [2831, 2832],
+      [2835, 2856],
+      [2858, 2864],
+      [2866, 2867],
+      [2869, 2873],
+      [2876, 2884],
+      [2887, 2888],
+      [2891, 2893],
+      [2901, 2903],
+      [2908, 2909],
+      [2911, 2915],
+      [2918, 2927],
+      [2929, 2929],
+      [2946, 2947],
+      [2949, 2954],
+      [2958, 2960],
+      [2962, 2965],
+      [2969, 2970],
+      [2972, 2972],
+      [2974, 2975],
+      [2979, 2980],
+      [2984, 2986],
+      [2990, 3001],
+      [3006, 3010],
+      [3014, 3016],
+      [3018, 3021],
+      [3024, 3024],
+      [3031, 3031],
+      [3046, 3055],
+      [3072, 3084],
+      [3086, 3088],
+      [3090, 3112],
+      [3114, 3129],
+      [3132, 3140],
+      [3142, 3144],
+      [3146, 3149],
+      [3157, 3158],
+      [3160, 3162],
+      [3165, 3165],
+      [3168, 3171],
+      [3174, 3183],
+      [3200, 3203],
+      [3205, 3212],
+      [3214, 3216],
+      [3218, 3240],
+      [3242, 3251],
+      [3253, 3257],
+      [3260, 3268],
+      [3270, 3272],
+      [3274, 3277],
+      [3285, 3286],
+      [3293, 3294],
+      [3296, 3299],
+      [3302, 3311],
+      [3313, 3315],
+      [3328, 3340],
+      [3342, 3344],
+      [3346, 3396],
+      [3398, 3400],
+      [3402, 3406],
+      [3412, 3415],
+      [3423, 3427],
+      [3430, 3439],
+      [3450, 3455],
+      [3457, 3459],
+      [3461, 3478],
+      [3482, 3505],
+      [3507, 3515],
+      [3517, 3517],
+      [3520, 3526],
+      [3530, 3530],
+      [3535, 3540],
+      [3542, 3542],
+      [3544, 3551],
+      [3558, 3567],
+      [3570, 3571],
+      [3585, 3642],
+      [3648, 3662],
+      [3664, 3673],
+      [3713, 3714],
+      [3716, 3716],
+      [3718, 3722],
+      [3724, 3747],
+      [3749, 3749],
+      [3751, 3773],
+      [3776, 3780],
+      [3782, 3782],
+      [3784, 3790],
+      [3792, 3801],
+      [3804, 3807],
+      [3840, 3840],
+      [3864, 3865],
+      [3872, 3881],
+      [3893, 3893],
+      [3895, 3895],
+      [3897, 3897],
+      [3902, 3911],
+      [3913, 3948],
+      [3953, 3972],
+      [3974, 3991],
+      [3993, 4028],
+      [4038, 4038],
+      [4096, 4169],
+      [4176, 4253],
+      [4256, 4293],
+      [4295, 4295],
+      [4301, 4301],
+      [4304, 4346],
+      [4348, 4680],
+      [4682, 4685],
+      [4688, 4694],
+      [4696, 4696],
+      [4698, 4701],
+      [4704, 4744],
+      [4746, 4749],
+      [4752, 4784],
+      [4786, 4789],
+      [4792, 4798],
+      [4800, 4800],
+      [4802, 4805],
+      [4808, 4822],
+      [4824, 4880],
+      [4882, 4885],
+      [4888, 4954],
+      [4957, 4959],
+      [4969, 4977],
+      [4992, 5007],
+      [5024, 5109],
+      [5112, 5117],
+      [5121, 5740],
+      [5743, 5759],
+      [5761, 5786],
+      [5792, 5866],
+      [5870, 5880],
+      [5888, 5909],
+      [5919, 5940],
+      [5952, 5971],
+      [5984, 5996],
+      [5998, 6e3],
+      [6002, 6003],
+      [6016, 6099],
+      [6103, 6103],
+      [6108, 6109],
+      [6112, 6121],
+      [6155, 6157],
+      [6159, 6169],
+      [6176, 6264],
+      [6272, 6314],
+      [6320, 6389],
+      [6400, 6430],
+      [6432, 6443],
+      [6448, 6459],
+      [6470, 6509],
+      [6512, 6516],
+      [6528, 6571],
+      [6576, 6601],
+      [6608, 6618],
+      [6656, 6683],
+      [6688, 6750],
+      [6752, 6780],
+      [6783, 6793],
+      [6800, 6809],
+      [6823, 6823],
+      [6832, 6845],
+      [6847, 6862],
+      [6912, 6988],
+      [6992, 7001],
+      [7019, 7027],
+      [7040, 7155],
+      [7168, 7223],
+      [7232, 7241],
+      [7245, 7293],
+      [7296, 7306],
+      [7312, 7354],
+      [7357, 7359],
+      [7376, 7378],
+      [7380, 7418],
+      [7424, 7957],
+      [7960, 7965],
+      [7968, 8005],
+      [8008, 8013],
+      [8016, 8023],
+      [8025, 8025],
+      [8027, 8027],
+      [8029, 8029],
+      [8031, 8061],
+      [8064, 8116],
+      [8118, 8124],
+      [8126, 8126],
+      [8130, 8132],
+      [8134, 8140],
+      [8144, 8147],
+      [8150, 8155],
+      [8160, 8172],
+      [8178, 8180],
+      [8182, 8188],
+      [8204, 8205],
+      [8255, 8256],
+      [8276, 8276],
+      [8305, 8305],
+      [8319, 8319],
+      [8336, 8348],
+      [8400, 8412],
+      [8417, 8417],
+      [8421, 8432],
+      [8450, 8450],
+      [8455, 8455],
+      [8458, 8467],
+      [8469, 8469],
+      [8472, 8477],
+      [8484, 8484],
+      [8486, 8486],
+      [8488, 8488],
+      [8490, 8505],
+      [8508, 8511],
+      [8517, 8521],
+      [8526, 8526],
+      [8544, 8584],
+      [11264, 11492],
+      [11499, 11507],
+      [11520, 11557],
+      [11559, 11559],
+      [11565, 11565],
+      [11568, 11623],
+      [11631, 11631],
+      [11647, 11670],
+      [11680, 11686],
+      [11688, 11694],
+      [11696, 11702],
+      [11704, 11710],
+      [11712, 11718],
+      [11720, 11726],
+      [11728, 11734],
+      [11736, 11742],
+      [11744, 11775],
+      [12293, 12295],
+      [12321, 12335],
+      [12337, 12341],
+      [12344, 12348],
+      [12353, 12438],
+      [12441, 12447],
+      [12449, 12543],
+      [12549, 12591],
+      [12593, 12686],
+      [12704, 12735],
+      [12784, 12799],
+      [13312, 19903],
+      [19968, 42124],
+      [42192, 42237],
+      [42240, 42508],
+      [42512, 42539],
+      [42560, 42607],
+      [42612, 42621],
+      [42623, 42737],
+      [42775, 42783],
+      [42786, 42888],
+      [42891, 42957],
+      [42960, 42961],
+      [42963, 42963],
+      [42965, 42972],
+      [42994, 43047],
+      [43052, 43052],
+      [43072, 43123],
+      [43136, 43205],
+      [43216, 43225],
+      [43232, 43255],
+      [43259, 43259],
+      [43261, 43309],
+      [43312, 43347],
+      [43360, 43388],
+      [43392, 43456],
+      [43471, 43481],
+      [43488, 43518],
+      [43520, 43574],
+      [43584, 43597],
+      [43600, 43609],
+      [43616, 43638],
+      [43642, 43714],
+      [43739, 43741],
+      [43744, 43759],
+      [43762, 43766],
+      [43777, 43782],
+      [43785, 43790],
+      [43793, 43798],
+      [43808, 43814],
+      [43816, 43822],
+      [43824, 43866],
+      [43868, 43881],
+      [43888, 44010],
+      [44012, 44013],
+      [44016, 44025],
+      [44032, 55203],
+      [55216, 55238],
+      [55243, 55291],
+      [63744, 64109],
+      [64112, 64217],
+      [64256, 64262],
+      [64275, 64279],
+      [64285, 64296],
+      [64298, 64310],
+      [64312, 64316],
+      [64318, 64318],
+      [64320, 64321],
+      [64323, 64324],
+      [64326, 64433],
+      [64467, 64605],
+      [64612, 64829],
+      [64848, 64911],
+      [64914, 64967],
+      [65008, 65017],
+      [65024, 65039],
+      [65056, 65071],
+      [65075, 65076],
+      [65101, 65103],
+      [65137, 65137],
+      [65139, 65139],
+      [65143, 65143],
+      [65145, 65145],
+      [65147, 65147],
+      [65149, 65149],
+      [65151, 65276],
+      [65296, 65305],
+      [65313, 65338],
+      [65343, 65343],
+      [65345, 65370],
+      [65381, 65470],
+      [65474, 65479],
+      [65482, 65487],
+      [65490, 65495],
+      [65498, 65500],
+      [65536, 65547],
+      [65549, 65574],
+      [65576, 65594],
+      [65596, 65597],
+      [65599, 65613],
+      [65616, 65629],
+      [65664, 65786],
+      [65856, 65908],
+      [66045, 66045],
+      [66176, 66204],
+      [66208, 66256],
+      [66272, 66272],
+      [66304, 66335],
+      [66349, 66378],
+      [66384, 66426],
+      [66432, 66461],
+      [66464, 66499],
+      [66504, 66511],
+      [66513, 66517],
+      [66560, 66717],
+      [66720, 66729],
+      [66736, 66771],
+      [66776, 66811],
+      [66816, 66855],
+      [66864, 66915],
+      [66928, 66938],
+      [66940, 66954],
+      [66956, 66962],
+      [66964, 66965],
+      [66967, 66977],
+      [66979, 66993],
+      [66995, 67001],
+      [67003, 67004],
+      [67008, 67059],
+      [67072, 67382],
+      [67392, 67413],
+      [67424, 67431],
+      [67456, 67461],
+      [67463, 67504],
+      [67506, 67514],
+      [67584, 67589],
+      [67592, 67592],
+      [67594, 67637],
+      [67639, 67640],
+      [67644, 67644],
+      [67647, 67669],
+      [67680, 67702],
+      [67712, 67742],
+      [67808, 67826],
+      [67828, 67829],
+      [67840, 67861],
+      [67872, 67897],
+      [67968, 68023],
+      [68030, 68031],
+      [68096, 68099],
+      [68101, 68102],
+      [68108, 68115],
+      [68117, 68119],
+      [68121, 68149],
+      [68152, 68154],
+      [68159, 68159],
+      [68192, 68220],
+      [68224, 68252],
+      [68288, 68295],
+      [68297, 68326],
+      [68352, 68405],
+      [68416, 68437],
+      [68448, 68466],
+      [68480, 68497],
+      [68608, 68680],
+      [68736, 68786],
+      [68800, 68850],
+      [68864, 68903],
+      [68912, 68921],
+      [68928, 68965],
+      [68969, 68973],
+      [68975, 68997],
+      [69248, 69289],
+      [69291, 69292],
+      [69296, 69297],
+      [69314, 69316],
+      [69372, 69404],
+      [69415, 69415],
+      [69424, 69456],
+      [69488, 69509],
+      [69552, 69572],
+      [69600, 69622],
+      [69632, 69702],
+      [69734, 69749],
+      [69759, 69818],
+      [69826, 69826],
+      [69840, 69864],
+      [69872, 69881],
+      [69888, 69940],
+      [69942, 69951],
+      [69956, 69959],
+      [69968, 70003],
+      [70006, 70006],
+      [70016, 70084],
+      [70089, 70092],
+      [70094, 70106],
+      [70108, 70108],
+      [70144, 70161],
+      [70163, 70199],
+      [70206, 70209],
+      [70272, 70278],
+      [70280, 70280],
+      [70282, 70285],
+      [70287, 70301],
+      [70303, 70312],
+      [70320, 70378],
+      [70384, 70393],
+      [70400, 70403],
+      [70405, 70412],
+      [70415, 70416],
+      [70419, 70440],
+      [70442, 70448],
+      [70450, 70451],
+      [70453, 70457],
+      [70459, 70468],
+      [70471, 70472],
+      [70475, 70477],
+      [70480, 70480],
+      [70487, 70487],
+      [70493, 70499],
+      [70502, 70508],
+      [70512, 70516],
+      [70528, 70537],
+      [70539, 70539],
+      [70542, 70542],
+      [70544, 70581],
+      [70583, 70592],
+      [70594, 70594],
+      [70597, 70597],
+      [70599, 70602],
+      [70604, 70611],
+      [70625, 70626],
+      [70656, 70730],
+      [70736, 70745],
+      [70750, 70753],
+      [70784, 70853],
+      [70855, 70855],
+      [70864, 70873],
+      [71040, 71093],
+      [71096, 71104],
+      [71128, 71133],
+      [71168, 71232],
+      [71236, 71236],
+      [71248, 71257],
+      [71296, 71352],
+      [71360, 71369],
+      [71376, 71395],
+      [71424, 71450],
+      [71453, 71467],
+      [71472, 71481],
+      [71488, 71494],
+      [71680, 71738],
+      [71840, 71913],
+      [71935, 71942],
+      [71945, 71945],
+      [71948, 71955],
+      [71957, 71958],
+      [71960, 71989],
+      [71991, 71992],
+      [71995, 72003],
+      [72016, 72025],
+      [72096, 72103],
+      [72106, 72151],
+      [72154, 72161],
+      [72163, 72164],
+      [72192, 72254],
+      [72263, 72263],
+      [72272, 72345],
+      [72349, 72349],
+      [72368, 72440],
+      [72640, 72672],
+      [72688, 72697],
+      [72704, 72712],
+      [72714, 72758],
+      [72760, 72768],
+      [72784, 72793],
+      [72818, 72847],
+      [72850, 72871],
+      [72873, 72886],
+      [72960, 72966],
+      [72968, 72969],
+      [72971, 73014],
+      [73018, 73018],
+      [73020, 73021],
+      [73023, 73031],
+      [73040, 73049],
+      [73056, 73061],
+      [73063, 73064],
+      [73066, 73102],
+      [73104, 73105],
+      [73107, 73112],
+      [73120, 73129],
+      [73440, 73462],
+      [73472, 73488],
+      [73490, 73530],
+      [73534, 73538],
+      [73552, 73562],
+      [73648, 73648],
+      [73728, 74649],
+      [74752, 74862],
+      [74880, 75075],
+      [77712, 77808],
+      [77824, 78895],
+      [78912, 78933],
+      [78944, 82938],
+      [82944, 83526],
+      [90368, 90425],
+      [92160, 92728],
+      [92736, 92766],
+      [92768, 92777],
+      [92784, 92862],
+      [92864, 92873],
+      [92880, 92909],
+      [92912, 92916],
+      [92928, 92982],
+      [92992, 92995],
+      [93008, 93017],
+      [93027, 93047],
+      [93053, 93071],
+      [93504, 93548],
+      [93552, 93561],
+      [93760, 93823],
+      [93952, 94026],
+      [94031, 94087],
+      [94095, 94111],
+      [94176, 94177],
+      [94179, 94180],
+      [94192, 94193],
+      [94208, 100343],
+      [100352, 101589],
+      [101631, 101640],
+      [110576, 110579],
+      [110581, 110587],
+      [110589, 110590],
+      [110592, 110882],
+      [110898, 110898],
+      [110928, 110930],
+      [110933, 110933],
+      [110948, 110951],
+      [110960, 111355],
+      [113664, 113770],
+      [113776, 113788],
+      [113792, 113800],
+      [113808, 113817],
+      [113821, 113822],
+      [118e3, 118009],
+      [118528, 118573],
+      [118576, 118598],
+      [119141, 119145],
+      [119149, 119154],
+      [119163, 119170],
+      [119173, 119179],
+      [119210, 119213],
+      [119362, 119364],
+      [119808, 119892],
+      [119894, 119964],
+      [119966, 119967],
+      [119970, 119970],
+      [119973, 119974],
+      [119977, 119980],
+      [119982, 119993],
+      [119995, 119995],
+      [119997, 120003],
+      [120005, 120069],
+      [120071, 120074],
+      [120077, 120084],
+      [120086, 120092],
+      [120094, 120121],
+      [120123, 120126],
+      [120128, 120132],
+      [120134, 120134],
+      [120138, 120144],
+      [120146, 120485],
+      [120488, 120512],
+      [120514, 120538],
+      [120540, 120570],
+      [120572, 120596],
+      [120598, 120628],
+      [120630, 120654],
+      [120656, 120686],
+      [120688, 120712],
+      [120714, 120744],
+      [120746, 120770],
+      [120772, 120779],
+      [120782, 120831],
+      [121344, 121398],
+      [121403, 121452],
+      [121461, 121461],
+      [121476, 121476],
+      [121499, 121503],
+      [121505, 121519],
+      [122624, 122654],
+      [122661, 122666],
+      [122880, 122886],
+      [122888, 122904],
+      [122907, 122913],
+      [122915, 122916],
+      [122918, 122922],
+      [122928, 122989],
+      [123023, 123023],
+      [123136, 123180],
+      [123184, 123197],
+      [123200, 123209],
+      [123214, 123214],
+      [123536, 123566],
+      [123584, 123641],
+      [124112, 124153],
+      [124368, 124410],
+      [124896, 124902],
+      [124904, 124907],
+      [124909, 124910],
+      [124912, 124926],
+      [124928, 125124],
+      [125136, 125142],
+      [125184, 125259],
+      [125264, 125273],
+      [126464, 126467],
+      [126469, 126495],
+      [126497, 126498],
+      [126500, 126500],
+      [126503, 126503],
+      [126505, 126514],
+      [126516, 126519],
+      [126521, 126521],
+      [126523, 126523],
+      [126530, 126530],
+      [126535, 126535],
+      [126537, 126537],
+      [126539, 126539],
+      [126541, 126543],
+      [126545, 126546],
+      [126548, 126548],
+      [126551, 126551],
+      [126553, 126553],
+      [126555, 126555],
+      [126557, 126557],
+      [126559, 126559],
+      [126561, 126562],
+      [126564, 126564],
+      [126567, 126570],
+      [126572, 126578],
+      [126580, 126583],
+      [126585, 126588],
+      [126590, 126590],
+      [126592, 126601],
+      [126603, 126619],
+      [126625, 126627],
+      [126629, 126633],
+      [126635, 126651],
+      [130032, 130041],
+      [131072, 173791],
+      [173824, 177977],
+      [177984, 178205],
+      [178208, 183969],
+      [183984, 191456],
+      [191472, 192093],
+      [194560, 195101],
+      [196608, 201546],
+      [201552, 205743],
+      [917760, 917999]
+    ];
+  }
+});
+
 // dist/duplicate-token-normalization.js
+function characterClassSource(ranges) {
+  const escape2 = (codePoint) => `\\u{${codePoint.toString(16)}}`;
+  return ranges.map(([from, to]) => from === to ? escape2(from) : `${escape2(from)}-${escape2(to)}`).join("");
+}
 function tokenizeDuplicateSource(text) {
   return text.match(duplicateTokenPattern) ?? [];
 }
@@ -29736,12 +31465,13 @@ function hasUnterminatedQuotedLiteral(text) {
   }
   return false;
 }
-var duplicateTokenPattern, identifierTokenPattern;
+var DUPLICATE_TOKENIZER_IDENTIFIER_SOURCE, duplicateTokenPattern, identifierTokenPattern;
 var init_duplicate_token_normalization = __esm({
   "dist/duplicate-token-normalization.js"() {
     "use strict";
     init_duplicate_keywords();
-    init_identifiers();
+    init_duplicate_identifier_ranges();
+    DUPLICATE_TOKENIZER_IDENTIFIER_SOURCE = `[${characterClassSource(DUPLICATE_IDENTIFIER_START_RANGES)}](?:[${characterClassSource(DUPLICATE_IDENTIFIER_CONTINUE_RANGES)}])*`;
     duplicateTokenPattern = new RegExp([
       String.raw`"(?:\\.|[^"\\])*"`,
       String.raw`'(?:\\.|[^'\\])*'`,
@@ -30779,23 +32509,38 @@ function transformPersistedExportFromModule(projectRoot, entry, toRelative) {
   entry.fromModule = assertFilePathWithinRoot(projectRoot, cacheAbsolutePath(projectRoot, entry.fromModule), "Persisted cache path");
 }
 function transformModulePaths(projectRoot, module2, toRelative) {
-  const copy = structuredClone(module2);
   const transform2 = (file2) => toRelative ? cacheRelativePath(projectRoot, file2) : assertFilePathWithinRoot(projectRoot, cacheAbsolutePath(projectRoot, file2), "Persisted cache path");
-  copy.file = transform2(copy.file);
-  for (const local of copy.locals)
-    local.file = transform2(local.file);
-  for (const entry of copy.exports) {
-    if (entry.type === "local") {
-      entry.target.file = transform2(entry.target.file);
-    } else {
-      transformPersistedExportFromModule(projectRoot, entry, toRelative);
+  if (!toRelative) {
+    module2.file = transform2(module2.file);
+    for (const local of module2.locals)
+      local.file = transform2(local.file);
+    for (const entry of module2.exports) {
+      if (entry.type === "local") {
+        entry.target.file = transform2(entry.target.file);
+      } else {
+        transformPersistedExportFromModule(projectRoot, entry, false);
+      }
     }
+    for (const binding of module2.imports) {
+      if (typeof binding.resolved === "string")
+        binding.resolved = transform2(binding.resolved);
+    }
+    return module2;
   }
-  for (const binding of copy.imports) {
-    if (typeof binding.resolved === "string")
-      binding.resolved = transform2(binding.resolved);
-  }
-  return copy;
+  return {
+    ...module2,
+    file: transform2(module2.file),
+    locals: module2.locals.map((local) => ({ ...local, file: transform2(local.file) })),
+    exports: module2.exports.map((entry) => {
+      if (entry.type === "local") {
+        return { ...entry, target: { ...entry.target, file: transform2(entry.target.file) } };
+      }
+      const copy = { ...entry };
+      transformPersistedExportFromModule(projectRoot, copy, true);
+      return copy;
+    }),
+    imports: module2.imports.map((binding) => typeof binding.resolved === "string" ? { ...binding, resolved: transform2(binding.resolved) } : binding)
+  };
 }
 function tryLoadFromCache(projectRoot, file2, sig, opts, report, diskCacheAvailable = true) {
   const mode = opts?.cache ?? "off";
@@ -31409,7 +33154,7 @@ var init_unitCache = __esm({
     DUPLICATE_UNIT_CACHE_SCHEMA_VERSION = 2;
     DUPLICATE_UNIT_CACHE_TABLE = "duplicate_unit_cache";
     DUPLICATE_UNIT_CACHE_SCHEMA_VERSION_KEY = "duplicate_unit_cache.schema_version";
-    DUPLICATE_TOKENIZER_REVISION = 5;
+    DUPLICATE_TOKENIZER_REVISION = 6;
     DUPLICATE_UNIT_CACHE_MAX_ROWS = 5e3;
     DUPLICATE_UNIT_CACHE_MAX_AGE_MS = 30 * 24 * 60 * 60 * 1e3;
     DUPLICATE_UNIT_MEMORY_CACHE_MAX_ENTRIES = 2048;
@@ -49038,14 +50783,32 @@ function resolveManifestSymlinkDirectories(projectRoot, storedProjectRoot, direc
   }
   return [...resolvedDirectories];
 }
+async function gitIgnoreConfigFiles(projectRoot) {
+  const gitRoot = await getGitRepositoryRoot(projectRoot);
+  if (!gitRoot)
+    return [];
+  const submoduleDirectories = await listGitSubmoduleDirectories(gitRoot, { recurse: true });
+  const sourceRoots = [projectRoot, gitRoot, ...submoduleDirectories];
+  const gitignoreFiles = await Promise.all(sourceRoots.map(async (root) => await (0, import_fast_glob3.default)(["**/.gitignore"], {
+    cwd: root,
+    absolute: true,
+    dot: true,
+    ignore: DEFAULT_PROJECT_FILE_IGNORES
+  })));
+  const excludeFiles = await Promise.all([gitRoot, ...submoduleDirectories].map(async (root) => await listGitExcludeFiles(root)));
+  return Array.from(/* @__PURE__ */ new Set([...gitignoreFiles.flat(), ...excludeFiles.flat().map(({ file: file2 }) => file2)])).sort();
+}
 async function computeConfigHash(projectRoot, logLevel) {
   try {
-    const configFiles = await (0, import_fast_glob3.default)([...DEFAULT_PROJECT_MANIFESTS, CODEGRAPH_CONFIG_FILE, "**/.gitignore"], {
-      cwd: projectRoot,
-      absolute: true,
-      dot: true,
-      ignore: DEFAULT_PROJECT_FILE_IGNORES
-    });
+    const configFiles = Array.from(/* @__PURE__ */ new Set([
+      ...await (0, import_fast_glob3.default)([...DEFAULT_PROJECT_MANIFESTS, CODEGRAPH_CONFIG_FILE, "**/.gitignore"], {
+        cwd: projectRoot,
+        absolute: true,
+        dot: true,
+        ignore: DEFAULT_PROJECT_FILE_IGNORES
+      }),
+      ...await gitIgnoreConfigFiles(projectRoot)
+    ]));
     configFiles.sort();
     const hash2 = crypto8.createHash("sha1");
     let firstError;
@@ -50095,6 +51858,7 @@ function migrateProjectSnapshotPayload(value, currentRoot) {
   const migrated = transformSnapshotPaths(relative, currentRoot, false);
   migrated.version = PROJECT_SNAPSHOT_VERSION;
   migrated.projectRoot = serializedProjectRoot(currentRoot);
+  delete migrated.projectFiles;
   return migrated;
 }
 function transformDetailedGraph(graph, root, toRelative) {
@@ -51082,7 +52846,7 @@ var init_project_snapshot = __esm({
     init_module_cache();
     init_location();
     SNAPSHOT_SYMBOL_KINDS = new Set(Object.values(SymbolKind));
-    PROJECT_SNAPSHOT_VERSION = 9;
+    PROJECT_SNAPSHOT_VERSION = 10;
     BLOOM_FILTER_SNAPSHOT_VERSION = 4;
     BLOOM_FILTER_SNAPSHOT_FILENAME = "bloom-filters.json";
     BLOOM_FILTER_MIN_SIZE = 1e3;
@@ -51312,8 +53076,9 @@ import { performance as performance2 } from "node:perf_hooks";
 async function finalizeProjectIndex(args) {
   if (args.timings)
     args.timings.totalMs = Math.round(performance2.now() - args.totalStart);
-  const projectFiles = await (args.projectFiles ?? discoverProjectFiles(args.projectRoot, {
-    ...args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {}
+  const projectFiles = await (args.projectFiles ?? discoverProjectFilesWithGitCandidates(args.projectRoot, {
+    ...args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {},
+    ...args.knownGitCandidates !== void 0 ? { knownGitCandidates: args.knownGitCandidates } : {}
   }));
   const languageExtensions = normalizeLanguageExtensions(args.opts?.languageExtensions);
   const parsed = retainedParsedCache(args.parsedMap, args.opts);
@@ -52769,13 +54534,26 @@ var init_esm_wrapper = __esm({
 var nativeWorkerPool_exports = {};
 __export(nativeWorkerPool_exports, {
   createNativeWorkerPool: () => createNativeWorkerPool,
-  resolveNativeWorkerPath: () => resolveNativeWorkerPath
+  defaultNativeWorkerThreadCount: () => defaultNativeWorkerThreadCount,
+  resolveNativeWorkerPath: () => resolveNativeWorkerPath,
+  resolveNativeWorkerThreadCount: () => resolveNativeWorkerThreadCount
 });
+import os6 from "node:os";
 import fs21 from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 import path46 from "node:path";
+function defaultNativeWorkerThreadCount(availableParallelism = os6.availableParallelism()) {
+  return Math.min(DEFAULT_NATIVE_THREAD_CAP, Math.max(1, Math.floor(availableParallelism * 0.75)));
+}
+function resolveNativeWorkerThreadCount(requested, availableParallelism = os6.availableParallelism()) {
+  return resolveWorkerThreadCount({
+    requested,
+    defaultCount: defaultNativeWorkerThreadCount(availableParallelism),
+    max: HARD_MAX_THREADS
+  });
+}
 function resolveThreadCount(requested) {
-  return resolveWorkerThreadCount({ requested, max: HARD_MAX_THREADS });
+  return resolveNativeWorkerThreadCount(requested);
 }
 function resolveNativeWorkerPath() {
   const selfDir = path46.dirname(fileURLToPath4(import.meta.url));
@@ -52802,13 +54580,14 @@ function createNativeWorkerPool(opts) {
     ...opts?.workerData === void 0 ? {} : { workerData: opts.workerData }
   });
 }
-var HARD_MAX_THREADS;
+var HARD_MAX_THREADS, DEFAULT_NATIVE_THREAD_CAP;
 var init_nativeWorkerPool = __esm({
   "dist/worker/nativeWorkerPool.js"() {
     "use strict";
     init_esm_wrapper();
     init_workerThreads();
     HARD_MAX_THREADS = 64;
+    DEFAULT_NATIVE_THREAD_CAP = 8;
   }
 });
 
@@ -52844,11 +54623,12 @@ function countNativeWorkerEligibleFiles(files, languageExtensions) {
   }
   return count;
 }
-function buildWorkerTask(filePath, sup, source) {
+function buildWorkerTask(filePath, sup, source, includeBloomFilter = false) {
   return {
     filePath,
     languageId: sup.id,
     ...source !== void 0 ? { source, includeSourceInResult: false } : {},
+    ...includeBloomFilter ? { includeBloomFilter: true } : {},
     importsQuery: getCachedNormalizedQuery(sup, "imports"),
     exportsQuery: getCachedNormalizedQuery(sup, "exports"),
     localsQuery: getCachedNormalizedQuery(sup, "locals"),
@@ -52867,7 +54647,8 @@ function workerResultToPrepared(result, sup, filePath, ownedSource) {
     nativeQueries: result.nativeResults,
     syntaxTree: result.syntaxTree,
     ...result.fallbackReason ? { nativeFallbackReason: result.fallbackReason } : {},
-    ...result.error ? { nativeError: result.error } : {}
+    ...result.error ? { nativeError: result.error } : {},
+    ...result.bloomFilter ? { workerBloomFilter: result.bloomFilter } : {}
   };
 }
 async function setupWorkerPool(opts, fileCount) {
@@ -52947,7 +54728,7 @@ function createOversizedNativeSourceFallback(file2, support, source) {
     nativeError: `source exceeds native byte limit (${bytes} > ${DEFAULT_NATIVE_SOURCE_MAX_BYTES})`
   };
 }
-async function prepareFileContextForBuild(file2, support, opts, workerSetup, report, confinedRoot, lexicalRoot, trustedSource) {
+async function prepareFileContextForBuild(file2, support, opts, workerSetup, report, confinedRoot, lexicalRoot, trustedSource, includeBloomFilter = false) {
   const source = trustedSource ?? (confinedRoot ? await readConfinedUtf8File(confinedRoot, lexicalRoot ?? confinedRoot, file2) : void 0);
   if (source && Buffer.byteLength(source, "utf8") > DEFAULT_NATIVE_SOURCE_MAX_BYTES) {
     const prepared2 = createOversizedNativeSourceFallback(file2, support, source);
@@ -52959,7 +54740,7 @@ async function prepareFileContextForBuild(file2, support, opts, workerSetup, rep
     if (workerSetup.report)
       workerSetup.report.tasksSubmitted++;
     try {
-      const workerResult = await workerSetup.pool.run(buildWorkerTask(file2, support, source));
+      const workerResult = await workerSetup.pool.run(buildWorkerTask(file2, support, source, includeBloomFilter));
       prepared = workerResultToPrepared(workerResult, support, file2, source);
     } catch (error51) {
       if (isNativeRequiredUnavailableError(error51) && error51 instanceof Error)
@@ -53250,7 +55031,7 @@ async function resolveCrossModuleSymbolExports(file2, mod2, support, projectRoot
   }
 }
 async function buildIndexedModuleForFile(args) {
-  const prepared = await prepareFileContextForBuild(args.file, args.support, args.opts, args.workerSetup, args.report, args.confinedRoot, args.projectRoot, args.trustedSource);
+  const prepared = await prepareFileContextForBuild(args.file, args.support, args.opts, args.workerSetup, args.report, args.confinedRoot, args.projectRoot, args.trustedSource, !!args.bloomFilterCache);
   const { source, sup, nativeQueries, embeddedBlocks } = prepared;
   let tree;
   const graphOnlyLanguage = isGraphOnlyLanguage(sup.id), nativeSourceLimitFallback = prepared.nativeFallbackReason === "queryFailure" && !!prepared.nativeError?.startsWith("source exceeds native byte limit");
@@ -53289,7 +55070,7 @@ async function buildIndexedModuleForFile(args) {
   }
   const lacksParserContext = !nativeQueries && !tree;
   if (args.bloomFilterCache && !nativeSourceLimitFallback) {
-    const filter = buildBloomFilterFromSource(source, sup);
+    const filter = prepared.workerBloomFilter ? BloomFilter.fromBuffer(Buffer.from(prepared.workerBloomFilter.bits), prepared.workerBloomFilter.size, prepared.workerBloomFilter.hashCount, prepared.workerBloomFilter.itemCount) : buildBloomFilterFromSource(source, sup);
     args.bloomFilterCache.set(args.file, filter);
   }
   const sharedImportOptions = {
@@ -53502,6 +55283,17 @@ function emitIndexLifecycleProgress(opts, phase, mode, total, elapsedMs2) {
     ...elapsedMs2 !== void 0 ? { elapsedMs: elapsedMs2 } : {}
   });
 }
+function emitIndexCheckActivity(opts, activity, current = 0, total = 0) {
+  opts?.onProgress?.({
+    type: "progress",
+    phase: "update",
+    mode: "check",
+    message: activity,
+    activity,
+    current,
+    total
+  });
+}
 function buildConcurrency(opts) {
   return resolveWorkerThreadCount({ requested: Number(opts?.threads || 0), defaultCount: 8, max: 64 });
 }
@@ -53918,11 +55710,20 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const onSymlinkDirectoriesDiscovered = (directories) => {
       discoveredSymlinkDirectories = Array.from(directories);
     };
-    const discoveredFiles = await listProjectFiles(projectRoot, projectPatternsForLanguageExtensions(opts), {
+    let discoveredGitCandidates;
+    const onGitCandidatesDiscovered = (candidates) => {
+      discoveredGitCandidates = candidates;
+    };
+    const onDiscoveryProgress = helperOpts?.reportDiscoveryProgress ? (progress) => emitIndexCheckActivity(opts, progress.activity, progress.current, progress.total) : void 0;
+    if (helperOpts?.reportDiscoveryProgress)
+      emitIndexCheckActivity(opts, "Discovering source files");
+    const discoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
       ...opts?.discovery,
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
       ...knownSymlinkDirectories !== void 0 ? { knownSymlinkDirectories } : {},
-      onSymlinkDirectoriesDiscovered
+      onSymlinkDirectoriesDiscovered,
+      onGitCandidatesDiscovered,
+      ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
     });
     const additionalFileCandidates = await normalizeIndexedFileInputsWithinRoot(projectRoot, opts?.additionalFiles ?? [], "Additional index file");
     const additionalFileExistence = await probePathExistence(additionalFileCandidates, buildConcurrency(opts));
@@ -53930,9 +55731,13 @@ async function buildProjectIndexWithManifestOptions(projectRoot, opts, helperOpt
     const discoveredFileSet = new Set(discoveredFiles);
     const files = Array.from(/* @__PURE__ */ new Set([...discoveredFiles, ...additionalFiles]));
     const transientFiles = additionalFiles.filter((file2) => !discoveredFileSet.has(file2));
-    const projectFiles = await discoverProjectFiles(projectRoot, {
+    if (helperOpts?.reportDiscoveryProgress)
+      emitIndexCheckActivity(opts, "Discovering project metadata");
+    const projectFiles = await discoverProjectFilesWithGitCandidates(projectRoot, {
       ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
-      ...discoveredSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: discoveredSymlinkDirectories } : {}
+      ...discoveredSymlinkDirectories !== void 0 ? { knownSymlinkDirectories: discoveredSymlinkDirectories } : {},
+      ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {},
+      ...onDiscoveryProgress ? { onDiscoveryProgress } : {}
     });
     return await buildIndexFromFileListShared(projectRoot, files, opts, {
       manifestMode: useDiskCache ? "read-write" : "off",
@@ -54072,7 +55877,10 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
         manifestReport.reason = reason;
         manifestReport.reused = false;
       }
-      return await buildProjectIndexFromExport(projectRoot, opts, { ignoreExistingManifest: true });
+      return await buildProjectIndexFromExport(projectRoot, opts, {
+        ignoreExistingManifest: true,
+        reportDiscoveryProgress: true
+      });
     }
     const gitAvailable = await isGitRepo(projectRoot);
     const hasExplicitGitRange = !!opts?.gitBase || !!opts?.gitHead;
@@ -54093,7 +55901,10 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
           manifestReport.reused = false;
         }
         logWithLevel(opts?.logLevel, "warn", "Warning: Manifest commit is no longer available; rebuilding full index.");
-        const rebuiltIndex = await buildProjectIndexFromExport(projectRoot, opts, { ignoreExistingManifest: true });
+        const rebuiltIndex = await buildProjectIndexFromExport(projectRoot, opts, {
+          ignoreExistingManifest: true,
+          reportDiscoveryProgress: true
+        });
         if (manifestReport) {
           manifestReport.reason = "staleGitCommit";
           manifestReport.reused = false;
@@ -54111,7 +55922,10 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
       }
       if (mismatches > 0 || missing > 0) {
         logWithLevel(opts?.logLevel, "warn", `Warning: Manifest verification failed (mismatches: ${mismatches}, missing: ${missing}). Rebuilding full index.`);
-        return await buildProjectIndexFromExport(projectRoot, opts, { ignoreExistingManifest: true });
+        return await buildProjectIndexFromExport(projectRoot, opts, {
+          ignoreExistingManifest: true,
+          reportDiscoveryProgress: true
+        });
       }
     }
     const trackedEntries = sanitizeManifestEntriesForRoot(projectRoot, manifest.files);
@@ -54126,6 +55940,7 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
     const gitFiles = needsGitScan ? await listChangedFiles(projectRoot, buildIncrementalGitDiffOptions(opts)) : [];
     let untrackedFiles = [];
     let rediscoveredFiles = [];
+    let discoveredGitCandidates;
     if (canUseIncrementalDiscoveryFastPath(gitAvailable, opts?.cacheStrict)) {
       try {
         untrackedFiles = (canReuseReconciliation ? opts?.reconciledUntrackedFiles : void 0) ?? await listUntrackedProjectFiles(projectRoot, opts?.discovery, gitAvailable);
@@ -54135,13 +55950,19 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
           manifestReport.reused = false;
         }
         logWithLevel(opts?.logLevel, "warn", "Warning: Failed to list untracked project files via Git; rebuilding full index.", error51);
-        return await buildProjectIndexFromExport(projectRoot, opts, { ignoreExistingManifest: true });
+        return await buildProjectIndexFromExport(projectRoot, opts, {
+          ignoreExistingManifest: true,
+          reportDiscoveryProgress: true
+        });
       }
     } else if (!opts?.filesAreProjectScope) {
-      rediscoveredFiles = await listProjectFiles(projectRoot, projectPatternsForLanguageExtensions(opts), {
+      rediscoveredFiles = await listProjectFilesWithGitCandidates(projectRoot, projectPatternsForLanguageExtensions(opts), {
         ...opts?.discovery,
         ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
-        ...!opts?.cacheStrict && manifest.symlinkDirectories !== void 0 ? { knownSymlinkDirectories: manifest.symlinkDirectories } : {}
+        ...!opts?.cacheStrict && manifest.symlinkDirectories !== void 0 ? { knownSymlinkDirectories: manifest.symlinkDirectories } : {},
+        onGitCandidatesDiscovered: (candidates) => {
+          discoveredGitCandidates = candidates;
+        }
       });
     }
     const candidateFiles = [
@@ -54241,8 +56062,9 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
       if (!snapshotLoad)
         return null;
       const snapshot = snapshotLoad.index;
-      snapshot.projectFiles ??= await discoverProjectFiles(projectRoot, {
-        ...opts?.logLevel ? { logLevel: opts.logLevel } : {}
+      snapshot.projectFiles ??= await discoverProjectFilesWithGitCandidates(projectRoot, {
+        ...opts?.logLevel ? { logLevel: opts.logLevel } : {},
+        ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {}
       });
       if (opts?.cache) {
         snapshot.cacheMode = opts.cache;
@@ -54549,6 +56371,7 @@ async function buildProjectIndexIncremental(projectRoot, opts) {
         modules,
         parsedMap,
         bloomFilterCache,
+        ...discoveredGitCandidates !== void 0 ? { knownGitCandidates: discoveredGitCandidates } : {},
         manifestEntries: projectIndexManifestEntries2(
           // `manifestEntries` (a `ManifestFileEntry`) never carries `cacheSig` -- that field
           // only lives on `FileSignature`. Overlay each entry with the `cacheSig` this build
@@ -57808,13 +59631,13 @@ __export(skill_exports, {
   handleSkillCommand: () => handleSkillCommand
 });
 import fsp30 from "node:fs/promises";
-import os6 from "node:os";
+import os7 from "node:os";
 import path53 from "node:path";
 function getBundledSkillDir(packageRoot) {
   const candidate = path53.join(packageRoot, "codegraph-skill", "codegraph");
   return pathExists(path53.join(candidate, "SKILL.md")) ? candidate : null;
 }
-function getSkillTargetDirForAgent(agent, homeDir = os6.homedir(), env = process.env) {
+function getSkillTargetDirForAgent(agent, homeDir = os7.homedir(), env = process.env) {
   if (agent === "agents") {
     return path53.join(homeDir, ".agents", "skills", "codegraph");
   }
@@ -58033,7 +59856,7 @@ var init_skill = __esm({
 // dist/installer/locks.js
 import { createHash as createHash5, randomUUID as randomUUID3 } from "node:crypto";
 import fsp31, {} from "node:fs/promises";
-import os7 from "node:os";
+import os8 from "node:os";
 import path54 from "node:path";
 function opencodeConfigHome(settings) {
   const configHome = settings.env.XDG_CONFIG_HOME?.trim();
@@ -58069,7 +59892,7 @@ function installerTransactionLockScopes(settings) {
 }
 function installerTransactionLockPath(scope) {
   const digest = createHash5("sha256").update(scope).digest("hex");
-  return path54.join(os7.tmpdir(), `codegraph-installer-${digest}.lock`);
+  return path54.join(os8.tmpdir(), `codegraph-installer-${digest}.lock`);
 }
 async function withInstallerLeaseLock(lockPath, resourceName, operation) {
   const lock = await acquireInstallerLeaseLock(lockPath, resourceName);
@@ -58235,7 +60058,7 @@ var init_locks = __esm({
 // dist/installer/registry.js
 import { createHash as createHash6, randomUUID as randomUUID4 } from "node:crypto";
 import fsp32 from "node:fs/promises";
-import os8 from "node:os";
+import os9 from "node:os";
 import path55 from "node:path";
 import { applyEdits, modify, parse as parseJsonc2 } from "jsonc-parser";
 function listInstallTargets() {
@@ -58984,7 +60807,7 @@ function installerSettings(options) {
   if (env === void 0)
     env = options.homeDir === void 0 ? process.env : {};
   return {
-    homeDir: options.homeDir ?? os8.homedir(),
+    homeDir: options.homeDir ?? os9.homedir(),
     env
   };
 }
@@ -59321,7 +61144,7 @@ __export(doctor_exports, {
   formatDoctorSummary: () => formatDoctorSummary
 });
 import fs25 from "node:fs";
-import os9 from "node:os";
+import os10 from "node:os";
 import path57 from "node:path";
 function statIfExists(filePath) {
   try {
@@ -59549,7 +61372,7 @@ function readCacheLocationField(configPath) {
   }
 }
 function readUserCacheLocation() {
-  const configRoot = process.platform === "win32" ? process.env.APPDATA?.trim() || path57.join(os9.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME?.trim() || path57.join(os9.homedir(), ".config");
+  const configRoot = process.platform === "win32" ? process.env.APPDATA?.trim() || path57.join(os10.homedir(), "AppData", "Roaming") : process.env.XDG_CONFIG_HOME?.trim() || path57.join(os10.homedir(), ".config");
   return readCacheLocationField(path57.join(configRoot, "codegraph", "config.json"));
 }
 function readEffectiveCacheLocation(root) {
@@ -72138,9 +73961,10 @@ var init_packet = __esm({
 import fs32 from "node:fs/promises";
 import { brotliCompressSync as brotliCompressSync4, constants as zlibConstants4 } from "node:zlib";
 function compressQueryText(text) {
-  return brotliCompressSync4(text, {
+  const compressed = brotliCompressSync4(text, {
     params: { [zlibConstants4.BROTLI_PARAM_QUALITY]: 4 }
   });
+  return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
 }
 function normalizeQuerySearchText(input) {
   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();
@@ -72982,12 +74806,19 @@ var init_sourceIdentity = __esm({
 // dist/agent/query-index/workerPool.js
 var workerPool_exports = {};
 __export(workerPool_exports, {
+  QUERY_INDEX_WORKER_MIN_FILES: () => QUERY_INDEX_WORKER_MIN_FILES,
+  prepareQueryIndexFiles: () => prepareQueryIndexFiles,
+  prepareQueryIndexFilesInProcess: () => prepareQueryIndexFilesInProcess,
   prepareQueryIndexFilesInWorker: () => prepareQueryIndexFilesInWorker,
-  resolveQueryIndexWorkerPath: () => resolveQueryIndexWorkerPath
+  resolveQueryIndexWorkerPath: () => resolveQueryIndexWorkerPath,
+  shouldPrepareQueryIndexFilesInWorker: () => shouldPrepareQueryIndexFilesInWorker
 });
 import fs33 from "node:fs";
 import path75 from "node:path";
 import { fileURLToPath as fileURLToPath6 } from "node:url";
+function shouldPrepareQueryIndexFilesInWorker(fileCount, threadCount = resolveWorkerThreads()) {
+  return threadCount > 1 && fileCount >= QUERY_INDEX_WORKER_MIN_FILES;
+}
 function resolveWorkerThreads() {
   return resolveWorkerThreadCount({ max: QUERY_INDEX_MAX_THREADS });
 }
@@ -73052,7 +74883,15 @@ async function prepareQueryIndexFilesInWorker(projectRoot, files) {
     await pool.destroy();
   }
 }
-var QUERY_INDEX_MAX_THREADS;
+async function prepareQueryIndexFiles(projectRoot, files) {
+  if (!files.length)
+    return [];
+  if (!shouldPrepareQueryIndexFilesInWorker(files.length)) {
+    return await prepareQueryIndexFilesInProcess(projectRoot, files);
+  }
+  return await prepareQueryIndexFilesInWorker(projectRoot, files);
+}
+var QUERY_INDEX_MAX_THREADS, QUERY_INDEX_WORKER_MIN_FILES;
 var init_workerPool = __esm({
   "dist/agent/query-index/workerPool.js"() {
     "use strict";
@@ -73062,6 +74901,7 @@ var init_workerPool = __esm({
     init_paths2();
     init_workerThreads();
     QUERY_INDEX_MAX_THREADS = 4;
+    QUERY_INDEX_WORKER_MIN_FILES = 512;
   }
 });
 
@@ -73146,8 +74986,8 @@ function buildMetadata(current) {
 }
 async function prepareFiles(projectRoot, files, diagnostics) {
   try {
-    const { prepareQueryIndexFilesInWorker: prepareQueryIndexFilesInWorker2 } = await Promise.resolve().then(() => (init_workerPool(), workerPool_exports));
-    const prepared = await prepareQueryIndexFilesInWorker2(projectRoot, files.map((file2) => ({
+    const { prepareQueryIndexFiles: prepareQueryIndexFiles2 } = await Promise.resolve().then(() => (init_workerPool(), workerPool_exports));
+    const prepared = await prepareQueryIndexFiles2(projectRoot, files.map((file2) => ({
       relativePath: file2.path,
       sourceIdentity: file2.sourceIdentity
     })));
@@ -102040,7 +103880,7 @@ var init_dist4 = __esm({
 });
 
 // dist/mcp/http.js
-import os10 from "node:os";
+import os11 from "node:os";
 function getRequestPath(request) {
   return new URL(request.url ?? "/", "http://127.0.0.1").pathname;
 }
@@ -102243,11 +104083,11 @@ function isWildcardBindHost(host) {
 }
 function localInterfaceHostnames() {
   const hosts = /* @__PURE__ */ new Set();
-  const hostname3 = os10.hostname().trim().toLowerCase();
+  const hostname3 = os11.hostname().trim().toLowerCase();
   if (hostname3) {
     hosts.add(hostname3);
   }
-  const interfaces = os10.networkInterfaces();
+  const interfaces = os11.networkInterfaces();
   for (const entries of Object.values(interfaces)) {
     for (const entry of entries ?? []) {
       if (entry.internal)
@@ -106287,7 +108127,7 @@ var init_artifact3 = __esm({
 // dist/drift/git.js
 import { execFile } from "node:child_process";
 import fsp42 from "node:fs/promises";
-import os11 from "node:os";
+import os12 from "node:os";
 import path91 from "node:path";
 import { promisify } from "node:util";
 function snapshotOptions(options) {
@@ -106326,7 +108166,7 @@ async function materializeGitRef(root, ref, prefix) {
   }
   if (checkoutRef === void 0 || checkoutRef === "." || isGitWorktreeSentinel(checkoutRef))
     return { root };
-  const tempRoot = await fsp42.mkdtemp(path91.join(os11.tmpdir(), prefix));
+  const tempRoot = await fsp42.mkdtemp(path91.join(os12.tmpdir(), prefix));
   try {
     await execFileAsync("git", ["clone", "--quiet", "--no-checkout", root, tempRoot], { env: process.env });
     const checkoutCommit = await resolveGitCommit(root, checkoutRef);