app-builder-lib 26.3.4 → 26.3.5

package/out/node-module-collector/moduleCache.d.ts

@@ -1,24 +1,27 @@
-import * as fs from "fs";
 import { PackageJson } from "./types";
-/**
- * Unified cache for all file system and module resolution operations
- */
-export type ModuleCache = {
+import * as fs from "fs-extra";
+type PackageJsonCache = Record<string, Promise<PackageJson>>;
+type RealPathCache = Record<string, Promise<string>>;
+type ExistsCache = Record<string, Promise<boolean>>;
+type LstatCache = Record<string, Promise<fs.Stats>>;
+type RequireResolveCache = Record<string, Promise<string | null>>;
+export declare class ModuleCache {
     /** Cache for package.json contents (readJson/require) */
-    packageJson: Map<string, PackageJson>;
+    readonly packageJson: PackageJsonCache;
     /** Cache for resolved real paths (realpath) */
-    realPath: Map<string, string>;
+    readonly realPath: RealPathCache;
     /** Cache for file/directory existence checks */
-    exists: Map<string, boolean>;
+    readonly exists: ExistsCache;
     /** Cache for lstat results */
-    lstat: Map<string, fs.Stats>;
+    readonly lstat: LstatCache;
     /** Cache for require.resolve results (key: "packageName::fromDir") */
-    requireResolve: Map<string, {
-        entry: string;
-        packageDir: string;
-    } | null>;
-};
-/**
- * Creates a new empty ModuleCache instance
- */
-export declare function createModuleCache(): ModuleCache;
+    readonly requireResolve: RequireResolveCache;
+    private readonly packageJsonMap;
+    private readonly realPathMap;
+    private readonly existsMap;
+    private readonly lstatMap;
+    private readonly requireResolveMap;
+    constructor();
+    private createAsyncProxy;
+}
+export {};

package/out/node-module-collector/moduleCache.js

@@ -1,16 +1,57 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createModuleCache = createModuleCache;
-/**
- * Creates a new empty ModuleCache instance
- */
-function createModuleCache() {
-    return {
-        packageJson: new Map(),
-        realPath: new Map(),
-        exists: new Map(),
-        lstat: new Map(),
-        requireResolve: new Map(),
-    };
+exports.ModuleCache = void 0;
+const builder_util_1 = require("builder-util");
+const fs = require("fs-extra");
+const path_1 = require("path");
+class ModuleCache {
+    constructor() {
+        this.packageJsonMap = new Map();
+        this.realPathMap = new Map();
+        this.existsMap = new Map();
+        this.lstatMap = new Map();
+        this.requireResolveMap = new Map();
+        this.packageJson = this.createAsyncProxy(this.packageJsonMap, (path) => fs.readJson(path));
+        this.exists = this.createAsyncProxy(this.existsMap, (path) => (0, builder_util_1.exists)(path));
+        this.lstat = this.createAsyncProxy(this.lstatMap, (path) => fs.lstat(path));
+        this.requireResolve = this.createAsyncProxy(this.requireResolveMap, (path) => require.resolve(path));
+        this.realPath = this.createAsyncProxy(this.realPathMap, async (path) => {
+            const p = (0, path_1.resolve)(path);
+            try {
+                const stats = await this.lstat[p];
+                if (stats.isSymbolicLink()) {
+                    return await fs.realpath(p);
+                }
+                return p;
+            }
+            catch (error) {
+                builder_util_1.log.debug({ filePath: p, message: error.message || error.stack }, "error resolving path");
+            }
+            return p;
+        });
+    }
+    // this allows dot-notation access while still supporting async retrieval
+    // e.g., cache.packageJson[somePath] returns Promise<PackageJson>
+    createAsyncProxy(map, compute) {
+        return new Proxy({}, {
+            async get(_, key) {
+                if (map.has(key)) {
+                    return Promise.resolve(map.get(key));
+                }
+                return await Promise.resolve(compute(key)).then(value => {
+                    map.set(key, value);
+                    return value;
+                });
+            },
+            set(_, key, value) {
+                map.set(key, value);
+                return true;
+            },
+            has(_, key) {
+                return map.has(key);
+            },
+        });
+    }
 }
+exports.ModuleCache = ModuleCache;
 //# sourceMappingURL=moduleCache.js.map

package/out/node-module-collector/moduleCache.js.map

@@ -1 +1 @@
-{"version":3,"file":"moduleCache.js","sourceRoot":"","sources":["../../src/node-module-collector/moduleCache.ts"],"names":[],"mappings":";;AAsBA,8CAQC;AAXD;;GAEG;AACH,SAAgB,iBAAiB;IAC/B,OAAO;QACL,WAAW,EAAE,IAAI,GAAG,EAAE;QACtB,QAAQ,EAAE,IAAI,GAAG,EAAE;QACnB,MAAM,EAAE,IAAI,GAAG,EAAE;QACjB,KAAK,EAAE,IAAI,GAAG,EAAE;QAChB,cAAc,EAAE,IAAI,GAAG,EAAE;KAC1B,CAAA;AACH,CAAC","sourcesContent":["import * as fs from \"fs\"\nimport { PackageJson } from \"./types\"\n\n/**\n * Unified cache for all file system and module resolution operations\n */\nexport type ModuleCache = {\n  /** Cache for package.json contents (readJson/require) */\n  packageJson: Map<string, PackageJson>\n  /** Cache for resolved real paths (realpath) */\n  realPath: Map<string, string>\n  /** Cache for file/directory existence checks */\n  exists: Map<string, boolean>\n  /** Cache for lstat results */\n  lstat: Map<string, fs.Stats>\n  /** Cache for require.resolve results (key: \"packageName::fromDir\") */\n  requireResolve: Map<string, { entry: string; packageDir: string } | null>\n}\n\n/**\n * Creates a new empty ModuleCache instance\n */\nexport function createModuleCache(): ModuleCache {\n  return {\n    packageJson: new Map(),\n    realPath: new Map(),\n    exists: new Map(),\n    lstat: new Map(),\n    requireResolve: new Map(),\n  }\n}\n"]}
+{"version":3,"file":"moduleCache.js","sourceRoot":"","sources":["../../src/node-module-collector/moduleCache.ts"],"names":[],"mappings":"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","sourcesContent":["import { exists, log } from \"builder-util\"\nimport { PackageJson } from \"./types\"\nimport * as fs from \"fs-extra\"\nimport { resolve } from \"path\"\n\n// Type aliases for clarity\ntype PackageJsonCache = Record<string, Promise<PackageJson>>\ntype RealPathCache = Record<string, Promise<string>>\ntype ExistsCache = Record<string, Promise<boolean>>\ntype LstatCache = Record<string, Promise<fs.Stats>>\ntype RequireResolveCache = Record<string, Promise<string | null>>\n\nexport class ModuleCache {\n  /** Cache for package.json contents (readJson/require) */\n  readonly packageJson: PackageJsonCache\n  /** Cache for resolved real paths (realpath) */\n  readonly realPath: RealPathCache\n  /** Cache for file/directory existence checks */\n  readonly exists: ExistsCache\n  /** Cache for lstat results */\n  readonly lstat: LstatCache\n  /** Cache for require.resolve results (key: \"packageName::fromDir\") */\n  readonly requireResolve: RequireResolveCache\n\n  private readonly packageJsonMap: Map<string, PackageJson> = new Map()\n  private readonly realPathMap: Map<string, string> = new Map()\n  private readonly existsMap: Map<string, boolean> = new Map()\n  private readonly lstatMap: Map<string, fs.Stats> = new Map()\n  private readonly requireResolveMap: Map<string, string | null> = new Map()\n\n  constructor() {\n    this.packageJson = this.createAsyncProxy(this.packageJsonMap, (path: string) => fs.readJson(path))\n    this.exists = this.createAsyncProxy(this.existsMap, (path: string) => exists(path))\n    this.lstat = this.createAsyncProxy(this.lstatMap, (path: string) => fs.lstat(path))\n    this.requireResolve = this.createAsyncProxy(this.requireResolveMap, (path: string) => require.resolve(path))\n    this.realPath = this.createAsyncProxy(this.realPathMap, async (path: string) => {\n      const p = resolve(path)\n      try {\n        const stats = await this.lstat[p]\n        if (stats.isSymbolicLink()) {\n          return await fs.realpath(p)\n        }\n        return p\n      } catch (error: any) {\n        log.debug({ filePath: p, message: error.message || error.stack }, \"error resolving path\")\n      }\n      return p\n    })\n  }\n\n  // this allows dot-notation access while still supporting async retrieval\n  // e.g., cache.packageJson[somePath] returns Promise<PackageJson>\n  private createAsyncProxy<T>(map: Map<string, T>, compute: (key: string) => T | Promise<T>): Record<string, Promise<T>> {\n    return new Proxy({} as Record<string, Promise<T>>, {\n      async get(_, key: string) {\n        if (map.has(key)) {\n          return Promise.resolve(map.get(key)!)\n        }\n        return await Promise.resolve(compute(key)).then(value => {\n          map.set(key, value)\n          return value\n        })\n      },\n      set(_, key: string, value: T) {\n        map.set(key, value)\n        return true\n      },\n      has(_, key: string) {\n        return map.has(key)\n      },\n    })\n  }\n}\n"]}

package/out/node-module-collector/nodeModulesCollector.d.ts

@@ -1,18 +1,21 @@
 import { TmpDir } from "builder-util";
 import { CancellationToken } from "builder-util-runtime";
-import * as fs from "fs-extra";
 import { Lazy } from "lazy-val";
+import { ModuleCache } from "./moduleCache";
 import { PM } from "./packageManager";
-import type { Dependency, DependencyGraph, NodeModuleInfo, PackageJson } from "./types";
+import type { Dependency, DependencyGraph, NodeModuleInfo } from "./types";
+type Result = {
+    packageDir: string;
+    version: string;
+} | null;
 export declare abstract class NodeModulesCollector<ProdDepType extends Dependency<ProdDepType, OptionalDepType>, OptionalDepType> {
     protected readonly rootDir: string;
     private readonly tempDirManager;
     private readonly nodeModules;
     protected readonly allDependencies: Map<string, ProdDepType>;
     protected readonly productionGraph: DependencyGraph;
-    private readonly cache;
-    protected readonly isHoisted: Lazy<boolean>;
-    protected appPkgJson: Lazy<PackageJson>;
+    protected readonly cache: ModuleCache;
+    protected isHoisted: Lazy<boolean>;
     constructor(rootDir: string, tempDirManager: TmpDir);
     getNodeModules({ cancellationToken, packageName }: {
         cancellationToken: CancellationToken;
@@ -27,23 +30,6 @@ export declare abstract class NodeModulesCollector<ProdDepType extends Dependenc
     protected abstract extractProductionDependencyGraph(tree: Dependency<ProdDepType, OptionalDepType>, dependencyId: string): Promise<void>;
     protected abstract collectAllDependencies(tree: Dependency<ProdDepType, OptionalDepType>, appPackageName: string): Promise<void>;
     protected getDependenciesTree(pm: PM): Promise<ProdDepType>;
-    protected existsMemoized(filePath: string): Promise<boolean>;
-    protected readJsonMemoized(filePath: string): Promise<PackageJson>;
-    protected lstatMemoized(filePath: string): Promise<fs.Stats>;
-    protected realpathMemoized(filePath: string): Promise<string>;
-    protected requireMemoized(pkgPath: string): PackageJson;
-    protected existsSyncMemoized(filePath: string): boolean;
-    protected resolvePath(filePath: string): Promise<string>;
-    /**
-     * Resolve a package directory purely from the filesystem.
-     * Does NOT attempt to load the module or resolve an "exports" entrypoint.
-     * Good for Yarn 4 because a package may not be resolvable as a module,
-     * but still exists on disk.
-     */
-    protected resolvePackage(packageName: string, fromDir: string): Promise<{
-        entry: string;
-        packageDir: string;
-    } | null>;
     protected cacheKey(pkg: ProdDepType): string;
     protected packageVersionString(pkg: ProdDepType): string;
     /**
@@ -61,4 +47,17 @@ export declare abstract class NodeModulesCollector<ProdDepType extends Dependenc
         stderr: string | undefined;
     }>;
     streamCollectorCommandToFile(command: string, args: string[], cwd: string, tempOutputFile: string): Promise<void>;
+    protected locatePackageVersion(parentDir: string, pkgName: string, requiredRange?: string): Promise<Result | null>;
+    protected readPackageVersion(pkgJsonPath: string): Promise<string | null>;
+    protected semverSatisfies(found: string, range?: string): boolean;
+    /**
+     * Upward search (hoisted)
+     */
+    private upwardSearch;
+    /**
+     * Breadth-first downward search from parentDir/node_modules
+     * Looks for node_modules/\*\/node_modules/pkgName (and deeper)
+     */
+    private downwardSearch;
 }
+export {};

package/out/node-module-collector/nodeModulesCollector.js

@@ -7,6 +7,7 @@ const fs = require("fs-extra");
 const fs_extra_1 = require("fs-extra");
 const lazy_val_1 = require("lazy-val");
 const path = require("path");
+const semver = require("semver");
 const hoist_1 = require("./hoist");
 const moduleCache_1 = require("./moduleCache");
 const packageManager_1 = require("./packageManager");
@@ -17,14 +18,12 @@ class NodeModulesCollector {
         this.nodeModules = [];
         this.allDependencies = new Map();
         this.productionGraph = {};
-        // Unified cache for all file system and module operations
-        this.cache = (0, moduleCache_1.createModuleCache)();
+        this.cache = new moduleCache_1.ModuleCache();
         this.isHoisted = new lazy_val_1.Lazy(async () => {
-            var _a;
             const { manager } = this.installOptions;
             const command = (0, packageManager_1.getPackageManagerCommand)(manager);
-            const config = (_a = (await this.asyncExec(command, ["config", "list"])).stdout) === null || _a === void 0 ? void 0 : _a.trim();
-            if ((0, builder_util_1.isEmptyOrSpaces)(config)) {
+            const config = (await this.asyncExec(command, ["config", "list"])).stdout;
+            if (config == null) {
                 builder_util_1.log.debug({ manager }, "unable to determine if node_modules are hoisted: no config output. falling back to hoisted mode");
                 return false;
             }
@@ -35,10 +34,6 @@ class NodeModulesCollector {
             }
             return false;
         });
-        this.appPkgJson = new lazy_val_1.Lazy(async () => {
-            const appPkgPath = path.join(this.rootDir, "package.json");
-            return this.readJsonMemoized(appPkgPath);
-        });
     }
     async getNodeModules({ cancellationToken, packageName }) {
         const tree = await this.getDependenciesTree(this.installOptions.manager);
@@ -76,7 +71,7 @@ class NodeModulesCollector {
             shouldRetry: async (error) => {
                 var _a;
                 const logFields = { error: error.message, tempOutputFile, cwd: this.rootDir };
-                if (!(await this.existsMemoized(tempOutputFile))) {
+                if (!(await this.cache.exists[tempOutputFile])) {
                     builder_util_1.log.debug(logFields, "dependency tree output file missing, retrying");
                     return true;
                 }
@@ -95,109 +90,6 @@ class NodeModulesCollector {
             },
         });
     }
-    async existsMemoized(filePath) {
-        if (!this.cache.exists.has(filePath)) {
-            this.cache.exists.set(filePath, await (0, builder_util_1.exists)(filePath));
-        }
-        return this.cache.exists.get(filePath);
-    }
-    async readJsonMemoized(filePath) {
-        if (!this.cache.packageJson.has(filePath)) {
-            this.cache.packageJson.set(filePath, await (0, fs_extra_1.readJson)(filePath));
-        }
-        return this.cache.packageJson.get(filePath);
-    }
-    async lstatMemoized(filePath) {
-        if (!this.cache.lstat.has(filePath)) {
-            this.cache.lstat.set(filePath, await fs.lstat(filePath));
-        }
-        return this.cache.lstat.get(filePath);
-    }
-    async realpathMemoized(filePath) {
-        if (!this.cache.realPath.has(filePath)) {
-            this.cache.realPath.set(filePath, await fs.realpath(filePath));
-        }
-        return this.cache.realPath.get(filePath);
-    }
-    requireMemoized(pkgPath) {
-        if (!this.cache.packageJson.has(pkgPath)) {
-            this.cache.packageJson.set(pkgPath, require(pkgPath));
-        }
-        return this.cache.packageJson.get(pkgPath);
-    }
-    existsSyncMemoized(filePath) {
-        if (!this.cache.exists.has(filePath)) {
-            this.cache.exists.set(filePath, fs.existsSync(filePath));
-        }
-        return this.cache.exists.get(filePath);
-    }
-    async resolvePath(filePath) {
-        // Check if we've already resolved this path
-        if (this.cache.realPath.has(filePath)) {
-            return this.cache.realPath.get(filePath);
-        }
-        try {
-            const stats = await this.lstatMemoized(filePath);
-            if (stats.isSymbolicLink()) {
-                const resolved = await this.realpathMemoized(filePath);
-                this.cache.realPath.set(filePath, resolved);
-                return resolved;
-            }
-            else {
-                this.cache.realPath.set(filePath, filePath);
-                return filePath;
-            }
-        }
-        catch (error) {
-            builder_util_1.log.debug({ filePath, message: error.message || error.stack }, "error resolving path");
-            this.cache.realPath.set(filePath, filePath);
-            return filePath;
-        }
-    }
-    /**
-     * Resolve a package directory purely from the filesystem.
-     * Does NOT attempt to load the module or resolve an "exports" entrypoint.
-     * Good for Yarn 4 because a package may not be resolvable as a module,
-     * but still exists on disk.
-     */
-    async resolvePackage(packageName, fromDir) {
-        const cacheKey = `${packageName}::${fromDir}`;
-        if (this.cache.requireResolve.has(cacheKey)) {
-            return this.cache.requireResolve.get(cacheKey);
-        }
-        // 1. NESTED under fromDir/node_modules/<name>
-        let candidate = path.join(fromDir, "node_modules", packageName);
-        let pkgJson = path.join(candidate, "package.json");
-        if (await this.existsMemoized(pkgJson)) {
-            this.cache.requireResolve.set(cacheKey, { entry: pkgJson, packageDir: candidate });
-            return { entry: pkgJson, packageDir: candidate };
-        }
-        // 2. HOISTED under rootDir/node_modules/<name>
-        candidate = path.join(this.rootDir, "node_modules", packageName);
-        pkgJson = path.join(candidate, "package.json");
-        if (await this.existsMemoized(pkgJson)) {
-            this.cache.requireResolve.set(cacheKey, { entry: pkgJson, packageDir: candidate });
-            return { entry: pkgJson, packageDir: candidate };
-        }
-        // 3. FALLBACK: try parent directories BFS (classic Node-style search)
-        let current = fromDir;
-        while (true) {
-            const nm = path.join(current, "node_modules", packageName);
-            const pkg = path.join(nm, "package.json");
-            if (await this.existsMemoized(pkg)) {
-                this.cache.requireResolve.set(cacheKey, { entry: pkg, packageDir: nm });
-                return { entry: pkg, packageDir: nm };
-            }
-            const parent = path.dirname(current);
-            if (parent === current) {
-                break;
-            }
-            current = parent;
-        }
-        // 4. LAST RESORT: DO NOT throw — just return null
-        this.cache.requireResolve.set(cacheKey, null);
-        return null;
-    }
     cacheKey(pkg) {
         const rel = path.relative(this.rootDir, pkg.path);
         return `${pkg.name}::${pkg.version}::${rel !== null && rel !== void 0 ? rel : "."}`;
@@ -225,7 +117,7 @@ class NodeModulesCollector {
         }
         if ((_a = tree.dependencies) === null || _a === void 0 ? void 0 : _a[packageName]) {
             const { name, path, dependencies } = tree.dependencies[packageName];
-            builder_util_1.log.debug({ name, path, dependencies: JSON.stringify(dependencies) }, "pruning root app/self reference from workspace tree, merging dependencies uptree");
+            builder_util_1.log.debug({ name, path, dependencies: JSON.stringify(dependencies) }, "pruning root app/self reference from workspace tree");
             for (const [name, pkg] of Object.entries(dependencies !== null && dependencies !== void 0 ? dependencies : {})) {
                 tree.dependencies[name] = pkg;
                 this.allDependencies.set(this.packageVersionString(pkg), pkg);
@@ -263,19 +155,19 @@ class NodeModulesCollector {
             const reference = [...d.references][0];
             const p = (_a = this.allDependencies.get(`${d.name}@${reference}`)) === null || _a === void 0 ? void 0 : _a.path;
             if (p === undefined) {
-                builder_util_1.log.debug({ name: d.name, reference }, "cannot find path for dependency");
+                builder_util_1.log.warn({ name: d.name, reference }, "cannot find path for dependency");
                 continue;
             }
             // fix npm list issue
             // https://github.com/npm/cli/issues/8535
-            if (!(await (0, builder_util_1.exists)(p))) {
+            if (!(await this.cache.exists[p])) {
                 builder_util_1.log.debug({ name: d.name, reference, p }, "dependency path does not exist");
                 continue;
             }
             const node = {
                 name: d.name,
                 version: reference,
-                dir: await this.resolvePath(p),
+                dir: await this.cache.realPath[p],
             };
             result.push(node);
             if (d.dependencies.size > 0) {
@@ -314,7 +206,6 @@ class NodeModulesCollector {
             command = "cmd.exe";
             args = ["/c", tempBatFile, ...args];
         }
-        builder_util_1.log.debug({ command, args, cwd, tempOutputFile }, "spawning node module collector process");
         await new Promise((resolve, reject) => {
             const outStream = (0, fs_extra_1.createWriteStream)(tempOutputFile);
             const child = childProcess.spawn(command, args, {
@@ -344,6 +235,175 @@ class NodeModulesCollector {
             });
         });
     }
+    async locatePackageVersion(parentDir, pkgName, requiredRange) {
+        // 1) check direct parent node_modules/pkgName first
+        const direct = path.join(path.resolve(parentDir), "node_modules", pkgName, "package.json");
+        if (await this.cache.exists[direct]) {
+            const ver = await this.readPackageVersion(direct);
+            if (ver && this.semverSatisfies(ver, requiredRange)) {
+                return { packageDir: path.dirname(direct), version: ver };
+            }
+        }
+        // 2) upward hoisted search, then 3) downward non-hoisted search
+        return (await this.upwardSearch(parentDir, pkgName, requiredRange)) || (await this.downwardSearch(parentDir, pkgName, requiredRange)) || null;
+    }
+    async readPackageVersion(pkgJsonPath) {
+        return await this.cache.packageJson[pkgJsonPath].then(pkg => pkg.version).catch(() => null);
+    }
+    semverSatisfies(found, range) {
+        if (!range || range === "*" || range === "") {
+            return true;
+        }
+        if (range === found) {
+            return true;
+        }
+        if (semver.validRange(range) == null) {
+            // ignore, we can't verify non-semver ranges
+            // e.g. git urls, file:, patch:, etc. Example:
+            // "@ai-sdk/google": "patch:@ai-sdk/google@npm%3A2.0.43#~/.yarn/patches/@ai-sdk-google-npm-2.0.43-689ed559b3.patch"
+            builder_util_1.log.debug({ found, range }, "unable to validate semver version range, assuming match");
+            return true;
+        }
+        try {
+            return semver.satisfies(found, range);
+        }
+        catch {
+            // fallback: simple equality or basic prefix handling (^, ~)
+            if (range.startsWith("^") || range.startsWith("~")) {
+                const r = range.slice(1);
+                return r === found;
+            }
+            // if range is like "8.x" or "8.*" match major
+            const m = range.match(/^(\d+)[.(*|x)]*/);
+            const fm = found.match(/^(\d+)\./);
+            if (m && fm) {
+                return m[1] === fm[1];
+            }
+            return false;
+        }
+    }
+    /**
+     * Upward search (hoisted)
+     */
+    async upwardSearch(parentDir, pkgName, requiredRange) {
+        let current = path.resolve(parentDir);
+        const root = path.parse(current).root;
+        while (true) {
+            const candidate = path.join(current, "node_modules", pkgName, "package.json");
+            if (await this.cache.exists[candidate]) {
+                const ver = await this.readPackageVersion(candidate);
+                if (ver && this.semverSatisfies(ver, requiredRange)) {
+                    return { packageDir: path.dirname(candidate), version: ver };
+                }
+                // otherwise keep searching upward (we may find a different hoisted version)
+            }
+            if (current === root) {
+                break;
+            }
+            const parent = path.dirname(current);
+            if (parent === current) {
+                break;
+            }
+            current = parent;
+        }
+        return null;
+    }
+    /**
+     * Breadth-first downward search from parentDir/node_modules
+     * Looks for node_modules/\*\/node_modules/pkgName (and deeper)
+     */
+    async downwardSearch(parentDir, pkgName, requiredRange, maxExplored = 2000, maxDepth = 6) {
+        const start = path.join(path.resolve(parentDir), "node_modules");
+        if (!(await this.cache.exists[start]) || !(await this.cache.lstat[start]).isDirectory()) {
+            return null;
+        }
+        const visited = new Set();
+        const queue = [{ dir: start, depth: 0 }];
+        let explored = 0;
+        while (queue.length > 0) {
+            const { dir, depth } = queue.shift();
+            if (explored++ > maxExplored) {
+                break;
+            }
+            if (depth > maxDepth) {
+                continue;
+            }
+            let entries;
+            try {
+                entries = await fs.readdir(dir);
+            }
+            catch (e) {
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.startsWith(".")) {
+                    continue;
+                }
+                const entryPath = path.join(dir, entry);
+                // handle scoped packages @scope/name
+                if (entry.startsWith("@")) {
+                    // queue the scope directory itself to explore its children
+                    if ((await this.cache.exists[entryPath]) && (await this.cache.lstat[entryPath]).isDirectory()) {
+                        const scopeEntries = await fs.readdir(entryPath);
+                        for (const sc of scopeEntries) {
+                            const scPath = path.join(entryPath, sc);
+                            // check scPath/node_modules/pkgName
+                            const candidatePkgJson = path.join(scPath, "node_modules", pkgName, "package.json");
+                            if (await this.cache.exists[candidatePkgJson]) {
+                                const ver = await this.readPackageVersion(candidatePkgJson);
+                                if (ver && this.semverSatisfies(ver, requiredRange)) {
+                                    return { packageDir: path.dirname(candidatePkgJson), version: ver };
+                                }
+                            }
+                            // enqueue scPath/node_modules to explore further
+                            const scNodeModules = path.join(scPath, "node_modules");
+                            if ((await this.cache.exists[scNodeModules]) && (await this.cache.lstat[scNodeModules]).isDirectory()) {
+                                if (!visited.has(scNodeModules)) {
+                                    visited.add(scNodeModules);
+                                    queue.push({ dir: scNodeModules, depth: depth + 1 });
+                                }
+                            }
+                        }
+                    }
+                    continue;
+                }
+                // check for direct candidate: entry/node_modules/pkgName
+                try {
+                    const stat = await this.cache.lstat[entryPath];
+                    if (!stat.isDirectory()) {
+                        continue;
+                    }
+                }
+                catch {
+                    continue;
+                }
+                const candidatePkgJson = path.join(entryPath, "node_modules", pkgName, "package.json");
+                if (await this.cache.exists[candidatePkgJson]) {
+                    const ver = await this.readPackageVersion(candidatePkgJson);
+                    if (ver && this.semverSatisfies(ver, requiredRange)) {
+                        return { packageDir: path.dirname(candidatePkgJson), version: ver };
+                    }
+                }
+                // also check entry/node_modules directly for pkgName (some layouts)
+                const candidateDirect = path.join(entryPath, pkgName, "package.json");
+                if (await this.cache.exists[candidateDirect]) {
+                    const ver = await this.readPackageVersion(candidateDirect);
+                    if (ver && this.semverSatisfies(ver, requiredRange)) {
+                        return { packageDir: path.dirname(candidateDirect), version: ver };
+                    }
+                }
+                // enqueue entry/node_modules for deeper traversal
+                const nextNodeModules = path.join(entryPath, "node_modules");
+                if ((await this.cache.exists[nextNodeModules]) && (await this.cache.lstat[nextNodeModules]).isDirectory()) {
+                    if (!visited.has(nextNodeModules)) {
+                        visited.add(nextNodeModules);
+                        queue.push({ dir: nextNodeModules, depth: depth + 1 });
+                    }
+                }
+            }
+        }
+        return null;
+    }
 }
 exports.NodeModulesCollector = NodeModulesCollector;
 //# sourceMappingURL=nodeModulesCollector.js.map