webpack 5.108.4 → 5.109.1

package/lib/FileSystemInfo.js

@@ -297,6 +297,22 @@ class SnapshotIterable {
 /** @typedef {Set<string>} ManagedMissing */
 /** @typedef {Set<Snapshot>} Children */
 
+// `Snapshot._flags` bit for each optional field. Serialized as a whole integer,
+// so these values are a persisted-cache format contract — never renumber them.
+const SNAPSHOT_FLAG_START_TIME = 1;
+const SNAPSHOT_FLAG_FILE_TIMESTAMPS = 2;
+const SNAPSHOT_FLAG_FILE_HASHES = 4;
+const SNAPSHOT_FLAG_FILE_TSHS = 8;
+const SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS = 0x10;
+const SNAPSHOT_FLAG_CONTEXT_HASHES = 0x20;
+const SNAPSHOT_FLAG_CONTEXT_TSHS = 0x40;
+const SNAPSHOT_FLAG_MISSING_EXISTENCE = 0x80;
+const SNAPSHOT_FLAG_MANAGED_ITEM_INFO = 0x100;
+const SNAPSHOT_FLAG_MANAGED_FILES = 0x200;
+const SNAPSHOT_FLAG_MANAGED_CONTEXTS = 0x400;
+const SNAPSHOT_FLAG_MANAGED_MISSING = 0x800;
+const SNAPSHOT_FLAG_CHILDREN = 0x1000;
+
 class Snapshot {
 	constructor() {
 		/** @type {number} */
@@ -336,7 +352,7 @@ class Snapshot {
 	}
 
 	hasStartTime() {
-		return (this._flags & 1) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_START_TIME) !== 0;
 	}
 
 	/**
@@ -344,7 +360,7 @@ class Snapshot {
 	 * @param {number} value start value
 	 */
 	setStartTime(value) {
-		this._flags |= 1;
+		this._flags |= SNAPSHOT_FLAG_START_TIME;
 		this.startTime = value;
 	}
 
@@ -375,7 +391,7 @@ class Snapshot {
 	}
 
 	hasFileTimestamps() {
-		return (this._flags & 2) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_TIMESTAMPS) !== 0;
 	}
 
 	/**
@@ -383,12 +399,12 @@ class Snapshot {
 	 * @param {FileTimestamps} value file timestamps
 	 */
 	setFileTimestamps(value) {
-		this._flags |= 2;
+		this._flags |= SNAPSHOT_FLAG_FILE_TIMESTAMPS;
 		this.fileTimestamps = value;
 	}
 
 	hasFileHashes() {
-		return (this._flags & 4) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_HASHES) !== 0;
 	}
 
 	/**
@@ -396,12 +412,12 @@ class Snapshot {
 	 * @param {FileHashes} value file hashes
 	 */
 	setFileHashes(value) {
-		this._flags |= 4;
+		this._flags |= SNAPSHOT_FLAG_FILE_HASHES;
 		this.fileHashes = value;
 	}
 
 	hasFileTshs() {
-		return (this._flags & 8) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_FILE_TSHS) !== 0;
 	}
 
 	/**
@@ -409,12 +425,12 @@ class Snapshot {
 	 * @param {FileTshs} value file tshs
 	 */
 	setFileTshs(value) {
-		this._flags |= 8;
+		this._flags |= SNAPSHOT_FLAG_FILE_TSHS;
 		this.fileTshs = value;
 	}
 
 	hasContextTimestamps() {
-		return (this._flags & 0x10) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS) !== 0;
 	}
 
 	/**
@@ -422,12 +438,12 @@ class Snapshot {
 	 * @param {ContextTimestamps} value context timestamps
 	 */
 	setContextTimestamps(value) {
-		this._flags |= 0x10;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_TIMESTAMPS;
 		this.contextTimestamps = value;
 	}
 
 	hasContextHashes() {
-		return (this._flags & 0x20) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_HASHES) !== 0;
 	}
 
 	/**
@@ -435,12 +451,12 @@ class Snapshot {
 	 * @param {ContextHashes} value context hashes
 	 */
 	setContextHashes(value) {
-		this._flags |= 0x20;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_HASHES;
 		this.contextHashes = value;
 	}
 
 	hasContextTshs() {
-		return (this._flags & 0x40) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CONTEXT_TSHS) !== 0;
 	}
 
 	/**
@@ -448,12 +464,12 @@ class Snapshot {
 	 * @param {ContextTshs} value context tshs
 	 */
 	setContextTshs(value) {
-		this._flags |= 0x40;
+		this._flags |= SNAPSHOT_FLAG_CONTEXT_TSHS;
 		this.contextTshs = value;
 	}
 
 	hasMissingExistence() {
-		return (this._flags & 0x80) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MISSING_EXISTENCE) !== 0;
 	}
 
 	/**
@@ -461,12 +477,12 @@ class Snapshot {
 	 * @param {MissingExistence} value context tshs
 	 */
 	setMissingExistence(value) {
-		this._flags |= 0x80;
+		this._flags |= SNAPSHOT_FLAG_MISSING_EXISTENCE;
 		this.missingExistence = value;
 	}
 
 	hasManagedItemInfo() {
-		return (this._flags & 0x100) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_ITEM_INFO) !== 0;
 	}
 
 	/**
@@ -474,12 +490,12 @@ class Snapshot {
 	 * @param {ManagedItemInfo} value managed item info
 	 */
 	setManagedItemInfo(value) {
-		this._flags |= 0x100;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_ITEM_INFO;
 		this.managedItemInfo = value;
 	}
 
 	hasManagedFiles() {
-		return (this._flags & 0x200) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_FILES) !== 0;
 	}
 
 	/**
@@ -487,12 +503,12 @@ class Snapshot {
 	 * @param {ManagedFiles} value managed files
 	 */
 	setManagedFiles(value) {
-		this._flags |= 0x200;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_FILES;
 		this.managedFiles = value;
 	}
 
 	hasManagedContexts() {
-		return (this._flags & 0x400) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_CONTEXTS) !== 0;
 	}
 
 	/**
@@ -500,12 +516,12 @@ class Snapshot {
 	 * @param {ManagedContexts} value managed contexts
 	 */
 	setManagedContexts(value) {
-		this._flags |= 0x400;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_CONTEXTS;
 		this.managedContexts = value;
 	}
 
 	hasManagedMissing() {
-		return (this._flags & 0x800) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_MANAGED_MISSING) !== 0;
 	}
 
 	/**
@@ -513,12 +529,12 @@ class Snapshot {
 	 * @param {ManagedMissing} value managed missing
 	 */
 	setManagedMissing(value) {
-		this._flags |= 0x800;
+		this._flags |= SNAPSHOT_FLAG_MANAGED_MISSING;
 		this.managedMissing = value;
 	}
 
 	hasChildren() {
-		return (this._flags & 0x1000) !== 0;
+		return (this._flags & SNAPSHOT_FLAG_CHILDREN) !== 0;
 	}
 
 	/**
@@ -526,7 +542,7 @@ class Snapshot {
 	 * @param {Children} value children
 	 */
 	setChildren(value) {
-		this._flags |= 0x1000;
+		this._flags |= SNAPSHOT_FLAG_CHILDREN;
 		this.children = value;
 	}
 
@@ -1221,6 +1237,58 @@ const addAll = (source, target) => {
 
 const getEsModuleLexer = memoize(() => require("es-module-lexer"));
 
+const getAcorn = memoize(/* istanbul ignore next */ () => require("acorn"));
+
+// Bun doesn't populate `require.cache` `module.children`, so the CJS build-dependency
+// walk needs a source-parsing fallback there. Node/Deno populate it — never pay for it.
+const IS_BUN = Boolean(process.versions.bun);
+
+/**
+ * Collects static `require("literal")` specifiers from CommonJS source. Used as a
+ * fallback where `require.cache` children aren't populated (e.g. Bun), so build
+ * dependencies of a CJS file are still tracked. Dynamic requires can't be seen here.
+ * @param {string} source source
+ * @returns {Set<string>} required specifiers
+ */
+// Bun-only: exercised by BuildDependencies.longtest under the Bun CI job (no coverage upload).
+/* istanbul ignore next */
+const parseCjsRequires = (source) => {
+	/** @type {Set<string>} */
+	const requires = new Set();
+	const ast = getAcorn().parse(source, {
+		ecmaVersion: "latest",
+		sourceType: "script",
+		allowReturnOutsideFunction: true
+	});
+	/** @type {EXPECTED_ANY[]} */
+	const stack = [ast];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node || typeof node.type !== "string") continue;
+		if (
+			node.type === "CallExpression" &&
+			node.callee.type === "Identifier" &&
+			node.callee.name === "require" &&
+			node.arguments.length === 1 &&
+			node.arguments[0].type === "Literal" &&
+			typeof node.arguments[0].value === "string"
+		) {
+			requires.add(node.arguments[0].value);
+		}
+		for (const key of Object.keys(node)) {
+			const value = node[key];
+			if (Array.isArray(value)) {
+				for (const item of value) {
+					if (item && typeof item.type === "string") stack.push(item);
+				}
+			} else if (value && typeof value.type === "string") {
+				stack.push(value);
+			}
+		}
+	}
+	return requires;
+};
+
 /** @typedef {Set<string>} LoggedPaths */
 
 /** @typedef {FileSystemInfoEntry | ExistenceOnlyTimeEntry | "ignore" | null} FileTimestamp */
@@ -1243,6 +1311,17 @@ const isExistenceOnly = (entry) => {
 	);
 };
 
+/**
+ * Watchpack directory entries may carry `safeTime` / `timestamp` but never
+ * `timestampHash`; such object caches cannot back snapshot checks or symlink walks.
+ * @param {ContextFileSystemInfoEntry | null | "ignore" | undefined} entry cache entry
+ * @returns {boolean} true when a non-null object entry lacks `timestampHash`
+ */
+const contextCacheEntryLacksTimestampHash = (entry) =>
+	entry !== null &&
+	typeof entry === "object" &&
+	/** @type {ContextFileSystemInfoEntry} */ (entry).timestampHash === undefined;
+
 /** @typedef {(err?: WebpackError | null, result?: boolean) => void} CheckSnapshotValidCallback */
 
 /**
@@ -1367,6 +1446,9 @@ class FileSystemInfo {
 		this._contextTshs = new Map();
 		/** @type {Map<string, string>} */
 		this._managedItems = new Map();
+		// memoized checkManaged results: 0 = not managed, 1 = immutable, string = managed item
+		/** @type {Map<string, 0 | 1 | string>} */
+		this._pathClassificationCache = new Map();
 		/** @type {AsyncQueue<string, string, FileSystemInfoEntry>} */
 		this.fileTimestampQueue = new AsyncQueue({
 			name: "file timestamp",
@@ -1596,7 +1678,7 @@ class FileSystemInfo {
 		this._contextHashes.clear();
 		this._contextTshs.clear();
 		this._managedItems.clear();
-		this._managedItems.clear();
+		this._pathClassificationCache.clear();
 
 		this._cachedDeprecatedFileTimestamps = undefined;
 		this._cachedDeprecatedContextTimestamps = undefined;
@@ -1705,7 +1787,13 @@ class FileSystemInfo {
 	 */
 	_getUnresolvedContextTimestamp(path, callback) {
 		const cache = this._contextTimestamps.get(path);
-		if (cache !== undefined && !isExistenceOnly(cache)) {
+		if (
+			cache !== undefined &&
+			!isExistenceOnly(cache) &&
+			!contextCacheEntryLacksTimestampHash(
+				/** @type {ContextFileSystemInfoEntry | null | "ignore"} */ (cache)
+			)
+		) {
 			return callback(
 				null,
 				/** @type {ContextFileSystemInfoEntry | "ignore" | null} */ (cache)
@@ -2193,6 +2281,38 @@ class FileSystemInfo {
 									});
 								}
 							}
+							// On Bun the children array is empty (unpopulated), so recover the
+							// static require() specifiers by parsing the source; Node/Deno don't.
+							/* istanbul ignore next */
+							if (IS_BUN && module.children.length === 0) {
+								this.fs.readFile(path, (err, content) => {
+									if (err) return callback(err);
+									try {
+										const context = dirname(this.fs, path);
+										const source = /** @type {Buffer} */ (content).toString();
+										/** @type {Set<string>} */
+										const added = new Set();
+										for (const dependency of parseCjsRequires(source)) {
+											if (dependency.startsWith("node:")) continue;
+											if (builtinModules.has(dependency)) continue;
+											if (added.has(dependency)) continue;
+											push({
+												type: RBDT_RESOLVE_CJS_FILE,
+												context,
+												path: dependency,
+												// Best effort: tolerate specifiers that don't resolve.
+												expected: false,
+												issuer: job
+											});
+											added.add(dependency);
+										}
+									} catch (_err) {
+										// Source we can't parse as CommonJS — ignore its dependencies.
+									}
+									process.nextTick(callback);
+								});
+								break;
+							}
 						} else if (supportsEsm && /\.m?js$/.test(path)) {
 							if (!this._warnAboutExperimentalEsmTracking) {
 								logger.log(
@@ -2460,30 +2580,29 @@ class FileSystemInfo {
 	 * @returns {void}
 	 */
 	createSnapshot(startTime, files, directories, missing, options, callback) {
-		/** @type {FileTimestamps} */
-		const fileTimestamps = new Map();
-		/** @type {FileHashes} */
-		const fileHashes = new Map();
-		/** @type {FileTshs} */
-		const fileTshs = new Map();
-		/** @type {ContextTimestamps} */
-		const contextTimestamps = new Map();
-		/** @type {ContextHashes} */
-		const contextHashes = new Map();
-		/** @type {ContextTshs} */
-		const contextTshs = new Map();
-		/** @type {MissingExistence} */
-		const missingExistence = new Map();
-		/** @type {ManagedItemInfo} */
-		const managedItemInfo = new Map();
+		// collections are allocated lazily to avoid per-snapshot garbage for unused modes
+		/** @type {FileTimestamps | undefined} */
+		let fileTimestamps;
+		/** @type {FileHashes | undefined} */
+		let fileHashes;
+		/** @type {FileTshs | undefined} */
+		let fileTshs;
+		/** @type {ContextTimestamps | undefined} */
+		let contextTimestamps;
+		/** @type {ContextHashes | undefined} */
+		let contextHashes;
+		/** @type {ContextTshs | undefined} */
+		let contextTshs;
+		/** @type {MissingExistence | undefined} */
+		let missingExistence;
+		/** @type {ManagedItemInfo | undefined} */
+		let managedItemInfo;
 		/** @type {ManagedFiles} */
 		const managedFiles = new Set();
 		/** @type {ManagedContexts} */
 		const managedContexts = new Set();
 		/** @type {ManagedMissing} */
 		const managedMissing = new Set();
-		/** @type {Children} */
-		const children = new Set();
 
 		const snapshot = new Snapshot();
 		if (startTime) snapshot.setStartTime(startTime);
@@ -2497,28 +2616,28 @@ class FileSystemInfo {
 		let jobs = 1;
 		const jobDone = () => {
 			if (--jobs === 0) {
-				if (fileTimestamps.size !== 0) {
+				if (fileTimestamps !== undefined && fileTimestamps.size !== 0) {
 					snapshot.setFileTimestamps(fileTimestamps);
 				}
-				if (fileHashes.size !== 0) {
+				if (fileHashes !== undefined && fileHashes.size !== 0) {
 					snapshot.setFileHashes(fileHashes);
 				}
-				if (fileTshs.size !== 0) {
+				if (fileTshs !== undefined && fileTshs.size !== 0) {
 					snapshot.setFileTshs(fileTshs);
 				}
-				if (contextTimestamps.size !== 0) {
+				if (contextTimestamps !== undefined && contextTimestamps.size !== 0) {
 					snapshot.setContextTimestamps(contextTimestamps);
 				}
-				if (contextHashes.size !== 0) {
+				if (contextHashes !== undefined && contextHashes.size !== 0) {
 					snapshot.setContextHashes(contextHashes);
 				}
-				if (contextTshs.size !== 0) {
+				if (contextTshs !== undefined && contextTshs.size !== 0) {
 					snapshot.setContextTshs(contextTshs);
 				}
-				if (missingExistence.size !== 0) {
+				if (missingExistence !== undefined && missingExistence.size !== 0) {
 					snapshot.setMissingExistence(missingExistence);
 				}
-				if (managedItemInfo.size !== 0) {
+				if (managedItemInfo !== undefined && managedItemInfo.size !== 0) {
 					snapshot.setManagedItemInfo(managedItemInfo);
 				}
 				this._managedFilesOptimization.optimize(snapshot, managedFiles);
@@ -2533,9 +2652,6 @@ class FileSystemInfo {
 				if (managedMissing.size !== 0) {
 					snapshot.setManagedMissing(managedMissing);
 				}
-				if (children.size !== 0) {
-					snapshot.setChildren(children);
-				}
 				this._snapshotCache.set(snapshot, true);
 				this._statCreatedSnapshots++;
 
@@ -2549,6 +2665,7 @@ class FileSystemInfo {
 				callback(null, null);
 			}
 		};
+		const classificationCache = this._pathClassificationCache;
 		/**
 		 * Checks true when managed.
 		 * @param {string} path path
@@ -2556,20 +2673,36 @@ class FileSystemInfo {
 		 * @returns {boolean} true when managed
 		 */
 		const checkManaged = (path, managedSet) => {
+			// classification is a pure function of the path, so it's shared across snapshots
+			const cached = classificationCache.get(path);
+			if (cached !== undefined) {
+				if (cached === 0) return false;
+				if (cached !== 1) managedItems.add(cached);
+				managedSet.add(path);
+				return true;
+			}
 			for (const unmanagedPath of this.unmanagedPathsRegExps) {
-				if (unmanagedPath.test(path)) return false;
+				if (unmanagedPath.test(path)) {
+					classificationCache.set(path, 0);
+					return false;
+				}
 			}
 			for (const unmanagedPath of this.unmanagedPathsWithSlash) {
-				if (path.startsWith(unmanagedPath)) return false;
+				if (path.startsWith(unmanagedPath)) {
+					classificationCache.set(path, 0);
+					return false;
+				}
 			}
 			for (const immutablePath of this.immutablePathsRegExps) {
 				if (immutablePath.test(path)) {
+					classificationCache.set(path, 1);
 					managedSet.add(path);
 					return true;
 				}
 			}
 			for (const immutablePath of this.immutablePathsWithSlash) {
 				if (path.startsWith(immutablePath)) {
+					classificationCache.set(path, 1);
 					managedSet.add(path);
 					return true;
 				}
@@ -2579,6 +2712,7 @@ class FileSystemInfo {
 				if (match) {
 					const managedItem = getManagedItem(match[1], path);
 					if (managedItem) {
+						classificationCache.set(path, managedItem);
 						managedItems.add(managedItem);
 						managedSet.add(path);
 						return true;
@@ -2589,12 +2723,14 @@ class FileSystemInfo {
 				if (path.startsWith(managedPath)) {
 					const managedItem = getManagedItem(managedPath, path);
 					if (managedItem) {
+						classificationCache.set(path, managedItem);
 						managedItems.add(managedItem);
 						managedSet.add(path);
 						return true;
 					}
 				}
 			}
+			classificationCache.set(path, 0);
 			return false;
 		};
 		/**
@@ -2620,12 +2756,14 @@ class FileSystemInfo {
 				return;
 			}
 			switch (mode) {
-				case 3:
+				case 3: {
 					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
+					if (fileTshs === undefined) fileTshs = new Map();
+					const fileTshsMap = fileTshs;
 					for (const path of capturedFiles) {
 						const cache = this._fileTshs.get(path);
 						if (cache !== undefined) {
-							fileTshs.set(path, cache);
+							fileTshsMap.set(path, cache);
 						} else {
 							jobs++;
 							this._getFileTimestampAndHash(path, (err, entry) => {
@@ -2637,19 +2775,25 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									fileTshs.set(path, /** @type {TimestampAndHash} */ (entry));
+									fileTshsMap.set(
+										path,
+										/** @type {TimestampAndHash} */ (entry)
+									);
 									jobDone();
 								}
 							});
 						}
 					}
 					break;
-				case 2:
+				}
+				case 2: {
 					this._fileHashesOptimization.optimize(snapshot, capturedFiles);
+					if (fileHashes === undefined) fileHashes = new Map();
+					const fileHashesMap = fileHashes;
 					for (const path of capturedFiles) {
 						const cache = this._fileHashes.get(path);
 						if (cache !== undefined) {
-							fileHashes.set(path, cache);
+							fileHashesMap.set(path, cache);
 						} else {
 							jobs++;
 							this.fileHashQueue.add(path, (err, entry) => {
@@ -2661,20 +2805,23 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									fileHashes.set(path, /** @type {string} */ (entry));
+									fileHashesMap.set(path, /** @type {string} */ (entry));
 									jobDone();
 								}
 							});
 						}
 					}
 					break;
-				case 1:
+				}
+				case 1: {
 					this._fileTimestampsOptimization.optimize(snapshot, capturedFiles);
+					if (fileTimestamps === undefined) fileTimestamps = new Map();
+					const fileTimestampsMap = fileTimestamps;
 					for (const path of capturedFiles) {
 						const cache = this._fileTimestamps.get(path);
 						if (cache !== undefined && !isExistenceOnly(cache)) {
 							if (cache !== "ignore") {
-								fileTimestamps.set(
+								fileTimestampsMap.set(
 									path,
 									/** @type {FileSystemInfoEntry | null} */ (cache)
 								);
@@ -2690,7 +2837,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									fileTimestamps.set(
+									fileTimestampsMap.set(
 										path,
 										/** @type {FileSystemInfoEntry} */
 										(entry)
@@ -2701,6 +2848,7 @@ class FileSystemInfo {
 						}
 					}
 					break;
+				}
 			}
 		};
 		if (files) {
@@ -2715,8 +2863,10 @@ class FileSystemInfo {
 				return;
 			}
 			switch (mode) {
-				case 3:
+				case 3: {
 					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
+					if (contextTshs === undefined) contextTshs = new Map();
+					const contextTshsMap = contextTshs;
 					for (const path of capturedDirectories) {
 						const cache = this._contextTshs.get(path);
 						/** @type {ResolvedContextTimestampAndHash | null | undefined} */
@@ -2725,7 +2875,7 @@ class FileSystemInfo {
 							cache !== undefined &&
 							(resolved = getResolvedTimestamp(cache)) !== undefined
 						) {
-							contextTshs.set(path, resolved);
+							contextTshsMap.set(path, resolved);
 						} else {
 							jobs++;
 							/**
@@ -2743,7 +2893,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									contextTshs.set(
+									contextTshsMap.set(
 										path,
 										/** @type {ResolvedContextTimestampAndHash | null} */
 										(entry)
@@ -2759,11 +2909,14 @@ class FileSystemInfo {
 						}
 					}
 					break;
-				case 2:
+				}
+				case 2: {
 					this._contextHashesOptimization.optimize(
 						snapshot,
 						capturedDirectories
 					);
+					if (contextHashes === undefined) contextHashes = new Map();
+					const contextHashesMap = contextHashes;
 					for (const path of capturedDirectories) {
 						const cache = this._contextHashes.get(path);
 						/** @type {undefined | null | string} */
@@ -2772,7 +2925,7 @@ class FileSystemInfo {
 							cache !== undefined &&
 							(resolved = getResolvedHash(cache)) !== undefined
 						) {
-							contextHashes.set(path, resolved);
+							contextHashesMap.set(path, resolved);
 						} else {
 							jobs++;
 							/**
@@ -2789,7 +2942,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									contextHashes.set(path, /** @type {string} */ (entry));
+									contextHashesMap.set(path, /** @type {string} */ (entry));
 									jobDone();
 								}
 							};
@@ -2801,11 +2954,14 @@ class FileSystemInfo {
 						}
 					}
 					break;
-				case 1:
+				}
+				case 1: {
 					this._contextTimestampsOptimization.optimize(
 						snapshot,
 						capturedDirectories
 					);
+					if (contextTimestamps === undefined) contextTimestamps = new Map();
+					const contextTimestampsMap = contextTimestamps;
 					for (const path of capturedDirectories) {
 						const cache = this._contextTimestamps.get(path);
 						if (cache === "ignore") continue;
@@ -2814,14 +2970,8 @@ class FileSystemInfo {
 							cache === undefined || isExistenceOnly(cache)
 								? undefined
 								: /** @type {ContextFileSystemInfoEntry | null} */ (cache);
-						// A non-null cache entry without `timestampHash` cannot be
-						// used to populate the snapshot — the snapshot would then
-						// miss directory-change detection, since validity relies on
-						// `timestampHash`. Re-read the directory in that case.
 						const cacheLacksHash =
-							usableCache !== undefined &&
-							usableCache !== null &&
-							usableCache.timestampHash === undefined;
+							contextCacheEntryLacksTimestampHash(usableCache);
 						/** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */
 						let resolved;
 						if (
@@ -2829,7 +2979,7 @@ class FileSystemInfo {
 							!cacheLacksHash &&
 							(resolved = getResolvedTimestamp(usableCache)) !== undefined
 						) {
-							contextTimestamps.set(path, resolved);
+							contextTimestampsMap.set(path, resolved);
 						} else {
 							jobs++;
 							/**
@@ -2847,7 +2997,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									contextTimestamps.set(
+									contextTimestampsMap.set(
 										path,
 										/** @type {ResolvedContextFileSystemInfoEntry | null} */
 										(entry)
@@ -2867,6 +3017,7 @@ class FileSystemInfo {
 						}
 					}
 					break;
+				}
 			}
 		};
 		if (directories) {
@@ -2883,11 +3034,13 @@ class FileSystemInfo {
 				return;
 			}
 			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
+			if (missingExistence === undefined) missingExistence = new Map();
+			const missingExistenceMap = missingExistence;
 			for (const path of capturedMissing) {
 				const cache = this._fileTimestamps.get(path);
 				if (cache !== undefined && !isExistenceOnly(cache)) {
 					if (cache !== "ignore") {
-						missingExistence.set(path, Boolean(cache));
+						missingExistenceMap.set(path, Boolean(cache));
 					}
 				} else {
 					jobs++;
@@ -2900,7 +3053,7 @@ class FileSystemInfo {
 							}
 							jobError();
 						} else {
-							missingExistence.set(path, Boolean(entry));
+							missingExistenceMap.set(path, Boolean(entry));
 							jobDone();
 						}
 					});
@@ -2911,6 +3064,10 @@ class FileSystemInfo {
 			processCapturedMissing(captureNonManaged(missing, managedMissing));
 		}
 		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
+		if (managedItems.size !== 0 && managedItemInfo === undefined) {
+			managedItemInfo = new Map();
+		}
+		const managedItemInfoMap = managedItemInfo;
 		for (const path of managedItems) {
 			const cache = this._managedItems.get(path);
 			if (cache !== undefined) {
@@ -2919,7 +3076,7 @@ class FileSystemInfo {
 				} else if (cache === "*nested") {
 					managedMissing.add(join(this.fs, path, "package.json"));
 				}
-				managedItemInfo.set(path, cache);
+				/** @type {ManagedItemInfo} */ (managedItemInfoMap).set(path, cache);
 			} else {
 				jobs++;
 				this.managedItemQueue.add(path, (err, entry) => {
@@ -2936,7 +3093,10 @@ class FileSystemInfo {
 						} else if (cache === "*nested") {
 							managedMissing.add(join(this.fs, path, "package.json"));
 						}
-						managedItemInfo.set(path, entry);
+						/** @type {ManagedItemInfo} */ (managedItemInfoMap).set(
+							path,
+							entry
+						);
 						jobDone();
 					} else {
 						// Fallback to normal snapshotting
@@ -3396,13 +3556,8 @@ class FileSystemInfo {
 					cache === undefined || isExistenceOnly(cache)
 						? undefined
 						: /** @type {ContextFileSystemInfoEntry | null} */ (cache);
-				// A non-null cache entry that lacks `timestampHash` while the
-				// snapshot has one cannot be used either; we re-read the
-				// directory through the disk-backed queue instead.
 				const cacheLacksHash =
-					usableCache !== undefined &&
-					usableCache !== null &&
-					usableCache.timestampHash === undefined &&
+					contextCacheEntryLacksTimestampHash(usableCache) &&
 					ts !== null &&
 					ts.timestampHash !== undefined;
 				/** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */
@@ -3513,9 +3668,7 @@ class FileSystemInfo {
 							? undefined
 							: /** @type {ContextFileSystemInfoEntry | null} */ (cache);
 					const cacheLacksHash =
-						usableCache !== undefined &&
-						usableCache !== null &&
-						usableCache.timestampHash === undefined &&
+						contextCacheEntryLacksTimestampHash(usableCache) &&
 						tsh !== null &&
 						tsh.timestampHash !== undefined;
 					/** @type {undefined | null | ResolvedContextFileSystemInfoEntry} */
@@ -4085,7 +4238,7 @@ class FileSystemInfo {
 				/**
 				 * Returns reduced hash.
 				 * @param {string[]} files files
-				 * @param {(string | ContextHash)[]} fileHashes hashes
+				 * @param {(string | ContextHash | null)[]} fileHashes hashes
 				 * @returns {ContextHash} reduced hash
 				 */
 				reduce: (files, fileHashes) => {
@@ -4095,10 +4248,13 @@ class FileSystemInfo {
 
 					for (const file of files) hash.update(file);
 					for (const entry of fileHashes) {
-						if (typeof entry === "string") {
+						// null for unsupported entry kinds (FIFO, socket); skip like the tsh reduce
+						if (!entry) {
+							continue;
+						} else if (typeof entry === "string") {
 							hash.update(entry);
 						} else {
-							hash.update(entry.hash);
+							if (entry.hash) hash.update(entry.hash);
 							if (entry.symlinks) {
 								if (symlinks === undefined) symlinks = new Set();
 								addAll(entry.symlinks, symlinks);