@angular/build 22.2.2 → 22.2.4

package/src/utils/watcher.js

@@ -43,14 +43,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangedFiles = void 0;
+exports.ParcelExternalManager = exports.ChangedFiles = void 0;
 exports.setupWatcher = setupWatcher;
 exports.toPosixPathNormalized = toPosixPathNormalized;
 exports.getDirectoryPath = getDirectoryPath;
 exports.createWatcher = createWatcher;
 exports.isPathInside = isPathInside;
 exports.extractNodeModulesPackageDir = extractNodeModulesPackageDir;
-const node_events_1 = require("node:events");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const picomatch_1 = __importDefault(require("picomatch"));
@@ -362,122 +361,450 @@ function extractNodeModulesPackageDir(posixPath) {
     }
     return `${nodeModulesPath}/${segments[0]}`;
 }
+/**
+ * Maximum number of concurrent external directory subscriptions before coalescing
+ * sibling/cousin directories into common ancestor directories.
+ * Kept well below macOS's ~512 per-process FSEvents stream limit.
+ */
+const DEFAULT_MAX_EXTERNAL_SUBSCRIPTIONS = 256;
+/**
+ * Checks whether any strict ancestor of the given trie node is already marked as a target.
+ */
+function hasTargetAncestor(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.isTarget) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/**
+ * Manages `@parcel/watcher` directory subscriptions for watched files located outside the
+ * primary `workspaceRoot`.
+ *
+ * Because `@parcel/watcher` watches directories recursively and macOS limits each process to
+ * ~512 concurrent `FSEvents` streams, this manager:
+ * - Normalizes external `node_modules` file paths to their package root directory.
+ * - Batches synchronous `watchFile` and `removeFile` calls within a microtask before subscribing.
+ * - Uses a directory prefix tree to subsume nested child directories and iteratively coalesce
+ *   deepest branching subdirectories into common ancestors when the subscription budget is exceeded.
+ * - Dynamically lowers its subscription budget and coalesces further if `subscribe()` fails on
+ *   an existing directory due to OS stream limits.
+ */
 class ParcelExternalManager {
-    parcelWatcher;
-    options;
-    rootDirLookupKey;
-    handleEvents;
-    extraSubscriptions = new Map();
-    pendingSubscriptions = new Map();
-    externalDirFiles = new Map();
-    constructor(parcelWatcher, options, rootDirLookupKey, handleEvents) {
-        this.parcelWatcher = parcelWatcher;
-        this.options = options;
-        this.rootDirLookupKey = rootDirLookupKey;
-        this.handleEvents = handleEvents;
-    }
-    async ensureWatched(posixPath, lookupKey) {
-        if (isPathInside(lookupKey, this.rootDirLookupKey) || lookupKey === this.rootDirLookupKey) {
+    /** Active `@parcel/watcher` subscriptions keyed by subscribed directory lookup key. */
+    #extraSubscriptions = new Map();
+    /** Reference-counted watched files grouped by their target external directory lookup key. */
+    #externalDirFiles = new Map();
+    /** Reverse lookup mapping each watched file lookup key to its target directory lookup key. */
+    #fileToDirKey = new Map();
+    /** The `@parcel/watcher` module instance. */
+    #parcelWatcher;
+    /** Watcher configuration options including ignore patterns. */
+    #options;
+    /** Normalized POSIX path of the primary watched workspace root. */
+    #rootDirPosix;
+    /** Case-normalized lookup key of the primary watched workspace root. */
+    #rootDirLookupKey;
+    /** Whether the underlying filesystem is case-sensitive. */
+    #isCaseSensitive;
+    /** Callback invoked when `@parcel/watcher` emits filesystem events. */
+    #handleEvents;
+    /** Current maximum number of concurrent external directory subscriptions allowed before coalescing. */
+    #maxSubscriptions;
+    /** Whether external directory state has changed and requires a reconciliation pass. */
+    #needsReconcile = false;
+    /** Whether obsolete subscriptions should be unsubscribed before creating new ones (used after stream limit errors). */
+    #shrinkBeforeSubscribe = false;
+    /** In-flight promise for the currently scheduled or running reconciliation loop. */
+    #reconcilePromise;
+    /** Whether this manager has been closed. */
+    #isClosed = false;
+    /**
+     * Creates a new external directory subscription manager for `@parcel/watcher`.
+     *
+     * @param parcelWatcher The `@parcel/watcher` module.
+     * @param options Watcher configuration options.
+     * @param rootDirPosix Normalized POSIX path of the primary workspace root.
+     * @param rootDirLookupKey Case-normalized lookup key of the primary workspace root.
+     * @param isCaseSensitive Whether the filesystem at the workspace root is case-sensitive.
+     * @param handleEvents Callback to process incoming `@parcel/watcher` events.
+     * @param maxSubscriptions Maximum number of concurrent external directory subscriptions before coalescing.
+     */
+    constructor(parcelWatcher, options, rootDirPosix, rootDirLookupKey, isCaseSensitive, handleEvents, maxSubscriptions = DEFAULT_MAX_EXTERNAL_SUBSCRIPTIONS) {
+        this.#parcelWatcher = parcelWatcher;
+        this.#options = options;
+        this.#rootDirPosix = rootDirPosix;
+        this.#rootDirLookupKey = rootDirLookupKey;
+        this.#isCaseSensitive = isCaseSensitive;
+        this.#handleEvents = handleEvents;
+        this.#maxSubscriptions = Math.max(1, maxSubscriptions);
+    }
+    /**
+     * Registers a file path to be watched if it resides outside the primary workspace root,
+     * and schedules an asynchronous subscription reconciliation pass if needed.
+     *
+     * @param posixPath Normalized POSIX file path preserving original casing.
+     * @param lookupKey Case-normalized lookup key for the file path.
+     */
+    watchFile(posixPath, lookupKey) {
+        if (this.#isClosed ||
+            isPathInside(lookupKey, this.#rootDirLookupKey) ||
+            lookupKey === this.#rootDirLookupKey) {
             return;
         }
-        const dirPath = getDirectoryPath(posixPath);
-        const dirKey = getDirectoryPath(lookupKey);
-        let dirEntry = this.externalDirFiles.get(dirKey);
+        const pkgDir = extractNodeModulesPackageDir(posixPath);
+        const dirPath = pkgDir ?? getDirectoryPath(posixPath);
+        const dirKey = pkgDir
+            ? toLookupKey(pkgDir, this.#isCaseSensitive)
+            : getDirectoryPath(lookupKey);
+        this.#fileToDirKey.set(lookupKey, dirKey);
+        let dirEntry = this.#externalDirFiles.get(dirKey);
+        const isNewDir = !dirEntry;
         if (!dirEntry) {
             dirEntry = { dirPath, files: new Set() };
-            this.externalDirFiles.set(dirKey, dirEntry);
+            this.#externalDirFiles.set(dirKey, dirEntry);
         }
         dirEntry.files.add(lookupKey);
-        await this.ensureDirWatched(dirPath, dirKey);
+        if (isNewDir || !this.#isCoveredByActiveSubscription(dirKey)) {
+            this.#scheduleReconcile();
+        }
     }
+    /**
+     * Unregisters a previously watched external file and schedules a reconciliation pass
+     * if it was the last watched file in its target directory.
+     *
+     * @param lookupKey Case-normalized lookup key for the file path to remove.
+     */
     removeFile(lookupKey) {
-        if (isPathInside(lookupKey, this.rootDirLookupKey) || lookupKey === this.rootDirLookupKey) {
+        const dirKey = this.#fileToDirKey.get(lookupKey);
+        if (!dirKey) {
             return;
         }
-        const dirKey = getDirectoryPath(lookupKey);
-        const dirEntry = this.externalDirFiles.get(dirKey);
+        this.#fileToDirKey.delete(lookupKey);
+        const dirEntry = this.#externalDirFiles.get(dirKey);
         if (dirEntry) {
             dirEntry.files.delete(lookupKey);
             if (dirEntry.files.size === 0) {
-                this.externalDirFiles.delete(dirKey);
-                const sub = this.extraSubscriptions.get(dirKey);
-                if (sub) {
-                    this.extraSubscriptions.delete(dirKey);
-                    sub.unsubscribe().catch(() => { });
-                    for (const [remainingDirKey, remainingDirEntry] of this.externalDirFiles.entries()) {
-                        if (!this.isCoveredByExistingExternal(remainingDirKey)) {
-                            this.ensureDirWatched(remainingDirEntry.dirPath, remainingDirKey).catch(() => { });
-                        }
-                    }
-                }
+                this.#externalDirFiles.delete(dirKey);
+                this.#scheduleReconcile();
             }
         }
     }
+    /**
+     * Waits for any scheduled or in-progress subscription reconciliation pass to complete.
+     */
+    async flush() {
+        if (this.#reconcilePromise) {
+            await this.#reconcilePromise;
+        }
+    }
+    /**
+     * Closes the manager, awaiting any pending reconciliation and unsubscribing all active
+     * external directory subscriptions.
+     */
     async close() {
+        this.#isClosed = true;
+        this.#needsReconcile = false;
         try {
-            if (this.pendingSubscriptions.size > 0) {
-                await Promise.allSettled(Array.from(this.pendingSubscriptions.values()));
+            if (this.#reconcilePromise) {
+                await this.#reconcilePromise.catch(() => { });
             }
-            if (this.extraSubscriptions.size > 0) {
-                await Promise.allSettled(Array.from(this.extraSubscriptions.values()).map((sub) => sub.unsubscribe()));
+            if (this.#extraSubscriptions.size > 0) {
+                await Promise.allSettled(Array.from(this.#extraSubscriptions.values(), (sub) => sub.unsubscribe()));
             }
         }
         finally {
-            this.extraSubscriptions.clear();
-            this.pendingSubscriptions.clear();
-            this.externalDirFiles.clear();
+            this.#extraSubscriptions.clear();
+            this.#externalDirFiles.clear();
+            this.#fileToDirKey.clear();
         }
     }
-    isCoveredByExistingExternal(dirLookupKey) {
-        for (const existingDir of this.extraSubscriptions.keys()) {
-            if (dirLookupKey === existingDir || isPathInside(dirLookupKey, existingDir)) {
-                return true;
+    /**
+     * Schedules a microtask to reconcile active `@parcel/watcher` subscriptions with the
+     * current set of external directories.
+     */
+    #scheduleReconcile() {
+        if (this.#isClosed) {
+            return;
+        }
+        this.#needsReconcile = true;
+        this.#reconcilePromise ??= Promise.resolve()
+            .then(() => this.#runReconcileLoop())
+            .finally(() => {
+            this.#reconcilePromise = undefined;
+        });
+    }
+    /**
+     * Continuously executes reconciliation passes until no further changes are pending.
+     */
+    async #runReconcileLoop() {
+        while (this.#needsReconcile && !this.#isClosed) {
+            this.#needsReconcile = false;
+            await this.#reconcileOnce();
+        }
+    }
+    /**
+     * Performs a single reconciliation pass: computes the desired coalesced directory set,
+     * subscribes to newly required directories, unsubscribes obsolete directories, and
+     * triggers fallback coalescing if OS stream limits are encountered.
+     */
+    async #reconcileOnce() {
+        const desiredDirs = this.#computeDesiredDirectories();
+        if (this.#shrinkBeforeSubscribe) {
+            this.#shrinkBeforeSubscribe = false;
+            const toUnsubscribe = [];
+            for (const [existingKey, sub] of this.#extraSubscriptions.entries()) {
+                if (!desiredDirs.has(existingKey)) {
+                    this.#extraSubscriptions.delete(existingKey);
+                    toUnsubscribe.push(sub.unsubscribe().catch(() => { }));
+                }
+            }
+            if (toUnsubscribe.length > 0) {
+                await Promise.allSettled(toUnsubscribe);
+            }
+        }
+        if (this.#isClosed) {
+            return;
+        }
+        const toSubscribe = [];
+        for (const [dirKey, dirPath] of desiredDirs.entries()) {
+            if (!this.#extraSubscriptions.has(dirKey)) {
+                toSubscribe.push([dirKey, dirPath]);
             }
         }
-        for (const pendingDir of this.pendingSubscriptions.keys()) {
-            if (dirLookupKey === pendingDir || isPathInside(dirLookupKey, pendingDir)) {
+        let hadExistingDirFailure = false;
+        if (toSubscribe.length > 0) {
+            await Promise.allSettled(toSubscribe.map(async ([dirKey, dirPath]) => {
+                const ignore = isPathInside(this.#rootDirLookupKey, dirKey)
+                    ? [...(this.#options?.ignored ?? []), this.#rootDirPosix, `${this.#rootDirPosix}/**`]
+                    : this.#options?.ignored;
+                try {
+                    const sub = await this.#parcelWatcher.subscribe(dirPath, (err, events) => {
+                        if (!err) {
+                            this.#handleEvents(events);
+                        }
+                    }, { ignore });
+                    if (this.#isClosed) {
+                        await sub.unsubscribe().catch(() => { });
+                        return;
+                    }
+                    this.#extraSubscriptions.set(dirKey, sub);
+                }
+                catch {
+                    // Ignore errors for missing directories; if the directory exists on disk,
+                    // mark failure so the manager can coalesce further if over OS stream limits.
+                    if (!this.#isClosed && fs.existsSync(dirPath)) {
+                        hadExistingDirFailure = true;
+                    }
+                }
+            }));
+        }
+        if (this.#isClosed) {
+            return;
+        }
+        // Unsubscribe any previous subscriptions that are no longer desired and whose
+        // remaining watched files (if any) are now covered by another active subscription.
+        for (const [existingKey, sub] of this.#extraSubscriptions.entries()) {
+            if (!desiredDirs.has(existingKey) && this.#canRemoveSubscription(existingKey)) {
+                this.#extraSubscriptions.delete(existingKey);
+                sub.unsubscribe().catch(() => { });
+            }
+        }
+        // If subscribing to an existing directory failed (e.g. macOS FSEvents per-process limit),
+        // dynamically lower the subscription budget and re-reconcile to coalesce into ancestors.
+        if (hadExistingDirFailure && desiredDirs.size > 1 && this.#maxSubscriptions > 1) {
+            const nextMax = this.#extraSubscriptions.size > 0
+                ? Math.max(1, Math.floor(this.#extraSubscriptions.size / 2))
+                : Math.max(1, Math.floor(Math.min(this.#maxSubscriptions, desiredDirs.size) / 2));
+            if (nextMax < desiredDirs.size && nextMax < this.#maxSubscriptions) {
+                this.#maxSubscriptions = nextMax;
+                this.#shrinkBeforeSubscribe = true;
+                this.#needsReconcile = true;
+            }
+        }
+    }
+    /**
+     * Checks whether a directory lookup key is already covered by an active subscription.
+     */
+    #isCoveredByActiveSubscription(dirLookupKey) {
+        for (const existingDir of this.#extraSubscriptions.keys()) {
+            if (dirLookupKey === existingDir || isPathInside(dirLookupKey, existingDir)) {
                 return true;
             }
         }
         return false;
     }
-    async ensureDirWatched(dirPath, dirKey) {
-        if (this.isCoveredByExistingExternal(dirKey)) {
-            return;
+    /**
+     * Determines whether an existing subscription can be safely removed without leaving
+     * any remaining watched target directories uncovered.
+     */
+    #canRemoveSubscription(subKey) {
+        for (const targetDirKey of this.#externalDirFiles.keys()) {
+            if (targetDirKey === subKey || isPathInside(targetDirKey, subKey)) {
+                let coveredByOther = false;
+                for (const otherSubKey of this.#extraSubscriptions.keys()) {
+                    if (otherSubKey !== subKey &&
+                        (targetDirKey === otherSubKey || isPathInside(targetDirKey, otherSubKey))) {
+                        coveredByOther = true;
+                        break;
+                    }
+                }
+                if (!coveredByOther) {
+                    return false;
+                }
+            }
         }
-        const subPromise = this.parcelWatcher.subscribe(dirPath, (err, events) => {
-            if (!err) {
-                this.handleEvents(events);
+        return true;
+    }
+    /**
+     * Computes the minimal set of external directories to subscribe to (mapped from `dirKey` to `dirPath`),
+     * subsuming nested directories and coalescing branching ancestors to stay within `#maxSubscriptions`.
+     */
+    #computeDesiredDirectories() {
+        if (this.#externalDirFiles.size === 0) {
+            return new Map();
+        }
+        const nodesByKey = new Map();
+        const roots = [];
+        for (const [dirKey, { dirPath }] of this.#externalDirFiles.entries()) {
+            const chain = [];
+            let currentKey = dirKey;
+            let currentPath = dirPath;
+            while (true) {
+                chain.push({ dirKey: currentKey, dirPath: currentPath });
+                const parentKey = getDirectoryPath(currentKey);
+                if (parentKey === currentKey) {
+                    break;
+                }
+                currentKey = parentKey;
+                currentPath = getDirectoryPath(currentPath);
             }
-        }, {
-            ignore: this.options?.ignored,
-        });
-        this.pendingSubscriptions.set(dirKey, subPromise);
-        try {
-            const sub = await subPromise;
-            this.pendingSubscriptions.delete(dirKey);
-            if (this.externalDirFiles.has(dirKey) && !this.isCoveredByExistingExternal(dirKey)) {
-                this.extraSubscriptions.set(dirKey, sub);
-                // Subsume any nested child subscriptions that are now covered by this parent subscription
-                for (const [childDir, childSub] of this.extraSubscriptions.entries()) {
-                    if (childDir !== dirKey && isPathInside(childDir, dirKey)) {
-                        this.extraSubscriptions.delete(childDir);
-                        childSub.unsubscribe().catch(() => { });
+            let parentNode;
+            for (let i = chain.length - 1; i >= 0; i--) {
+                const { dirKey: nodeKey, dirPath: nodePath } = chain[i];
+                const depth = chain.length - 1 - i;
+                let node = nodesByKey.get(nodeKey);
+                if (!node) {
+                    node = {
+                        dirKey: nodeKey,
+                        dirPath: nodePath,
+                        depth,
+                        parent: parentNode,
+                        children: new Map(),
+                        isTarget: false,
+                        leafCount: 0,
+                    };
+                    nodesByKey.set(nodeKey, node);
+                    if (parentNode) {
+                        parentNode.children.set(nodeKey, node);
+                    }
+                    else {
+                        roots.push(node);
                     }
                 }
+                parentNode = node;
             }
-            else {
-                sub.unsubscribe().catch(() => { });
+            if (parentNode) {
+                parentNode.isTarget = true;
             }
         }
-        catch {
-            // Ignore subscription errors for missing or restricted external directories
+        const initSubtree = (node) => {
+            if (node.isTarget) {
+                node.children.clear();
+                node.leafCount = 1;
+                return 1;
+            }
+            let count = 0;
+            for (const child of node.children.values()) {
+                count += initSubtree(child);
+            }
+            node.leafCount = count;
+            return count;
+        };
+        let totalLeaves = 0;
+        for (const root of roots) {
+            totalLeaves += initSubtree(root);
         }
-        finally {
-            this.pendingSubscriptions.delete(dirKey);
+        if (totalLeaves > this.#maxSubscriptions) {
+            // Tier 1: non-ancestors of workspaceRoot (e.g., <monorepo>/libs, <monorepo>/node_modules)
+            // Tier 2: ancestors of workspaceRoot (e.g., <monorepo> when sibling apps/libs are directly under it)
+            const tier1ByDepth = new Map();
+            const tier2ByDepth = new Map();
+            const collectInternalNodes = (node) => {
+                if (node.isTarget) {
+                    return;
+                }
+                if (node.parent !== undefined && node.leafCount > 1) {
+                    const isWorkspaceAncestor = isPathInside(this.#rootDirLookupKey, node.dirKey);
+                    const bucketMap = isWorkspaceAncestor ? tier2ByDepth : tier1ByDepth;
+                    let bucket = bucketMap.get(node.depth);
+                    if (!bucket) {
+                        bucket = [];
+                        bucketMap.set(node.depth, bucket);
+                    }
+                    bucket.push(node);
+                }
+                for (const child of node.children.values()) {
+                    collectInternalNodes(child);
+                }
+            };
+            for (const root of roots) {
+                collectInternalNodes(root);
+            }
+            const collapseTier = (byDepth) => {
+                const sortedLevels = Array.from(byDepth.entries()).sort(([a], [b]) => b - a);
+                for (const [, nodes] of sortedLevels) {
+                    if (totalLeaves <= this.#maxSubscriptions) {
+                        return;
+                    }
+                    const candidates = nodes
+                        .filter((n) => n.leafCount > 1 && !hasTargetAncestor(n))
+                        .sort((a, b) => b.leafCount - a.leafCount || a.dirKey.localeCompare(b.dirKey));
+                    for (const candidate of candidates) {
+                        if (totalLeaves <= this.#maxSubscriptions) {
+                            return;
+                        }
+                        if (candidate.leafCount <= 1 || hasTargetAncestor(candidate)) {
+                            continue;
+                        }
+                        const reduction = candidate.leafCount - 1;
+                        candidate.isTarget = true;
+                        candidate.children.clear();
+                        candidate.leafCount = 1;
+                        totalLeaves -= reduction;
+                        let ancestor = candidate.parent;
+                        while (ancestor) {
+                            ancestor.leafCount -= reduction;
+                            ancestor = ancestor.parent;
+                        }
+                    }
+                }
+            };
+            collapseTier(tier1ByDepth);
+            if (totalLeaves > this.#maxSubscriptions) {
+                collapseTier(tier2ByDepth);
+            }
+        }
+        const desired = new Map();
+        const collectTargets = (node) => {
+            if (node.isTarget) {
+                desired.set(node.dirKey, node.dirPath);
+                return;
+            }
+            for (const child of node.children.values()) {
+                collectTargets(child);
+            }
+        };
+        for (const root of roots) {
+            collectTargets(root);
         }
+        return desired;
     }
 }
+exports.ParcelExternalManager = ParcelExternalManager;
 async function createParcelWatcher(options, parcelWatcher) {
     const watchedFiles = new Set();
     const queue = new WatcherQueue();
@@ -516,7 +843,7 @@ async function createParcelWatcher(options, parcelWatcher) {
     }, {
         ignore: options?.ignored,
     });
-    const externalManager = new ParcelExternalManager(parcelWatcher, options, rootDirLookupKey, handleEvents);
+    const externalManager = new ParcelExternalManager(parcelWatcher, options, rootDirPosix, rootDirLookupKey, isCaseSensitive, handleEvents);
     const buildWatcher = {
         [Symbol.asyncIterator]() {
             return this;
@@ -531,7 +858,7 @@ async function createParcelWatcher(options, parcelWatcher) {
                 const lookupKey = toLookupKey(posixPath, isCaseSensitive);
                 if (!watchedFiles.has(lookupKey)) {
                     watchedFiles.add(lookupKey);
-                    void externalManager.ensureWatched(posixPath, lookupKey);
+                    externalManager.watchFile(posixPath, lookupKey);
                 }
             }
         },
@@ -559,119 +886,91 @@ async function createParcelWatcher(options, parcelWatcher) {
     };
     return buildWatcher;
 }
-/**
- * Manages selective node_modules watching for Chokidar.
- *
- * During Chokidar's initial scan, the allowed packages set is empty, causing Chokidar to prune the entire
- * node_modules directory immediately and avoid blocking the 'ready' event for minutes.
- * Packages are dynamically allowed and watched at the package root level as files are added via `watcher.add`.
- * Tracking files per package allows reference-counting so that package directories are unwatched when no
- * longer needed.
- */
-class ChokidarNodeModulesManager {
-    isCaseSensitive;
-    allowedPackages = new Map();
-    constructor(isCaseSensitive) {
-        this.isCaseSensitive = isCaseSensitive;
-    }
-    registerPackage(posixPath, lookupKey) {
-        const packageDir = extractNodeModulesPackageDir(posixPath);
-        if (!packageDir) {
-            return { isPackage: false };
-        }
-        const packageKey = toLookupKey(packageDir, this.isCaseSensitive);
-        let watchedInPkg = this.allowedPackages.get(packageKey);
-        if (!watchedInPkg) {
-            watchedInPkg = new Set();
-            this.allowedPackages.set(packageKey, watchedInPkg);
-            watchedInPkg.add(lookupKey);
-            return { isPackage: true, newPkgDir: packageDir };
-        }
-        watchedInPkg.add(lookupKey);
-        return { isPackage: true };
-    }
-    removePackageFile(posixPath, lookupKey) {
-        const packageDir = extractNodeModulesPackageDir(posixPath);
-        if (!packageDir) {
-            return { isPackage: false };
-        }
-        const packageKey = toLookupKey(packageDir, this.isCaseSensitive);
-        const watchedInPkg = this.allowedPackages.get(packageKey);
-        if (watchedInPkg) {
-            watchedInPkg.delete(lookupKey);
-            if (watchedInPkg.size === 0) {
-                this.allowedPackages.delete(packageKey);
-                return { isPackage: true, unwatchPkgDir: packageDir };
-            }
-        }
-        return { isPackage: true };
-    }
-    isIgnored(filePath) {
-        // Fast path: avoid expensive normalization for non-node_modules files
-        if (!filePath.includes(NODE_MODULES)) {
-            return false;
-        }
-        const posixPath = toPosixPathNormalized(filePath);
-        const lookupKey = toLookupKey(posixPath, this.isCaseSensitive);
-        if (!`${lookupKey}/`.includes(NODE_MODULES_SEGMENT)) {
-            return false;
-        }
-        if (this.allowedPackages.has(lookupKey)) {
-            return false;
-        }
-        for (const pkg of this.allowedPackages.keys()) {
-            if (isPathInside(lookupKey, pkg)) {
+function createChokidarIgnored(ignoredPatterns, isCaseSensitive, watchedFiles) {
+    // Strip static node_modules ignore patterns (e.g. `**/node_modules/**` from setupWatcher).
+    // If left in place, picomatch would unconditionally ignore all node_modules files and prevent
+    // watching explicitly added files inside node_modules.
+    const customIgnored = ignoredPatterns
+        ?.filter((pattern) => {
+        const base = toPosixPathNormalized(pattern).replace(/\/\*\*$/, '');
+        return base !== NODE_MODULES && !base.endsWith(`/${NODE_MODULES}`);
+    })
+        .map((pattern) => {
+        if (/[*?[\]{}()]/.test(pattern)) {
+            const isMatch = (0, picomatch_1.default)(pattern, { dot: true });
+            return (filePath) => isMatch(toPosixPathNormalized(filePath));
+        }
+        return { path: toPosixPathNormalized(pattern), recursive: true };
+    }) ?? [];
+    // When watching a directory (e.g. projectRoot via NG_BUILD_WATCH_ROOT), prune `node_modules`
+    // directories unless explicitly added to `watchedFiles`. Explicitly added files inside
+    // `node_modules` do not end with `/node_modules` and remain watchable.
+    return [
+        ...customIgnored,
+        (filePath) => {
+            if (!filePath.includes(NODE_MODULES)) {
                 return false;
             }
+            const posixPath = toPosixPathNormalized(filePath);
+            const lookupKey = toLookupKey(posixPath, isCaseSensitive);
+            return ((lookupKey === NODE_MODULES || lookupKey.endsWith(`/${NODE_MODULES}`)) &&
+                !watchedFiles.has(lookupKey));
+        },
+    ];
+}
+// Chokidar initializes file watchers asynchronously (`await stat(path)` followed by
+// `fs.watch` or `fs.watchFile`). If a file is modified or recreated immediately after
+// `watcher.add()` is called, Chokidar may capture the post-modification state as its initial
+// baseline (or suppress the initial `'add'` event due to `ignoreInitial: true`) and miss the
+// change. Re-statting after a short delay catches any modifications or recreations that occurred
+// during asynchronous watcher registration, while `fileStats` deduplicates if Chokidar also fired.
+async function checkChokidarBaselines(baselineStats, watchedFiles, fileStats, watcher, handleEvent) {
+    await Promise.all(Array.from(baselineStats, async ([lookupKey, baseline]) => {
+        if (!watchedFiles.has(lookupKey)) {
+            return;
         }
-        return true;
-    }
+        const currentStat = await fs.promises.stat(baseline.posixPath).catch(() => null);
+        if (!watchedFiles.has(lookupKey) || !currentStat?.isFile()) {
+            return;
+        }
+        if (baseline.mtimeMs === undefined || baseline.size === undefined) {
+            const recorded = fileStats.get(lookupKey);
+            if (!recorded) {
+                watcher.add(baseline.posixPath);
+                handleEvent('added', path.normalize(baseline.posixPath));
+            }
+            else if (currentStat.mtimeMs !== recorded.mtimeMs || currentStat.size !== recorded.size) {
+                handleEvent('modified', path.normalize(baseline.posixPath));
+            }
+        }
+        else if (currentStat.mtimeMs !== baseline.mtimeMs || currentStat.size !== baseline.size) {
+            handleEvent('modified', path.normalize(baseline.posixPath));
+        }
+    }));
 }
 async function createChokidarWatcher(options, chokidarModule) {
     const chokidar = chokidarModule ?? (await Promise.resolve().then(() => __importStar(require('chokidar'))));
     const watchedFiles = new Set();
     const fileStats = new Map();
-    let queue;
-    if (options?.polling) {
-        const pollingInterval = options.interval ?? 100;
-        const debounceMs = Math.min(250, Math.max(100, Math.ceil(pollingInterval * 1.5)));
-        const maxWaitMs = Math.max(500, debounceMs * 3);
-        queue = new WatcherQueue(debounceMs, maxWaitMs);
-    }
-    else {
-        queue = new WatcherQueue();
-    }
+    const pendingTimers = new Set();
+    const pollingInterval = options?.interval ?? 100;
+    const debounceMs = Math.min(250, Math.max(100, Math.ceil(pollingInterval * 1.5)));
+    const queue = options?.polling
+        ? new WatcherQueue(debounceMs, Math.max(500, debounceMs * 3))
+        : new WatcherQueue();
     const rootDir = options?.cwd ?? process.cwd();
     const isCaseSensitive = isFileSystemCaseSensitive(rootDir);
-    const rootDirPosix = toPosixPathNormalized(rootDir);
-    const rootDirLookupKey = toLookupKey(rootDirPosix, isCaseSensitive);
-    const nodeModulesManager = new ChokidarNodeModulesManager(isCaseSensitive);
-    // Strip static node_modules ignore patterns (e.g. `**/node_modules/**` from setupWatcher).
-    // If left in place, picomatch would unconditionally ignore all node_modules files and override
-    // our dynamic package allowlist above.
-    const customIgnored = options?.ignored
-        ?.filter((pattern) => !pattern.includes(NODE_MODULES))
-        .map((pattern) => {
-        if (/[*?[\]{}()]/.test(pattern)) {
-            const isMatch = (0, picomatch_1.default)(pattern, { dot: true });
-            return (filePath) => isMatch(toPosixPathNormalized(filePath));
-        }
-        return { path: toPosixPathNormalized(pattern), recursive: true };
-    }) ?? [];
-    const ignored = [...customIgnored, (filePath) => nodeModulesManager.isIgnored(filePath)];
-    const watcher = chokidar.watch(rootDir, {
+    const ignored = createChokidarIgnored(options?.ignored, isCaseSensitive, watchedFiles);
+    const watcher = chokidar.watch([], {
         ignoreInitial: true,
         ignored,
         followSymlinks: options?.followSymlinks,
         usePolling: !!options?.polling,
         interval: options?.interval,
     });
+    // Prevent unhandled watcher errors (such as EMFILE or EACCES) from crashing the process.
+    watcher.on('error', () => { });
     const initTime = Date.now();
-    // Wait for the watcher to complete its initial filesystem scan before returning.
-    // With `ignoreInitial: true`, any file visited during the initial scan is treated as the initial baseline
-    // and will not emit 'add' or 'change' events. Awaiting 'ready' ensures that rapid file modifications
-    // made right after watcher setup (e.g. in rebuild tests) are not swallowed as initial files.
-    await (0, node_events_1.once)(watcher, 'ready');
     const handleEvent = (type, rawPath) => {
         const posixPath = toPosixPathNormalized(rawPath);
         const lookupKey = toLookupKey(posixPath, isCaseSensitive);
@@ -684,13 +983,10 @@ async function createChokidarWatcher(options, chokidarModule) {
             return;
         }
         const stat = fs.statSync(rawPath, { throwIfNoEntry: false });
-        if (!stat) {
-            return;
-        }
         // Ignore historical events from before watcher initialization, but allow a 1000 ms window
         // to account for coarse filesystem timestamp resolution (e.g., ext4/overlayfs integer second
         // mtime truncation on Linux) where files modified during startup may have truncated .000 ms mtimes.
-        if (stat.mtimeMs < initTime - 1000) {
+        if (!stat || stat.mtimeMs < initTime - 1000) {
             return;
         }
         const previousStat = fileStats.get(lookupKey);
@@ -703,10 +999,45 @@ async function createChokidarWatcher(options, chokidarModule) {
         fileStats.set(lookupKey, { mtimeMs: stat.mtimeMs, size: stat.size });
         queue.addChange(type, rawPath);
     };
+    const scheduleBaselineCheck = (baselineStats) => {
+        if (baselineStats.size === 0) {
+            return;
+        }
+        const timer = setTimeout(() => {
+            pendingTimers.delete(timer);
+            void checkChokidarBaselines(baselineStats, watchedFiles, fileStats, watcher, handleEvent);
+        }, 50);
+        timer.unref();
+        pendingTimers.add(timer);
+    };
     watcher.on('add', (path) => handleEvent('added', path));
     watcher.on('change', (path) => handleEvent('modified', path));
-    watcher.on('unlink', (path) => handleEvent('removed', path));
-    const buildWatcher = {
+    watcher.on('unlink', (rawPath) => {
+        const posixPath = toPosixPathNormalized(rawPath);
+        const lookupKey = toLookupKey(posixPath, isCaseSensitive);
+        if (!isPathWatched(lookupKey, watchedFiles)) {
+            return;
+        }
+        // When Chokidar processes a file removal, it closes the underlying file watcher unless only a
+        // single directory is tracked (`_watched.size === 1`). Re-adding a directly watched path
+        // ensures Chokidar continues watching either the recreated file (if replaced within the atomic
+        // window) or its parent directory for future recreation.
+        if (watchedFiles.has(lookupKey)) {
+            fileStats.delete(lookupKey);
+            watcher.add(posixPath);
+            const stat = fs.statSync(rawPath, { throwIfNoEntry: false });
+            if (stat?.isFile()) {
+                handleEvent('modified', rawPath);
+                scheduleBaselineCheck(new Map([[lookupKey, { posixPath, mtimeMs: stat.mtimeMs, size: stat.size }]]));
+                return;
+            }
+            handleEvent('removed', rawPath);
+            scheduleBaselineCheck(new Map([[lookupKey, { posixPath }]]));
+            return;
+        }
+        handleEvent('removed', rawPath);
+    });
+    return {
         [Symbol.asyncIterator]() {
             return this;
         },
@@ -728,26 +1059,22 @@ async function createChokidarWatcher(options, chokidarModule) {
         add(paths) {
             const targets = typeof paths === 'string' ? [paths] : paths;
             const newPaths = [];
+            const baselineStats = new Map();
             for (const p of targets) {
                 const posixPath = toPosixPathNormalized(p);
                 const lookupKey = toLookupKey(posixPath, isCaseSensitive);
                 if (!watchedFiles.has(lookupKey)) {
                     watchedFiles.add(lookupKey);
-                    // For files inside node_modules, register their package directory. Only newly encountered
-                    // package directories need to be added to Chokidar.
-                    const { isPackage, newPkgDir } = nodeModulesManager.registerPackage(posixPath, lookupKey);
-                    if (newPkgDir) {
-                        newPaths.push(newPkgDir);
-                    }
-                    else if (!isPackage &&
-                        !isPathInside(lookupKey, rootDirLookupKey) &&
-                        lookupKey !== rootDirLookupKey) {
-                        newPaths.push(posixPath);
+                    newPaths.push(posixPath);
+                    const stat = fs.statSync(posixPath, { throwIfNoEntry: false });
+                    if (stat?.isFile()) {
+                        baselineStats.set(lookupKey, { posixPath, mtimeMs: stat.mtimeMs, size: stat.size });
                     }
                 }
             }
             if (newPaths.length > 0) {
                 watcher.add(newPaths);
+                scheduleBaselineCheck(baselineStats);
             }
         },
         remove(paths) {
@@ -759,16 +1086,7 @@ async function createChokidarWatcher(options, chokidarModule) {
                 if (watchedFiles.has(lookupKey)) {
                     watchedFiles.delete(lookupKey);
                     fileStats.delete(lookupKey);
-                    // When the last watched file in a package is removed, unwatch the package directory.
-                    const { isPackage, unwatchPkgDir } = nodeModulesManager.removePackageFile(posixPath, lookupKey);
-                    if (unwatchPkgDir) {
-                        removePaths.push(unwatchPkgDir);
-                    }
-                    else if (!isPackage &&
-                        !isPathInside(lookupKey, rootDirLookupKey) &&
-                        lookupKey !== rootDirLookupKey) {
-                        removePaths.push(posixPath);
-                    }
+                    removePaths.push(posixPath);
                 }
             }
             if (removePaths.length > 0) {
@@ -776,6 +1094,10 @@ async function createChokidarWatcher(options, chokidarModule) {
             }
         },
         async close() {
+            for (const timer of pendingTimers) {
+                clearTimeout(timer);
+            }
+            pendingTimers.clear();
             try {
                 await watcher.close();
             }
@@ -784,6 +1106,5 @@ async function createChokidarWatcher(options, chokidarModule) {
             }
         },
     };
-    return buildWatcher;
 }
 //# sourceMappingURL=watcher.js.map