perf(file): Fast-path the ignore-file predicate without per-path resolution

The isIgnored() predicate returned by buildIgnoreFileFilter routed every
tested path through createIgnoreMatcher, which performs ~5 path operations
per call (resolve, normalize, relative, isInsidePath check, slash
conversion) before reaching the `ignore` matcher — applied to every file
and directory the scans emit (~1,400 paths per search on this repo, plus
the empty-directory scans), this dominated the post-scan filter cost.

fast-glob only ever emits clean, slash-separated paths relative to the
scan root. For those, the baseDir-relative form the `ignore` package
expects is a constant prefix (the scan root's path below the git root;
empty when they coincide) plus the input string, so the fast path is now
one string concatenation + ig.ignores(). A single regex routes every
other input shape ('', '.'/'..' segments, backslashes, doubled or
trailing slashes, absolute paths) to the unchanged legacy matcher, so
edge-case semantics stay exactly as before.

decision(gitignore-filter): keep createIgnoreMatcher as the fallback for
non-fast-glob input shapes instead of replicating its normalization
inline — equivalence by construction, and the fallback never runs on the
hot path
rejected(double-sort): skipping the second sortOutputFiles inside
generateOutput — re-measured at ~0.12ms isolated; the change-7 round's
22ms figure was the git-log subprocess cost already eliminated by
prefetchSortData
rejected(xml-direct-builder): direct string builder replacing the
Handlebars xml render — noise-level on the current tip (t=-0.14 over 20
interleaved pairs); earlier ~19ms estimates came from builds without the
landed lazy render-context getters
rejected(md5-precompute): computing contentCacheKey during processFiles
to clear it from the tail — +7.6ms (noise, t=0.86) over 20 interleaved
pairs on the current tip
learned(bench): this container runs ~1.6-1.7x slower than the previous
rounds' quiet host (e2e baseline ~1615ms vs ~800-950ms); relative deltas
from interleaved pairs are the comparable metric

Benchmark (32 interleaved ABBA pairs, warm, default pack of this repo,
4-core Linux): e2e median 1615ms -> 1540ms, paired mean delta -82.0ms
(-5.1%), median delta -74ms (-4.6%), t = -7.68, 29/32 pairs improved.
Search phase ([globby] trace, --verbose): 749-778ms -> 643-684ms with
identical results (1099 files, 255 directories).

Output byte-identical (cmp) vs the previous build for: default pack,
subdirectory pack (website/client — exercises the git-root prefix
branch), multi-root (src website), and --no-gitignore. 1416/1416 tests
pass; lint clean (3 pre-existing warnings in unrelated files).

https://claude.ai/code/session_01N3uqykUShsrDKkyvjuKi13

Author: claude

src/core/file/gitignoreFilter.ts

@@ -21,6 +21,7 @@ import fs from 'node:fs/promises';
 import nodePath from 'node:path';
 import fastGlob from 'fast-glob';
 import type { Options as GlobbyOptions } from 'globby';
+import ignore from 'ignore';
 import {
   convertPatternsForFastGlob,
   createIgnoreMatcher,
@@ -202,13 +203,40 @@ export const buildIgnoreFileFilter = async (
   const resolvedCwd = nodePath.resolve(cwd);
   const patternsForFastGlob = convertPatternsForFastGlob(patterns, usingGitRoot);
 
+  // Fast path for the strings fast-glob actually emits: clean, slash-separated
+  // paths relative to the scan root. For those, the baseDir-relative form the
+  // `ignore` package expects is a constant prefix (scan root's path below the
+  // git root, empty when they coincide) plus the input — no per-path
+  // resolve/normalize/relative calls. Routing every tested path through
+  // `createIgnoreMatcher` instead cost ~5 path operations per call, which
+  // dominated the post-scan filter (~15ms per search on a ~1,100-file repo).
+  const ig = ignore().add(patterns);
+  const cwdFromBase = nodePath.relative(nodePath.resolve(baseDir), resolvedCwd).replace(/\\/g, '/');
+  const baseRelativePrefix = cwdFromBase ? `${cwdFromBase}/` : '';
+
+  // Inputs the fast path cannot take: empty, `.`/`..` segments, backslashes,
+  // doubled or trailing slashes (all of which path normalization would have
+  // rewritten), plus absolute paths. fast-glob never produces these, but the
+  // legacy matcher resolves them exactly as globby did, so fall back for them.
+  const needsLegacyResolution = /(?:^|\/)\.\.?(?:\/|$)|\\|\/\/|\/$/;
+
   return {
     isIgnored: (relativePath: string, isDirectory: boolean): boolean => {
-      const absolutePath = nodePath.resolve(resolvedCwd, nodePath.normalize(relativePath));
-      if (matcher(absolutePath).ignored) {
+      if (relativePath === '' || needsLegacyResolution.test(relativePath) || nodePath.isAbsolute(relativePath)) {
+        const absolutePath = nodePath.resolve(resolvedCwd, nodePath.normalize(relativePath));
+        if (matcher(absolutePath).ignored) {
+          return true;
+        }
+        return isDirectory && matcher(absolutePath + nodePath.sep).ignored;
+      }
+
+      const baseRelativePath = baseRelativePrefix + relativePath;
+      if (ig.ignores(baseRelativePath)) {
         return true;
       }
-      return isDirectory && matcher(absolutePath + nodePath.sep).ignored;
+      // Directory-only rules (`dir/`) only match when the tested path carries a
+      // trailing separator, mirroring the legacy matcher's second test.
+      return isDirectory && ig.ignores(`${baseRelativePath}/`);
     },
     patternsForFastGlob,
   };

tests/core/file/gitignoreFilter.test.ts

@@ -96,6 +96,38 @@ describe('buildIgnoreFileFilter', () => {
     expect(filter.isIgnored('excluded/hidden.txt', false)).toBe(false);
   });
 
+  describe('inputs needing legacy path resolution (never produced by fast-glob)', () => {
+    test('normalizes dot segments, doubled and trailing slashes before matching', async () => {
+      await write('.gitignore', '*.log\nbuild/\n');
+
+      const filter = await buildIgnoreFileFilter(tempDir, true, IGNORE_FILE_PATTERNS, [], undefined);
+      // Equivalent to the clean forms after path normalization.
+      expect(filter.isIgnored('./a.log', false)).toBe(true);
+      expect(filter.isIgnored('sub/../a.log', false)).toBe(true);
+      expect(filter.isIgnored('sub//deep/a.log', false)).toBe(true);
+      expect(filter.isIgnored('build/', true)).toBe(true);
+      // Negative control through the same fallback branch.
+      expect(filter.isIgnored('./a.txt', false)).toBe(false);
+    });
+
+    test('never ignores the scan root itself or paths outside the base directory', async () => {
+      await write('.gitignore', '*\n');
+
+      const filter = await buildIgnoreFileFilter(tempDir, true, IGNORE_FILE_PATTERNS, [], undefined);
+      expect(filter.isIgnored('', false)).toBe(false);
+      expect(filter.isIgnored('.', true)).toBe(false);
+      expect(filter.isIgnored('../outside.txt', false)).toBe(false);
+    });
+
+    test('resolves absolute inputs against the base directory', async () => {
+      await write('.gitignore', '*.log\n');
+
+      const filter = await buildIgnoreFileFilter(tempDir, true, IGNORE_FILE_PATTERNS, [], undefined);
+      expect(filter.isIgnored(path.join(tempDir, 'a.log'), false)).toBe(true);
+      expect(filter.isIgnored(path.join(tempDir, 'a.txt'), false)).toBe(false);
+    });
+  });
+
   describe('with a git root above the scan root', () => {
     test('collects parent .gitignore files and anchors them at the git root', async () => {
       await fs.mkdir(path.join(tempDir, '.git'), { recursive: true });