@lzehrung/codegraph 2.3.19 → 2.3.21

package/dist/util/projectFiles.js

@@ -12,7 +12,8 @@ export { isRelativePathInside, matchesDiscoveryGlob } from "./discoveryPath.js";
 import { PROJECT_FILE_DEFINITIONS, } from "./projectFiles/definitions.js";
 import { trimToNull } from "./projectFiles/parsers.js";
 import { mapLimitSemaphore } from "./concurrency.js";
-import { getGitRepositoryRoot, isGitProjectRootIgnored, isGitRepo, isGitTimeoutError, listGitExcludeFiles, listGitStageSpecialPaths, listTrackedFiles, listUntrackedFiles, } from "./git.js";
+import { CODEGRAPH_CONFIG_FILE } from "../config.js";
+import { createGitDiscoveryCache, getGitRepositoryRoot, isGitProjectRootIgnored, isGitRepo, isGitTimeoutError, listGitExcludeFiles, listGitStageSpecialPaths, listGitSubmoduleDirectories, listTrackedFiles, listUntrackedFiles, } from "./git.js";
 export const DEFAULT_PROJECT_FILE_IGNORES = [
     "**/node_modules/**",
     "**/.git/**",
@@ -100,6 +101,9 @@ export const DEFAULT_PROJECT_PATTERNS = [
     ...DEFAULT_PROJECT_MANIFESTS.map((name) => `**/${name}`),
 ];
 const REALPATH_FILTER_CONCURRENCY = 64;
+export function createProjectDiscoveryContext(projectRoot) {
+    return new DiscoveryContext(projectRoot);
+}
 function emitDiscoveryActivity(report, activity, current = 0, total = 0) {
     report?.({ activity, current, total });
 }
@@ -121,6 +125,35 @@ function isPresent(value) {
 function normalizeGlobPattern(globPattern) {
     return globPattern.trim().replace(/\\/g, "/");
 }
+const ROOT_CONFIG_NAME_MATCHERS = [...DEFAULT_PROJECT_MANIFESTS, CODEGRAPH_CONFIG_FILE].map((pattern) => picomatch(normalizeGlobPattern(pattern), { dot: true }));
+function isRootConfigFileName(fileName) {
+    return ROOT_CONFIG_NAME_MATCHERS.some((matcher) => matcher(fileName));
+}
+async function listRootConfigFiles(root, state) {
+    const entries = await readDirectoryWithFileTypes(root, state);
+    const files = [];
+    for (const entry of entries) {
+        if (!isRootConfigFileName(entry.name))
+            continue;
+        const file = normalizePath(path.join(root, entry.name));
+        if (!entry.isFile()) {
+            if (!entry.isSymbolicLink())
+                continue;
+            try {
+                if (!(await fsp.stat(file)).isFile())
+                    continue;
+            }
+            catch (error) {
+                const code = error.code;
+                if (code === "ENOENT" || code === "ENOTDIR")
+                    continue;
+                throw error;
+            }
+        }
+        files.push(file);
+    }
+    return files;
+}
 const DIRECTORY_METADATA_EXTENSIONS = new Set();
 const DIRECTORY_METADATA_BASENAMES = new Set();
 for (const definition of PROJECT_FILE_DEFINITIONS) {
@@ -275,6 +308,126 @@ const EMPTY_GITIGNORE_INDEX = {
     repositoryAliases: [],
     byBaseDir: new Map(),
 };
+class DiscoveryContext {
+    projectRoot;
+    git;
+    gitCandidatesByRoot = new Map();
+    ignoreIndexByKey = new Map();
+    fileTextByPath = new Map();
+    readdirCache = new Map();
+    globFilesystem;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.git = createGitDiscoveryCache();
+        this.globFilesystem = { readdir: createSharedReaddir(this) };
+    }
+}
+function createSharedReaddir(state) {
+    function readdir(directory, optionsOrCallback, callback) {
+        const listing = readDirectoryWithFileTypes(directory, state);
+        if (typeof optionsOrCallback === "function") {
+            listing.then((entries) => optionsOrCallback(null, entries.map((entry) => entry.name)), (error) => optionsOrCallback(error, []));
+        }
+        else if (callback) {
+            listing.then((entries) => callback(null, entries), (error) => callback(error, []));
+        }
+    }
+    return readdir;
+}
+function globFilesystemOption(state) {
+    if (!state)
+        return {};
+    return { fs: state.globFilesystem };
+}
+function globFilesystemField(state) {
+    if (!state)
+        return {};
+    return { globFilesystem: state.globFilesystem };
+}
+async function readDirectoryWithFileTypes(directory, state) {
+    if (!state)
+        return fsp.readdir(directory, { withFileTypes: true });
+    const key = fileIdentityKey(directory);
+    const cached = state.readdirCache.get(key);
+    if (cached)
+        return cached;
+    const pending = fsp.readdir(directory, { withFileTypes: true });
+    state.readdirCache.set(key, pending);
+    return pending;
+}
+async function readDiscoveryFileResult(state, filePath) {
+    if (!state) {
+        try {
+            return { ok: true, text: await fsp.readFile(filePath, "utf8") };
+        }
+        catch (error) {
+            return { ok: false, error };
+        }
+    }
+    const key = fileIdentityKey(filePath);
+    const cached = state.fileTextByPath.get(key);
+    if (cached)
+        return await cached;
+    const pending = (async () => {
+        try {
+            return { ok: true, text: await fsp.readFile(filePath, "utf8") };
+        }
+        catch (error) {
+            return { ok: false, error };
+        }
+    })();
+    state.fileTextByPath.set(key, pending);
+    return await pending;
+}
+export async function readProjectDiscoveryFileText(discoveryContext, filePath) {
+    const result = await readDiscoveryFileResult(discoveryContext, filePath);
+    if (result.ok)
+        return result.text;
+    if (result.error instanceof Error)
+        throw result.error;
+    throw new Error(`Failed to read ${filePath}: ${stringifyUnknown(result.error)}`);
+}
+async function sharedGitignoreIndex(state, cacheKey, load) {
+    if (!state)
+        return await load();
+    const cached = state.ignoreIndexByKey.get(cacheKey);
+    if (cached)
+        return await cached;
+    const pending = load();
+    state.ignoreIndexByKey.set(cacheKey, pending);
+    return await pending;
+}
+function rememberGitCandidates(state, root, candidates) {
+    if (!state)
+        return;
+    const key = fileIdentityKey(root);
+    if (state.gitCandidatesByRoot.has(key))
+        return;
+    state.gitCandidatesByRoot.set(key, Promise.resolve(candidates));
+}
+async function getSharedGitCandidates(context, root, logLevel, callbacks) {
+    const state = context;
+    const gitCache = context?.git;
+    if (!state)
+        return await listGitCandidateFiles(root, logLevel, callbacks, gitCache);
+    const key = fileIdentityKey(root);
+    const cached = state.gitCandidatesByRoot.get(key);
+    if (cached)
+        return await cached;
+    const pending = listGitCandidateFiles(root, logLevel, callbacks, gitCache);
+    state.gitCandidatesByRoot.set(key, pending);
+    return await pending;
+}
+function gitExcludeListOptions(gitCache) {
+    if (!gitCache)
+        return undefined;
+    return { discoveryCache: gitCache };
+}
+function gitUntrackedListOptions(gitCache) {
+    if (!gitCache)
+        return { respectGitignore: true };
+    return { respectGitignore: true, discoveryCache: gitCache };
+}
 /**
  * Parse `.gitignore` rules from an already-discovered set of `.gitignore` files.
  *
@@ -284,7 +437,7 @@ const EMPTY_GITIGNORE_INDEX = {
  * child negation could re-include files. Depth-first ordering also keeps the "last match
  * wins" order deeper files depend on, and drops the locale sensitivity of `localeCompare`.
  */
-async function buildGitignoreIndex(sources, repositoryRoots = [], repositoryAliases = []) {
+async function buildGitignoreIndex(sources, repositoryRoots = [], repositoryAliases = [], state) {
     const sorted = [...sources]
         .map(({ file, baseDir, repositoryRoot, priority }) => ({
         file: normalizePath(file),
@@ -316,13 +469,10 @@ async function buildGitignoreIndex(sources, repositoryRoots = [], repositoryAlia
         if (isIgnoredByGitignore(path.dirname(file), gitignoreIndex, true)) {
             continue;
         }
-        let raw;
-        try {
-            raw = await fsp.readFile(file, "utf8");
-        }
-        catch {
+        const fileText = await readDiscoveryFileResult(state, file);
+        if (!fileText.ok)
             continue;
-        }
+        const raw = fileText.text;
         const baseKey = fileIdentityKey(baseDir);
         for (const line of raw.split(/\r?\n/)) {
             const rule = parseGitignoreRule(baseDir, line);
@@ -338,16 +488,17 @@ async function buildGitignoreIndex(sources, repositoryRoots = [], repositoryAlia
     }
     return gitignoreIndex;
 }
-async function findGitignoreFiles(projectRoot) {
+async function findGitignoreFiles(projectRoot, state) {
     return await fg(["**/.gitignore"], {
         cwd: projectRoot,
         absolute: true,
         dot: true,
         followSymbolicLinks: false,
         ignore: DEFAULT_PROJECT_FILE_IGNORES,
+        ...globFilesystemOption(state),
     });
 }
-async function loadGitignoreIndexForRootAliases(projectRoot) {
+async function loadGitignoreIndexForRootAliases(projectRoot, state) {
     const roots = [projectRoot];
     const realRoot = await fsp.realpath(projectRoot);
     if (normalizePath(realRoot) !== normalizePath(projectRoot)) {
@@ -355,11 +506,11 @@ async function loadGitignoreIndexForRootAliases(projectRoot) {
     }
     const sources = [];
     for (const root of roots) {
-        for (const file of await findGitignoreFiles(root)) {
+        for (const file of await findGitignoreFiles(root, state)) {
             sources.push({ file, baseDir: path.dirname(file) });
         }
     }
-    return await buildGitignoreIndex(sources);
+    return await buildGitignoreIndex(sources, [], [], state);
 }
 /**
  * Whether `.gitignore` rules ignore `absolutePath`.
@@ -459,11 +610,12 @@ function collectCandidateAncestorDirectories(root, files) {
     }
     return directories;
 }
-function owningGitIgnoreSourceRoot(file, roots) {
+export function owningGitIgnoreSourceRoot(file, roots, realpathMemo) {
     const normalized = normalizePath(file);
     let owning;
     for (const root of roots) {
-        if (!isFilePathWithinRoot(root.path, normalized) && !isFilePathWithinRoot(root.repositoryRoot, normalized)) {
+        if (!isFilePathWithinRoot(root.path, normalized, realpathMemo) &&
+            !isFilePathWithinRoot(root.repositoryRoot, normalized, realpathMemo)) {
             continue;
         }
         if (!owning || root.repositoryRoot.length > owning.repositoryRoot.length) {
@@ -472,6 +624,24 @@ function owningGitIgnoreSourceRoot(file, roots) {
     }
     return owning;
 }
+/**
+ * Ownership is pure path containment, so every candidate in the same parent directory
+ * shares one answer. The lookup and its realpath memo live only for this discovery pass,
+ * so a long-lived process cannot serve a stale owner after the tree changes.
+ */
+export function createGitIgnoreSourceOwnershipLookup(roots, realpathMemo) {
+    const ownershipByDirectory = new Map();
+    return (file) => {
+        const directory = normalizePath(path.dirname(file));
+        const key = fileIdentityKey(directory);
+        if (ownershipByDirectory.has(key)) {
+            return ownershipByDirectory.get(key);
+        }
+        const owning = owningGitIgnoreSourceRoot(directory, roots, realpathMemo);
+        ownershipByDirectory.set(key, owning);
+        return owning;
+    };
+}
 async function gitignoreFileIfPresent(directory) {
     const file = normalizePath(path.join(directory, ".gitignore"));
     try {
@@ -494,7 +664,7 @@ async function gitignoreFileIfPresent(directory) {
  * `.gitignore` files walks every gitignored tree looking for them, which times
  * out on a large ignored data directory even after file listing already finished.
  */
-async function findGitIgnoreSources(sourceRoots, candidateFiles) {
+async function findGitIgnoreSources(sourceRoots, candidateFiles, gitCache) {
     const roots = Array.from(new Map(sourceRoots.map(({ path: sourceRoot, repositoryRoot }) => [
         fileIdentityKey(sourceRoot),
         { path: normalizePath(sourceRoot), repositoryRoot: normalizePath(repositoryRoot) },
@@ -510,13 +680,15 @@ async function findGitIgnoreSources(sourceRoots, candidateFiles) {
     for (const { path: sourceRoot, repositoryRoot } of roots) {
         addDirectory(sourceRoot, repositoryRoot);
     }
+    const realpathMemo = new Map();
+    const owningOf = createGitIgnoreSourceOwnershipLookup(roots, realpathMemo);
     for (const file of candidateFiles) {
-        const owning = owningGitIgnoreSourceRoot(file, roots);
+        const owning = owningOf(file);
         if (!owning)
             continue;
         let dir = normalizePath(path.dirname(file));
         const stopKey = fileIdentityKey(owning.repositoryRoot);
-        for (;;) {
+        while (true) {
             const dirKey = fileIdentityKey(dir);
             const walkKey = `${dirKey}\0${stopKey}`;
             if (walkedDirectoryKeys.has(walkKey))
@@ -527,7 +699,8 @@ async function findGitIgnoreSources(sourceRoots, candidateFiles) {
                 break;
             const parent = normalizePath(path.dirname(dir));
             if (parent === dir ||
-                (!isFilePathWithinRoot(owning.path, parent) && !isFilePathWithinRoot(owning.repositoryRoot, parent))) {
+                (!isFilePathWithinRoot(owning.path, parent, realpathMemo) &&
+                    !isFilePathWithinRoot(owning.repositoryRoot, parent, realpathMemo))) {
                 break;
             }
             dir = parent;
@@ -539,7 +712,7 @@ async function findGitIgnoreSources(sourceRoots, candidateFiles) {
             const file = await gitignoreFileIfPresent(dir);
             return file ? [{ file, baseDir: dir, repositoryRoot, priority: 2 }] : [];
         }),
-        Promise.all(uniqueRepositoryRoots.map((repositoryRoot) => listGitExcludeFiles(repositoryRoot))),
+        Promise.all(uniqueRepositoryRoots.map((repositoryRoot) => listGitExcludeFiles(repositoryRoot, gitExcludeListOptions(gitCache)))),
     ]);
     return [
         ...gitignoreHits.flat(),
@@ -555,15 +728,15 @@ async function findGitIgnoreSources(sourceRoots, candidateFiles) {
  * Tracked plus untracked-but-not-ignored files are Git candidates. Submodule files retain
  * their own repository boundary, and source roots cover logical and physical aliases.
  */
-async function listGitCandidateFiles(root, logLevel, opts) {
+async function listGitCandidateFiles(root, logLevel, opts, gitCache) {
     let gitListStart;
     let gitIgnoreStart;
     try {
         const realRoot = normalizePath(await fsp.realpath(root));
-        const gitRoot = (await isGitRepo(root)) ? root : realRoot;
-        if (!(await isGitRepo(gitRoot)))
+        const gitRoot = (await isGitRepo(root, gitCache)) ? root : realRoot;
+        if (!(await isGitRepo(gitRoot, gitCache)))
             return null;
-        if (await isGitProjectRootIgnored(realRoot))
+        if (await isGitProjectRootIgnored(realRoot, gitCache))
             return null;
         const gitRepositoryRoot = await getGitRepositoryRoot(gitRoot);
         if (!gitRepositoryRoot)
@@ -571,9 +744,10 @@ async function listGitCandidateFiles(root, logLevel, opts) {
         emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git files");
         const listStartedAt = performance.now();
         gitListStart = listStartedAt;
+        const untrackedOptions = gitUntrackedListOptions(gitCache);
         const [tracked, untracked, stageSpecial] = await Promise.all([
             listTrackedFiles(gitRoot, { recurseSubmodules: true, ...(logLevel === undefined ? {} : { logLevel }) }),
-            listUntrackedFiles(gitRoot, { respectGitignore: true }),
+            listUntrackedFiles(gitRoot, untrackedOptions),
             listGitStageSpecialPaths(gitRoot, { recurse: true }),
         ]);
         const submoduleDirectories = stageSpecial.gitlinks;
@@ -581,7 +755,7 @@ async function listGitCandidateFiles(root, logLevel, opts) {
             logicalPath: normalizePath(logicalPath),
             physicalPath: normalizePath(await fsp.realpath(logicalPath).catch(() => logicalPath)),
         })));
-        const submoduleUntracked = await Promise.all(submoduleRoots.map(async ({ physicalPath }) => await listUntrackedFiles(physicalPath, { respectGitignore: true })));
+        const submoduleUntracked = await Promise.all(submoduleRoots.map(async ({ physicalPath }) => await listUntrackedFiles(physicalPath, untrackedOptions)));
         const rawFiles = Array.from(new Set([...tracked, ...untracked, ...submoduleUntracked.flat()])).sort();
         const needsLogicalRemap = normalizePath(gitRoot) !== normalizePath(root);
         const files = Array.from(new Set(rawFiles.map((file) => needsLogicalRemap && isFilePathWithinRoot(realRoot, file)
@@ -607,7 +781,7 @@ async function listGitCandidateFiles(root, logLevel, opts) {
         emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git ignore files");
         const ignoreStartedAt = performance.now();
         gitIgnoreStart = ignoreStartedAt;
-        const gitignoreFiles = await findGitIgnoreSources(sourceRoots, files);
+        const gitignoreFiles = await findGitIgnoreSources(sourceRoots, files, gitCache);
         emitDiscoveryTiming(opts?.onDiscoveryTiming, "git-ignore", ignoreStartedAt);
         gitIgnoreStart = undefined;
         emitDiscoveryActivity(opts?.onDiscoveryProgress, "Listing Git ignore files", gitignoreFiles.length, gitignoreFiles.length);
@@ -673,15 +847,26 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
         // disk): on an Unreal project holding 100,168 files (818 tracked) the scan produced
         // 55,983 pattern-matching candidates, nearly all generated sources under a gitignored
         // `Intermediate/` tree, and discovery took 26.1s. Git lists 4,010 in about 111ms.
-        // An aliased root or a gitignore-root override means Git's notion of the project is
-        // not this call's, so those fall back to the scan.
-        const attemptedGitCandidates = useGitignore && options?.gitignoreRoot === undefined && normalizePath(realRoot) === normalizePath(root);
+        // An aliased root or a gitignore-root override that points elsewhere means Git's notion
+        // of the project is not this call's, so those fall back to the scan. Passing
+        // `gitignoreRoot` equal to the scan root (the CLI's historical whole-project form) still
+        // wants this repository's ignore rules, so keep the Git candidate path. On a 501-file
+        // Git repo with a 20,000-file gitignored tree, `gitignoreRoot: scanRoot` otherwise
+        // forced a filesystem scan plus a full-tree symlink probe (~403ms) instead of Git
+        // listing (~66ms) of the 502 tracked paths.
+        // Compare by identity key, not slash normalization: on a case-insensitive filesystem a
+        // casing or drive-letter difference still names the same directory, and calling that a
+        // mismatch would silently drop back to the slow scan this fast path exists to avoid.
+        const scanRootKey = fileIdentityKey(root);
+        const gitignoreRootMatchesScanRoot = options?.gitignoreRoot === undefined || fileIdentityKey(options.gitignoreRoot) === scanRootKey;
+        const attemptedGitCandidates = useGitignore && gitignoreRootMatchesScanRoot && fileIdentityKey(realRoot) === scanRootKey;
         const gitDiscoveryCallbacks = {
             ...(options?.onDiscoveryProgress ? { onDiscoveryProgress: options.onDiscoveryProgress } : {}),
             ...(options?.onDiscoveryTiming ? { onDiscoveryTiming: options.onDiscoveryTiming } : {}),
         };
+        const discovery = options?.discoveryContext ?? createProjectDiscoveryContext(root);
         const gitCandidates = attemptedGitCandidates
-            ? await listGitCandidateFiles(root, options?.logLevel, gitDiscoveryCallbacks)
+            ? await getSharedGitCandidates(discovery, root, options?.logLevel, gitDiscoveryCallbacks)
             : null;
         // Report only when this call actually asked Git, including a null result. Callers that
         // already enumerated candidates (build-index) can hand the same set to metadata discovery
@@ -691,13 +876,13 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
         }
         let gitignoreIndex = EMPTY_GITIGNORE_INDEX;
         if (useGitignore && gitCandidates) {
-            gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases);
+            gitignoreIndex = await sharedGitignoreIndex(discovery, `git:${fileIdentityKey(root)}`, () => buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases, discovery));
         }
         else if (useGitignore) {
             const gitignoreRoot = options?.gitignoreRoot
                 ? await ensureDirectoryReadable(options.gitignoreRoot, "Gitignore root")
                 : root;
-            gitignoreIndex = await loadGitignoreIndexForRootAliases(gitignoreRoot);
+            gitignoreIndex = await sharedGitignoreIndex(discovery, `fs:${fileIdentityKey(gitignoreRoot)}`, () => loadGitignoreIndexForRootAliases(gitignoreRoot, discovery));
         }
         // Git returns a candidate set, not a filtered result: the pattern, include,
         // default-ignore, and gitignore checks below still decide what is indexable.
@@ -714,6 +899,7 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
                 dot: true,
                 followSymbolicLinks: false,
                 ignore: fastGlobIgnoreGlobs,
+                ...globFilesystemOption(discovery),
             });
             emitDiscoveryTiming(options?.onDiscoveryTiming, "filesystem-scan", scanStart);
             emitDiscoveryActivity(options?.onDiscoveryProgress, "Scanning project files", files.length, files.length);
@@ -733,6 +919,7 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
                 dot: true,
                 followSymbolicLinks: false,
                 ignore: translatedUserIgnoreGlobs,
+                ...globFilesystemOption(discovery),
             })
             : [];
         const reportSourceSymlinkChecks = options?.onDiscoveryProgress
@@ -751,6 +938,7 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
                 ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
                 : {}),
             ...(reportSourceSymlinkChecks ? { onPathCheckProgress: reportSourceSymlinkChecks } : {}),
+            ...globFilesystemField(discovery),
         };
         const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, symlinkProbeIgnoreGlobs, symlinkOptions);
         const linkedFiles = await listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, fastGlobIgnoreGlobs, {
@@ -764,6 +952,7 @@ async function listProjectFilesInternal(projectRoot, patterns = DEFAULT_PROJECT_
                 globRoot,
                 filterIgnoreGlobs: userIgnoreGlobs,
                 resolvedSafeSymlinkDirectories: safeSymlinkDirectories,
+                ...globFilesystemField(discovery),
             });
         // Cheap path predicates run before the realpath confinement probe. Git enumerates
         // every tracked and untracked file it knows about, including trees this project
@@ -928,6 +1117,7 @@ async function resolveSafeSymlinkDirectories(root, realRoot, ignore, options) {
         followSymbolicLinks: false,
         objectMode: true,
         ignore,
+        ...(options.globFilesystem ? { fs: options.globFilesystem } : {}),
     }));
     const discovered = await verifySafeSymlinkDirectories(root, realRoot, entries.filter((entry) => entry.dirent.isSymbolicLink()).map((entry) => entry.path), options.onPathCheckProgress);
     options.onSymlinkDirectoriesDiscovered?.(discovered, "filesystem");
@@ -953,6 +1143,7 @@ async function listEntriesFromSafeSymlinkDirectories(root, realRoot, patterns, i
         ignore: locationIndependentIgnores,
         ...(options.onlyFiles !== undefined ? { onlyFiles: options.onlyFiles } : {}),
         ...(options.markDirectories !== undefined ? { markDirectories: options.markDirectories } : {}),
+        ...(options.globFilesystem ? { fs: options.globFilesystem } : {}),
     })).filter((filePath) => {
         const cleanPath = filePath.endsWith("/") ? filePath.slice(0, -1) : filePath;
         return !rootRelativeIgnoreMatchers.some((matcher) => matchesDiscoveryGlob(cleanPath, globRoot, matcher));
@@ -987,14 +1178,14 @@ export async function filterRealPathsWithinRoot(paths, realRoot, onPathCheckProg
 function toProjectGlob(pattern) {
     return pattern.startsWith("**/") ? pattern : `**/${pattern}`;
 }
-async function buildProjectFileInfo(def, filePath) {
+async function buildProjectFileInfo(def, filePath, state) {
     const normalizedPath = normalizePath(filePath);
     const projectRoot = normalizePath(path.dirname(filePath));
     let name = null;
     if (def.parseName && def.kind === "file") {
         try {
-            const raw = await fsp.readFile(filePath, "utf8");
-            name = def.parseName(raw, filePath);
+            const text = await readProjectDiscoveryFileText(state, filePath);
+            name = def.parseName(text, filePath);
         }
         catch {
             name = null;
@@ -1037,12 +1228,14 @@ async function discoverProjectFilesInternal(projectRoot, options) {
                 return matcher ? matcher.test(fileName) : pattern === fileName;
             });
         };
+        const discovery = options?.discoveryContext ?? createProjectDiscoveryContext(root);
         let gitCandidates;
         if (options?.knownGitCandidates !== undefined) {
             gitCandidates = options.knownGitCandidates;
+            rememberGitCandidates(discovery, root, gitCandidates);
         }
         else {
-            gitCandidates = await listGitCandidateFiles(root, options?.logLevel, {
+            gitCandidates = await getSharedGitCandidates(discovery, root, options?.logLevel, {
                 ...(options?.onDiscoveryProgress ? { onDiscoveryProgress: options.onDiscoveryProgress } : {}),
                 ...(options?.onDiscoveryTiming ? { onDiscoveryTiming: options.onDiscoveryTiming } : {}),
             });
@@ -1059,7 +1252,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
             : undefined;
         let rootSafeMatches;
         if (gitCandidates) {
-            const gitignoreIndex = await buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases);
+            const gitignoreIndex = await sharedGitignoreIndex(discovery, `git:${fileIdentityKey(root)}`, () => buildGitignoreIndex(gitCandidates.gitignoreFiles, gitCandidates.gitignoreRoots, gitCandidates.gitignoreAliases, discovery));
             const defaultIgnoreMatchers = DEFAULT_PROJECT_FILE_IGNORES.map((globPattern) => picomatch(globPattern, { dot: true }));
             const filterGitIgnoredEntries = (entries, directoryKeys = new Set()) => entries
                 .map(({ path: filePath, realPath }) => ({ filePath: normalizePath(filePath), realPath }))
@@ -1084,6 +1277,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
                     ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
                     : {}),
                 ...(reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}),
+                ...globFilesystemField(discovery),
             };
             const safeSymlinkDirectories = await resolveSafeSymlinkDirectories(root, realRoot, DEFAULT_PROJECT_FILE_IGNORES, symlinkOptions);
             const allPatterns = PROJECT_FILE_DEFINITIONS.flatMap((definition) => definition.patterns.map(toProjectGlob));
@@ -1091,6 +1285,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
                 markDirectories: true,
                 onlyFiles: false,
                 resolvedSafeSymlinkDirectories: safeSymlinkDirectories,
+                ...globFilesystemField(discovery),
             });
             const candidateFiles = Array.from(new Set(gitCandidates.files.map(normalizePath)));
             // Only a candidate whose basename can name a manifest becomes a metadata entry, so
@@ -1123,6 +1318,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
                 ignore: DEFAULT_PROJECT_FILE_IGNORES,
                 markDirectories: true,
                 onlyFiles: false,
+                ...globFilesystemOption(discovery),
             });
             const linkedMatches = await listEntriesFromSafeSymlinkDirectories(root, realRoot, allPatterns, DEFAULT_PROJECT_FILE_IGNORES, {
                 markDirectories: true,
@@ -1134,6 +1330,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
                     ? { onSymlinkDirectoriesDiscovered: options.onSymlinkDirectoriesDiscovered }
                     : {}),
                 ...(reportMetadataSymlinkChecks ? { onPathCheckProgress: reportMetadataSymlinkChecks } : {}),
+                ...globFilesystemField(discovery),
             });
             rootSafeMatches = await filterRealPathsWithinRoot([...matches, ...linkedMatches].map((match) => (match.endsWith("/") ? match.slice(0, -1) : match)), realRoot, reportMetadataFileChecks);
         }
@@ -1150,7 +1347,7 @@ async function discoverProjectFilesInternal(projectRoot, options) {
                     continue;
                 const matchesPattern = matchesDefinition(fileName, definitionIndex);
                 if (matchesPattern) {
-                    entries.push(await buildProjectFileInfo(def, cleanMatch));
+                    entries.push(await buildProjectFileInfo(def, cleanMatch, discovery));
                 }
             }
         });
@@ -1174,4 +1371,88 @@ async function discoverProjectFilesInternal(projectRoot, options) {
         throw new Error(`Failed to discover project files in ${root}: ${stringifyUnknown(error)}`);
     }
 }
+async function addGitExcludeFiles(files, repositoryRoot, gitCache) {
+    const excludes = await listGitExcludeFiles(repositoryRoot, gitExcludeListOptions(gitCache));
+    for (const source of excludes) {
+        files.add(normalizePath(source.file));
+    }
+}
+async function collectAncestorGitignoreFiles(fromDir, stopDir) {
+    const files = [];
+    let current = normalizePath(fromDir);
+    const stopKey = fileIdentityKey(stopDir);
+    while (true) {
+        const hit = await gitignoreFileIfPresent(current);
+        if (hit)
+            files.push(hit);
+        if (fileIdentityKey(current) === stopKey)
+            break;
+        const parent = normalizePath(path.dirname(current));
+        if (parent === current)
+            break;
+        if (!isFilePathWithinRoot(stopDir, parent) && fileIdentityKey(parent) !== stopKey)
+            break;
+        current = parent;
+    }
+    return files;
+}
+async function addGitignoreFilesForRoots(files, roots, state, scanned) {
+    for (const ignoreRoot of roots) {
+        const key = fileIdentityKey(ignoreRoot);
+        if (scanned.has(key))
+            continue;
+        scanned.add(key);
+        for (const file of await findGitignoreFiles(ignoreRoot, state)) {
+            files.add(normalizePath(file));
+        }
+    }
+}
+export async function collectConfigHashInputFiles(projectRoot, discoveryContext, logLevel, callbacks) {
+    const root = await ensureDirectoryReadable(projectRoot, "Project root");
+    const state = discoveryContext;
+    const files = new Set(await listRootConfigFiles(root, state));
+    const gitCache = discoveryContext.git;
+    const gitCandidates = await getSharedGitCandidates(discoveryContext, root, logLevel, callbacks);
+    if (gitCandidates) {
+        for (const source of gitCandidates.gitignoreFiles) {
+            files.add(normalizePath(source.file));
+        }
+        return { files: Array.from(files).sort() };
+    }
+    const realRoot = normalizePath(await fsp.realpath(root));
+    const gitRootCandidate = (await isGitRepo(root, gitCache)) ? root : realRoot;
+    if (!(await isGitRepo(gitRootCandidate, gitCache))) {
+        await addGitignoreFilesForRoots(files, [root], state, new Set());
+        return { files: Array.from(files).sort() };
+    }
+    if (await isGitProjectRootIgnored(realRoot, gitCache)) {
+        const scanned = new Set();
+        await addGitignoreFilesForRoots(files, [root], state, scanned);
+        const gitRoot = await getGitRepositoryRoot(gitRootCandidate);
+        if (gitRoot) {
+            await addGitExcludeFiles(files, gitRoot, gitCache);
+            const submoduleDirectories = await listGitSubmoduleDirectories(gitRoot, { recurse: true });
+            await addGitignoreFilesForRoots(files, [gitRoot, ...submoduleDirectories], state, scanned);
+            for (const submodule of submoduleDirectories) {
+                await addGitExcludeFiles(files, submodule, gitCache);
+            }
+        }
+        return { files: Array.from(files).sort() };
+    }
+    const gitRoot = await getGitRepositoryRoot(gitRootCandidate);
+    if (gitRoot) {
+        for (const file of await collectAncestorGitignoreFiles(root, gitRoot)) {
+            files.add(normalizePath(file));
+        }
+        await addGitExcludeFiles(files, gitRoot, gitCache);
+        const submoduleDirectories = await listGitSubmoduleDirectories(gitRoot, { recurse: true });
+        for (const submodule of submoduleDirectories) {
+            await addGitExcludeFiles(files, submodule, gitCache);
+        }
+    }
+    return {
+        files: Array.from(files).sort(),
+        error: "Failed to enumerate config files: Git listing unavailable",
+    };
+}
 //# sourceMappingURL=projectFiles.js.map