@vibe-agent-toolkit/utils 0.1.42 → 0.2.0-rc.10

package/dist/git-tracker.d.ts

@@ -56,6 +56,33 @@ export declare class GitTracker {
     private readonly activeSet;
     /** Absolute paths of every directory that contains at least one active-set file. */
     private readonly activeAncestors;
+    /**
+     * Lowercased absolute path → the root-relative path spelled the way git
+     * spelled it. Built from the very same `git ls-files` output `activeSet`
+     * comes from, so it costs one extra `Map` and no extra git invocation.
+     */
+    private readonly indexPaths;
+    /**
+     * Absolute, forward-slashed directories the active-set listing could not
+     * OPEN, so nothing beneath them is in the set — read off `git ls-files
+     * --others`' stderr through the listing's `unreadable` policy (`degrade`).
+     *
+     * 🚨 Beneath one of these the active set has no opinion. Its rule is "absent
+     * from the set and present on disk ⇒ ignored", and that rule is sound only
+     * where the listing LOOKED: an untracked, non-ignored file under a `--x`
+     * directory is absent because git could not read the directory, not because
+     * a pattern excludes it, and `git check-ignore` — which answers from the
+     * patterns and needs no listing — says so. Before this was recorded the
+     * tracker called such a file gitignored, silently, and every consumer of
+     * that answer (the leak judge, the link-graph walker, audit's distributed
+     * lane) was one refused `opendir` from a wrong verdict.
+     *
+     * The directory ITSELF is non-ignored by construction — git opened it
+     * precisely because no pattern excluded it — so it and its ancestors are
+     * entered into {@link activeAncestors}: a walker must not prune what the
+     * listing could not see into.
+     */
+    private readonly unlistableDirectories;
     private initialized;
     private activeSetPopulated;
     /** Whether `git ls-files` actually answered during {@link initialize}. */
@@ -72,8 +99,60 @@ export declare class GitTracker {
      * With `includeUntracked: false`, only tracked files are pre-populated.
      * Untracked non-ignored files will miss the cache and fall through to
      * `git check-ignore` via {@link isIgnored}.
+     *
+     * ## This is the one bracket in the crawl-timing seam's `shared` stratum
+     *
+     * The `git ls-files` spawn below is preparation BOTH crawlers consume and
+     * NEITHER owns — the incumbent link walk and the projection's contributors are
+     * each handed a tracker by their caller — so it is charged to
+     * {@link CRAWL_SHARED_GIT_TRACKER_ID}, in a stratum belonging to no arm.
+     *
+     * The bracket is here, inside the class, and not at the six sites that build a
+     * tracker, for the reason `crawl-timing.ts` gives about `ResourceRegistry`: six
+     * copies are six chances to disagree, and a seventh site added later would
+     * silently go uncharged. Here, every caller is covered by construction — which
+     * includes `@vibe-agent-toolkit/discovery`, a package that could not have filed
+     * a row from its own call site at all, since it depends on `utils` alone.
+     *
+     * The early return above is deliberately OUTSIDE it: a re-entrant call does no
+     * work, and charging it would inflate `calls` with questions rather than
+     * spawns.
      */
     initialize(options?: GitTrackerInitOptions): Promise<void>;
+    /**
+     * The active set read off a snapshot this process has ALREADY taken — or
+     * `null` to say "ask git yourself".
+     *
+     * ## Why this is the same question, not a similar one
+     *
+     * `git ls-files --cached --others --exclude-standard` returns
+     * `tracked ∪ (untracked ∧ ¬ignored)`. A snapshot is `git add --all` **without**
+     * `--force` staged into a throwaway index, whose membership is that same set
+     * by construction — the exclusion of ignored paths is `--force`'s absence in
+     * both cases. So where a snapshot is already in hand, the spawn this method
+     * replaces would re-derive a set the process is already holding.
+     *
+     * It is deliberately a PEEK ({@link peekGitTreeSnapshot}) and never a take: a
+     * snapshot costs a `git add --all`, so causing one to avoid an `ls-files`
+     * would be a large loss dressed as a saving. On the incumbent walk no snapshot
+     * is ever taken, the peek misses, and this tracker spawns exactly as it always
+     * has.
+     *
+     * ## The one divergence, and why it is an improvement
+     *
+     * `--cached` reads the REAL index, so a tracked file deleted from the working
+     * tree is still listed. `git add --all` stages that deletion, so the snapshot
+     * omits it. The set is therefore not identical — it is the same set minus
+     * paths that do not exist, which is what {@link isIgnoredByActiveSet} already
+     * documents the active set to be ("it can only ever contain paths that
+     * EXIST"). The snapshot-sourced set honours that sentence more exactly than
+     * the spawn does.
+     *
+     * @param includeUntracked - The caller's requested membership
+     * @returns Root-relative paths in `git ls-files` shape, or `null` when no
+     *   snapshot is available or the request is one a snapshot cannot answer
+     */
+    private activePathsFromOpenSnapshot;
     /**
      * Did git actually answer, or is this tracker an empty shell?
      *
@@ -98,6 +177,22 @@ export declare class GitTracker {
      * `hasActiveDescendant` / `isIgnoredByActiveSet` ancestor lookup misses on Windows.
      */
     private populateAncestorSet;
+    /**
+     * Record `start` and every directory above it up to (not including) the
+     * project root as active ancestors, stopping at the first one already known
+     * — everything above it necessarily is too.
+     *
+     * @param start - Forward-slashed absolute directory to begin at
+     */
+    private recordAncestorsFrom;
+    /**
+     * Whether the active set can say anything about a path: it cannot beneath a
+     * directory the listing was refused — see {@link unlistableDirectories}.
+     *
+     * @param normalizedAbsolutePath - Forward-slashed absolute path
+     * @returns True when the path lies strictly beneath a refused directory
+     */
+    private beneathUnlistable;
     /**
      * Returns true if the given absolute path IS an active-set file OR is an
      * ancestor directory of at least one active-set file.
@@ -117,7 +212,9 @@ export declare class GitTracker {
      * For paths INSIDE the project root **that exist on disk**, membership in the
      * active set is authoritative: such a path is ignored iff it is not in the
      * active set AND not an ancestor of any active-set path. No `git
-     * check-ignore` spawn.
+     * check-ignore` spawn. The one exception is a path beneath a directory the
+     * listing could not OPEN — see {@link unlistableDirectories} — where absence
+     * says nothing and the question goes to `git check-ignore`.
      *
      * The existence qualifier is load-bearing, not a caveat. The active set is
      * built from `git ls-files`, so it can only ever contain paths that EXIST — a
@@ -131,7 +228,38 @@ export declare class GitTracker {
      * so a repeated miss on the same path stays O(1).
      *
      * For paths OUTSIDE the project root, falls back to {@link isIgnored} so
-     * legacy behavior is preserved.
+     * legacy behavior is preserved. That fallback is the expensive one, and its
+     * cost does not resemble the in-root cost at all.
+     *
+     * ## ⚠️ The out-of-root fallback costs an order of magnitude more per path
+     *
+     * Measured in the D9 parity fixture: an out-of-root path costs
+     * **185–427 ms**, against **12–28 ms** for every in-repo path — ≈7–36× on
+     * those ranges.
+     *
+     * The mechanism is the delegation above plus what git does with it.
+     * {@link isIgnored} runs `git check-ignore` with the PROJECT ROOT as cwd; git
+     * exits 128 for a path outside that repository; and {@link isGitIgnored}'s
+     * exit-128 recovery walk then spawns `check-ignore` ONCE PER ANCESTOR up to
+     * `/`. No ancestor of an out-of-root path is ever the project root that would
+     * stop the walk, and every one of those ancestors is outside the repository
+     * too — so each also exits 128 and the walk never breaks early either. The
+     * verdict is cached, so the price is paid once per DISTINCT out-of-root path
+     * rather than once per call.
+     *
+     * The consequence for a caller choosing between the two oracles: switching
+     * from {@link isIgnored} to this method removes the spawn population **only
+     * for in-root paths**. A lane feeding out-of-root paths in bulk keeps the
+     * per-path spawn in full. So a comment asserting that the out-of-project case
+     * is rare, safe or cheap is asserting something this measurement contradicts:
+     * it is rare in some lanes, and it is never cheap.
+     *
+     * The exit-128 walk itself is documented in {@link isGitIgnored} — but only
+     * for the two cases already answered there: the SYMLINK case it exists to
+     * serve, and the NO-REPOSITORY case, which an early return now short-circuits
+     * before any spawn. The IN-REPO OUT-OF-ROOT path is the third case, it is
+     * documented nowhere there, and it is the one that still pays the walk in
+     * full. That is why the number lives here.
      *
      * Requires {@link initialize} with `includeUntracked: true` (the default).
      * When initialized without untracked files, this method delegates to
@@ -139,8 +267,21 @@ export declare class GitTracker {
      * possible per-path spawn.
      *
      * @param absolutePath - Absolute path to check
+     * @param knownToExist - The caller's own answer to the existence question, when
+     *   it has already asked. Supplying it skips this method's `existsSync`, which
+     *   is otherwise paid once per path that is absent from the active set — i.e.
+     *   once per ignored path, and the projection's `filesystem` extent enumerates
+     *   all of them (11,108 calls on an 8,496-path adopter tree).
+     *
+     *   **It must mean what `existsSync` means: `stat` succeeds, following
+     *   symlinks.** A caller holding only an `lstat` result has a DIFFERENT fact —
+     *   `lstat` succeeds on a dangling symlink where `existsSync` returns false —
+     *   and must narrow it to `exists && symlinkResolves !== false` rather than
+     *   pass the `lstat` boolean through, or dangling symlinks silently stop
+     *   falling back to `git check-ignore` and start reporting as ignored.
+     *   Omit it and nothing changes.
      */
-    isIgnoredByActiveSet(absolutePath: string): boolean;
+    isIgnoredByActiveSet(absolutePath: string, knownToExist?: boolean): boolean;
     private isWithinProjectRoot;
     /**
      * Check if a file is ignored by git.
@@ -151,6 +292,28 @@ export declare class GitTracker {
      * @returns true if file is gitignored, false otherwise
      */
     isIgnored(filePath: string): boolean;
+    /**
+     * The spelling git records for a path, or `null` if git has no record of it.
+     *
+     * This is the casing oracle, not another ignore check. On a case-insensitive
+     * filesystem `docs/Readme.md` and `docs/README.md` are one inode with two
+     * spellings, and Node's two `realpath` implementations disagree about which
+     * one they hand back — so anything that derives an identity from a path needs
+     * a single authoritative spelling, and git's is it wherever git has one.
+     *
+     * The lookup key is lowercased, which is the point: the caller asks with
+     * whatever casing it observed and gets back the casing git holds.
+     *
+     * Answers only from the pre-populated set — never spawns. A path git does not
+     * know (untracked-and-ignored, non-existent, outside the project root, or any
+     * path at all when `git ls-files` did not answer) returns `null`, and the
+     * caller falls back to the on-disk casing.
+     *
+     * @param absolutePath - Absolute path to look up
+     * @returns Root-relative, forward-slashed path as git spells it — relative to
+     *   THIS tracker's project root — or `null` when git has no record of it
+     */
+    indexPathFor(absolutePath: string): string | null;
     /**
      * Get cache statistics.
      */

package/dist/git-tracker.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-tracker.d.ts","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IACzD,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0B;IAC1D,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAS;IACnC,0EAA0E;IAC1E,OAAO,CAAC,WAAW,CAAS;gBAEhB,WAAW,EAAE,MAAM;IAK/B;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BhE;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,OAAO;IAInB;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAwB3B;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAQlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IA0BnD,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAqBpC;;OAEG;IACH,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE;IAQrF;;OAEG;IACH,KAAK,IAAI,IAAI;CAQd"}
+{"version":3,"file":"git-tracker.d.ts","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAcH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;;;;;;OAWG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAS;IAC/C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmC;IACzD,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA0B;IACpD,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0B;IAC1D;;;;OAIG;IACH,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAkC;IAC7D;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAgB;IACtD,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,kBAAkB,CAAS;IACnC,0EAA0E;IAC1E,OAAO,CAAC,WAAW,CAAS;gBAEhB,WAAW,EAAE,MAAM;IAK/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,UAAU,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC;IA0ChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACH,OAAO,CAAC,2BAA2B;IA6BnC;;;;;;;;;;;;;OAaG;IACH,QAAQ,IAAI,OAAO;IAInB;;;;;;;OAOG;IACH,OAAO,CAAC,mBAAmB;IAe3B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAiB3B;;;;;;OAMG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;;;;;;;;;;OAWG;IACH,mBAAmB,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO;IAUlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0EG;IACH,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC,EAAE,OAAO,GAAG,OAAO;IAiC3E,OAAO,CAAC,mBAAmB;IAQ3B;;;;;;;OAOG;IACH,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAqBpC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAIjD;;OAEG;IACH,QAAQ,IAAI;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,mBAAmB,EAAE,MAAM,CAAA;KAAE;IAQrF;;OAEG;IACH,KAAK,IAAI,IAAI;CAUd"}

package/dist/git-tracker.js

@@ -6,6 +6,8 @@
  */
 import { existsSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { CRAWL_SHARED_GIT_TRACKER_ID, crawlTimingStart, recordSharedPass, } from './crawl-timing.js';
+import { peekGitTreeSnapshot } from './git-snapshot.js';
 import { gitLsFiles, isGitIgnored } from './git-utils.js';
 import { safePath, toForwardSlash } from './path-utils.js';
 /**
@@ -42,6 +44,33 @@ export class GitTracker {
     activeSet = new Set();
     /** Absolute paths of every directory that contains at least one active-set file. */
     activeAncestors = new Set();
+    /**
+     * Lowercased absolute path → the root-relative path spelled the way git
+     * spelled it. Built from the very same `git ls-files` output `activeSet`
+     * comes from, so it costs one extra `Map` and no extra git invocation.
+     */
+    indexPaths = new Map();
+    /**
+     * Absolute, forward-slashed directories the active-set listing could not
+     * OPEN, so nothing beneath them is in the set — read off `git ls-files
+     * --others`' stderr through the listing's `unreadable` policy (`degrade`).
+     *
+     * 🚨 Beneath one of these the active set has no opinion. Its rule is "absent
+     * from the set and present on disk ⇒ ignored", and that rule is sound only
+     * where the listing LOOKED: an untracked, non-ignored file under a `--x`
+     * directory is absent because git could not read the directory, not because
+     * a pattern excludes it, and `git check-ignore` — which answers from the
+     * patterns and needs no listing — says so. Before this was recorded the
+     * tracker called such a file gitignored, silently, and every consumer of
+     * that answer (the leak judge, the link-graph walker, audit's distributed
+     * lane) was one refused `opendir` from a wrong verdict.
+     *
+     * The directory ITSELF is non-ignored by construction — git opened it
+     * precisely because no pattern excluded it — so it and its ancestors are
+     * entered into {@link activeAncestors}: a walker must not prune what the
+     * listing could not see into.
+     */
+    unlistableDirectories = [];
     initialized = false;
     activeSetPopulated = false;
     /** Whether `git ls-files` actually answered during {@link initialize}. */
@@ -61,27 +90,121 @@ export class GitTracker {
      * With `includeUntracked: false`, only tracked files are pre-populated.
      * Untracked non-ignored files will miss the cache and fall through to
      * `git check-ignore` via {@link isIgnored}.
+     *
+     * ## This is the one bracket in the crawl-timing seam's `shared` stratum
+     *
+     * The `git ls-files` spawn below is preparation BOTH crawlers consume and
+     * NEITHER owns — the incumbent link walk and the projection's contributors are
+     * each handed a tracker by their caller — so it is charged to
+     * {@link CRAWL_SHARED_GIT_TRACKER_ID}, in a stratum belonging to no arm.
+     *
+     * The bracket is here, inside the class, and not at the six sites that build a
+     * tracker, for the reason `crawl-timing.ts` gives about `ResourceRegistry`: six
+     * copies are six chances to disagree, and a seventh site added later would
+     * silently go uncharged. Here, every caller is covered by construction — which
+     * includes `@vibe-agent-toolkit/discovery`, a package that could not have filed
+     * a row from its own call site at all, since it depends on `utils` alone.
+     *
+     * The early return above is deliberately OUTSIDE it: a re-entrant call does no
+     * work, and charging it would inflate `calls` with questions rather than
+     * spawns.
      */
     async initialize(options) {
         if (this.initialized) {
             return;
         }
+        const startedAt = crawlTimingStart();
         const includeUntracked = options?.includeUntracked ?? true;
-        const files = gitLsFiles({
+        const files = this.activePathsFromOpenSnapshot(includeUntracked) ?? gitLsFiles({
             cwd: this.projectRoot,
             ...(includeUntracked ? { includeUntracked: true } : {}),
+            // Degrade, and RECORD: a directory git could not open is a shorter list
+            // nothing can tell from a complete one — see {@link unlistableDirectories}
+            // for how the tracker keeps that gap honest. Only the untracked listing
+            // walks the tree, so the tracked-only one never calls this.
+            unreadable: {
+                degrade: (refusal) => {
+                    this.unlistableDirectories.push(refusal.directory);
+                },
+            },
         });
         if (files !== null) {
             for (const relativePath of files) {
                 const absolutePath = safePath.resolve(this.projectRoot, relativePath);
                 this.cache.set(absolutePath, false); // false = not ignored
                 this.activeSet.add(absolutePath);
+                this.indexPaths.set(absolutePath.toLowerCase(), toForwardSlash(relativePath));
             }
             this.populateAncestorSet();
         }
         this.gitAnswered = files !== null;
         this.activeSetPopulated = includeUntracked && files !== null;
         this.initialized = true;
+        // After the state above is settled, so a throw from the seam could never
+        // leave a half-initialized tracker; and charged even when git did not answer,
+        // because a failed `git ls-files` still spawned a process and still cost the
+        // command the time it took to fail.
+        recordSharedPass(CRAWL_SHARED_GIT_TRACKER_ID, startedAt);
+    }
+    /**
+     * The active set read off a snapshot this process has ALREADY taken — or
+     * `null` to say "ask git yourself".
+     *
+     * ## Why this is the same question, not a similar one
+     *
+     * `git ls-files --cached --others --exclude-standard` returns
+     * `tracked ∪ (untracked ∧ ¬ignored)`. A snapshot is `git add --all` **without**
+     * `--force` staged into a throwaway index, whose membership is that same set
+     * by construction — the exclusion of ignored paths is `--force`'s absence in
+     * both cases. So where a snapshot is already in hand, the spawn this method
+     * replaces would re-derive a set the process is already holding.
+     *
+     * It is deliberately a PEEK ({@link peekGitTreeSnapshot}) and never a take: a
+     * snapshot costs a `git add --all`, so causing one to avoid an `ls-files`
+     * would be a large loss dressed as a saving. On the incumbent walk no snapshot
+     * is ever taken, the peek misses, and this tracker spawns exactly as it always
+     * has.
+     *
+     * ## The one divergence, and why it is an improvement
+     *
+     * `--cached` reads the REAL index, so a tracked file deleted from the working
+     * tree is still listed. `git add --all` stages that deletion, so the snapshot
+     * omits it. The set is therefore not identical — it is the same set minus
+     * paths that do not exist, which is what {@link isIgnoredByActiveSet} already
+     * documents the active set to be ("it can only ever contain paths that
+     * EXIST"). The snapshot-sourced set honours that sentence more exactly than
+     * the spawn does.
+     *
+     * @param includeUntracked - The caller's requested membership
+     * @returns Root-relative paths in `git ls-files` shape, or `null` when no
+     *   snapshot is available or the request is one a snapshot cannot answer
+     */
+    activePathsFromOpenSnapshot(includeUntracked) {
+        // A snapshot cannot express the tracked-ONLY set: `add --all` stages
+        // untracked-not-ignored files too, and nothing in the result marks which
+        // entries were already tracked. Declining is the only correct answer.
+        if (!includeUntracked)
+            return null;
+        const snapshot = peekGitTreeSnapshot(this.projectRoot);
+        if (snapshot === undefined)
+            return null;
+        const relativePaths = [];
+        for (const entry of snapshot.entries) {
+            // A snapshot covers the whole REPOSITORY, which may be an ancestor of this
+            // tracker's root — `git ls-files` run at that root scopes its listing to
+            // it, so anything above is not this tracker's business and must not enter
+            // the active set. Everything below is kept verbatim, symlinks and
+            // submodule gitlinks included, because `--cached` lists those too.
+            const relativePath = toForwardSlash(safePath.relative(this.normalizedProjectRoot, entry.absolutePath));
+            // A leading `..` SEGMENT, not a `../` prefix: compared as a path segment,
+            // a file legitimately named `..hidden` is kept rather than silently
+            // dropped as if it were an escape.
+            if (relativePath.length === 0 || relativePath.split('/')[0] === '..') {
+                continue;
+            }
+            relativePaths.push(relativePath);
+        }
+        return relativePaths;
     }
     /**
      * Did git actually answer, or is this tracker an empty shell?
@@ -109,24 +232,49 @@ export class GitTracker {
      * `hasActiveDescendant` / `isIgnoredByActiveSet` ancestor lookup misses on Windows.
      */
     populateAncestorSet() {
-        const root = this.normalizedProjectRoot;
         for (const absolutePath of this.activeSet) {
-            let current = toForwardSlash(dirname(absolutePath));
-            while (current !== root && current.length > root.length) {
-                if (this.activeAncestors.has(current)) {
-                    // Ancestor (and all of its ancestors) already recorded — avoid redundant work.
-                    break;
-                }
-                this.activeAncestors.add(current);
-                const parent = toForwardSlash(dirname(current));
-                if (parent === current) {
-                    break;
-                }
-                current = parent;
-            }
+            this.recordAncestorsFrom(toForwardSlash(dirname(absolutePath)));
+        }
+        // A directory the listing could not open is itself non-ignored (git opened
+        // it because no pattern excluded it) and may hold active files nobody could
+        // list — so it counts as an ancestor from ITSELF down, not from its parent.
+        for (const directory of this.unlistableDirectories) {
+            this.recordAncestorsFrom(directory);
         }
         // projectRoot itself is always an implicit ancestor of everything under it.
-        this.activeAncestors.add(root);
+        this.activeAncestors.add(this.normalizedProjectRoot);
+    }
+    /**
+     * Record `start` and every directory above it up to (not including) the
+     * project root as active ancestors, stopping at the first one already known
+     * — everything above it necessarily is too.
+     *
+     * @param start - Forward-slashed absolute directory to begin at
+     */
+    recordAncestorsFrom(start) {
+        const root = this.normalizedProjectRoot;
+        let current = start;
+        while (current !== root && current.length > root.length) {
+            if (this.activeAncestors.has(current)) {
+                break;
+            }
+            this.activeAncestors.add(current);
+            const parent = toForwardSlash(dirname(current));
+            if (parent === current) {
+                break;
+            }
+            current = parent;
+        }
+    }
+    /**
+     * Whether the active set can say anything about a path: it cannot beneath a
+     * directory the listing was refused — see {@link unlistableDirectories}.
+     *
+     * @param normalizedAbsolutePath - Forward-slashed absolute path
+     * @returns True when the path lies strictly beneath a refused directory
+     */
+    beneathUnlistable(normalizedAbsolutePath) {
+        return this.unlistableDirectories.some((directory) => normalizedAbsolutePath.startsWith(`${directory}/`));
     }
     /**
      * Returns true if the given absolute path IS an active-set file OR is an
@@ -145,7 +293,9 @@ export class GitTracker {
             return true;
         }
         const normalized = safePath.resolve(absolutePath);
-        return this.activeSet.has(normalized) || this.activeAncestors.has(normalized);
+        // Beneath a refused directory nothing was listed, so "no active descendant"
+        // would be a claim the listing never earned.
+        return this.activeSet.has(normalized) || this.activeAncestors.has(normalized) || this.beneathUnlistable(normalized);
     }
     /**
      * Fast O(1) ignore check against the pre-populated active set.
@@ -153,7 +303,9 @@ export class GitTracker {
      * For paths INSIDE the project root **that exist on disk**, membership in the
      * active set is authoritative: such a path is ignored iff it is not in the
      * active set AND not an ancestor of any active-set path. No `git
-     * check-ignore` spawn.
+     * check-ignore` spawn. The one exception is a path beneath a directory the
+     * listing could not OPEN — see {@link unlistableDirectories} — where absence
+     * says nothing and the question goes to `git check-ignore`.
      *
      * The existence qualifier is load-bearing, not a caveat. The active set is
      * built from `git ls-files`, so it can only ever contain paths that EXIST — a
@@ -167,7 +319,38 @@ export class GitTracker {
      * so a repeated miss on the same path stays O(1).
      *
      * For paths OUTSIDE the project root, falls back to {@link isIgnored} so
-     * legacy behavior is preserved.
+     * legacy behavior is preserved. That fallback is the expensive one, and its
+     * cost does not resemble the in-root cost at all.
+     *
+     * ## ⚠️ The out-of-root fallback costs an order of magnitude more per path
+     *
+     * Measured in the D9 parity fixture: an out-of-root path costs
+     * **185–427 ms**, against **12–28 ms** for every in-repo path — ≈7–36× on
+     * those ranges.
+     *
+     * The mechanism is the delegation above plus what git does with it.
+     * {@link isIgnored} runs `git check-ignore` with the PROJECT ROOT as cwd; git
+     * exits 128 for a path outside that repository; and {@link isGitIgnored}'s
+     * exit-128 recovery walk then spawns `check-ignore` ONCE PER ANCESTOR up to
+     * `/`. No ancestor of an out-of-root path is ever the project root that would
+     * stop the walk, and every one of those ancestors is outside the repository
+     * too — so each also exits 128 and the walk never breaks early either. The
+     * verdict is cached, so the price is paid once per DISTINCT out-of-root path
+     * rather than once per call.
+     *
+     * The consequence for a caller choosing between the two oracles: switching
+     * from {@link isIgnored} to this method removes the spawn population **only
+     * for in-root paths**. A lane feeding out-of-root paths in bulk keeps the
+     * per-path spawn in full. So a comment asserting that the out-of-project case
+     * is rare, safe or cheap is asserting something this measurement contradicts:
+     * it is rare in some lanes, and it is never cheap.
+     *
+     * The exit-128 walk itself is documented in {@link isGitIgnored} — but only
+     * for the two cases already answered there: the SYMLINK case it exists to
+     * serve, and the NO-REPOSITORY case, which an early return now short-circuits
+     * before any spawn. The IN-REPO OUT-OF-ROOT path is the third case, it is
+     * documented nowhere there, and it is the one that still pays the walk in
+     * full. That is why the number lives here.
      *
      * Requires {@link initialize} with `includeUntracked: true` (the default).
      * When initialized without untracked files, this method delegates to
@@ -175,8 +358,21 @@ export class GitTracker {
      * possible per-path spawn.
      *
      * @param absolutePath - Absolute path to check
+     * @param knownToExist - The caller's own answer to the existence question, when
+     *   it has already asked. Supplying it skips this method's `existsSync`, which
+     *   is otherwise paid once per path that is absent from the active set — i.e.
+     *   once per ignored path, and the projection's `filesystem` extent enumerates
+     *   all of them (11,108 calls on an 8,496-path adopter tree).
+     *
+     *   **It must mean what `existsSync` means: `stat` succeeds, following
+     *   symlinks.** A caller holding only an `lstat` result has a DIFFERENT fact —
+     *   `lstat` succeeds on a dangling symlink where `existsSync` returns false —
+     *   and must narrow it to `exists && symlinkResolves !== false` rather than
+     *   pass the `lstat` boolean through, or dangling symlinks silently stop
+     *   falling back to `git check-ignore` and start reporting as ignored.
+     *   Omit it and nothing changes.
      */
-    isIgnoredByActiveSet(absolutePath) {
+    isIgnoredByActiveSet(absolutePath, knownToExist) {
         if (!this.activeSetPopulated) {
             return this.isIgnored(absolutePath);
         }
@@ -188,10 +384,16 @@ export class GitTracker {
         if (this.activeSet.has(normalized) || this.activeAncestors.has(normalized)) {
             return false;
         }
+        // Absent from the set beneath a directory the listing could not open: the
+        // set never looked there, so absence is not evidence — see
+        // {@link unlistableDirectories}. Only `git check-ignore` can answer.
+        if (this.beneathUnlistable(normalized)) {
+            return this.isIgnored(absolutePath);
+        }
         // Absent from the active set. That means "ignored" only for a path that is
         // actually there; otherwise the set has no opinion and git must be asked.
-        // eslint-disable-next-line security/detect-non-literal-fs-filename -- caller-supplied path, read-only existence probe
-        if (!existsSync(normalized)) {
+        const present = knownToExist ?? existsSync(normalized);
+        if (!present) {
             return this.isIgnored(absolutePath);
         }
         return true;
@@ -228,6 +430,30 @@ export class GitTracker {
         this.cache.set(cacheKey, ignored);
         return ignored;
     }
+    /**
+     * The spelling git records for a path, or `null` if git has no record of it.
+     *
+     * This is the casing oracle, not another ignore check. On a case-insensitive
+     * filesystem `docs/Readme.md` and `docs/README.md` are one inode with two
+     * spellings, and Node's two `realpath` implementations disagree about which
+     * one they hand back — so anything that derives an identity from a path needs
+     * a single authoritative spelling, and git's is it wherever git has one.
+     *
+     * The lookup key is lowercased, which is the point: the caller asks with
+     * whatever casing it observed and gets back the casing git holds.
+     *
+     * Answers only from the pre-populated set — never spawns. A path git does not
+     * know (untracked-and-ignored, non-existent, outside the project root, or any
+     * path at all when `git ls-files` did not answer) returns `null`, and the
+     * caller falls back to the on-disk casing.
+     *
+     * @param absolutePath - Absolute path to look up
+     * @returns Root-relative, forward-slashed path as git spells it — relative to
+     *   THIS tracker's project root — or `null` when git has no record of it
+     */
+    indexPathFor(absolutePath) {
+        return this.indexPaths.get(safePath.resolve(absolutePath).toLowerCase()) ?? null;
+    }
     /**
      * Get cache statistics.
      */
@@ -245,6 +471,8 @@ export class GitTracker {
         this.cache.clear();
         this.activeSet.clear();
         this.activeAncestors.clear();
+        this.indexPaths.clear();
+        this.unlistableDirectories.length = 0;
         this.initialized = false;
         this.activeSetPopulated = false;
         this.gitAnswered = false;

package/dist/git-tracker.js.map

@@ -1 +1 @@
-{"version":3,"file":"git-tracker.js","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"git-tracker.js","sourceRoot":"","sources":["../src/git-tracker.ts"],"names":[],"mappings":"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"}