webpack 5.112.0 → 5.112.2

package/bin/webpack.js

@@ -4,11 +4,21 @@
 
 // Cache compiled module bytecode on disk (available since Node.js 22.8)
 // eslint-disable-next-line n/no-unsupported-features/node-builtins
-const { enableCompileCache } = require("module");
+const { constants, enableCompileCache } = require("module");
 
 if (enableCompileCache) {
 	try {
-		enableCompileCache();
+		const { status, directory } = enableCompileCache();
+		// Minimizer workers and other child processes start without the cache;
+		// the variable Node reads at startup hands them the same directory. Only a
+		// fresh start returns the base directory, which children tag by version.
+		if (
+			// eslint-disable-next-line n/no-unsupported-features/node-builtins
+			status === constants.compileCacheStatus.ENABLED &&
+			process.env.NODE_COMPILE_CACHE === undefined
+		) {
+			process.env.NODE_COMPILE_CACHE = directory;
+		}
 	} catch (_error) {
 		// Nothing
 	}
@@ -190,11 +200,7 @@ if (!cli.installed) {
 			}')...`
 		);
 
-		runCommand(
-			/** @type {string} */
-			(packageManager),
-			[...installOptions, cli.package]
-		)
+		runCommand(packageManager, [...installOptions, cli.package])
 			.then(() => {
 				runCli(cli);
 			})

package/lib/Compilation.js

@@ -36,6 +36,7 @@ const { LogType, Logger } = require("./logging/Logger");
 const CodeGenerationResults = require("./module/CodeGenerationResults");
 const Module = require("./module/Module");
 const ModuleProfile = require("./module/ModuleProfile");
+const { JAVASCRIPT_TYPE } = require("./module/ModuleSourceTypeConstants");
 const LazyBarrels = require("./optimize/LazyBarrels");
 const RuntimeGlobals = require("./runtime/RuntimeGlobals");
 const Stats = require("./stats/Stats");
@@ -189,6 +190,7 @@ const { toError } = ErrorHelpers;
  * @import {
  * 	StatsAsset,
  * 	StatsError,
+ * 	StatsJsonValue,
  * 	StatsModule
  * } from "./stats/DefaultStatsFactoryPlugin"
  */
@@ -247,7 +249,7 @@ const { toError } = ErrorHelpers;
  * @returns {void}
  */
 
-/** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DependencyConstructor */
+/** @typedef {abstract new (...args: never[]) => Dependency} DependencyConstructor */
 
 /** @typedef {Record<string, Source>} CompilationAssets */
 
@@ -527,7 +529,7 @@ const { toError } = ErrorHelpers;
  * @property {false | "none" | "error" | "warn" | "info" | "log" | "verbose"} logging
  * @property {((value: string) => boolean)[]} loggingDebug
  * @property {boolean} loggingTrace
- * @property {EXPECTED_ANY} _env
+ * @property {StatsJsonValue} _env
  */
 
 /** @typedef {KnownNormalizedStatsOptions & Omit<StatsOptions, keyof KnownNormalizedStatsOptions> & Record<string, EXPECTED_ANY>} NormalizedStatsOptions */
@@ -633,11 +635,19 @@ const unsafeCacheData = new WeakMap();
 const dependencyReportCacheTokens = new WeakMap();
 
 /**
- * Modules known to have no dependency errors/warnings, per cache token.
- * @type {WeakMap<DependencyReportCacheToken, WeakSet<Module>>}
+ * Modules known to have no dependency errors/warnings, per cache token, with
+ * the deferred requests they were checked with (`true` for none).
+ * @type {WeakMap<DependencyReportCacheToken, WeakMap<Module, string | true>>}
  */
 const modulesWithoutProblems = new WeakMap();
 
+/**
+ * How many connections each stored reference map holds, so a module whose
+ * connection is gone or new, not only one pointing elsewhere, counts as affected.
+ * @type {WeakMap<WeakReferences, number>}
+ */
+const referenceCounts = new WeakMap();
+
 /**
  * Reduce affect type.
  * @param {Readonly<ModuleGraphConnection[]>} connections connections
@@ -655,9 +665,13 @@ const reduceAffectType = (connections) => {
 	return affected;
 };
 
-/** @typedef {{ id: ModuleId, modules?: Map<Module, string>, blocks?: (ChunkId | null)[], sourceTypes?: SourceTypes }} References */
+/** @typedef {{ id: ModuleId, modules?: Map<Module, string>, blocks?: (ChunkId | null)[], sourceTypes?: SourceTypes, chunkSourceTypes?: string }} References */
 /** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
-/** @typedef {{ chunk: Chunk, load: () => Promise<EXPECTED_ANY>, create: (loaded: EXPECTED_ANY) => RuntimeModule, chunkGraph: ChunkGraph }} PendingRuntimeModule */
+/**
+ * A queued lazy runtime module; `create` takes exactly what its own `load`
+ * resolves, which differs per entry.
+ * @typedef {{ chunk: Chunk, load: () => Promise<EXPECTED_OBJECT>, create: (loaded: never) => RuntimeModule, chunkGraph: ChunkGraph }} PendingRuntimeModule
+ */
 
 class Compilation {
 	/**
@@ -908,7 +922,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						processAssetsHook.tapAsync(
 							getOptions(options),
 							(assets, callback) =>
-								/** @type {EXPECTED_ANY} */ (fn)(...getArgs(), callback)
+								/** @type {(...args: [...AsArray<T>, typeof callback]) => void} */ (
+									/** @type {typeof fn | ((...args: [...AsArray<T>, typeof callback]) => void)} */ (
+										fn
+									)
+								)(...getArgs(), callback)
 						);
 					},
 					/** @type {AsyncSeriesHook<T>["tapPromise"]} */
@@ -1847,8 +1865,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					this.options,
 					this,
 					this.resolverFactory.get("normal", module.resolveOptions),
-					/** @type {InputFileSystem} */
-					(this.inputFileSystem),
+					this.inputFileSystem,
 					(err) => {
 						if (currentProfile !== undefined) {
 							currentProfile.markBuildingEnd();
@@ -2549,9 +2566,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						module.restoreFromUnsafeCache &&
 						this._unsafeCachePredicate(module)
 					) {
-						const unsafeCacheableModule =
-							/** @type {ModuleWithRestoreFromUnsafeCache} */
-							(module);
+						const unsafeCacheableModule = module;
 						for (const dependency of dependencies) {
 							moduleGraph.setResolvedModule(
 								connectOrigin ? originModule : null,
@@ -2969,6 +2984,18 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		});
 	}
 
+	/**
+	 * Returns the requests a lazy barrel still defers, which neither render nor
+	 * report what they would once requested, though no connection changes.
+	 * @private
+	 * @param {Module} module the module
+	 * @returns {string | undefined} the deferred requests as one key, if any
+	 */
+	_getLazyRequests(module) {
+		const lazyRequests = this._lazyBarrels.getLazyRequests(module);
+		return lazyRequests && JSON.stringify([...lazyRequests]);
+	}
+
 	/**
 	 * Compute affected modules.
 	 * @private
@@ -3000,13 +3027,16 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		const computeReferences = (module) => {
 			/** @type {WeakReferences | undefined} */
 			let references;
+			let count = 0;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
 				const m = connection.module;
 				if (!d || !m || unsafeCacheDependencies.has(d)) continue;
 				if (references === undefined) references = new WeakMap();
 				references.set(d, m);
+				count++;
 			}
+			if (references !== undefined) referenceCounts.set(references, count);
 			return references;
 		};
 
@@ -3017,15 +3047,21 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @returns {boolean} true, when the references differ
 		 */
 		const compareReferences = (module, references) => {
-			if (references === undefined) return true;
+			let count = 0;
 			for (const connection of moduleGraph.getOutgoingConnections(module)) {
 				const d = connection.dependency;
 				if (!d) continue;
-				const entry = references.get(d);
-				if (entry === undefined) continue;
-				if (entry !== connection.module) return false;
+				const entry = references === undefined ? undefined : references.get(d);
+				if (entry === connection.module) {
+					count++;
+				} else if (entry !== undefined || !unsafeCacheDependencies.has(d)) {
+					return false;
+				}
 			}
-			return true;
+			return (
+				count ===
+				(references === undefined ? 0 : referenceCounts.get(references))
+			);
 		};
 
 		const modulesWithoutCache = new Set(modules);
@@ -3033,6 +3069,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			if (modulesWithoutCache.has(module)) {
 				const buildInfo = module.buildInfo;
 				if (buildInfo) {
+					const lazyRequests = this._getLazyRequests(module);
 					if (cachedMemCache.buildInfo !== buildInfo) {
 						// use a new one
 						/** @type {MemCache} */
@@ -3041,15 +3078,20 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						affectedModules.add(module);
 						cachedMemCache.buildInfo = buildInfo;
 						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.lazyRequests = lazyRequests;
 						cachedMemCache.memCache = memCache;
 						statChanged++;
-					} else if (!compareReferences(module, cachedMemCache.references)) {
+					} else if (
+						!compareReferences(module, cachedMemCache.references) ||
+						cachedMemCache.lazyRequests !== lazyRequests
+					) {
 						// use a new one
 						/** @type {MemCache} */
 						const memCache = new WeakTupleMap();
 						moduleMemCaches.set(module, memCache);
 						affectedModules.add(module);
 						cachedMemCache.references = computeReferences(module);
+						cachedMemCache.lazyRequests = lazyRequests;
 						cachedMemCache.memCache = memCache;
 						statReferencesChanged++;
 					} else {
@@ -3076,6 +3118,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				moduleMemCacheCache.set(module, {
 					buildInfo,
 					references: computeReferences(module),
+					lazyRequests: this._getLazyRequests(module),
 					memCache
 				});
 				moduleMemCaches.set(module, memCache);
@@ -3168,6 +3211,17 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 			return key;
 		};
+		/**
+		 * Key the source types the chunk graph overrides for the module, which module concatenation narrows for an inner module that keeps other source types.
+		 * @param {Module} module module
+		 * @returns {string | undefined} key, undefined when the module's own source types stand
+		 */
+		const chunkSourceTypesKey = (module) => {
+			const sourceTypes = chunkGraph.getModuleSourceTypes(module);
+			return sourceTypes === module.getSourceTypes()
+				? undefined
+				: [...sourceTypes].join();
+		};
 		/**
 		 * Compute references.
 		 * @param {Module} module module
@@ -3210,7 +3264,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				id,
 				modules,
 				blocks,
-				sourceTypes: module.getReferencedSourceTypes()
+				sourceTypes: module.getReferencedSourceTypes(),
+				chunkSourceTypes: chunkSourceTypesKey(module)
 			};
 		};
 		/**
@@ -3221,11 +3276,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {Map<Module, string>=} references.modules modules
 		 * @param {(string | number | null)[]=} references.blocks blocks
 		 * @param {SourceTypes=} references.sourceTypes connection-dependent source types
+		 * @param {string=} references.chunkSourceTypes key of the source types the chunk graph overrides
 		 * @returns {boolean} ok?
 		 */
 		const compareReferences = (
 			module,
-			{ id, modules, blocks, sourceTypes }
+			{ id, modules, blocks, sourceTypes, chunkSourceTypes }
 		) => {
 			if (id !== chunkGraph.getModuleId(module)) return false;
 			if (modules !== undefined) {
@@ -3264,6 +3320,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			) {
 				return false;
 			}
+			if (chunkSourceTypesKey(module) !== chunkSourceTypes) return false;
 			return true;
 		};
 
@@ -3473,20 +3530,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					if (d === 0 || p === 0) continue;
 					const t = d / p;
 					sum += t;
-					if (t <= 10) continue;
+					/* istanbul ignore next -- @preserve: only slow (>10ms) modules are logged, timing-dependent */
+					if (t > 10) {
+						logByValue(
+							t,
+							` | ${Math.round(t)} ms${
+								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
+							} ${category} > ${module.readableIdentifier(this.requestShortener)}`
+						);
+						max = Math.max(max, t);
+					}
+				}
+				/* istanbul ignore next -- @preserve: only slow (>10ms) categories are logged, timing-dependent */
+				if (sum > 10) {
 					logByValue(
-						t,
-						` | ${Math.round(t)} ms${
-							p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-						} ${category} > ${module.readableIdentifier(this.requestShortener)}`
+						Math.max(sum / 10, max),
+						`${Math.round(sum)} ms ${category}`
 					);
-					max = Math.max(max, t);
 				}
-				if (sum <= 10) return;
-				logByValue(
-					Math.max(sum / 10, max),
-					`${Math.round(sum)} ms ${category}`
-				);
 			};
 			/**
 			 * Log by loaders summary.
@@ -3531,30 +3592,34 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						}
 					}
 					sum += innerSum;
-					if (innerSum <= 10) continue;
-					const idx = key.indexOf("!");
-					const loaders = key.slice(idx + 1);
-					const moduleType = key.slice(0, idx);
-					const t = Math.max(innerSum / 10, innerMax);
+					/* istanbul ignore next -- @preserve: only slow (>10ms) loader groups are logged, timing-dependent */
+					if (innerSum > 10) {
+						const idx = key.indexOf("!");
+						const loaders = key.slice(idx + 1);
+						const moduleType = key.slice(0, idx);
+						const t = Math.max(innerSum / 10, innerMax);
+						logByValue(
+							t,
+							` | ${Math.round(innerSum)} ms ${category} > ${
+								loaders
+									? `${
+											modules.length
+										} x ${moduleType} with ${this.requestShortener.shorten(
+											loaders
+										)}`
+									: `${modules.length} x ${moduleType}`
+							}`
+						);
+						max = Math.max(max, t);
+					}
+				}
+				/* istanbul ignore next -- @preserve: only slow (>10ms) categories are logged, timing-dependent */
+				if (sum > 10) {
 					logByValue(
-						t,
-						` | ${Math.round(innerSum)} ms ${category} > ${
-							loaders
-								? `${
-										modules.length
-									} x ${moduleType} with ${this.requestShortener.shorten(
-										loaders
-									)}`
-								: `${modules.length} x ${moduleType}`
-						}`
+						Math.max(sum / 10, max),
+						`${Math.round(sum)} ms ${category}`
 					);
-					max = Math.max(max, t);
 				}
-				if (sum <= 10) return;
-				logByValue(
-					Math.max(sum / 10, max),
-					`${Math.round(sum)} ms ${category}`
-				);
 			};
 			logNormalSummary(
 				"resolve to new modules",
@@ -3614,7 +3679,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					continue;
 				}
 				let token;
+				/** @type {string | true} */
+				let clean = true;
 				if (useReportCacheTokens) {
+					// a request leaving a lazy barrel reports without any rebuild
+					const lazyRequests = this._getLazyRequests(module);
+					if (lazyRequests !== undefined) clean = lazyRequests;
 					token = dependencyReportCacheTokens.get(module);
 					const cleanModules = modulesWithoutProblems.get(
 						/** @type {DependencyReportCacheToken} */ (token)
@@ -3622,7 +3692,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					if (
 						!unresolved &&
 						cleanModules !== undefined &&
-						cleanModules.has(module)
+						cleanModules.get(module) === clean
 					) {
 						continue;
 					}
@@ -3659,10 +3729,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						if (cleanModules === undefined) {
 							modulesWithoutProblems.set(
 								/** @type {DependencyReportCacheToken} */ (token),
-								(cleanModules = new WeakSet())
+								(cleanModules = new WeakMap())
 							);
 						}
-						cleanModules.add(module);
+						cleanModules.set(module, clean);
 					}
 				}
 			}
@@ -4364,8 +4434,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 							if (!referencedModule) return false;
 							return (
 								notCodeGeneratedModules === undefined ||
-								/** @type {NotCodeGeneratedModules} */
-								(notCodeGeneratedModules).has(referencedModule)
+								notCodeGeneratedModules.has(referencedModule)
 							);
 						})
 					) {
@@ -4734,7 +4803,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 	 * is over. `runtimeRequirementInTree` is a sync hook, so a tap cannot await
 	 * the load itself; anything the tap reads off the requirement set must be
 	 * captured before queueing, since `create` runs later.
-	 * @template T
+	 * @template {object} T
 	 * @param {Chunk} chunk target chunk
 	 * @param {() => Promise<T>} load resolves the runtime module implementation
 	 * @param {(loaded: T) => RuntimeModule} create builds the runtime module from it
@@ -4762,7 +4831,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			.then((loaded) => {
 				for (let i = 0; i < pending.length; i++) {
 					const { chunk, create, chunkGraph } = pending[i];
-					this.addRuntimeModule(chunk, create(loaded[i]), chunkGraph);
+					this.addRuntimeModule(
+						chunk,
+						create(/** @type {never} */ (loaded[i])),
+						chunkGraph
+					);
 				}
 			})
 			// a `runtimeModule` tap may have queued more
@@ -5288,7 +5361,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 
 	createHash() {
 		this.logger.time("hashing: initialize hash");
-		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunkGraph = this.chunkGraph;
 		const runtimeTemplate = this.runtimeTemplate;
 		const outputOptions = this.outputOptions;
 		const hashFunction = outputOptions.hashFunction;
@@ -5431,6 +5504,26 @@ This prevents using hashes of each other and should be avoided.`);
 			this.warnings.push(err);
 			for (const i of circularRuntimeChunkInfo) runtimeChunks.push(i.chunk);
 		}
+		// An ESM entry chunk imports the chunks of the entrypoints it depends on
+		// (`dependOn`) by hashed filename, so their entry chunks are hashed first.
+		/** @type {Set<Chunk>} */
+		const unorderedEntryChunks = new Set(entryChunks);
+		entryChunks.length = 0;
+		/**
+		 * Adds an entry chunk after the entry chunks of its parent entrypoints.
+		 * @param {Chunk} chunk the entry chunk
+		 * @returns {void}
+		 */
+		const addEntryChunk = (chunk) => {
+			if (!unorderedEntryChunks.delete(chunk)) return;
+			for (const group of chunk.groupsIterable) {
+				for (const parent of group.parentsIterable) {
+					for (const c of parent.chunks) addEntryChunk(c);
+				}
+			}
+			entryChunks.push(chunk);
+		};
+		for (const chunk of unorderedEntryChunks) addEntryChunk(chunk);
 		this.logger.timeEnd("hashing: sort chunks");
 
 		/** @type {Set<Chunk>} */
@@ -6323,6 +6416,16 @@ This prevents using hashes of each other and should be avoided.`);
 					chunkGraph.connectChunkAndModule(chunk, module);
 				}
 
+				// The loader reads `module` as JavaScript, a consumer only this chunk graph has.
+				const sourceTypes = module.getSourceTypes();
+				if (!sourceTypes.has(JAVASCRIPT_TYPE)) {
+					chunkGraph.setChunkModuleSourceTypes(
+						chunk,
+						module,
+						new Set([...sourceTypes, JAVASCRIPT_TYPE])
+					);
+				}
+
 				/** @type {WebpackError[]} */
 				const errors = [];
 
@@ -6379,8 +6482,42 @@ This prevents using hashes of each other and should be avoided.`);
 					}
 				};
 
+				/**
+				 * Generates code for modules, each after the ones its `codeGenerationDependencies` read.
+				 * @param {Module[]} pending modules whose code is not generated yet
+				 * @param {Callback} callback callback
+				 * @returns {void}
+				 */
+				const codeGenInOrder = (pending, callback) => {
+					const pendingSet = new Set(pending);
+					/** @type {Module[]} */
+					const ready = [];
+					/** @type {Module[]} */
+					const delayed = [];
+					for (const module of pending) {
+						const { codeGenerationDependencies } = module;
+						const waits =
+							codeGenerationDependencies !== undefined &&
+							codeGenerationDependencies.some((dep) => {
+								const referencedModule = this.moduleGraph.getModule(dep);
+								return (
+									referencedModule !== null && pendingSet.has(referencedModule)
+								);
+							});
+						(waits ? delayed : ready).push(module);
+					}
+					// A cycle never frees a module, so generate them all and let templates report.
+					if (ready.length === 0) {
+						return asyncLib.eachLimit(pending, 10, codeGen, callback);
+					}
+					asyncLib.eachLimit(ready, 10, codeGen, (err) => {
+						if (err || delayed.length === 0) return callback(err);
+						codeGenInOrder(delayed, callback);
+					});
+				};
+
 				// Generate code for all aggregated modules
-				asyncLib.eachLimit(modules, 10, codeGen, (err) => {
+				codeGenInOrder([...modules], (err) => {
 					if (err) return callback(err);
 					reportErrors();
 

package/lib/Compiler.js

@@ -140,7 +140,7 @@ const getConcurrentCompilationError = memoize(() =>
 
 /** @typedef {WeakMap<Dependency, Module>} WeakReferences */
 /** @typedef {import("./util/WeakTupleMap")<EXPECTED_ANY[], EXPECTED_ANY>} MemCache */
-/** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, memCache: MemCache }} ModuleMemCachesItem */
+/** @typedef {{ buildInfo: BuildInfo, references: WeakReferences | undefined, lazyRequests: string | undefined, memCache: MemCache }} ModuleMemCachesItem */
 
 /**
  * Checks whether this object is sorted.
@@ -925,11 +925,9 @@ ${other}`);
 							if (targetFileGeneration === undefined) {
 								const newGeneration = 1;
 								this._assetEmittingWrittenFiles.set(targetPath, newGeneration);
-								/** @type {CacheEntry} */
-								(cacheEntry).writtenTo.set(targetPath, newGeneration);
+								cacheEntry.writtenTo.set(targetPath, newGeneration);
 							} else {
-								/** @type {CacheEntry} */
-								(cacheEntry).writtenTo.set(targetPath, targetFileGeneration);
+								cacheEntry.writtenTo.set(targetPath, targetFileGeneration);
 							}
 							callback();
 						};
@@ -957,8 +955,7 @@ ${other}`);
 										targetFileGeneration === undefined
 											? 1
 											: targetFileGeneration + 1;
-									/** @type {CacheEntry} */
-									(cacheEntry).writtenTo.set(targetPath, newGeneration);
+									cacheEntry.writtenTo.set(targetPath, newGeneration);
 									this._assetEmittingWrittenFiles.set(
 										targetPath,
 										newGeneration
@@ -983,11 +980,7 @@ ${other}`);
 						 * @param {number} size size
 						 */
 						const updateWithReplacementSource = (size) => {
-							updateFileWithReplacementSource(
-								file,
-								/** @type {CacheEntry} */ (cacheEntry),
-								size
-							);
+							updateFileWithReplacementSource(file, cacheEntry, size);
 							/** @type {SimilarEntry} */
 							(similarEntry).size = size;
 							if (
@@ -1055,7 +1048,7 @@ ${other}`);
 						const processExistingFile = (stats) => {
 							// skip emitting if it's already there and an immutable file
 							if (immutable) {
-								updateWithReplacementSource(/** @type {number} */ (stats.size));
+								updateWithReplacementSource(stats.size);
 								return keepExistingFile(stats);
 							}
 
@@ -1095,9 +1088,7 @@ ${other}`);
 						// if the target file has already been written
 						if (targetFileGeneration !== undefined) {
 							// check if the Source has been written to this target file
-							const writtenGeneration = /** @type {CacheEntry} */ (
-								cacheEntry
-							).writtenTo.get(targetPath);
+							const writtenGeneration = cacheEntry.writtenTo.get(targetPath);
 							if (writtenGeneration === targetFileGeneration) {
 								// if yes, we may skip writing the file
 								// if it's already there
@@ -1105,7 +1096,7 @@ ${other}`);
 
 								if (this._assetEmittingPreviousFiles.has(targetPath)) {
 									const sizeOnlySource = /** @type {SizeOnlySource} */ (
-										/** @type {CacheEntry} */ (cacheEntry).sizeOnlySource
+										cacheEntry.sizeOnlySource
 									);
 
 									// We assume that assets from the last compilation say intact on disk (they are not removed)
@@ -1209,8 +1200,7 @@ ${other}`);
 					)
 				);
 			}
-			/** @type {NonNullable<OutputFileSystem["utimes"]>} */
-			(fs.utimes)(
+			fs.utimes(
 				targetPath,
 				new Date(timestamps.atime),
 				new Date(timestamps.mtime),
@@ -1226,8 +1216,7 @@ ${other}`);
 				)
 			);
 		}
-		/** @type {NonNullable<OutputFileSystem["chmod"]>} */
-		(fs.chmod)(targetPath, mode, setTimestamps);
+		fs.chmod(targetPath, mode, setTimestamps);
 	}
 
 	/**
@@ -1282,13 +1271,11 @@ ${other}`);
 
 		const replace = () => {
 			if (!fs.unlink) return create();
-			/** @type {NonNullable<OutputFileSystem["unlink"]>} */
-			(fs.unlink)(targetPath, () => create());
+			fs.unlink(targetPath, () => create());
 		};
 
 		if (!fs.readlink) return replace();
-		/** @type {NonNullable<OutputFileSystem["readlink"]>} */
-		(fs.readlink)(targetPath, (err, existingTarget) => {
+		fs.readlink(targetPath, (err, existingTarget) => {
 			if (!err && existingTarget === target) return callback(null);
 			replace();
 		});