style(glob): trim comments to at most four lines

Author: simonhj

src/utils/glob-oom.test.mts

@@ -16,16 +16,10 @@ function filterJsonFiles(filepath: string): boolean {
 // This suite lives in its own file, with no mock-fs node_modules preload, so the
 // large ignore set it builds is the only significant allocation in the worker.
 describe('globWithGitIgnore() large monorepo memory', () => {
-  // Regression: `socket fix` / `socket scan` aborted with
-  // `FATAL ERROR: CALL_AND_RETRY_LAST … heap out of memory` (SIGABRT) on large
-  // monorepos. globWithGitIgnore discovers every nested .gitignore and unions
-  // their patterns; handing that whole set to fast-glob's `ignore` option made
-  // fast-glob re-compile and re-test the entire array inside every directory
-  // scan, so tens of thousands of patterns exhausted V8 code space. Routing the
-  // gitignore set through a single reused `ignore` instance bounds the cost. The
-  // flat union built below is large enough to crash the old path; the walk must
-  // instead complete and return the right manifests. Uses the real filesystem
-  // because mock-fs would hold every pattern in memory and add its own overhead.
+  // Regression: scanning a large monorepo OOM'd because the whole unioned
+  // gitignore set was handed to fast-glob, which recompiled it per directory
+  // scan. The 100k-pattern tree below crashes the pre-fix path; the walk must
+  // complete with the right manifests. Real fs (mock-fs is too heavy here).
   it('does not exhaust memory on a huge nested-.gitignore pattern set', async () => {
     const realTmp = mkdtempSync(path.join(tmpdir(), 'socket-glob-oom-'))
     try {

src/utils/glob.mts

@@ -291,28 +291,10 @@ export async function globWithGitIgnore(
     }
   }
 
-  // Match every gitignore-derived pattern through a single reused `ignore`
-  // instance instead of handing the whole set to fast-glob's native `ignore`
-  // option. fast-glob re-compiles and re-tests its entire ignore array inside
-  // each directory scan (`node::fs::AfterScanDir`), so a large monorepo whose
-  // nested `.gitignore` files union to tens of thousands of patterns aborts with
-  // `CALL_AND_RETRY_LAST … heap out of memory`. Raising `--max-old-space-size`
-  // does not reliably help: much of the cost is regex executable code in V8 code
-  // space rather than the data heap. The `ignore` package compiles each rule
-  // once and memoizes it, so the cost scales with the pattern count rather than
-  // being multiplied by the number of directories walked. fast-glob
-  // keeps only the small, bounded set it needs to PRUNE directories during the
-  // walk (`defaultIgnore`, which already excludes node_modules and .git, plus
-  // the anchored CLI minimatch ignores); the high-cardinality gitignore set is
-  // applied per streamed entry by `ig` below. The `ignore` package also honors
-  // negated re-includes, which fast-glob, globby, and tinyglobby cannot express.
-  // The negated-pattern path already worked this way; routing both cases through
-  // it removes the asymmetry that left the common, non-negated case crashing on
-  // large repos.
-  // Match fast-glob's case sensitivity (its `caseSensitiveMatch` defaults to
-  // true) so routing the non-negated path through the `ignore` package does not
-  // silently start matching case-insensitively, which is the `ignore` package's
-  // own default.
+  // Match the high-cardinality gitignore set through one reused `ignore`
+  // instance, not fast-glob's `ignore` (which recompiles its whole array per
+  // directory scan and OOMs on tens of thousands of patterns); fast-glob keeps
+  // only the bounded prune set. `ignorecase` tracks fast-glob's default.
   const ig = ignore({
     ignorecase: additionalOptions.caseSensitiveMatch === false,
   }).add([...ignores])
@@ -343,11 +325,10 @@ export async function globWithGitIgnore(
     globOptions,
   ) as AsyncIterable<string>
   for await (const p of stream) {
-    // Note: the input files must be INSIDE the cwd. If you get strange looking
-    // relative path errors here, most likely your path is outside the given cwd.
     // Normalize to POSIX separators: the `ignore` patterns are forward-slash
-    // anchored (see ignoreFileLinesToGlobPatterns), so a Windows backslash path
-    // from path.relative would never match them.
+    // anchored (ignoreFileLinesToGlobPatterns), so a Windows backslash path from
+    // path.relative would never match. Input must be inside cwd, else
+    // path.relative returns an odd `..`-prefixed relative path.
     const relPath = normalizePath(
       globOptions.absolute ? path.relative(cwd, p) : p,
     )

src/utils/path-resolve.mts

@@ -145,11 +145,9 @@ export async function getPackageFilesForScan(
   } as PackageFilesForScanOptions
 
   // Apply the supported files filter during streaming so globWithGitIgnore drops
-  // non-manifest paths as they are walked instead of collecting every path first.
-  // This bounds RESULT-path memory on large monorepos with 100k+ files. Note it
-  // does NOT bound the gitignore ignore-pattern memory: that OOM (regex compile
-  // exhausting V8 code space) is handled inside globWithGitIgnore by matching the
-  // gitignore set through a single reused `ignore` instance.
+  // non-manifest paths as they are walked. This bounds RESULT-path memory; it
+  // does NOT bound the gitignore ignore-pattern memory (that OOM is handled
+  // inside globWithGitIgnore via a single reused `ignore` instance).
   const filter = createSupportedFilesFilter(supportedFiles)
 
   const normalizedInputPaths = inputPaths.map(p =>