webpack 5.59.0 → 5.94.0

package/lib/FileSystemInfo.js

@@ -6,7 +6,9 @@
 "use strict";
 
 const { create: createResolver } = require("enhanced-resolve");
+const nodeModule = require("module");
 const asyncLib = require("neo-async");
+const { isAbsolute } = require("path");
 const AsyncQueue = require("./util/AsyncQueue");
 const StackedCacheMap = require("./util/StackedCacheMap");
 const createHash = require("./util/createHash");
@@ -14,13 +16,31 @@ const { join, dirname, relative, lstatReadlinkAbsolute } = require("./util/fs");
 const makeSerializable = require("./util/makeSerializable");
 const processAsyncTree = require("./util/processAsyncTree");
 
+/** @typedef {import("enhanced-resolve").Resolver} Resolver */
+/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
+/** @typedef {import("enhanced-resolve").ResolveFunctionAsync} ResolveFunctionAsync */
 /** @typedef {import("./WebpackError")} WebpackError */
 /** @typedef {import("./logging/Logger").Logger} Logger */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 /** @typedef {typeof import("./util/Hash")} Hash */
 /** @typedef {import("./util/fs").IStats} IStats */
 /** @typedef {import("./util/fs").InputFileSystem} InputFileSystem */
+/** @typedef {import("./util/fs").PathLike} PathLike */
+/** @typedef {import("./util/fs").StringCallback} StringCallback */
+/**
+ * @template T
+ * @typedef {import("./util/AsyncQueue").Callback<T>} ProcessorCallback
+ */
+/**
+ * @template T, R
+ * @typedef {import("./util/AsyncQueue").Processor<T, R>} Processor
+ */
+
+const supportsEsm = Number(process.versions.modules) >= 83;
 
-const supportsEsm = +process.versions.modules >= 83;
+/** @type {Set<string>} */
+const builtinModules = new Set(nodeModule.builtinModules);
 
 let FS_ACCURACY = 2000;
 
@@ -37,22 +57,24 @@ const RBDT_FILE = 7;
 const RBDT_DIRECTORY_DEPENDENCIES = 8;
 const RBDT_FILE_DEPENDENCIES = 9;
 
+/** @typedef {RBDT_RESOLVE_CJS | RBDT_RESOLVE_ESM | RBDT_RESOLVE_DIRECTORY | RBDT_RESOLVE_CJS_FILE | RBDT_RESOLVE_CJS_FILE_AS_CHILD | RBDT_RESOLVE_ESM_FILE | RBDT_DIRECTORY | RBDT_FILE | RBDT_DIRECTORY_DEPENDENCIES | RBDT_FILE_DEPENDENCIES} JobType */
+
 const INVALID = Symbol("invalid");
 
 /**
- * @typedef {Object} FileSystemInfoEntry
+ * @typedef {object} FileSystemInfoEntry
  * @property {number} safeTime
  * @property {number=} timestamp
  */
 
 /**
- * @typedef {Object} ResolvedContextFileSystemInfoEntry
+ * @typedef {object} ResolvedContextFileSystemInfoEntry
  * @property {number} safeTime
  * @property {string=} timestampHash
  */
 
 /**
- * @typedef {Object} ContextFileSystemInfoEntry
+ * @typedef {object} ContextFileSystemInfoEntry
  * @property {number} safeTime
  * @property {string=} timestampHash
  * @property {ResolvedContextFileSystemInfoEntry=} resolved
@@ -60,55 +82,65 @@ const INVALID = Symbol("invalid");
  */
 
 /**
- * @typedef {Object} TimestampAndHash
+ * @typedef {object} TimestampAndHash
  * @property {number} safeTime
  * @property {number=} timestamp
  * @property {string} hash
  */
 
 /**
- * @typedef {Object} ResolvedContextTimestampAndHash
+ * @typedef {object} ResolvedContextTimestampAndHash
  * @property {number} safeTime
  * @property {string=} timestampHash
  * @property {string} hash
  */
 
+/** @typedef {Set<string>} Symlinks */
+
 /**
- * @typedef {Object} ContextTimestampAndHash
+ * @typedef {object} ContextTimestampAndHash
  * @property {number} safeTime
  * @property {string=} timestampHash
  * @property {string} hash
  * @property {ResolvedContextTimestampAndHash=} resolved
- * @property {Set<string>=} symlinks
+ * @property {Symlinks=} symlinks
  */
 
 /**
- * @typedef {Object} ContextHash
+ * @typedef {object} ContextHash
  * @property {string} hash
  * @property {string=} resolved
- * @property {Set<string>=} symlinks
+ * @property {Symlinks=} symlinks
  */
 
+/** @typedef {Set<string>} SnapshotContent */
+
 /**
- * @typedef {Object} SnapshotOptimizationEntry
+ * @typedef {object} SnapshotOptimizationEntry
  * @property {Snapshot} snapshot
  * @property {number} shared
- * @property {Set<string>} snapshotContent
- * @property {Set<SnapshotOptimizationEntry>} children
+ * @property {SnapshotContent | undefined} snapshotContent
+ * @property {Set<SnapshotOptimizationEntry> | undefined} children
  */
 
 /**
- * @typedef {Object} ResolveBuildDependenciesResult
+ * @typedef {object} ResolveBuildDependenciesResult
  * @property {Set<string>} files list of files
  * @property {Set<string>} directories list of directories
  * @property {Set<string>} missing list of missing entries
- * @property {Map<string, string | false>} resolveResults stored resolve results
- * @property {Object} resolveDependencies dependencies of the resolving
+ * @property {Map<string, string | false | undefined>} resolveResults stored resolve results
+ * @property {object} resolveDependencies dependencies of the resolving
  * @property {Set<string>} resolveDependencies.files list of files
  * @property {Set<string>} resolveDependencies.directories list of directories
  * @property {Set<string>} resolveDependencies.missing list of missing entries
  */
 
+/**
+ * @typedef {object} SnapshotOptions
+ * @property {boolean=} hash should use hash to snapshot
+ * @property {boolean=} timestamp should use timestamp to snapshot
+ */
+
 const DONE_ITERATOR_RESULT = new Set().keys().next();
 
 // cspell:word tshs
@@ -116,12 +148,23 @@ const DONE_ITERATOR_RESULT = new Set().keys().next();
 // Tshs = Timestamp + Hash combinations
 
 class SnapshotIterator {
+	/**
+	 * @param {() => IteratorResult<string>} next next
+	 */
 	constructor(next) {
 		this.next = next;
 	}
 }
 
+/**
+ * @typedef {(snapshot: Snapshot) => (Map<string, any> | Set<string> | undefined)[]} GetMapsFunction
+ */
+
 class SnapshotIterable {
+	/**
+	 * @param {Snapshot} snapshot snapshot
+	 * @param {GetMapsFunction} getMaps get maps function
+	 */
 	constructor(snapshot, getMaps) {
 		this.snapshot = snapshot;
 		this.getMaps = getMaps;
@@ -131,12 +174,13 @@ class SnapshotIterable {
 		let state = 0;
 		/** @type {IterableIterator<string>} */
 		let it;
-		/** @type {(Snapshot) => (Map<string, any> | Set<string>)[]} */
+		/** @type {(snapshot: Snapshot) => (Map<string, any> | Set<string> | undefined)[]} */
 		let getMaps;
-		/** @type {(Map<string, any> | Set<string>)[]} */
+		/** @type {(Map<string, any> | Set<string> | undefined)[]} */
 		let maps;
 		/** @type {Snapshot} */
 		let snapshot;
+		/** @type {Snapshot[] | undefined} */
 		let queue;
 		return new SnapshotIterator(() => {
 			for (;;) {
@@ -184,7 +228,7 @@ class SnapshotIterable {
 							}
 						}
 						if (queue !== undefined && queue.length > 0) {
-							snapshot = queue.pop();
+							snapshot = /** @type {Snapshot} */ (queue.pop());
 							maps = getMaps(snapshot);
 							state = 1;
 							break;
@@ -201,34 +245,53 @@ class SnapshotIterable {
 	}
 }
 
+/** @typedef {Map<string, FileSystemInfoEntry | null>} FileTimestamps */
+/** @typedef {Map<string, string | null>} FileHashes */
+/** @typedef {Map<string, TimestampAndHash | string | null>} FileTshs */
+/** @typedef {Map<string, ResolvedContextFileSystemInfoEntry | null>} ContextTimestamps */
+/** @typedef {Map<string, string | null>} ContextHashes */
+/** @typedef {Map<string, ResolvedContextTimestampAndHash | null>} ContextTshs */
+/** @typedef {Map<string, boolean>} MissingExistence */
+/** @typedef {Map<string, string>} ManagedItemInfo */
+/** @typedef {Set<string>} ManagedFiles */
+/** @typedef {Set<string>} ManagedContexts */
+/** @typedef {Set<string>} ManagedMissing */
+/** @typedef {Set<Snapshot>} Children */
+
 class Snapshot {
 	constructor() {
 		this._flags = 0;
+		/** @type {Iterable<string> | undefined} */
+		this._cachedFileIterable = undefined;
+		/** @type {Iterable<string> | undefined} */
+		this._cachedContextIterable = undefined;
+		/** @type {Iterable<string> | undefined} */
+		this._cachedMissingIterable = undefined;
 		/** @type {number | undefined} */
 		this.startTime = undefined;
-		/** @type {Map<string, FileSystemInfoEntry | null> | undefined} */
+		/** @type {FileTimestamps | undefined} */
 		this.fileTimestamps = undefined;
-		/** @type {Map<string, string | null> | undefined} */
+		/** @type {FileHashes | undefined} */
 		this.fileHashes = undefined;
-		/** @type {Map<string, TimestampAndHash | string | null> | undefined} */
+		/** @type {FileTshs | undefined} */
 		this.fileTshs = undefined;
-		/** @type {Map<string, ResolvedContextFileSystemInfoEntry | null> | undefined} */
+		/** @type {ContextTimestamps | undefined} */
 		this.contextTimestamps = undefined;
-		/** @type {Map<string, string | null> | undefined} */
+		/** @type {ContextHashes | undefined} */
 		this.contextHashes = undefined;
-		/** @type {Map<string, ResolvedContextTimestampAndHash | null> | undefined} */
+		/** @type {ContextTshs | undefined} */
 		this.contextTshs = undefined;
-		/** @type {Map<string, boolean> | undefined} */
+		/** @type {MissingExistence | undefined} */
 		this.missingExistence = undefined;
-		/** @type {Map<string, string> | undefined} */
+		/** @type {ManagedItemInfo | undefined} */
 		this.managedItemInfo = undefined;
-		/** @type {Set<string> | undefined} */
+		/** @type {ManagedFiles | undefined} */
 		this.managedFiles = undefined;
-		/** @type {Set<string> | undefined} */
+		/** @type {ManagedContexts | undefined} */
 		this.managedContexts = undefined;
-		/** @type {Set<string> | undefined} */
+		/** @type {ManagedMissing | undefined} */
 		this.managedMissing = undefined;
-		/** @type {Set<Snapshot> | undefined} */
+		/** @type {Children | undefined} */
 		this.children = undefined;
 	}
 
@@ -236,20 +299,36 @@ class Snapshot {
 		return (this._flags & 1) !== 0;
 	}
 
+	/**
+	 * @param {number} value start value
+	 */
 	setStartTime(value) {
 		this._flags = this._flags | 1;
 		this.startTime = value;
 	}
 
+	/**
+	 * @param {number | undefined} value value
+	 * @param {Snapshot} snapshot snapshot
+	 */
 	setMergedStartTime(value, snapshot) {
 		if (value) {
 			if (snapshot.hasStartTime()) {
-				this.setStartTime(Math.min(value, snapshot.startTime));
+				this.setStartTime(
+					Math.min(
+						value,
+						/** @type {NonNullable<Snapshot["startTime"]>} */
+						(snapshot.startTime)
+					)
+				);
 			} else {
 				this.setStartTime(value);
 			}
-		} else {
-			if (snapshot.hasStartTime()) this.setStartTime(snapshot.startTime);
+		} else if (snapshot.hasStartTime()) {
+			this.setStartTime(
+				/** @type {NonNullable<Snapshot["startTime"]>} */
+				(snapshot.startTime)
+			);
 		}
 	}
 
@@ -257,6 +336,9 @@ class Snapshot {
 		return (this._flags & 2) !== 0;
 	}
 
+	/**
+	 * @param {FileTimestamps} value file timestamps
+	 */
 	setFileTimestamps(value) {
 		this._flags = this._flags | 2;
 		this.fileTimestamps = value;
@@ -266,6 +348,9 @@ class Snapshot {
 		return (this._flags & 4) !== 0;
 	}
 
+	/**
+	 * @param {FileHashes} value file hashes
+	 */
 	setFileHashes(value) {
 		this._flags = this._flags | 4;
 		this.fileHashes = value;
@@ -275,6 +360,9 @@ class Snapshot {
 		return (this._flags & 8) !== 0;
 	}
 
+	/**
+	 * @param {FileTshs} value file tshs
+	 */
 	setFileTshs(value) {
 		this._flags = this._flags | 8;
 		this.fileTshs = value;
@@ -284,6 +372,9 @@ class Snapshot {
 		return (this._flags & 0x10) !== 0;
 	}
 
+	/**
+	 * @param {ContextTimestamps} value context timestamps
+	 */
 	setContextTimestamps(value) {
 		this._flags = this._flags | 0x10;
 		this.contextTimestamps = value;
@@ -293,6 +384,9 @@ class Snapshot {
 		return (this._flags & 0x20) !== 0;
 	}
 
+	/**
+	 * @param {ContextHashes} value context hashes
+	 */
 	setContextHashes(value) {
 		this._flags = this._flags | 0x20;
 		this.contextHashes = value;
@@ -302,6 +396,9 @@ class Snapshot {
 		return (this._flags & 0x40) !== 0;
 	}
 
+	/**
+	 * @param {ContextTshs} value context tshs
+	 */
 	setContextTshs(value) {
 		this._flags = this._flags | 0x40;
 		this.contextTshs = value;
@@ -311,6 +408,9 @@ class Snapshot {
 		return (this._flags & 0x80) !== 0;
 	}
 
+	/**
+	 * @param {MissingExistence} value context tshs
+	 */
 	setMissingExistence(value) {
 		this._flags = this._flags | 0x80;
 		this.missingExistence = value;
@@ -320,6 +420,9 @@ class Snapshot {
 		return (this._flags & 0x100) !== 0;
 	}
 
+	/**
+	 * @param {ManagedItemInfo} value managed item info
+	 */
 	setManagedItemInfo(value) {
 		this._flags = this._flags | 0x100;
 		this.managedItemInfo = value;
@@ -329,6 +432,9 @@ class Snapshot {
 		return (this._flags & 0x200) !== 0;
 	}
 
+	/**
+	 * @param {ManagedFiles} value managed files
+	 */
 	setManagedFiles(value) {
 		this._flags = this._flags | 0x200;
 		this.managedFiles = value;
@@ -338,6 +444,9 @@ class Snapshot {
 		return (this._flags & 0x400) !== 0;
 	}
 
+	/**
+	 * @param {ManagedContexts} value managed contexts
+	 */
 	setManagedContexts(value) {
 		this._flags = this._flags | 0x400;
 		this.managedContexts = value;
@@ -347,6 +456,9 @@ class Snapshot {
 		return (this._flags & 0x800) !== 0;
 	}
 
+	/**
+	 * @param {ManagedMissing} value managed missing
+	 */
 	setManagedMissing(value) {
 		this._flags = this._flags | 0x800;
 		this.managedMissing = value;
@@ -356,18 +468,28 @@ class Snapshot {
 		return (this._flags & 0x1000) !== 0;
 	}
 
+	/**
+	 * @param {Children} value children
+	 */
 	setChildren(value) {
 		this._flags = this._flags | 0x1000;
 		this.children = value;
 	}
 
+	/**
+	 * @param {Snapshot} child children
+	 */
 	addChild(child) {
 		if (!this.hasChildren()) {
 			this.setChildren(new Set());
 		}
-		this.children.add(child);
+		/** @type {Children} */
+		(this.children).add(child);
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize({ write }) {
 		write(this._flags);
 		if (this.hasStartTime()) write(this.startTime);
@@ -385,6 +507,9 @@ class Snapshot {
 		if (this.hasChildren()) write(this.children);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize({ read }) {
 		this._flags = read();
 		if (this.hasStartTime()) this.startTime = read();
@@ -403,7 +528,7 @@ class Snapshot {
 	}
 
 	/**
-	 * @param {function(Snapshot): (ReadonlyMap<string, any> | ReadonlySet<string>)[]} getMaps first
+	 * @param {GetMapsFunction} getMaps first
 	 * @returns {Iterable<string>} iterable
 	 */
 	_createIterable(getMaps) {
@@ -414,31 +539,43 @@ class Snapshot {
 	 * @returns {Iterable<string>} iterable
 	 */
 	getFileIterable() {
-		return this._createIterable(s => [
-			s.fileTimestamps,
-			s.fileHashes,
-			s.fileTshs,
-			s.managedFiles
-		]);
+		if (this._cachedFileIterable === undefined) {
+			this._cachedFileIterable = this._createIterable(s => [
+				s.fileTimestamps,
+				s.fileHashes,
+				s.fileTshs,
+				s.managedFiles
+			]);
+		}
+		return this._cachedFileIterable;
 	}
 
 	/**
 	 * @returns {Iterable<string>} iterable
 	 */
 	getContextIterable() {
-		return this._createIterable(s => [
-			s.contextTimestamps,
-			s.contextHashes,
-			s.contextTshs,
-			s.managedContexts
-		]);
+		if (this._cachedContextIterable === undefined) {
+			this._cachedContextIterable = this._createIterable(s => [
+				s.contextTimestamps,
+				s.contextHashes,
+				s.contextTshs,
+				s.managedContexts
+			]);
+		}
+		return this._cachedContextIterable;
 	}
 
 	/**
 	 * @returns {Iterable<string>} iterable
 	 */
 	getMissingIterable() {
-		return this._createIterable(s => [s.missingExistence, s.managedMissing]);
+		if (this._cachedMissingIterable === undefined) {
+			this._cachedMissingIterable = this._createIterable(s => [
+				s.missingExistence,
+				s.managedMissing
+			]);
+		}
+		return this._cachedMissingIterable;
 	}
 }
 
@@ -446,22 +583,35 @@ makeSerializable(Snapshot, "webpack/lib/FileSystemInfo", "Snapshot");
 
 const MIN_COMMON_SNAPSHOT_SIZE = 3;
 
+/**
+ * @template U, T
+ * @typedef {U extends true ? Set<string> : Map<string, T>} SnapshotOptimizationValue
+ */
+
 /**
  * @template T
+ * @template {boolean} [U=false]
  */
 class SnapshotOptimization {
 	/**
 	 * @param {function(Snapshot): boolean} has has value
-	 * @param {function(Snapshot): Map<string, T> | Set<string>} get get value
-	 * @param {function(Snapshot, Map<string, T> | Set<string>): void} set set value
+	 * @param {function(Snapshot): SnapshotOptimizationValue<U, T> | undefined} get get value
+	 * @param {function(Snapshot, SnapshotOptimizationValue<U, T>): void} set set value
 	 * @param {boolean=} useStartTime use the start time of snapshots
-	 * @param {boolean=} isSet value is an Set instead of a Map
+	 * @param {U=} isSet value is an Set instead of a Map
 	 */
-	constructor(has, get, set, useStartTime = true, isSet = false) {
+	constructor(
+		has,
+		get,
+		set,
+		useStartTime = true,
+		isSet = /** @type {U} */ (false)
+	) {
 		this._has = has;
 		this._get = get;
 		this._set = set;
 		this._useStartTime = useStartTime;
+		/** @type {U} */
 		this._isSet = isSet;
 		/** @type {Map<string, SnapshotOptimizationEntry>} */
 		this._map = new Map();
@@ -473,7 +623,7 @@ class SnapshotOptimization {
 
 	getStatisticMessage() {
 		const total = this._statItemsShared + this._statItemsUnshared;
-		if (total === 0) return undefined;
+		if (total === 0) return;
 		return `${
 			this._statItemsShared && Math.round((this._statItemsShared * 100) / total)
 		}% (${this._statItemsShared}/${total}) entries shared via ${
@@ -503,7 +653,9 @@ class SnapshotOptimization {
 		 */
 		const increaseSharedAndStoreOptimizationEntry = entry => {
 			if (entry.children !== undefined) {
-				entry.children.forEach(increaseSharedAndStoreOptimizationEntry);
+				for (const child of entry.children) {
+					increaseSharedAndStoreOptimizationEntry(child);
+				}
 			}
 			entry.shared++;
 			storeOptimizationEntry(entry);
@@ -513,8 +665,12 @@ class SnapshotOptimization {
 		 * @returns {void}
 		 */
 		const storeOptimizationEntry = entry => {
-			for (const path of entry.snapshotContent) {
-				const old = this._map.get(path);
+			for (const path of /** @type {SnapshotContent} */ (
+				entry.snapshotContent
+			)) {
+				const old =
+					/** @type {SnapshotOptimizationEntry} */
+					(this._map.get(path));
 				if (old.shared < entry.shared) {
 					this._map.set(path, entry);
 				}
@@ -522,8 +678,8 @@ class SnapshotOptimization {
 			}
 		};
 
-		/** @type {SnapshotOptimizationEntry} */
-		let newOptimizationEntry = undefined;
+		/** @type {SnapshotOptimizationEntry | undefined} */
+		let newOptimizationEntry;
 
 		const capturedFilesSize = capturedFiles.size;
 
@@ -548,7 +704,7 @@ class SnapshotOptimization {
 			}
 		}
 
-		optimizationEntries: for (const optimizationEntry of optimizationEntries) {
+		optimizationEntriesLabel: for (const optimizationEntry of optimizationEntries) {
 			const snapshot = optimizationEntry.snapshot;
 			if (optimizationEntry.shared > 0) {
 				// It's a shared snapshot
@@ -562,14 +718,18 @@ class SnapshotOptimization {
 					continue;
 				}
 				const nonSharedFiles = new Set();
-				const snapshotContent = optimizationEntry.snapshotContent;
-				const snapshotEntries = this._get(snapshot);
+				const snapshotContent =
+					/** @type {NonNullable<SnapshotOptimizationEntry["snapshotContent"]>} */
+					(optimizationEntry.snapshotContent);
+				const snapshotEntries =
+					/** @type {SnapshotOptimizationValue<U, T>} */
+					(this._get(snapshot));
 				for (const path of snapshotContent) {
 					if (!capturedFiles.has(path)) {
 						if (!snapshotEntries.has(path)) {
 							// File is not shared and can't be removed from the snapshot
 							// because it's in a child of the snapshot
-							continue optimizationEntries;
+							continue optimizationEntriesLabel;
 						}
 						nonSharedFiles.add(path);
 						continue;
@@ -586,7 +746,7 @@ class SnapshotOptimization {
 					const sharedCount = snapshotContent.size - nonSharedFiles.size;
 					if (sharedCount < MIN_COMMON_SNAPSHOT_SIZE) {
 						// Common part it too small
-						continue optimizationEntries;
+						continue;
 					}
 					// Extract common timestamps from both snapshots
 					let commonMap;
@@ -611,7 +771,10 @@ class SnapshotOptimization {
 					if (this._useStartTime) {
 						commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
 					}
-					this._set(commonSnapshot, commonMap);
+					this._set(
+						commonSnapshot,
+						/** @type {SnapshotOptimizationValue<U, T>} */ (commonMap)
+					);
 					newSnapshot.addChild(commonSnapshot);
 					snapshot.addChild(commonSnapshot);
 					// Create optimization entry
@@ -634,7 +797,7 @@ class SnapshotOptimization {
 				const snapshotEntries = this._get(snapshot);
 				if (snapshotEntries === undefined) {
 					// Incomplete snapshot, that can't be used
-					continue optimizationEntries;
+					continue;
 				}
 				let commonMap;
 				if (this._isSet) {
@@ -661,14 +824,18 @@ class SnapshotOptimization {
 
 				if (commonMap.size < MIN_COMMON_SNAPSHOT_SIZE) {
 					// Common part it too small
-					continue optimizationEntries;
+					continue;
 				}
 				// Create and attach snapshot
 				const commonSnapshot = new Snapshot();
 				if (this._useStartTime) {
 					commonSnapshot.setMergedStartTime(newSnapshot.startTime, snapshot);
 				}
-				this._set(commonSnapshot, commonMap);
+				this._set(
+					commonSnapshot,
+					/** @type {SnapshotOptimizationValue<U, T>} */
+					(commonMap)
+				);
 				newSnapshot.addChild(commonSnapshot);
 				snapshot.addChild(commonSnapshot);
 				// Remove files from snapshot
@@ -692,6 +859,16 @@ class SnapshotOptimization {
 	}
 }
 
+/**
+ * @param {string} str input
+ * @returns {string} result
+ */
+const parseString = str => {
+	if (str[0] === "'" || str[0] === "`")
+		str = `"${str.slice(1, -1).replace(/"/g, '\\"')}"`;
+	return JSON.parse(str);
+};
+
 /* istanbul ignore next */
 /**
  * @param {number} mtime mtime
@@ -706,13 +883,14 @@ const applyMtime = mtime => {
 /**
  * @template T
  * @template K
- * @param {Map<T, K>} a source map
- * @param {Map<T, K>} b joining map
+ * @param {Map<T, K> | undefined} a source map
+ * @param {Map<T, K> | undefined} b joining map
  * @returns {Map<T, K>} joined map
  */
 const mergeMaps = (a, b) => {
-	if (!b || b.size === 0) return a;
-	if (!a || a.size === 0) return b;
+	if (!b || b.size === 0) return /** @type {Map<T, K>} */ (a);
+	if (!a || a.size === 0) return /** @type {Map<T, K>} */ (b);
+	/** @type {Map<T, K>} */
 	const map = new Map(a);
 	for (const [key, value] of b) {
 		map.set(key, value);
@@ -722,14 +900,14 @@ const mergeMaps = (a, b) => {
 
 /**
  * @template T
- * @template K
- * @param {Set<T, K>} a source map
- * @param {Set<T, K>} b joining map
- * @returns {Set<T, K>} joined map
+ * @param {Set<T> | undefined} a source map
+ * @param {Set<T> | undefined} b joining map
+ * @returns {Set<T>} joined map
  */
 const mergeSets = (a, b) => {
-	if (!b || b.size === 0) return a;
-	if (!a || a.size === 0) return b;
+	if (!b || b.size === 0) return /** @type {Set<T>} */ (a);
+	if (!a || a.size === 0) return /** @type {Set<T>} */ (b);
+	/** @type {Set<T>} */
 	const map = new Set(a);
 	for (const item of b) {
 		map.add(item);
@@ -823,8 +1001,8 @@ const getManagedItem = (managedPath, path) => {
 
 /**
  * @template {ContextFileSystemInfoEntry | ContextTimestampAndHash} T
- * @param {T} entry entry
- * @returns {T["resolved"] | undefined} the resolved entry
+ * @param {T | null} entry entry
+ * @returns {T["resolved"] | null | undefined} the resolved entry
  */
 const getResolvedTimestamp = entry => {
 	if (entry === null) return null;
@@ -833,8 +1011,8 @@ const getResolvedTimestamp = entry => {
 };
 
 /**
- * @param {ContextHash} entry entry
- * @returns {string | undefined} the resolved entry
+ * @param {ContextHash | null} entry entry
+ * @returns {string | null | undefined} the resolved entry
  */
 const getResolvedHash = entry => {
 	if (entry === null) return null;
@@ -842,17 +1020,25 @@ const getResolvedHash = entry => {
 	return entry.symlinks === undefined ? entry.hash : undefined;
 };
 
+/**
+ * @template T
+ * @param {Set<T>} source source
+ * @param {Set<T>} target target
+ */
 const addAll = (source, target) => {
 	for (const key of source) target.add(key);
 };
 
+/** @typedef {Set<string>} LoggedPaths */
+
 /**
  * Used to access information about the filesystem in a cached way
  */
 class FileSystemInfo {
 	/**
 	 * @param {InputFileSystem} fs file system
-	 * @param {Object} options options
+	 * @param {object} options options
+	 * @param {Iterable<string | RegExp>=} options.unmanagedPaths paths that are not managed by a package manager and the contents are subject to change
 	 * @param {Iterable<string | RegExp>=} options.managedPaths paths that are only managed by a package manager
 	 * @param {Iterable<string | RegExp>=} options.immutablePaths paths that are immutable
 	 * @param {Logger=} options.logger logger used to log invalid snapshots
@@ -861,6 +1047,7 @@ class FileSystemInfo {
 	constructor(
 		fs,
 		{
+			unmanagedPaths = [],
 			managedPaths = [],
 			immutablePaths = [],
 			logger,
@@ -870,9 +1057,10 @@ class FileSystemInfo {
 		this.fs = fs;
 		this.logger = logger;
 		this._remainingLogs = logger ? 40 : 0;
+		/** @type {LoggedPaths | undefined} */
 		this._loggedPaths = logger ? new Set() : undefined;
 		this._hashFunction = hashFunction;
-		/** @type {WeakMap<Snapshot, boolean | (function(WebpackError=, boolean=): void)[]>} */
+		/** @type {WeakMap<Snapshot, boolean | (function((WebpackError | null)=, boolean=): void)[]>} */
 		this._snapshotCache = new WeakMap();
 		this._fileTimestampsOptimization = new SnapshotOptimization(
 			s => s.hasFileTimestamps(),
@@ -941,7 +1129,7 @@ class FileSystemInfo {
 		);
 		/** @type {StackedCacheMap<string, FileSystemInfoEntry | "ignore" | null>} */
 		this._fileTimestamps = new StackedCacheMap();
-		/** @type {Map<string, string>} */
+		/** @type {Map<string, string | null>} */
 		this._fileHashes = new Map();
 		/** @type {Map<string, TimestampAndHash | string>} */
 		this._fileTshs = new Map();
@@ -953,37 +1141,37 @@ class FileSystemInfo {
 		this._contextTshs = new Map();
 		/** @type {Map<string, string>} */
 		this._managedItems = new Map();
-		/** @type {AsyncQueue<string, string, FileSystemInfoEntry | null>} */
+		/** @type {AsyncQueue<string, string, FileSystemInfoEntry>} */
 		this.fileTimestampQueue = new AsyncQueue({
 			name: "file timestamp",
 			parallelism: 30,
 			processor: this._readFileTimestamp.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, string | null>} */
+		/** @type {AsyncQueue<string, string, string>} */
 		this.fileHashQueue = new AsyncQueue({
 			name: "file hash",
 			parallelism: 10,
 			processor: this._readFileHash.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry | null>} */
+		/** @type {AsyncQueue<string, string, ContextFileSystemInfoEntry>} */
 		this.contextTimestampQueue = new AsyncQueue({
 			name: "context timestamp",
 			parallelism: 2,
 			processor: this._readContextTimestamp.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, ContextHash | null>} */
+		/** @type {AsyncQueue<string, string, ContextHash>} */
 		this.contextHashQueue = new AsyncQueue({
 			name: "context hash",
 			parallelism: 2,
 			processor: this._readContextHash.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, ContextTimestampAndHash | null>} */
+		/** @type {AsyncQueue<string, string, ContextTimestampAndHash>} */
 		this.contextTshQueue = new AsyncQueue({
 			name: "context hash and timestamp",
 			parallelism: 2,
 			processor: this._readContextTimestampAndHash.bind(this)
 		});
-		/** @type {AsyncQueue<string, string, string | null>} */
+		/** @type {AsyncQueue<string, string, string>} */
 		this.managedItemQueue = new AsyncQueue({
 			name: "managed item info",
 			parallelism: 10,
@@ -995,6 +1183,14 @@ class FileSystemInfo {
 			parallelism: 10,
 			processor: this._getManagedItemDirectoryInfo.bind(this)
 		});
+		const _unmanagedPaths = Array.from(unmanagedPaths);
+		this.unmanagedPathsWithSlash = /** @type {string[]} */ (
+			_unmanagedPaths.filter(p => typeof p === "string")
+		).map(p => join(fs, p, "_").slice(0, -1));
+		this.unmanagedPathsRegExps = /** @type {RegExp[]} */ (
+			_unmanagedPaths.filter(p => typeof p !== "string")
+		);
+
 		this.managedPaths = Array.from(managedPaths);
 		this.managedPathsWithSlash = /** @type {string[]} */ (
 			this.managedPaths.filter(p => typeof p === "string")
@@ -1025,13 +1221,18 @@ class FileSystemInfo {
 	}
 
 	logStatistics() {
+		const logger = /** @type {Logger} */ (this.logger);
+		/**
+		 * @param {string} header header
+		 * @param {string | undefined} message message
+		 */
 		const logWhenMessage = (header, message) => {
 			if (message) {
-				this.logger.log(`${header}: ${message}`);
+				logger.log(`${header}: ${message}`);
 			}
 		};
-		this.logger.log(`${this._statCreatedSnapshots} new snapshots created`);
-		this.logger.log(
+		logger.log(`${this._statCreatedSnapshots} new snapshots created`);
+		logger.log(
 			`${
 				this._statTestedSnapshotsNotCached &&
 				Math.round(
@@ -1043,7 +1244,7 @@ class FileSystemInfo {
 				this._statTestedSnapshotsCached + this._statTestedSnapshotsNotCached
 			})`
 		);
-		this.logger.log(
+		logger.log(
 			`${
 				this._statTestedChildrenNotCached &&
 				Math.round(
@@ -1054,69 +1255,75 @@ class FileSystemInfo {
 				this._statTestedChildrenCached + this._statTestedChildrenNotCached
 			})`
 		);
-		this.logger.log(`${this._statTestedEntries} entries tested`);
-		this.logger.log(
+		logger.log(`${this._statTestedEntries} entries tested`);
+		logger.log(
 			`File info in cache: ${this._fileTimestamps.size} timestamps ${this._fileHashes.size} hashes ${this._fileTshs.size} timestamp hash combinations`
 		);
 		logWhenMessage(
-			`File timestamp snapshot optimization`,
+			"File timestamp snapshot optimization",
 			this._fileTimestampsOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`File hash snapshot optimization`,
+			"File hash snapshot optimization",
 			this._fileHashesOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`File timestamp hash combination snapshot optimization`,
+			"File timestamp hash combination snapshot optimization",
 			this._fileTshsOptimization.getStatisticMessage()
 		);
-		this.logger.log(
+		logger.log(
 			`Directory info in cache: ${this._contextTimestamps.size} timestamps ${this._contextHashes.size} hashes ${this._contextTshs.size} timestamp hash combinations`
 		);
 		logWhenMessage(
-			`Directory timestamp snapshot optimization`,
+			"Directory timestamp snapshot optimization",
 			this._contextTimestampsOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`Directory hash snapshot optimization`,
+			"Directory hash snapshot optimization",
 			this._contextHashesOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`Directory timestamp hash combination snapshot optimization`,
+			"Directory timestamp hash combination snapshot optimization",
 			this._contextTshsOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`Missing items snapshot optimization`,
+			"Missing items snapshot optimization",
 			this._missingExistenceOptimization.getStatisticMessage()
 		);
-		this.logger.log(
-			`Managed items info in cache: ${this._managedItems.size} items`
-		);
+		logger.log(`Managed items info in cache: ${this._managedItems.size} items`);
 		logWhenMessage(
-			`Managed items snapshot optimization`,
+			"Managed items snapshot optimization",
 			this._managedItemInfoOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`Managed files snapshot optimization`,
+			"Managed files snapshot optimization",
 			this._managedFilesOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`Managed contexts snapshot optimization`,
+			"Managed contexts snapshot optimization",
 			this._managedContextsOptimization.getStatisticMessage()
 		);
 		logWhenMessage(
-			`Managed missing snapshot optimization`,
+			"Managed missing snapshot optimization",
 			this._managedMissingOptimization.getStatisticMessage()
 		);
 	}
 
+	/**
+	 * @param {string} path path
+	 * @param {string} reason reason
+	 * @param {any[]} args arguments
+	 */
 	_log(path, reason, ...args) {
 		const key = path + reason;
-		if (this._loggedPaths.has(key)) return;
-		this._loggedPaths.add(key);
-		this.logger.debug(`${path} invalidated because ${reason}`, ...args);
+		const loggedPaths = /** @type {LoggedPaths} */ (this._loggedPaths);
+		if (loggedPaths.has(key)) return;
+		loggedPaths.add(key);
+		/** @type {Logger} */
+		(this.logger).debug(`${path} invalidated because ${reason}`, ...args);
 		if (--this._remainingLogs === 0) {
-			this.logger.debug(
+			/** @type {Logger} */
+			(this.logger).debug(
 				"Logging limit has been reached and no further logging will be emitted by FileSystemInfo"
 			);
 		}
@@ -1180,7 +1387,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path file path
-	 * @param {function(WebpackError=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (FileSystemInfoEntry | "ignore" | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	getFileTimestamp(path, callback) {
@@ -1191,7 +1398,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	getContextTimestamp(path, callback) {
@@ -1200,10 +1407,15 @@ class FileSystemInfo {
 			if (cache === "ignore") return callback(null, "ignore");
 			const resolved = getResolvedTimestamp(cache);
 			if (resolved !== undefined) return callback(null, resolved);
-			return this._resolveContextTimestamp(cache, callback);
+			return this._resolveContextTimestamp(
+				/** @type {ResolvedContextFileSystemInfoEntry} */
+				(cache),
+				callback
+			);
 		}
-		this.contextTimestampQueue.add(path, (err, entry) => {
+		this.contextTimestampQueue.add(path, (err, _entry) => {
 			if (err) return callback(err);
+			const entry = /** @type {ContextFileSystemInfoEntry} */ (_entry);
 			const resolved = getResolvedTimestamp(entry);
 			if (resolved !== undefined) return callback(null, resolved);
 			this._resolveContextTimestamp(entry, callback);
@@ -1212,7 +1424,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (ContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextTimestamp(path, callback) {
@@ -1223,7 +1435,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path file path
-	 * @param {function(WebpackError=, string=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (string | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	getFileHash(path, callback) {
@@ -1234,27 +1446,30 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, string=): void} callback callback function
+	 * @param {function((WebpackError | null)=, string=): void} callback callback function
 	 * @returns {void}
 	 */
 	getContextHash(path, callback) {
 		const cache = this._contextHashes.get(path);
 		if (cache !== undefined) {
 			const resolved = getResolvedHash(cache);
-			if (resolved !== undefined) return callback(null, resolved);
+			if (resolved !== undefined)
+				return callback(null, /** @type {string} */ (resolved));
 			return this._resolveContextHash(cache, callback);
 		}
-		this.contextHashQueue.add(path, (err, entry) => {
+		this.contextHashQueue.add(path, (err, _entry) => {
 			if (err) return callback(err);
+			const entry = /** @type {ContextHash} */ (_entry);
 			const resolved = getResolvedHash(entry);
-			if (resolved !== undefined) return callback(null, resolved);
+			if (resolved !== undefined)
+				return callback(null, /** @type {string} */ (resolved));
 			this._resolveContextHash(entry, callback);
 		});
 	}
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, ContextHash=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (ContextHash | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextHash(path, callback) {
@@ -1265,7 +1480,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, ResolvedContextTimestampAndHash=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (ResolvedContextTimestampAndHash | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	getContextTsh(path, callback) {
@@ -1275,8 +1490,9 @@ class FileSystemInfo {
 			if (resolved !== undefined) return callback(null, resolved);
 			return this._resolveContextTsh(cache, callback);
 		}
-		this.contextTshQueue.add(path, (err, entry) => {
+		this.contextTshQueue.add(path, (err, _entry) => {
 			if (err) return callback(err);
+			const entry = /** @type {ContextTimestampAndHash} */ (_entry);
 			const resolved = getResolvedTimestamp(entry);
 			if (resolved !== undefined) return callback(null, resolved);
 			this._resolveContextTsh(entry, callback);
@@ -1285,7 +1501,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {string} path context path
-	 * @param {function(WebpackError=, ContextTimestampAndHash=): void} callback callback function
+	 * @param {function((WebpackError | null)=, (ContextTimestampAndHash | null)=): void} callback callback function
 	 * @returns {void}
 	 */
 	_getUnresolvedContextTsh(path, callback) {
@@ -1325,7 +1541,7 @@ class FileSystemInfo {
 	/**
 	 * @param {string} context context directory
 	 * @param {Iterable<string>} deps dependencies
-	 * @param {function(Error=, ResolveBuildDependenciesResult=): void} callback callback function
+	 * @param {function((Error | null)=, ResolveBuildDependenciesResult=): void} callback callback function
 	 * @returns {void}
 	 */
 	resolveBuildDependencies(context, deps, callback) {
@@ -1348,7 +1564,7 @@ class FileSystemInfo {
 		const resolveDirectories = new Set();
 		/** @type {Set<string>} */
 		const resolveMissing = new Set();
-		/** @type {Map<string, string | false>} */
+		/** @type {Map<string, string | false | undefined>} */
 		const resolveResults = new Map();
 		const invalidResolveResults = new Set();
 		const resolverContext = {
@@ -1356,9 +1572,18 @@ class FileSystemInfo {
 			contextDependencies: resolveDirectories,
 			missingDependencies: resolveMissing
 		};
-		const expectedToString = expected => {
-			return expected ? ` (expected ${expected})` : "";
-		};
+		/**
+		 * @param {undefined | boolean | string} expected expected result
+		 * @returns {string} expected result
+		 */
+		const expectedToString = expected =>
+			expected ? ` (expected ${expected})` : "";
+		/** @typedef {{ type: JobType, context: string | undefined, path: string, issuer: Job | undefined, expected: undefined | boolean | string }} Job */
+
+		/**
+		 * @param {Job} job job
+		 * @returns {`resolve commonjs file ${string}${string}`|`resolve esm file ${string}${string}`|`resolve esm ${string}${string}`|`resolve directory ${string}`|`file ${string}`|`unknown ${string} ${string}`|`resolve commonjs ${string}${string}`|`directory ${string}`|`file dependencies ${string}`|`directory dependencies ${string}`} result
+		 */
 		const jobToString = job => {
 			switch (job.type) {
 				case RBDT_RESOLVE_CJS:
@@ -1388,104 +1613,135 @@ class FileSystemInfo {
 			}
 			return `unknown ${job.type} ${job.path}`;
 		};
+		/**
+		 * @param {Job} job job
+		 * @returns {string} string value
+		 */
 		const pathToString = job => {
 			let result = ` at ${jobToString(job)}`;
-			job = job.issuer;
+			/** @type {Job | undefined} */
+			(job) = job.issuer;
 			while (job !== undefined) {
 				result += `\n at ${jobToString(job)}`;
-				job = job.issuer;
+				job = /** @type {Job} */ (job.issuer);
 			}
 			return result;
 		};
+		const logger = /** @type {Logger} */ (this.logger);
 		processAsyncTree(
-			Array.from(deps, dep => ({
-				type: RBDT_RESOLVE_CJS,
-				context,
-				path: dep,
-				expected: undefined,
-				issuer: undefined
-			})),
+			Array.from(
+				deps,
+				dep =>
+					/** @type {Job} */ ({
+						type: RBDT_RESOLVE_CJS,
+						context,
+						path: dep,
+						expected: undefined,
+						issuer: undefined
+					})
+			),
 			20,
 			(job, push, callback) => {
 				const { type, context, path, expected } = job;
+				/**
+				 * @param {string} path path
+				 * @returns {void}
+				 */
 				const resolveDirectory = path => {
 					const key = `d\n${context}\n${path}`;
 					if (resolveResults.has(key)) {
 						return callback();
 					}
 					resolveResults.set(key, undefined);
-					resolveContext(context, path, resolverContext, (err, _, result) => {
-						if (err) {
-							if (expected === false) {
-								resolveResults.set(key, false);
-								return callback();
-							}
-							invalidResolveResults.add(key);
-							err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
-							return callback(err);
-						}
-						const resultPath = result.path;
-						resolveResults.set(key, resultPath);
-						push({
-							type: RBDT_DIRECTORY,
-							context: undefined,
-							path: resultPath,
-							expected: undefined,
-							issuer: job
-						});
-						callback();
-					});
-				};
-				const resolveFile = (path, symbol, resolve) => {
-					const key = `${symbol}\n${context}\n${path}`;
-					if (resolveResults.has(key)) {
-						return callback();
-					}
-					resolveResults.set(key, undefined);
-					resolve(context, path, resolverContext, (err, _, result) => {
-						if (typeof expected === "string") {
-							if (!err && result && result.path === expected) {
-								resolveResults.set(key, result.path);
-							} else {
-								invalidResolveResults.add(key);
-								this.logger.warn(
-									`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
-										err || (result && result.path)
-									}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
-										job
-									)}`
-								);
-							}
-						} else {
+					resolveContext(
+						/** @type {string} */ (context),
+						path,
+						resolverContext,
+						(err, _, result) => {
 							if (err) {
 								if (expected === false) {
 									resolveResults.set(key, false);
 									return callback();
 								}
 								invalidResolveResults.add(key);
-								err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString(
-									job
-								)}`;
+								err.message += `\nwhile resolving '${path}' in ${context} to a directory`;
 								return callback(err);
 							}
-							const resultPath = result.path;
+							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							resolveResults.set(key, resultPath);
 							push({
-								type: RBDT_FILE,
+								type: RBDT_DIRECTORY,
 								context: undefined,
-								path: resultPath,
+								path: /** @type {string} */ (resultPath),
 								expected: undefined,
 								issuer: job
 							});
+							callback();
 						}
-						callback();
-					});
+					);
+				};
+				/**
+				 * @param {string} path path
+				 * @param {("f" | "c" | "e")=} symbol symbol
+				 * @param {(ResolveFunctionAsync)=} resolve resolve fn
+				 * @returns {void}
+				 */
+				const resolveFile = (path, symbol, resolve) => {
+					const key = `${symbol}\n${context}\n${path}`;
+					if (resolveResults.has(key)) {
+						return callback();
+					}
+					resolveResults.set(key, undefined);
+					/** @type {ResolveFunctionAsync} */
+					(resolve)(
+						/** @type {string} */ (context),
+						path,
+						resolverContext,
+						(err, _, result) => {
+							if (typeof expected === "string") {
+								if (!err && result && result.path === expected) {
+									resolveResults.set(key, result.path);
+								} else {
+									invalidResolveResults.add(key);
+									logger.warn(
+										`Resolving '${path}' in ${context} for build dependencies doesn't lead to expected result '${expected}', but to '${
+											err || (result && result.path)
+										}' instead. Resolving dependencies are ignored for this path.\n${pathToString(
+											job
+										)}`
+									);
+								}
+							} else {
+								if (err) {
+									if (expected === false) {
+										resolveResults.set(key, false);
+										return callback();
+									}
+									invalidResolveResults.add(key);
+									err.message += `\nwhile resolving '${path}' in ${context} as file\n${pathToString(
+										job
+									)}`;
+									return callback(err);
+								}
+								const resultPath = /** @type {ResolveRequest} */ (result).path;
+								resolveResults.set(key, resultPath);
+								push({
+									type: RBDT_FILE,
+									context: undefined,
+									path: /** @type {string} */ (resultPath),
+									expected: undefined,
+									issuer: job
+								});
+							}
+							callback();
+						}
+					);
 				};
 				switch (type) {
 					case RBDT_RESOLVE_CJS: {
 						const isDirectory = /[\\/]$/.test(path);
 						if (isDirectory) {
-							resolveDirectory(path.slice(0, path.length - 1));
+							resolveDirectory(path.slice(0, -1));
 						} else {
 							resolveFile(path, "f", resolveCjs);
 						}
@@ -1494,7 +1750,7 @@ class FileSystemInfo {
 					case RBDT_RESOLVE_ESM: {
 						const isDirectory = /[\\/]$/.test(path);
 						if (isDirectory) {
-							resolveDirectory(path.slice(0, path.length - 1));
+							resolveDirectory(path.slice(0, -1));
 						} else {
 							resolveFile(path);
 						}
@@ -1522,7 +1778,8 @@ class FileSystemInfo {
 							break;
 						}
 						files.add(path);
-						this.fs.realpath(path, (err, _realPath) => {
+						/** @type {NonNullable<InputFileSystem["realpath"]>} */
+						(this.fs.realpath)(path, (err, _realPath) => {
 							if (err) return callback(err);
 							const realPath = /** @type {string} */ (_realPath);
 							if (realPath !== path) {
@@ -1548,7 +1805,8 @@ class FileSystemInfo {
 							break;
 						}
 						directories.add(path);
-						this.fs.realpath(path, (err, _realPath) => {
+						/** @type {NonNullable<InputFileSystem["realpath"]>} */
+						(this.fs.realpath)(path, (err, _realPath) => {
 							if (err) return callback(err);
 							const realPath = /** @type {string} */ (_realPath);
 							if (realPath !== path) {
@@ -1575,11 +1833,11 @@ class FileSystemInfo {
 							break;
 						}
 						// Check commonjs cache for the module
-						/** @type {NodeModule} */
+						/** @type {NodeModule | undefined} */
 						const module = require.cache[path];
 						if (module && Array.isArray(module.children)) {
 							children: for (const child of module.children) {
-								let childPath = child.filename;
+								const childPath = child.filename;
 								if (childPath) {
 									push({
 										type: RBDT_FILE,
@@ -1591,7 +1849,7 @@ class FileSystemInfo {
 									const context = dirname(this.fs, path);
 									for (const modulePath of module.paths) {
 										if (childPath.startsWith(modulePath)) {
-											let subPath = childPath.slice(modulePath.length + 1);
+											const subPath = childPath.slice(modulePath.length + 1);
 											const packageMatch = /^(@[^\\/]+[\\/])[^\\/]+/.exec(
 												subPath
 											);
@@ -1599,12 +1857,12 @@ class FileSystemInfo {
 												push({
 													type: RBDT_FILE,
 													context: undefined,
-													path:
+													path: `${
 														modulePath +
 														childPath[modulePath.length] +
 														packageMatch[0] +
-														childPath[modulePath.length] +
-														"package.json",
+														childPath[modulePath.length]
+													}package.json`,
 													expected: false,
 													issuer: job
 												});
@@ -1625,7 +1883,9 @@ class FileSystemInfo {
 									let request = relative(this.fs, context, childPath);
 									if (request.endsWith(".js")) request = request.slice(0, -3);
 									request = request.replace(/\\/g, "/");
-									if (!request.startsWith("../")) request = `./${request}`;
+									if (!request.startsWith("../") && !isAbsolute(request)) {
+										request = `./${request}`;
+									}
 									push({
 										type: RBDT_RESOLVE_CJS_FILE,
 										context,
@@ -1637,7 +1897,7 @@ class FileSystemInfo {
 							}
 						} else if (supportsEsm && /\.m?js$/.test(path)) {
 							if (!this._warnAboutExperimentalEsmTracking) {
-								this.logger.log(
+								logger.log(
 									"Node.js doesn't offer a (nice) way to introspect the ESM dependency graph yet.\n" +
 										"Until a full solution is available webpack uses an experimental ESM tracking based on parsing.\n" +
 										"As best effort webpack parses the ESM files to guess dependencies. But this can lead to expensive and incorrect tracking."
@@ -1650,63 +1910,64 @@ class FileSystemInfo {
 									if (err) return callback(err);
 									try {
 										const context = dirname(this.fs, path);
-										const source = content.toString();
+										const source = /** @type {Buffer} */ (content).toString();
 										const [imports] = lexer.parse(source);
 										for (const imp of imports) {
 											try {
 												let dependency;
 												if (imp.d === -1) {
 													// import ... from "..."
-													dependency = JSON.parse(
+													dependency = parseString(
 														source.substring(imp.s - 1, imp.e + 1)
 													);
 												} else if (imp.d > -1) {
 													// import()
-													let expr = source.substring(imp.s, imp.e).trim();
-													if (expr[0] === "'")
-														expr = `"${expr
-															.slice(1, -1)
-															.replace(/"/g, '\\"')}"`;
-													dependency = JSON.parse(expr);
+													const expr = source.substring(imp.s, imp.e).trim();
+													dependency = parseString(expr);
 												} else {
 													// e.g. import.meta
 													continue;
 												}
+
+												// we should not track Node.js build dependencies
+												if (dependency.startsWith("node:")) continue;
+												if (builtinModules.has(dependency)) continue;
+
 												push({
 													type: RBDT_RESOLVE_ESM_FILE,
 													context,
 													path: dependency,
-													expected: undefined,
+													expected: imp.d > -1 ? false : undefined,
 													issuer: job
 												});
-											} catch (e) {
-												this.logger.warn(
+											} catch (err1) {
+												logger.warn(
 													`Parsing of ${path} for build dependencies failed at 'import(${source.substring(
 														imp.s,
 														imp.e
 													)})'.\n` +
 														"Build dependencies behind this expression are ignored and might cause incorrect cache invalidation."
 												);
-												this.logger.debug(pathToString(job));
-												this.logger.debug(e.stack);
+												logger.debug(pathToString(job));
+												logger.debug(/** @type {Error} */ (err1).stack);
 											}
 										}
-									} catch (e) {
-										this.logger.warn(
+									} catch (err2) {
+										logger.warn(
 											`Parsing of ${path} for build dependencies failed and all dependencies of this file are ignored, which might cause incorrect cache invalidation..`
 										);
-										this.logger.debug(pathToString(job));
-										this.logger.debug(e.stack);
+										logger.debug(pathToString(job));
+										logger.debug(/** @type {Error} */ (err2).stack);
 									}
 									process.nextTick(callback);
 								});
 							}, callback);
 							break;
 						} else {
-							this.logger.log(
+							logger.log(
 								`Assuming ${path} has no dependencies as we were unable to assign it to any module system.`
 							);
-							this.logger.debug(pathToString(job));
+							logger.debug(pathToString(job));
 						}
 						process.nextTick(callback);
 						break;
@@ -1738,9 +1999,11 @@ class FileSystemInfo {
 							resolveFiles.add(packageJson);
 							let packageData;
 							try {
-								packageData = JSON.parse(content.toString("utf-8"));
-							} catch (e) {
-								return callback(e);
+								packageData = JSON.parse(
+									/** @type {Buffer} */ (content).toString("utf-8")
+								);
+							} catch (parseErr) {
+								return callback(/** @type {Error} */ (parseErr));
 							}
 							const depsObject = packageData.dependencies;
 							const optionalDepsObject = packageData.optionalDependencies;
@@ -1797,7 +2060,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {Map<string, string | false>} resolveResults results from resolving
-	 * @param {function(Error=, boolean=): void} callback callback with true when resolveResults resolve the same way
+	 * @param {function((Error | null)=, boolean=): void} callback callback with true when resolveResults resolve the same way
 	 * @returns {void}
 	 */
 	checkResolveResultsValid(resolveResults, callback) {
@@ -1814,7 +2077,7 @@ class FileSystemInfo {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							const resultPath = result.path;
+							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
@@ -1824,7 +2087,7 @@ class FileSystemInfo {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							const resultPath = result.path;
+							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
@@ -1834,7 +2097,7 @@ class FileSystemInfo {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							const resultPath = result.path;
+							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
@@ -1844,7 +2107,7 @@ class FileSystemInfo {
 							if (expectedResult === false)
 								return callback(err ? undefined : INVALID);
 							if (err) return callback(err);
-							const resultPath = result.path;
+							const resultPath = /** @type {ResolveRequest} */ (result).path;
 							if (resultPath !== expectedResult) return callback(INVALID);
 							callback();
 						});
@@ -1871,41 +2134,38 @@ class FileSystemInfo {
 	}
 
 	/**
-	 *
-	 * @param {number} startTime when processing the files has started
-	 * @param {Iterable<string>} files all files
-	 * @param {Iterable<string>} directories all directories
-	 * @param {Iterable<string>} missing all missing files or directories
-	 * @param {Object} options options object (for future extensions)
-	 * @param {boolean=} options.hash should use hash to snapshot
-	 * @param {boolean=} options.timestamp should use timestamp to snapshot
-	 * @param {function(WebpackError=, Snapshot=): void} callback callback function
+	 * @param {number | null | undefined} startTime when processing the files has started
+	 * @param {Iterable<string> | null} files all files
+	 * @param {Iterable<string> | null} directories all directories
+	 * @param {Iterable<string> | null} missing all missing files or directories
+	 * @param {SnapshotOptions | null | undefined} options options object (for future extensions)
+	 * @param {function(WebpackError | null, Snapshot | null): void} callback callback function
 	 * @returns {void}
 	 */
 	createSnapshot(startTime, files, directories, missing, options, callback) {
-		/** @type {Map<string, FileSystemInfoEntry | null>} */
+		/** @type {FileTimestamps} */
 		const fileTimestamps = new Map();
-		/** @type {Map<string, string | null>} */
+		/** @type {FileHashes} */
 		const fileHashes = new Map();
-		/** @type {Map<string, TimestampAndHash | string | null>} */
+		/** @type {FileTshs} */
 		const fileTshs = new Map();
-		/** @type {Map<string, FileSystemInfoEntry | null>} */
+		/** @type {ContextTimestamps} */
 		const contextTimestamps = new Map();
-		/** @type {Map<string, string | null>} */
+		/** @type {ContextHashes} */
 		const contextHashes = new Map();
-		/** @type {Map<string, ResolvedContextTimestampAndHash | null>} */
+		/** @type {ContextTshs} */
 		const contextTshs = new Map();
-		/** @type {Map<string, boolean>} */
+		/** @type {MissingExistence} */
 		const missingExistence = new Map();
-		/** @type {Map<string, string>} */
+		/** @type {ManagedItemInfo} */
 		const managedItemInfo = new Map();
-		/** @type {Set<string>} */
+		/** @type {ManagedFiles} */
 		const managedFiles = new Set();
-		/** @type {Set<string>} */
+		/** @type {ManagedContexts} */
 		const managedContexts = new Set();
-		/** @type {Set<string>} */
+		/** @type {ManagedMissing} */
 		const managedMissing = new Set();
-		/** @type {Set<Snapshot>} */
+		/** @type {Children} */
 		const children = new Set();
 
 		const snapshot = new Snapshot();
@@ -1972,7 +2232,18 @@ class FileSystemInfo {
 				callback(null, null);
 			}
 		};
+		/**
+		 * @param {string} path path
+		 * @param {Set<string>} managedSet managed set
+		 * @returns {boolean} true when managed
+		 */
 		const checkManaged = (path, managedSet) => {
+			for (const unmanagedPath of this.unmanagedPathsRegExps) {
+				if (unmanagedPath.test(path)) return false;
+			}
+			for (const unmanagedPath of this.unmanagedPathsWithSlash) {
+				if (path.startsWith(unmanagedPath)) return false;
+			}
 			for (const immutablePath of this.immutablePathsRegExps) {
 				if (immutablePath.test(path)) {
 					managedSet.add(path);
@@ -1988,7 +2259,7 @@ class FileSystemInfo {
 			for (const managedPath of this.managedPathsRegExps) {
 				const match = managedPath.exec(path);
 				if (match) {
-					const managedItem = getManagedItem(managedPath[1], path);
+					const managedItem = getManagedItem(match[1], path);
 					if (managedItem) {
 						managedItems.add(managedItem);
 						managedSet.add(path);
@@ -2008,6 +2279,11 @@ class FileSystemInfo {
 			}
 			return false;
 		};
+		/**
+		 * @param {Iterable<string>} items items
+		 * @param {Set<string>} managedSet managed set
+		 * @returns {Set<string>} result
+		 */
 		const captureNonManaged = (items, managedSet) => {
 			const capturedItems = new Set();
 			for (const path of items) {
@@ -2015,8 +2291,10 @@ class FileSystemInfo {
 			}
 			return capturedItems;
 		};
-		if (files) {
-			const capturedFiles = captureNonManaged(files, managedFiles);
+		/**
+		 * @param {Set<string>} capturedFiles captured files
+		 */
+		const processCapturedFiles = capturedFiles => {
 			switch (mode) {
 				case 3:
 					this._fileTshsOptimization.optimize(snapshot, capturedFiles);
@@ -2035,7 +2313,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									fileTshs.set(path, entry);
+									fileTshs.set(path, /** @type {TimestampAndHash} */ (entry));
 									jobDone();
 								}
 							});
@@ -2059,7 +2337,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									fileHashes.set(path, entry);
+									fileHashes.set(path, /** @type {string} */ (entry));
 									jobDone();
 								}
 							});
@@ -2085,7 +2363,11 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									fileTimestamps.set(path, entry);
+									fileTimestamps.set(
+										path,
+										/** @type {FileSystemInfoEntry} */
+										(entry)
+									);
 									jobDone();
 								}
 							});
@@ -2093,18 +2375,20 @@ class FileSystemInfo {
 					}
 					break;
 			}
+		};
+		if (files) {
+			processCapturedFiles(captureNonManaged(files, managedFiles));
 		}
-		if (directories) {
-			const capturedDirectories = captureNonManaged(
-				directories,
-				managedContexts
-			);
+		/**
+		 * @param {Set<string>} capturedDirectories captured directories
+		 */
+		const processCapturedDirectories = capturedDirectories => {
 			switch (mode) {
 				case 3:
 					this._contextTshsOptimization.optimize(snapshot, capturedDirectories);
 					for (const path of capturedDirectories) {
 						const cache = this._contextTshs.get(path);
-						/** @type {ResolvedContextTimestampAndHash} */
+						/** @type {ResolvedContextTimestampAndHash | null | undefined} */
 						let resolved;
 						if (
 							cache !== undefined &&
@@ -2114,8 +2398,8 @@ class FileSystemInfo {
 						} else {
 							jobs++;
 							/**
-							 * @param {Error=} err error
-							 * @param {ResolvedContextTimestampAndHash=} entry entry
+							 * @param {(WebpackError | null)=} err error
+							 * @param {(ResolvedContextTimestampAndHash | null)=} entry entry
 							 * @returns {void}
 							 */
 							const callback = (err, entry) => {
@@ -2127,7 +2411,11 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									contextTshs.set(path, entry);
+									contextTshs.set(
+										path,
+										/** @type {ResolvedContextTimestampAndHash | null} */
+										(entry)
+									);
 									jobDone();
 								}
 							};
@@ -2154,6 +2442,10 @@ class FileSystemInfo {
 							contextHashes.set(path, resolved);
 						} else {
 							jobs++;
+							/**
+							 * @param {(WebpackError | null)=} err err
+							 * @param {string=} entry entry
+							 */
 							const callback = (err, entry) => {
 								if (err) {
 									if (this.logger) {
@@ -2163,7 +2455,7 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									contextHashes.set(path, entry);
+									contextHashes.set(path, /** @type {string} */ (entry));
 									jobDone();
 								}
 							};
@@ -2192,8 +2484,8 @@ class FileSystemInfo {
 						} else {
 							jobs++;
 							/**
-							 * @param {Error=} err error
-							 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+							 * @param {(Error | null)=} err error
+							 * @param {(FileSystemInfoEntry | "ignore" | null)=} entry entry
 							 * @returns {void}
 							 */
 							const callback = (err, entry) => {
@@ -2205,12 +2497,20 @@ class FileSystemInfo {
 									}
 									jobError();
 								} else {
-									contextTimestamps.set(path, entry);
+									contextTimestamps.set(
+										path,
+										/** @type {FileSystemInfoEntry | null} */
+										(entry)
+									);
 									jobDone();
 								}
 							};
 							if (cache !== undefined) {
-								this._resolveContextTimestamp(cache, callback);
+								this._resolveContextTimestamp(
+									/** @type {ContextFileSystemInfoEntry} */
+									(cache),
+									callback
+								);
 							} else {
 								this.getContextTimestamp(path, callback);
 							}
@@ -2218,9 +2518,16 @@ class FileSystemInfo {
 					}
 					break;
 			}
+		};
+		if (directories) {
+			processCapturedDirectories(
+				captureNonManaged(directories, managedContexts)
+			);
 		}
-		if (missing) {
-			const capturedMissing = captureNonManaged(missing, managedMissing);
+		/**
+		 * @param {Set<string>} capturedMissing captured missing
+		 */
+		const processCapturedMissing = capturedMissing => {
 			this._missingExistenceOptimization.optimize(snapshot, capturedMissing);
 			for (const path of capturedMissing) {
 				const cache = this._fileTimestamps.get(path);
@@ -2245,11 +2552,19 @@ class FileSystemInfo {
 					});
 				}
 			}
+		};
+		if (missing) {
+			processCapturedMissing(captureNonManaged(missing, managedMissing));
 		}
 		this._managedItemInfoOptimization.optimize(snapshot, managedItems);
 		for (const path of managedItems) {
 			const cache = this._managedItems.get(path);
 			if (cache !== undefined) {
+				if (!cache.startsWith("*")) {
+					managedFiles.add(join(this.fs, path, "package.json"));
+				} else if (cache === "*nested") {
+					managedMissing.add(join(this.fs, path, "package.json"));
+				}
 				managedItemInfo.set(path, cache);
 			} else {
 				jobs++;
@@ -2261,9 +2576,32 @@ class FileSystemInfo {
 							);
 						}
 						jobError();
-					} else {
+					} else if (entry) {
+						if (!entry.startsWith("*")) {
+							managedFiles.add(join(this.fs, path, "package.json"));
+						} else if (cache === "*nested") {
+							managedMissing.add(join(this.fs, path, "package.json"));
+						}
 						managedItemInfo.set(path, entry);
 						jobDone();
+					} else {
+						// Fallback to normal snapshotting
+						/**
+						 * @param {Set<string>} set set
+						 * @param {function(Set<string>): void} fn fn
+						 */
+						const process = (set, fn) => {
+							if (set.size === 0) return;
+							const captured = new Set();
+							for (const file of set) {
+								if (file.startsWith(path)) captured.add(file);
+							}
+							if (captured.size > 0) fn(captured);
+						};
+						process(managedFiles, processCapturedFiles);
+						process(managedContexts, processCapturedDirectories);
+						process(managedMissing, processCapturedMissing);
+						jobDone();
 					}
 				});
 			}
@@ -2278,10 +2616,20 @@ class FileSystemInfo {
 	 */
 	mergeSnapshots(snapshot1, snapshot2) {
 		const snapshot = new Snapshot();
-		if (snapshot1.hasStartTime() && snapshot2.hasStartTime())
-			snapshot.setStartTime(Math.min(snapshot1.startTime, snapshot2.startTime));
-		else if (snapshot2.hasStartTime()) snapshot.startTime = snapshot2.startTime;
-		else if (snapshot1.hasStartTime()) snapshot.startTime = snapshot1.startTime;
+		if (snapshot1.hasStartTime() && snapshot2.hasStartTime()) {
+			snapshot.setStartTime(
+				Math.min(
+					/** @type {NonNullable<Snapshot["startTime"]>} */
+					(snapshot1.startTime),
+					/** @type {NonNullable<Snapshot["startTime"]>} */
+					(snapshot2.startTime)
+				)
+			);
+		} else if (snapshot2.hasStartTime()) {
+			snapshot.startTime = snapshot2.startTime;
+		} else if (snapshot1.hasStartTime()) {
+			snapshot.startTime = snapshot1.startTime;
+		}
 		if (snapshot1.hasFileTimestamps() || snapshot2.hasFileTimestamps()) {
 			snapshot.setFileTimestamps(
 				mergeMaps(snapshot1.fileTimestamps, snapshot2.fileTimestamps)
@@ -2349,7 +2697,7 @@ class FileSystemInfo {
 
 	/**
 	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function(WebpackError=, boolean=): void} callback callback function
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
 	 * @returns {void}
 	 */
 	checkSnapshotValid(snapshot, callback) {
@@ -2369,12 +2717,12 @@ class FileSystemInfo {
 
 	/**
 	 * @param {Snapshot} snapshot the snapshot made
-	 * @param {function(WebpackError=, boolean=): void} callback callback function
+	 * @param {function((WebpackError | null)=, boolean=): void} callback callback function
 	 * @returns {void}
 	 */
 	_checkSnapshotValidNoCache(snapshot, callback) {
 		/** @type {number | undefined} */
-		let startTime = undefined;
+		let startTime;
 		if (snapshot.hasStartTime()) {
 			startTime = snapshot.startTime;
 		}
@@ -2393,23 +2741,27 @@ class FileSystemInfo {
 				callback(null, false);
 			}
 		};
+		/**
+		 * @param {string} path path
+		 * @param {WebpackError} err err
+		 */
 		const invalidWithError = (path, err) => {
 			if (this._remainingLogs > 0) {
-				this._log(path, `error occurred: %s`, err);
+				this._log(path, "error occurred: %s", err);
 			}
 			invalid();
 		};
 		/**
 		 * @param {string} path file path
-		 * @param {string} current current hash
-		 * @param {string} snap snapshot hash
+		 * @param {string | null} current current hash
+		 * @param {string | null} snap snapshot hash
 		 * @returns {boolean} true, if ok
 		 */
 		const checkHash = (path, current, snap) => {
 			if (current !== snap) {
 				// If hash differ it's invalid
 				if (this._remainingLogs > 0) {
-					this._log(path, `hashes differ (%s != %s)`, current, snap);
+					this._log(path, "hashes differ (%s != %s)", current, snap);
 				}
 				return false;
 			}
@@ -2437,40 +2789,38 @@ class FileSystemInfo {
 		};
 		/**
 		 * @param {string} path file path
-		 * @param {FileSystemInfoEntry} current current entry
-		 * @param {FileSystemInfoEntry} snap entry from snapshot
+		 * @param {FileSystemInfoEntry | null} c current entry
+		 * @param {FileSystemInfoEntry | null} s entry from snapshot
 		 * @param {boolean} log log reason
 		 * @returns {boolean} true, if ok
 		 */
-		const checkFile = (path, current, snap, log = true) => {
-			if (current === snap) return true;
-			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
-			if (current) {
+		const checkFile = (path, c, s, log = true) => {
+			if (c === s) return true;
+			if (!checkExistence(path, Boolean(c), Boolean(s))) return false;
+			if (c) {
 				// For existing items only
-				if (typeof startTime === "number" && current.safeTime > startTime) {
+				if (typeof startTime === "number" && c.safeTime > startTime) {
 					// If a change happened after starting reading the item
 					// this may no longer be valid
 					if (log && this._remainingLogs > 0) {
 						this._log(
 							path,
-							`it may have changed (%d) after the start time of the snapshot (%d)`,
-							current.safeTime,
+							"it may have changed (%d) after the start time of the snapshot (%d)",
+							c.safeTime,
 							startTime
 						);
 					}
 					return false;
 				}
-				if (
-					snap.timestamp !== undefined &&
-					current.timestamp !== snap.timestamp
-				) {
+				const snap = /** @type {FileSystemInfoEntry} */ (s);
+				if (snap.timestamp !== undefined && c.timestamp !== snap.timestamp) {
 					// If we have a timestamp (it was a file or symlink) and it differs from current timestamp
 					// it's invalid
 					if (log && this._remainingLogs > 0) {
 						this._log(
 							path,
-							`timestamps differ (%d != %d)`,
-							current.timestamp,
+							"timestamps differ (%d != %d)",
+							c.timestamp,
 							snap.timestamp
 						);
 					}
@@ -2481,40 +2831,41 @@ class FileSystemInfo {
 		};
 		/**
 		 * @param {string} path file path
-		 * @param {ResolvedContextFileSystemInfoEntry} current current entry
-		 * @param {ResolvedContextFileSystemInfoEntry} snap entry from snapshot
+		 * @param {ResolvedContextFileSystemInfoEntry | null} c current entry
+		 * @param {ResolvedContextFileSystemInfoEntry | null} s entry from snapshot
 		 * @param {boolean} log log reason
 		 * @returns {boolean} true, if ok
 		 */
-		const checkContext = (path, current, snap, log = true) => {
-			if (current === snap) return true;
-			if (!checkExistence(path, Boolean(current), Boolean(snap))) return false;
-			if (current) {
+		const checkContext = (path, c, s, log = true) => {
+			if (c === s) return true;
+			if (!checkExistence(path, Boolean(c), Boolean(s))) return false;
+			if (c) {
 				// For existing items only
-				if (typeof startTime === "number" && current.safeTime > startTime) {
+				if (typeof startTime === "number" && c.safeTime > startTime) {
 					// If a change happened after starting reading the item
 					// this may no longer be valid
 					if (log && this._remainingLogs > 0) {
 						this._log(
 							path,
-							`it may have changed (%d) after the start time of the snapshot (%d)`,
-							current.safeTime,
+							"it may have changed (%d) after the start time of the snapshot (%d)",
+							c.safeTime,
 							startTime
 						);
 					}
 					return false;
 				}
+				const snap = /** @type {ResolvedContextFileSystemInfoEntry} */ (s);
 				if (
 					snap.timestampHash !== undefined &&
-					current.timestampHash !== snap.timestampHash
+					c.timestampHash !== snap.timestampHash
 				) {
 					// If we have a timestampHash (it was a directory) and it differs from current timestampHash
 					// it's invalid
 					if (log && this._remainingLogs > 0) {
 						this._log(
 							path,
-							`timestamps hashes differ (%s != %s)`,
-							current.timestampHash,
+							"timestamps hashes differ (%s != %s)",
+							c.timestampHash,
 							snap.timestampHash
 						);
 					}
@@ -2524,11 +2875,16 @@ class FileSystemInfo {
 			return true;
 		};
 		if (snapshot.hasChildren()) {
+			/**
+			 * @param {(WebpackError | null)=} err err
+			 * @param {boolean=} result result
+			 * @returns {void}
+			 */
 			const childCallback = (err, result) => {
 				if (err || !result) return invalid();
-				else jobDone();
+				jobDone();
 			};
-			for (const child of snapshot.children) {
+			for (const child of /** @type {Children} */ (snapshot.children)) {
 				const cache = this._snapshotCache.get(child);
 				if (cache !== undefined) {
 					this._statTestedChildrenCached++;
@@ -2550,7 +2906,9 @@ class FileSystemInfo {
 			}
 		}
 		if (snapshot.hasFileTimestamps()) {
-			const { fileTimestamps } = snapshot;
+			const fileTimestamps =
+				/** @type {FileTimestamps} */
+				(snapshot.fileTimestamps);
 			this._statTestedEntries += fileTimestamps.size;
 			for (const [path, ts] of fileTimestamps) {
 				const cache = this._fileTimestamps.get(path);
@@ -2563,7 +2921,13 @@ class FileSystemInfo {
 					jobs++;
 					this.fileTimestampQueue.add(path, (err, entry) => {
 						if (err) return invalidWithError(path, err);
-						if (!checkFile(path, entry, ts)) {
+						if (
+							!checkFile(
+								path,
+								/** @type {FileSystemInfoEntry | null} */ (entry),
+								ts
+							)
+						) {
 							invalid();
 						} else {
 							jobDone();
@@ -2572,18 +2936,21 @@ class FileSystemInfo {
 				}
 			}
 		}
+		/**
+		 * @param {string} path file path
+		 * @param {string | null} hash hash
+		 */
 		const processFileHashSnapshot = (path, hash) => {
 			const cache = this._fileHashes.get(path);
 			if (cache !== undefined) {
 				if (cache !== "ignore" && !checkHash(path, cache, hash)) {
 					invalid();
-					return;
 				}
 			} else {
 				jobs++;
 				this.fileHashQueue.add(path, (err, entry) => {
 					if (err) return invalidWithError(path, err);
-					if (!checkHash(path, entry, hash)) {
+					if (!checkHash(path, /** @type {string} */ (entry), hash)) {
 						invalid();
 					} else {
 						jobDone();
@@ -2592,14 +2959,14 @@ class FileSystemInfo {
 			}
 		};
 		if (snapshot.hasFileHashes()) {
-			const { fileHashes } = snapshot;
+			const fileHashes = /** @type {FileHashes} */ (snapshot.fileHashes);
 			this._statTestedEntries += fileHashes.size;
 			for (const [path, hash] of fileHashes) {
 				processFileHashSnapshot(path, hash);
 			}
 		}
 		if (snapshot.hasFileTshs()) {
-			const { fileTshs } = snapshot;
+			const fileTshs = /** @type {FileTshs} */ (snapshot.fileTshs);
 			this._statTestedEntries += fileTshs.size;
 			for (const [path, tsh] of fileTshs) {
 				if (typeof tsh === "string") {
@@ -2614,7 +2981,15 @@ class FileSystemInfo {
 						jobs++;
 						this.fileTimestampQueue.add(path, (err, entry) => {
 							if (err) return invalidWithError(path, err);
-							if (!checkFile(path, entry, tsh, false)) {
+							if (
+								!checkFile(
+									path,
+									/** @type {FileSystemInfoEntry | null} */
+									(entry),
+									tsh,
+									false
+								)
+							) {
 								processFileHashSnapshot(path, tsh && tsh.hash);
 							}
 							jobDone();
@@ -2624,7 +2999,9 @@ class FileSystemInfo {
 			}
 		}
 		if (snapshot.hasContextTimestamps()) {
-			const { contextTimestamps } = snapshot;
+			const contextTimestamps =
+				/** @type {ContextTimestamps} */
+				(snapshot.contextTimestamps);
 			this._statTestedEntries += contextTimestamps.size;
 			for (const [path, ts] of contextTimestamps) {
 				const cache = this._contextTimestamps.get(path);
@@ -2641,26 +3018,41 @@ class FileSystemInfo {
 				} else {
 					jobs++;
 					/**
-					 * @param {Error=} err error
-					 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+					 * @param {(WebpackError | null)=} err error
+					 * @param {(ResolvedContextFileSystemInfoEntry | "ignore" | null)=} entry entry
 					 * @returns {void}
 					 */
 					const callback = (err, entry) => {
 						if (err) return invalidWithError(path, err);
-						if (!checkContext(path, entry, ts)) {
+						if (
+							!checkContext(
+								path,
+								/** @type {ResolvedContextFileSystemInfoEntry | null} */
+								(entry),
+								ts
+							)
+						) {
 							invalid();
 						} else {
 							jobDone();
 						}
 					};
 					if (cache !== undefined) {
-						this._resolveContextTimestamp(cache, callback);
+						this._resolveContextTimestamp(
+							/** @type {ContextFileSystemInfoEntry} */
+							(cache),
+							callback
+						);
 					} else {
 						this.getContextTimestamp(path, callback);
 					}
 				}
 			}
 		}
+		/**
+		 * @param {string} path path
+		 * @param {string | null} hash hash
+		 */
 		const processContextHashSnapshot = (path, hash) => {
 			const cache = this._contextHashes.get(path);
 			let resolved;
@@ -2670,13 +3062,17 @@ class FileSystemInfo {
 			) {
 				if (!checkHash(path, resolved, hash)) {
 					invalid();
-					return;
 				}
 			} else {
 				jobs++;
+				/**
+				 * @param {(WebpackError | null)=} err err
+				 * @param {string=} entry entry
+				 * @returns {void}
+				 */
 				const callback = (err, entry) => {
 					if (err) return invalidWithError(path, err);
-					if (!checkHash(path, entry, hash)) {
+					if (!checkHash(path, /** @type {string} */ (entry), hash)) {
 						invalid();
 					} else {
 						jobDone();
@@ -2690,14 +3086,16 @@ class FileSystemInfo {
 			}
 		};
 		if (snapshot.hasContextHashes()) {
-			const { contextHashes } = snapshot;
+			const contextHashes =
+				/** @type {ContextHashes} */
+				(snapshot.contextHashes);
 			this._statTestedEntries += contextHashes.size;
 			for (const [path, hash] of contextHashes) {
 				processContextHashSnapshot(path, hash);
 			}
 		}
 		if (snapshot.hasContextTshs()) {
-			const { contextTshs } = snapshot;
+			const contextTshs = /** @type {ContextTshs} */ (snapshot.contextTshs);
 			this._statTestedEntries += contextTshs.size;
 			for (const [path, tsh] of contextTshs) {
 				if (typeof tsh === "string") {
@@ -2710,25 +3108,46 @@ class FileSystemInfo {
 						cache !== undefined &&
 						(resolved = getResolvedTimestamp(cache)) !== undefined
 					) {
-						if (!checkContext(path, resolved, tsh, false)) {
+						if (
+							!checkContext(
+								path,
+								/** @type {ResolvedContextFileSystemInfoEntry | null} */
+								(resolved),
+								tsh,
+								false
+							)
+						) {
 							processContextHashSnapshot(path, tsh && tsh.hash);
 						}
 					} else {
 						jobs++;
 						/**
-						 * @param {Error=} err error
-						 * @param {ResolvedContextFileSystemInfoEntry=} entry entry
+						 * @param {(WebpackError | null)=} err error
+						 * @param {(ResolvedContextFileSystemInfoEntry | "ignore" | null)=} entry entry
 						 * @returns {void}
 						 */
 						const callback = (err, entry) => {
 							if (err) return invalidWithError(path, err);
-							if (!checkContext(path, entry, tsh, false)) {
+							if (
+								!checkContext(
+									path,
+									// TODO: test with `"ignore"`
+									/** @type {ResolvedContextFileSystemInfoEntry | null} */
+									(entry),
+									tsh,
+									false
+								)
+							) {
 								processContextHashSnapshot(path, tsh && tsh.hash);
 							}
 							jobDone();
 						};
 						if (cache !== undefined) {
-							this._resolveContextTimestamp(cache, callback);
+							this._resolveContextTimestamp(
+								/** @type {ContextFileSystemInfoEntry} */
+								(cache),
+								callback
+							);
 						} else {
 							this.getContextTimestamp(path, callback);
 						}
@@ -2737,7 +3156,9 @@ class FileSystemInfo {
 			}
 		}
 		if (snapshot.hasMissingExistence()) {
-			const { missingExistence } = snapshot;
+			const missingExistence =
+				/** @type {MissingExistence} */
+				(snapshot.missingExistence);
 			this._statTestedEntries += missingExistence.size;
 			for (const [path, existence] of missingExistence) {
 				const cache = this._fileTimestamps.get(path);
@@ -2763,7 +3184,9 @@ class FileSystemInfo {
 			}
 		}
 		if (snapshot.hasManagedItemInfo()) {
-			const { managedItemInfo } = snapshot;
+			const managedItemInfo =
+				/** @type {ManagedItemInfo} */
+				(snapshot.managedItemInfo);
 			this._statTestedEntries += managedItemInfo.size;
 			for (const [path, info] of managedItemInfo) {
 				const cache = this._managedItems.get(path);
@@ -2776,7 +3199,7 @@ class FileSystemInfo {
 					jobs++;
 					this.managedItemQueue.add(path, (err, entry) => {
 						if (err) return invalidWithError(path, err);
-						if (!checkHash(path, entry, info)) {
+						if (!checkHash(path, /** @type {string} */ (entry), info)) {
 							invalid();
 						} else {
 							jobDone();
@@ -2798,17 +3221,21 @@ class FileSystemInfo {
 		}
 	}
 
+	/**
+	 * @type {Processor<string, FileSystemInfoEntry>}
+	 * @private
+	 */
 	_readFileTimestamp(path, callback) {
-		this.fs.stat(path, (err, stat) => {
+		this.fs.stat(path, (err, _stat) => {
 			if (err) {
 				if (err.code === "ENOENT") {
 					this._fileTimestamps.set(path, null);
 					this._cachedDeprecatedFileTimestamps = undefined;
 					return callback(null, null);
 				}
-				return callback(err);
+				return callback(/** @type {WebpackError} */ (err));
 			}
-
+			const stat = /** @type {IStats} */ (_stat);
 			let ts;
 			if (stat.isDirectory()) {
 				ts = {
@@ -2816,7 +3243,7 @@ class FileSystemInfo {
 					timestamp: undefined
 				};
 			} else {
-				const mtime = +stat.mtime;
+				const mtime = Number(stat.mtime);
 
 				if (mtime) applyMtime(mtime);
 
@@ -2833,6 +3260,10 @@ class FileSystemInfo {
 		});
 	}
 
+	/**
+	 * @type {Processor<string, string>}
+	 * @private
+	 */
 	_readFileHash(path, callback) {
 		this.fs.readFile(path, (err, content) => {
 			if (err) {
@@ -2845,16 +3276,17 @@ class FileSystemInfo {
 					return callback(null, null);
 				}
 				if (err.code === "ERR_FS_FILE_TOO_LARGE") {
-					this.logger.warn(`Ignoring ${path} for hashing as it's very large`);
+					/** @type {Logger} */
+					(this.logger).warn(`Ignoring ${path} for hashing as it's very large`);
 					this._fileHashes.set(path, "too large");
 					return callback(null, "too large");
 				}
-				return callback(err);
+				return callback(/** @type {WebpackError} */ (err));
 			}
 
 			const hash = createHash(this._hashFunction);
 
-			hash.update(content);
+			hash.update(/** @type {string | Buffer} */ (content));
 
 			const digest = /** @type {string} */ (hash.digest("hex"));
 
@@ -2864,45 +3296,54 @@ class FileSystemInfo {
 		});
 	}
 
+	/**
+	 * @param {string} path path
+	 * @param {function(WebpackError | null, TimestampAndHash=) : void} callback callback
+	 * @private
+	 */
 	_getFileTimestampAndHash(path, callback) {
+		/**
+		 * @param {string} hash hash
+		 * @returns {void}
+		 */
 		const continueWithHash = hash => {
 			const cache = this._fileTimestamps.get(path);
 			if (cache !== undefined) {
 				if (cache !== "ignore") {
+					/** @type {TimestampAndHash} */
 					const result = {
-						...cache,
+						.../** @type {FileSystemInfoEntry} */ (cache),
 						hash
 					};
 					this._fileTshs.set(path, result);
 					return callback(null, result);
-				} else {
-					this._fileTshs.set(path, hash);
-					return callback(null, hash);
 				}
-			} else {
-				this.fileTimestampQueue.add(path, (err, entry) => {
-					if (err) {
-						return callback(err);
-					}
-					const result = {
-						...entry,
-						hash
-					};
-					this._fileTshs.set(path, result);
-					return callback(null, result);
-				});
+				this._fileTshs.set(path, hash);
+				return callback(null, /** @type {TODO} */ (hash));
 			}
+			this.fileTimestampQueue.add(path, (err, entry) => {
+				if (err) {
+					return callback(err);
+				}
+				/** @type {TimestampAndHash} */
+				const result = {
+					.../** @type {FileSystemInfoEntry} */ (entry),
+					hash
+				};
+				this._fileTshs.set(path, result);
+				return callback(null, result);
+			});
 		};
 
 		const cache = this._fileHashes.get(path);
 		if (cache !== undefined) {
-			continueWithHash(cache);
+			continueWithHash(/** @type {string} */ (cache));
 		} else {
 			this.fileHashQueue.add(path, (err, entry) => {
 				if (err) {
 					return callback(err);
 				}
-				continueWithHash(entry);
+				continueWithHash(/** @type {string} */ (entry));
 			});
 		}
 	}
@@ -2910,15 +3351,15 @@ class FileSystemInfo {
 	/**
 	 * @template T
 	 * @template ItemType
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {string} options.path path
 	 * @param {function(string): ItemType} options.fromImmutablePath called when context item is an immutable path
 	 * @param {function(string): ItemType} options.fromManagedItem called when context item is a managed path
-	 * @param {function(string, string, function(Error=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
-	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromFile called when context item is a file
-	 * @param {function(string, IStats, function(Error=, ItemType=): void): void} options.fromDirectory called when context item is a directory
+	 * @param {function(string, string, function((WebpackError | null)=, ItemType=): void): void} options.fromSymlink called when context item is a symlink
+	 * @param {function(string, IStats, function((WebpackError | null)=, (ItemType | null)=): void): void} options.fromFile called when context item is a file
+	 * @param {function(string, IStats, function((WebpackError | null)=, ItemType=): void): void} options.fromDirectory called when context item is a directory
 	 * @param {function(string[], ItemType[]): T} options.reduce called from all context items
-	 * @param {function(Error=, (T)=): void} callback callback
+	 * @param {function((Error | null)=, (T | null)=): void} callback callback
 	 */
 	_readContext(
 		{
@@ -2962,12 +3403,15 @@ class FileSystemInfo {
 					for (const managedPath of this.managedPathsRegExps) {
 						const match = managedPath.exec(path);
 						if (match) {
-							const managedItem = getManagedItem(managedPath[1], path);
+							const managedItem = getManagedItem(match[1], path);
 							if (managedItem) {
 								// construct timestampHash from managed info
 								return this.managedItemQueue.add(managedItem, (err, info) => {
 									if (err) return callback(err);
-									return callback(null, fromManagedItem(info));
+									return callback(
+										null,
+										fromManagedItem(/** @type {string} */ (info))
+									);
 								});
 							}
 						}
@@ -2979,15 +3423,20 @@ class FileSystemInfo {
 								// construct timestampHash from managed info
 								return this.managedItemQueue.add(managedItem, (err, info) => {
 									if (err) return callback(err);
-									return callback(null, fromManagedItem(info));
+									return callback(
+										null,
+										fromManagedItem(/** @type {string} */ (info))
+									);
 								});
 							}
 						}
 					}
 
-					lstatReadlinkAbsolute(this.fs, child, (err, stat) => {
+					lstatReadlinkAbsolute(this.fs, child, (err, _stat) => {
 						if (err) return callback(err);
 
+						const stat = /** @type {IStats | string} */ (_stat);
+
 						if (typeof stat === "string") {
 							return fromSymlink(child, stat, callback);
 						}
@@ -3003,27 +3452,37 @@ class FileSystemInfo {
 				},
 				(err, results) => {
 					if (err) return callback(err);
-					const result = reduce(files, results);
+					const result = reduce(files, /** @type {ItemType[]} */ (results));
 					callback(null, result);
 				}
 			);
 		});
 	}
 
+	/**
+	 * @type {Processor<string, ContextFileSystemInfoEntry>}
+	 * @private
+	 */
 	_readContextTimestamp(path, callback) {
 		this._readContext(
 			{
 				path,
-				fromImmutablePath: () => null,
+				fromImmutablePath: () =>
+					/** @type {ContextFileSystemInfoEntry | FileSystemInfoEntry | "ignore" | null} */
+					(null),
 				fromManagedItem: info => ({
 					safeTime: 0,
 					timestampHash: info
 				}),
 				fromSymlink: (file, target, callback) => {
-					callback(null, {
-						timestampHash: target,
-						symlinks: new Set([target])
-					});
+					callback(
+						null,
+						/** @type {ContextFileSystemInfoEntry} */
+						({
+							timestampHash: target,
+							symlinks: new Set([target])
+						})
+					);
 				},
 				fromFile: (file, stat, callback) => {
 					// Prefer the cached value over our new stat to report consistent results
@@ -3031,10 +3490,11 @@ class FileSystemInfo {
 					if (cache !== undefined)
 						return callback(null, cache === "ignore" ? null : cache);
 
-					const mtime = +stat.mtime;
+					const mtime = Number(stat.mtime);
 
 					if (mtime) applyMtime(mtime);
 
+					/** @type {FileSystemInfoEntry} */
 					const ts = {
 						safeTime: mtime ? mtime + FS_ACCURACY : Infinity,
 						timestamp: mtime
@@ -3052,27 +3512,42 @@ class FileSystemInfo {
 					});
 				},
 				reduce: (files, tsEntries) => {
-					let symlinks = undefined;
+					let symlinks;
 
 					const hash = createHash(this._hashFunction);
 
 					for (const file of files) hash.update(file);
 					let safeTime = 0;
-					for (const entry of tsEntries) {
-						if (!entry) {
+					for (const _e of tsEntries) {
+						if (!_e) {
 							hash.update("n");
 							continue;
 						}
-						if (entry.timestamp) {
+						const entry =
+							/** @type {FileSystemInfoEntry | ContextFileSystemInfoEntry} */
+							(_e);
+						if (/** @type {FileSystemInfoEntry} */ (entry).timestamp) {
 							hash.update("f");
-							hash.update(`${entry.timestamp}`);
-						} else if (entry.timestampHash) {
+							hash.update(
+								`${/** @type {FileSystemInfoEntry} */ (entry).timestamp}`
+							);
+						} else if (
+							/** @type {ContextFileSystemInfoEntry} */ (entry).timestampHash
+						) {
 							hash.update("d");
-							hash.update(`${entry.timestampHash}`);
+							hash.update(
+								`${/** @type {ContextFileSystemInfoEntry} */ (entry).timestampHash}`
+							);
 						}
-						if (entry.symlinks !== undefined) {
+						if (
+							/** @type {ContextFileSystemInfoEntry} */
+							(entry).symlinks !== undefined
+						) {
 							if (symlinks === undefined) symlinks = new Set();
-							addAll(entry.symlinks, symlinks);
+							addAll(
+								/** @type {ContextFileSystemInfoEntry} */ (entry).symlinks,
+								symlinks
+							);
 						}
 						if (entry.safeTime) {
 							safeTime = Math.max(safeTime, entry.safeTime);
@@ -3080,7 +3555,7 @@ class FileSystemInfo {
 					}
 
 					const digest = /** @type {string} */ (hash.digest("hex"));
-
+					/** @type {ContextFileSystemInfoEntry} */
 					const result = {
 						safeTime,
 						timestampHash: digest
@@ -3090,7 +3565,7 @@ class FileSystemInfo {
 				}
 			},
 			(err, result) => {
-				if (err) return callback(err);
+				if (err) return callback(/** @type {WebpackError} */ (err));
 				this._contextTimestamps.set(path, result);
 				this._cachedDeprecatedContextTimestamps = undefined;
 
@@ -3101,20 +3576,21 @@ class FileSystemInfo {
 
 	/**
 	 * @param {ContextFileSystemInfoEntry} entry entry
-	 * @param {function(Error=, ResolvedContextFileSystemInfoEntry=): void} callback callback
+	 * @param {function((WebpackError | null)=, (ResolvedContextFileSystemInfoEntry | "ignore" | null)=): void} callback callback
 	 * @returns {void}
 	 */
 	_resolveContextTimestamp(entry, callback) {
+		/** @type {string[]} */
 		const hashes = [];
 		let safeTime = 0;
 		processAsyncTree(
-			entry.symlinks,
+			/** @type {NonNullable<ContextHash["symlinks"]>} */ (entry.symlinks),
 			10,
 			(target, push, callback) => {
 				this._getUnresolvedContextTimestamp(target, (err, entry) => {
 					if (err) return callback(err);
 					if (entry && entry !== "ignore") {
-						hashes.push(entry.timestampHash);
+						hashes.push(/** @type {string} */ (entry.timestampHash));
 						if (entry.safeTime) {
 							safeTime = Math.max(safeTime, entry.safeTime);
 						}
@@ -3126,9 +3602,9 @@ class FileSystemInfo {
 				});
 			},
 			err => {
-				if (err) return callback(err);
+				if (err) return callback(/** @type {WebpackError} */ (err));
 				const hash = createHash(this._hashFunction);
-				hash.update(entry.timestampHash);
+				hash.update(/** @type {string} */ (entry.timestampHash));
 				if (entry.safeTime) {
 					safeTime = Math.max(safeTime, entry.safeTime);
 				}
@@ -3147,17 +3623,26 @@ class FileSystemInfo {
 		);
 	}
 
+	/**
+	 * @type {Processor<string, ContextHash>}
+	 * @private
+	 */
 	_readContextHash(path, callback) {
 		this._readContext(
 			{
 				path,
-				fromImmutablePath: () => "",
+				fromImmutablePath: () =>
+					/** @type {ContextHash} */ (/** @type {unknown} */ ("")),
 				fromManagedItem: info => info || "",
 				fromSymlink: (file, target, callback) => {
-					callback(null, {
-						hash: target,
-						symlinks: new Set([target])
-					});
+					callback(
+						null,
+						/** @type {ContextHash} */
+						({
+							hash: target,
+							symlinks: new Set([target])
+						})
+					);
 				},
 				fromFile: (file, stat, callback) =>
 					this.getFileHash(file, (err, hash) => {
@@ -3176,7 +3661,7 @@ class FileSystemInfo {
 				 * @returns {ContextHash} reduced hash
 				 */
 				reduce: (files, fileHashes) => {
-					let symlinks = undefined;
+					let symlinks;
 					const hash = createHash(this._hashFunction);
 
 					for (const file of files) hash.update(file);
@@ -3192,6 +3677,7 @@ class FileSystemInfo {
 						}
 					}
 
+					/** @type {ContextHash} */
 					const result = {
 						hash: /** @type {string} */ (hash.digest("hex"))
 					};
@@ -3199,8 +3685,9 @@ class FileSystemInfo {
 					return result;
 				}
 			},
-			(err, result) => {
-				if (err) return callback(err);
+			(err, _result) => {
+				if (err) return callback(/** @type {WebpackError} */ (err));
+				const result = /** @type {ContextHash} */ (_result);
 				this._contextHashes.set(path, result);
 				return callback(null, result);
 			}
@@ -3209,13 +3696,14 @@ class FileSystemInfo {
 
 	/**
 	 * @param {ContextHash} entry context hash
-	 * @param {function(Error=, string=): void} callback callback
+	 * @param {function(WebpackError | null, string=): void} callback callback
 	 * @returns {void}
 	 */
 	_resolveContextHash(entry, callback) {
+		/** @type {string[]} */
 		const hashes = [];
 		processAsyncTree(
-			entry.symlinks,
+			/** @type {NonNullable<ContextHash["symlinks"]>} */ (entry.symlinks),
 			10,
 			(target, push, callback) => {
 				this._getUnresolvedContextHash(target, (err, hash) => {
@@ -3230,7 +3718,7 @@ class FileSystemInfo {
 				});
 			},
 			err => {
-				if (err) return callback(err);
+				if (err) return callback(/** @type {WebpackError} */ (err));
 				const hash = createHash(this._hashFunction);
 				hash.update(entry.hash);
 				hashes.sort();
@@ -3245,15 +3733,19 @@ class FileSystemInfo {
 		);
 	}
 
+	/**
+	 * @type {Processor<string, ContextTimestampAndHash>}
+	 * @private
+	 */
 	_readContextTimestampAndHash(path, callback) {
+		/**
+		 * @param {ContextFileSystemInfoEntry | "ignore" | null} timestamp timestamp
+		 * @param {ContextHash} hash hash
+		 */
 		const finalize = (timestamp, hash) => {
 			const result =
-				timestamp === "ignore"
-					? hash
-					: {
-							...timestamp,
-							...hash
-					  };
+				/** @type {ContextTimestampAndHash} */
+				(timestamp === "ignore" ? hash : { ...timestamp, ...hash });
 			this._contextTshs.set(path, result);
 			callback(null, result);
 		};
@@ -3265,115 +3757,121 @@ class FileSystemInfo {
 			} else {
 				this.contextTimestampQueue.add(path, (err, entry) => {
 					if (err) return callback(err);
-					finalize(entry, cachedHash);
+					finalize(
+						/** @type {ContextFileSystemInfoEntry} */
+						(entry),
+						cachedHash
+					);
 				});
 			}
+		} else if (cachedTimestamp !== undefined) {
+			this.contextHashQueue.add(path, (err, entry) => {
+				if (err) return callback(err);
+				finalize(cachedTimestamp, /** @type {ContextHash} */ (entry));
+			});
 		} else {
-			if (cachedTimestamp !== undefined) {
-				this.contextHashQueue.add(path, (err, entry) => {
-					if (err) return callback(err);
-					finalize(cachedTimestamp, entry);
-				});
-			} else {
-				this._readContext(
-					{
-						path,
-						fromImmutablePath: () => null,
-						fromManagedItem: info => ({
-							safeTime: 0,
-							timestampHash: info,
-							hash: info || ""
-						}),
-						fromSymlink: (fle, target, callback) => {
-							callback(null, {
-								timestampHash: target,
-								hash: target,
-								symlinks: new Set([target])
-							});
-						},
-						fromFile: (file, stat, callback) => {
-							this._getFileTimestampAndHash(file, callback);
-						},
-						fromDirectory: (directory, stat, callback) => {
-							this.contextTshQueue.increaseParallelism();
-							this.contextTshQueue.add(directory, (err, result) => {
-								this.contextTshQueue.decreaseParallelism();
-								callback(err, result);
-							});
-						},
-						/**
-						 * @param {string[]} files files
-						 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
-						 * @returns {ContextTimestampAndHash} tsh
-						 */
-						reduce: (files, results) => {
-							let symlinks = undefined;
+			this._readContext(
+				{
+					path,
+					fromImmutablePath: () => null,
+					fromManagedItem: info => ({
+						safeTime: 0,
+						timestampHash: info,
+						hash: info || ""
+					}),
+					fromSymlink: (file, target, callback) => {
+						callback(null, {
+							timestampHash: target,
+							hash: target,
+							symlinks: new Set([target])
+						});
+					},
+					fromFile: (file, stat, callback) => {
+						this._getFileTimestampAndHash(file, callback);
+					},
+					fromDirectory: (directory, stat, callback) => {
+						this.contextTshQueue.increaseParallelism();
+						this.contextTshQueue.add(directory, (err, result) => {
+							this.contextTshQueue.decreaseParallelism();
+							callback(err, result);
+						});
+					},
+					/**
+					 * @param {string[]} files files
+					 * @param {(Partial<TimestampAndHash> & Partial<ContextTimestampAndHash> | string | null)[]} results results
+					 * @returns {ContextTimestampAndHash} tsh
+					 */
+					reduce: (files, results) => {
+						let symlinks;
 
-							const tsHash = createHash(this._hashFunction);
-							const hash = createHash(this._hashFunction);
+						const tsHash = createHash(this._hashFunction);
+						const hash = createHash(this._hashFunction);
 
-							for (const file of files) {
-								tsHash.update(file);
-								hash.update(file);
+						for (const file of files) {
+							tsHash.update(file);
+							hash.update(file);
+						}
+						let safeTime = 0;
+						for (const entry of results) {
+							if (!entry) {
+								tsHash.update("n");
+								continue;
 							}
-							let safeTime = 0;
-							for (const entry of results) {
-								if (!entry) {
-									tsHash.update("n");
-									continue;
-								}
-								if (typeof entry === "string") {
-									tsHash.update("n");
-									hash.update(entry);
-									continue;
-								}
-								if (entry.timestamp) {
-									tsHash.update("f");
-									tsHash.update(`${entry.timestamp}`);
-								} else if (entry.timestampHash) {
-									tsHash.update("d");
-									tsHash.update(`${entry.timestampHash}`);
-								}
-								if (entry.symlinks !== undefined) {
-									if (symlinks === undefined) symlinks = new Set();
-									addAll(entry.symlinks, symlinks);
-								}
-								if (entry.safeTime) {
-									safeTime = Math.max(safeTime, entry.safeTime);
-								}
-								hash.update(entry.hash);
+							if (typeof entry === "string") {
+								tsHash.update("n");
+								hash.update(entry);
+								continue;
 							}
-
-							const result = {
-								safeTime,
-								timestampHash: /** @type {string} */ (tsHash.digest("hex")),
-								hash: /** @type {string} */ (hash.digest("hex"))
-							};
-							if (symlinks) result.symlinks = symlinks;
-							return result;
+							if (entry.timestamp) {
+								tsHash.update("f");
+								tsHash.update(`${entry.timestamp}`);
+							} else if (entry.timestampHash) {
+								tsHash.update("d");
+								tsHash.update(`${entry.timestampHash}`);
+							}
+							if (entry.symlinks !== undefined) {
+								if (symlinks === undefined) symlinks = new Set();
+								addAll(entry.symlinks, symlinks);
+							}
+							if (entry.safeTime) {
+								safeTime = Math.max(safeTime, entry.safeTime);
+							}
+							hash.update(/** @type {string} */ (entry.hash));
 						}
-					},
-					(err, result) => {
-						if (err) return callback(err);
-						this._contextTshs.set(path, result);
-						return callback(null, result);
+
+						/** @type {ContextTimestampAndHash} */
+						const result = {
+							safeTime,
+							timestampHash: /** @type {string} */ (tsHash.digest("hex")),
+							hash: /** @type {string} */ (hash.digest("hex"))
+						};
+						if (symlinks) result.symlinks = symlinks;
+						return result;
 					}
-				);
-			}
+				},
+				(err, _result) => {
+					if (err) return callback(/** @type {WebpackError} */ (err));
+					const result = /** @type {ContextTimestampAndHash} */ (_result);
+					this._contextTshs.set(path, result);
+					return callback(null, result);
+				}
+			);
 		}
 	}
 
 	/**
 	 * @param {ContextTimestampAndHash} entry entry
-	 * @param {function(Error=, ResolvedContextTimestampAndHash=): void} callback callback
+	 * @param {ProcessorCallback<ResolvedContextTimestampAndHash>} callback callback
 	 * @returns {void}
 	 */
 	_resolveContextTsh(entry, callback) {
+		/** @type {string[]} */
 		const hashes = [];
+		/** @type {string[]} */
 		const tsHashes = [];
 		let safeTime = 0;
 		processAsyncTree(
-			entry.symlinks,
+			/** @type {NonNullable<ContextHash["symlinks"]>} */ (entry.symlinks),
 			10,
 			(target, push, callback) => {
 				this._getUnresolvedContextTsh(target, (err, entry) => {
@@ -3392,7 +3890,7 @@ class FileSystemInfo {
 				});
 			},
 			err => {
-				if (err) return callback(err);
+				if (err) return callback(/** @type {WebpackError} */ (err));
 				const hash = createHash(this._hashFunction);
 				const tsHash = createHash(this._hashFunction);
 				hash.update(entry.hash);
@@ -3420,13 +3918,17 @@ class FileSystemInfo {
 		);
 	}
 
+	/**
+	 * @type {Processor<string, Set<string>>}
+	 * @private
+	 */
 	_getManagedItemDirectoryInfo(path, callback) {
 		this.fs.readdir(path, (err, elements) => {
 			if (err) {
 				if (err.code === "ENOENT" || err.code === "ENOTDIR") {
 					return callback(null, EMPTY_SET);
 				}
-				return callback(err);
+				return callback(/** @type {WebpackError} */ (err));
 			}
 			const set = new Set(
 				/** @type {string[]} */ (elements).map(element =>
@@ -3437,16 +3939,20 @@ class FileSystemInfo {
 		});
 	}
 
+	/**
+	 * @type {Processor<string, string>}
+	 * @private
+	 */
 	_getManagedItemInfo(path, callback) {
 		const dir = dirname(this.fs, path);
 		this.managedItemDirectoryQueue.add(dir, (err, elements) => {
 			if (err) {
 				return callback(err);
 			}
-			if (!elements.has(path)) {
+			if (!(/** @type {Set<string>} */ (elements).has(path))) {
 				// file or directory doesn't exist
-				this._managedItems.set(path, "missing");
-				return callback(null, "missing");
+				this._managedItems.set(path, "*missing");
+				return callback(null, "*missing");
 			}
 			// something exists
 			// it may be a file or directory
@@ -3455,8 +3961,8 @@ class FileSystemInfo {
 				(path.endsWith("/node_modules") || path.endsWith("\\node_modules"))
 			) {
 				// we are only interested in existence of this special directory
-				this._managedItems.set(path, "exists");
-				return callback(null, "exists");
+				this._managedItems.set(path, "*node_modules");
+				return callback(null, "*node_modules");
 			}
 
 			// we assume it's a directory, as files shouldn't occur in managed paths
@@ -3468,27 +3974,36 @@ class FileSystemInfo {
 						this.fs.readdir(path, (err, elements) => {
 							if (
 								!err &&
-								elements.length === 1 &&
-								elements[0] === "node_modules"
+								/** @type {string[]} */ (elements).length === 1 &&
+								/** @type {string[]} */ (elements)[0] === "node_modules"
 							) {
-								// This is only a grouping folder e. g. used by yarn
+								// This is only a grouping folder e.g. used by yarn
 								// we are only interested in existence of this special directory
-								this._managedItems.set(path, "nested");
-								return callback(null, "nested");
+								this._managedItems.set(path, "*nested");
+								return callback(null, "*nested");
 							}
-							const problem = `Managed item ${path} isn't a directory or doesn't contain a package.json`;
-							this.logger.warn(problem);
-							return callback(new Error(problem));
+							/** @type {Logger} */
+							(this.logger).warn(
+								`Managed item ${path} isn't a directory or doesn't contain a package.json (see snapshot.managedPaths option)`
+							);
+							return callback();
 						});
 						return;
 					}
-					return callback(err);
+					return callback(/** @type {WebpackError} */ (err));
 				}
 				let data;
 				try {
-					data = JSON.parse(content.toString("utf-8"));
-				} catch (e) {
-					return callback(e);
+					data = JSON.parse(/** @type {Buffer} */ (content).toString("utf-8"));
+				} catch (parseErr) {
+					return callback(/** @type {WebpackError} */ (parseErr));
+				}
+				if (!data.name) {
+					/** @type {Logger} */
+					(this.logger).warn(
+						`${packageJsonPath} doesn't contain a "name" property (see snapshot.managedPaths option)`
+					);
+					return callback();
 				}
 				const info = `${data.name || ""}@${data.version || ""}`;
 				this._managedItems.set(path, info);