@happyvertical/smrt-scanner 0.40.61 → 0.40.63

package/AGENTS.md

@@ -22,11 +22,37 @@ executes the source.
   and asserts every `@smrt()` object reached `dist/manifest.json` (issue #1483).
   Returns `ok` / `incomplete` / `missing-manifest` / `scan-error` / `skipped`.
   Driven by `scripts/verify-manifest-completeness.mjs` from `prepack`.
+- `discoverSourceFiles(options)` — shared bounded source-discovery policy used
+  by `OxcScanner` and the core manifest preflight.
 - Types (re-exported from `./types`): `RawClassDefinition`,
   `RawFieldDefinition`, `RawMethodDefinition`, `ResolvedClassDefinition`,
   `ScanResults`, `FileScanResult`, `OxcScannerOptions`, `InferredFieldType`,
   `FieldTypeInference`.
 
+## Discovery boundaries
+
+File discovery is the difference between a scan that finishes and one that
+exhausts the heap when the scanner is pointed at an application root (#2275):
+
+- `dot: true` is set so ignore patterns apply beneath dot directories. Without
+  it a `**` cannot cross a dot segment, so `**/node_modules/**` pruned the root
+  `node_modules` but nothing under `.svelte-kit/`, `.vercel/`, or `.turbo/`.
+- Mandatory excludes (`**/node_modules/**`, `**/.*/**`, `**/.*`) are unioned
+  with the caller's `exclude` and cannot be overridden. `exclude` REPLACES the
+  defaults, so every caller that narrowed it had silently reopened
+  `node_modules`.
+- `followSymbolicLinks` defaults to `false`. A pnpm `node_modules` is a symlink
+  graph with cycles, not a tree, so a link-following walk reaches the same real
+  directory once per path leading to it. This drops symlinked *files* as well as
+  directories, so pass `followSymbolicLinks: true` for a project that genuinely
+  keeps sources behind a link — it is threaded through `smrtPlugin` and
+  `ManifestBuilderOptions` for the build path.
+- Patterns are rewritten relative to `cwd` before globbing. Globs match as text,
+  so an absolute pattern would hand `**/.*/**` the project's own ancestors and a
+  checkout under `~/.worktrees` or `~/.cache` would match nothing at all.
+- `dot: true` would otherwise widen the result to hidden files, so `**/.*` is in
+  the mandatory prunes too: hidden files stay out, exactly as before.
+
 ## How It Works
 
 1. `fast-glob` finds `.ts` files matching include/exclude patterns.
@@ -43,6 +69,7 @@ executes the source.
   `parseSource`, `extractSmrtImports`, field/decorator/type extractors).
 - `src/scanner.ts` — `OxcScanner`: globbing + multi-file orchestration
   (`scan` / `scanAndResolve`).
+- `src/discovery.ts` — shared bounded glob policy for every scanner entry point.
 - `src/inheritance-resolver.ts` — `InheritanceResolver`: cross-file inheritance
   merging.
 - `src/manifest-adapter.ts` — `ManifestAdapter`: raw → manifest conversion and

package/dist/chunks/{scanner-DEGZfoLz.js → scanner-LeMvLJ6X.js}

@@ -1,7 +1,49 @@
+import { isAbsolute, resolve, sep, win32 } from "node:path";
+import fg from "fast-glob";
 import { readFileSync } from "node:fs";
 import { parseSync } from "oxc-parser";
-import "node:path";
-import fg from "fast-glob";
+//#region src/discovery.ts
+var MANDATORY_DISCOVERY_EXCLUDES = Object.freeze([
+	"**/node_modules/**",
+	"**/.*/**",
+	"**/.*"
+]);
+async function discoverSourceFiles(options) {
+	const cwd = resolve(options.cwd);
+	return fg(options.include.map((pattern) => relativeGlobToCwd(pattern, cwd)), {
+		cwd,
+		ignore: [...options.exclude.map((pattern) => relativeGlobToCwd(pattern, cwd)), ...MANDATORY_DISCOVERY_EXCLUDES],
+		absolute: true,
+		onlyFiles: true,
+		dot: true,
+		followSymbolicLinks: options.followSymbolicLinks ?? false
+	});
+}
+function relativeGlobToCwd(pattern, cwd) {
+	const windowsAbsolute = win32.isAbsolute(pattern);
+	if (!isAbsolute(pattern) && !windowsAbsolute) return pattern;
+	const cwdVariants = [
+		cwd,
+		cwd.replaceAll("\\", "/"),
+		cwd.replaceAll("/", "\\")
+	];
+	for (const prefix of new Set(cwdVariants)) {
+		const comparablePattern = windowsAbsolute ? pattern.toLowerCase() : pattern;
+		const comparablePrefix = windowsAbsolute ? prefix.toLowerCase() : prefix;
+		if (comparablePattern === comparablePrefix) return ".";
+		const boundary = pattern.charAt(prefix.length);
+		if (comparablePattern.startsWith(comparablePrefix) && (boundary === "/" || boundary === "\\")) {
+			const rewritten = pattern.slice(prefix.length + 1);
+			return boundary === "\\" ? normalizeGlobSeparators(rewritten, "\\") : rewritten;
+		}
+	}
+	const slashAuthoredWindows = /^[A-Za-z]:\//.test(pattern);
+	return windowsAbsolute && !slashAuthoredWindows ? normalizeGlobSeparators(pattern, "\\") : pattern;
+}
+function normalizeGlobSeparators(pattern, pathSeparator = sep) {
+	return pathSeparator === "/" ? pattern : pattern.replaceAll(pathSeparator, "/");
+}
+//#endregion
 //#region src/inheritance-resolver.ts
 var FRAMEWORK_BASE_CLASSES = /* @__PURE__ */ new Set([
 	"SmrtObject",
@@ -1928,7 +1970,8 @@ var OxcScanner = class {
 			baseClasses: options.baseClasses || [],
 			includePrivateMethods: options.includePrivateMethods ?? false,
 			includeStaticMethods: options.includeStaticMethods ?? true,
-			externalManifests: options.externalManifests || /* @__PURE__ */ new Map()
+			externalManifests: options.externalManifests || /* @__PURE__ */ new Map(),
+			followSymbolicLinks: options.followSymbolicLinks ?? false
 		};
 		this.resolver = new InheritanceResolver({
 			baseClasses: this.options.baseClasses,
@@ -2085,15 +2128,34 @@ var OxcScanner = class {
 		};
 	}
 	/**
-	* Discover files to scan using fast-glob
+	* Discover files to scan using fast-glob.
+	*
+	* Two settings here decide whether discovery terminates at all when the
+	* scanner is pointed at an application root rather than a package `src/`:
+	*
+	* - `dot: true`. Without it a `**` in an ignore pattern cannot cross a
+	*   dot segment, so `**\/node_modules/**` prunes `node_modules` at the root
+	*   but NOT `.svelte-kit/…/node_modules` or any other `node_modules` under a
+	*   dot directory. Those subtrees were then walked in full and every entry
+	*   discarded — unbounded work that could never produce a match.
+	* - `followSymbolicLinks: false`. pnpm materializes `node_modules` as a
+	*   symlink graph with cycles, so a link-following walk revisits the same
+	*   real directories once per path that reaches them.
+	*
+	* Together they were enough to exhaust a 4 GB heap on a consumer app that
+	* installs the published packages (#2275).
+	*
+	* Patterns are rewritten relative to `cwd` first. fast-glob matches `ignore`
+	* in whatever space the patterns use, so an absolute pattern would hand
+	* `**\/.*\/**` the project's own ancestors — a checkout under `~/.worktrees`
+	* or `~/.cache` would then match nothing at all, silently.
 	*/
 	async discoverFiles() {
-		const patterns = this.options.include;
-		return await fg(patterns, {
+		return discoverSourceFiles({
 			cwd: this.options.cwd,
-			ignore: this.options.exclude,
-			absolute: true,
-			onlyFiles: true
+			include: this.options.include,
+			exclude: this.options.exclude,
+			followSymbolicLinks: this.options.followSymbolicLinks
 		});
 	}
 	/**
@@ -2104,6 +2166,6 @@ var OxcScanner = class {
 	}
 };
 //#endregion
-export { parseSource as a, parseFile as i, ManifestAdapter as n, InheritanceResolver as o, extractSmrtImports as r, OxcScanner as t };
+export { parseSource as a, normalizeGlobSeparators as c, parseFile as i, relativeGlobToCwd as l, ManifestAdapter as n, InheritanceResolver as o, extractSmrtImports as r, discoverSourceFiles as s, OxcScanner as t };
 
-//# sourceMappingURL=scanner-DEGZfoLz.js.map
+//# sourceMappingURL=scanner-LeMvLJ6X.js.map