webpack 5.112.0 → 5.112.1

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

@@ -189,6 +189,7 @@ const { toError } = ErrorHelpers;
  * @import {
  * 	StatsAsset,
  * 	StatsError,
+ * 	StatsJsonValue,
  * 	StatsModule
  * } from "./stats/DefaultStatsFactoryPlugin"
  */
@@ -247,7 +248,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 +528,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 +634,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 +664,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 +921,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 +1864,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 +2565,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 +2983,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 +3026,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 +3046,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 +3068,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 +3077,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 +3117,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 +3210,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 +3263,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 +3275,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 +3319,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 +3529,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 +3591,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 +3678,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 +3691,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 +3728,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 +4433,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 +4802,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 +4830,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 +5360,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 +5503,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>} */

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();
 		});

package/lib/asset/AssetBytesGenerator.js

@@ -20,6 +20,7 @@ const {
 const ConcatenationScope = require("../optimize/ConcatenationScope");
 const RuntimeGlobals = require("../runtime/RuntimeGlobals");
 
+/** @import { AssetNormalModule } from "./AssetModule" */
 /** @import { Source } from "webpack-sources" */
 /** @import { GenerateContext } from "../module/Generator" */
 /**
@@ -30,8 +31,15 @@ const RuntimeGlobals = require("../runtime/RuntimeGlobals");
  * } from "../module/Module"
  */
 /** @import ModuleGraph from "../graph/ModuleGraph" */
-/** @import NormalModule from "../module/NormalModule" */
 
+/**
+ * The module type the JSDoc inherited from `Generator` names.
+ * @typedef {AssetNormalModule} TModule
+ */
+
+/**
+ * @extends {Generator<TModule>}
+ */
 class AssetBytesGenerator extends Generator {
 	/**
 	 * Creates an instance of AssetBytesGenerator.
@@ -46,7 +54,7 @@ class AssetBytesGenerator extends Generator {
 
 	/**
 	 * Generates generated code for this runtime module.
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -107,7 +115,7 @@ class AssetBytesGenerator extends Generator {
 	/**
 	 * Generates fallback output for the provided error condition.
 	 * @param {Error} error the error
-	 * @param {NormalModule} module module for which the code should be generated
+	 * @param {TModule} module module for which the code should be generated
 	 * @param {GenerateContext} generateContext context for generate
 	 * @returns {Source | null} generated code
 	 */
@@ -129,7 +137,7 @@ class AssetBytesGenerator extends Generator {
 
 	/**
 	 * Returns the reason this module cannot be concatenated, when one exists.
-	 * @param {NormalModule} module module for which the bailout reason should be determined
+	 * @param {TModule} module module for which the bailout reason should be determined
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -139,7 +147,7 @@ class AssetBytesGenerator extends Generator {
 
 	/**
 	 * Returns the source types available for this module.
-	 * @param {NormalModule} module fresh module
+	 * @param {TModule} module fresh module
 	 * @returns {SourceTypes} available types (do not mutate)
 	 */
 	getTypes(module) {
@@ -179,7 +187,7 @@ class AssetBytesGenerator extends Generator {
 
 	/**
 	 * Returns the estimated size for the requested source type.
-	 * @param {NormalModule} module the module
+	 * @param {TModule} module the module
 	 * @param {SourceType=} type source type
 	 * @returns {number} estimate size of the module
 	 */

package/lib/asset/AssetBytesParser.js

@@ -7,9 +7,12 @@
 
 const Parser = require("../module/Parser");
 
-/** @import { BuildInfo, BuildMeta } from "../module/Module" */
+/** @import { BuiltAssetModule } from "./AssetModule" */
 /** @import { ParserState, PreparsedAst } from "../module/Parser" */
 
+/**
+ * @extends {Parser<BuiltAssetModule>}
+ */
 class AssetBytesParser extends Parser {
 	/**
 	 * Parses the provided source and updates the parser state.
@@ -21,13 +24,12 @@ class AssetBytesParser extends Parser {
 		if (typeof source === "object" && !Buffer.isBuffer(source)) {
 			throw new Error("AssetBytesParser doesn't accept preparsed AST");
 		}
-		const { module } = state;
-		/** @type {BuildInfo} */
-		(module.buildInfo).strict = true;
-		/** @type {BuildMeta} */
-		(module.buildMeta).exportsType = "default";
-		/** @type {BuildMeta} */
-		(state.module.buildMeta).defaultObject = false;
+		const { buildInfo, buildMeta } = /** @type {BuiltAssetModule} */ (
+			state.module
+		);
+		buildInfo.strict = true;
+		buildMeta.exportsType = "default";
+		buildMeta.defaultObject = false;
 
 		return state;
 	}