webpack 5.111.1 → 5.112.1

package/lib/Compilation.js

@@ -17,39 +17,35 @@ const {
 	SyncWaterfallHook
 } = require("tapable");
 const { CachedSource } = require("webpack-sources");
-const { MultiItemCache } = require("./CacheFacade");
-const Chunk = require("./Chunk");
-const ChunkGraph = require("./ChunkGraph");
-const ChunkGroup = require("./ChunkGroup");
-const ChunkTemplate = require("./ChunkTemplate");
-const CodeGenerationResults = require("./CodeGenerationResults");
-const Dependency = require("./Dependency");
-const DependencyTemplates = require("./DependencyTemplates");
-const Entrypoint = require("./Entrypoint");
-const ErrorHelpers = require("./ErrorHelpers");
-
-const { toError } = ErrorHelpers;
-
-const FileSystemInfo = require("./FileSystemInfo");
-const LazyBarrelController = require("./LazyBarrel");
-const MainTemplate = require("./MainTemplate");
-const Module = require("./Module");
-const ModuleGraph = require("./ModuleGraph");
-const ModuleProfile = require("./ModuleProfile");
-const ModuleTemplate = require("./ModuleTemplate");
-const { WEBPACK_MODULE_TYPE_RUNTIME } = require("./ModuleTypeConstants");
-const RuntimeGlobals = require("./RuntimeGlobals");
-const RuntimeTemplate = require("./RuntimeTemplate");
-const Stats = require("./Stats");
-const buildChunkGraph = require("./buildChunkGraph");
+const { MultiItemCache } = require("./cache/CacheFacade");
+const ErrorHelpers = require("./errors/ErrorHelpers");
 const {
 	makeWebpackError,
 	tryRunOrWebpackError
 } = require("./errors/HookWebpackError");
 const WebpackError = require("./errors/WebpackError");
+const FileSystemInfo = require("./fs/FileSystemInfo");
+const Chunk = require("./graph/Chunk");
+const ChunkGraph = require("./graph/ChunkGraph");
+const ChunkGroup = require("./graph/ChunkGroup");
+const Dependency = require("./graph/Dependency");
+const Entrypoint = require("./graph/Entrypoint");
+const ModuleGraph = require("./graph/ModuleGraph");
+const buildChunkGraph = require("./graph/buildChunkGraph");
 const { LogType, Logger } = require("./logging/Logger");
+const CodeGenerationResults = require("./module/CodeGenerationResults");
+const Module = require("./module/Module");
+const ModuleProfile = require("./module/ModuleProfile");
+const LazyBarrels = require("./optimize/LazyBarrels");
+const RuntimeGlobals = require("./runtime/RuntimeGlobals");
+const Stats = require("./stats/Stats");
 const StatsFactory = require("./stats/StatsFactory");
 const StatsPrinter = require("./stats/StatsPrinter");
+const ChunkTemplate = require("./template/ChunkTemplate");
+const DependencyTemplates = require("./template/DependencyTemplates");
+const MainTemplate = require("./template/MainTemplate");
+const ModuleTemplate = require("./template/ModuleTemplate");
+const RuntimeTemplate = require("./template/RuntimeTemplate");
 const { equals: arrayEquals } = require("./util/ArrayHelpers");
 const AsyncQueue = require("./util/AsyncQueue");
 const LazySet = require("./util/LazySet");
@@ -106,6 +102,8 @@ const getChunkRenderError = memoize(() => require("./errors/ChunkRenderError"));
 
 const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
 
+const { toError } = ErrorHelpers;
+
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -124,11 +122,11 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * 	OutputNormalizedWithDefaults as OutputOptionsWithDefaults
  * } from "./config/defaults"
  */
-/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
-/** @import Cache from "./Cache" */
-/** @import CacheFacade from "./CacheFacade" */
-/** @import { ChunkName, ChunkId } from "./Chunk" */
-/** @import { ChunkGroupOptions } from "./ChunkGroup" */
+/** @import AsyncDependenciesBlock from "./graph/AsyncDependenciesBlock" */
+/** @import Cache from "./cache/Cache" */
+/** @import CacheFacade from "./cache/CacheFacade" */
+/** @import { ChunkName, ChunkId } from "./graph/Chunk" */
+/** @import { ChunkGroupOptions } from "./graph/ChunkGroup" */
 /**
  * @import Compiler, {
  * 	CompilationParams,
@@ -138,9 +136,9 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * 	Records
  * } from "./Compiler"
  */
-/** @import DependenciesBlock from "./DependenciesBlock" */
-/** @import { DependencyLocation, ReferencedExports } from "./Dependency" */
-/** @typedef {import("./Entrypoint").EntryOptions} EntryOptions */
+/** @import DependenciesBlock from "./graph/DependenciesBlock" */
+/** @import { DependencyLocation, ReferencedExports } from "./graph/Dependency" */
+/** @typedef {import("./graph/Entrypoint").EntryOptions} EntryOptions */
 /**
  * @import {
  * 	NameForCondition,
@@ -151,7 +149,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * 	SourceType,
  * 	FactoryMeta,
  * 	CodeGenerationResult
- * } from "./Module"
+ * } from "./module/Module"
  */
 /**
  * @import NormalModule, {
@@ -159,19 +157,25 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * 	AnyLoaderContext,
  * 	ParserOptions,
  * 	GeneratorOptions
- * } from "./NormalModule"
+ * } from "./module/NormalModule"
  */
 /**
  * @import ModuleFactory, {
  * 	ModuleFactoryCreateDataContextInfo,
  * 	ModuleFactoryResult
- * } from "./ModuleFactory"
+ * } from "./module/ModuleFactory"
+ */
+/** @import { ModuleId } from "./graph/ChunkGraph" */
+/** @import ModuleGraphConnection from "./graph/ModuleGraphConnection" */
+/** @import RequestShortener from "./util/RequestShortener" */
+/** @import RuntimeModule from "./runtime/RuntimeModule" */
+/**
+ * @import {
+ * 	RenderManifestEntry,
+ * 	RenderManifestEntryTemplated,
+ * 	RenderManifestOptions
+ * } from "./template/Template"
  */
-/** @import { ModuleId } from "./ChunkGraph" */
-/** @import ModuleGraphConnection from "./ModuleGraphConnection" */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import RuntimeModule from "./RuntimeModule" */
-/** @import { RenderManifestEntry, RenderManifestOptions } from "./Template" */
 
 /**
  * One language's source embedded in another's output.
@@ -185,6 +189,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * @import {
  * 	StatsAsset,
  * 	StatsError,
+ * 	StatsJsonValue,
  * 	StatsModule
  * } from "./stats/DefaultStatsFactoryPlugin"
  */
@@ -202,7 +207,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * @typedef {import("./util/deprecation").FakeHook<T>} FakeHook<T>
  */
 /** @import { RuntimeSpec } from "./util/runtime" */
-/** @import { InputFileSystem } from "./util/fs" */
+/** @import { InputFileSystem } from "./fs/fs" */
 
 /**
  * Defines the callback callback.
@@ -243,7 +248,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * @returns {void}
  */
 
-/** @typedef {new (...args: EXPECTED_ANY[]) => Dependency} DependencyConstructor */
+/** @typedef {abstract new (...args: never[]) => Dependency} DependencyConstructor */
 
 /** @typedef {Record<string, Source>} CompilationAssets */
 
@@ -523,7 +528,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * @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 */
@@ -547,9 +552,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
 /** @type {AssetInfo} */
 const EMPTY_ASSET_INFO = Object.freeze({});
 
-const esmDependencyCategory = "esm";
-
-// TODO webpack 6: remove
+// TODO in the next major release: remove
 const deprecatedNormalModuleLoaderHook = util.deprecate(
 	/**
 	 * Handles the callback logic for this hook.
@@ -557,12 +560,12 @@ const deprecatedNormalModuleLoaderHook = util.deprecate(
 	 * @returns {NormalModuleCompilationHooks["loader"]} hooks
 	 */
 	(compilation) =>
-		require("./NormalModule").getCompilationHooks(compilation).loader,
+		require("./module/NormalModule").getCompilationHooks(compilation).loader,
 	"Compilation.hooks.normalModuleLoader was moved to NormalModule.getCompilationHooks(compilation).loader",
 	"DEP_WEBPACK_COMPILATION_NORMAL_MODULE_LOADER_HOOK"
 );
 
-// TODO webpack 6: remove
+// TODO in the next major release: remove
 /**
  * Define removed module templates.
  * @param {ModuleTemplates | undefined} moduleTemplates module templates
@@ -631,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
@@ -653,9 +664,13 @@ const reduceAffectType = (connections) => {
 	return affected;
 };
 
-/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, 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 {
 	/**
@@ -906,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"]} */
@@ -1101,7 +1120,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			shouldGenerateChunkAssets: new SyncBailHook([]),
 			/** @type {SyncHook<[]>} */
 			beforeChunkAssets: new SyncHook([]),
-			// TODO webpack 6 remove
+			// TODO in the next major release: remove
 			/** @deprecated */
 			additionalChunkAssets:
 				/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
@@ -1114,7 +1133,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					)
 				),
 
-			// TODO webpack 6 deprecate
+			// TODO in the next major release: deprecate
 			/** @deprecated */
 			additionalAssets:
 				/** @type {FakeHook<Pick<AsyncSeriesHook<[]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
@@ -1125,7 +1144,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						() => []
 					)
 				),
-			// TODO webpack 6 remove
+			// TODO in the next major release: remove
 			/** @deprecated */
 			optimizeChunkAssets:
 				/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
@@ -1137,7 +1156,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						"DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS"
 					)
 				),
-			// TODO webpack 6 remove
+			// TODO in the next major release: remove
 			/** @deprecated */
 			afterOptimizeChunkAssets:
 				/** @type {FakeHook<Pick<AsyncSeriesHook<[Chunks]>, "tap" | "tapAsync" | "tapPromise" | "name">>} */
@@ -1149,10 +1168,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						"DEP_WEBPACK_COMPILATION_AFTER_OPTIMIZE_CHUNK_ASSETS"
 					)
 				),
-			// TODO webpack 6 deprecate
+			// TODO in the next major release: deprecate
 			/** @deprecated */
 			optimizeAssets: processAssetsHook,
-			// TODO webpack 6 deprecate
+			// TODO in the next major release: deprecate
 			/** @deprecated */
 			afterOptimizeAssets: afterProcessAssetsHook,
 
@@ -1464,6 +1483,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._restoredUnsafeCacheEntries = new Map();
 		/** @type {WeakSet<Module>} */
 		this.builtModules = new WeakSet();
+		// a module whose dependency failed to resolve reports nothing for it now,
+		// but will once the target exists, which needs no module to be rebuilt
+		/** @type {Set<Module>} */
+		this._modulesWithUnresolvedDependencies = new Set();
 		/** @type {WeakSet<Module>} */
 		this.codeGeneratedModules = new WeakSet();
 		/** @type {WeakSet<Module>} */
@@ -1482,7 +1505,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.buildDependencies = new LazySet();
 		/** @type {FileSystemDependencies} */
 		this.optionalBuildDependencies = new LazySet();
-		// TODO webpack 6 remove
+		// TODO in the next major release: remove
 		/**
 		 * @deprecated
 		 * @type {{ add: (item: string) => FileSystemDependencies }}
@@ -1516,8 +1539,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this._unsafeCachePredicate =
 			typeof unsafeCache === "function" ? unsafeCache : () => true;
 
-		/** @type {LazyBarrelController} */
-		this._lazyBarrelController = new LazyBarrelController(this);
+		/** @type {LazyBarrels} */
+		this._lazyBarrels = new LazyBarrels(this);
 	}
 
 	getStats() {
@@ -1841,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();
@@ -1930,7 +1952,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 
 		// lazy barrel: defer re-export targets of side-effect-free modules
-		const hasLazyBarrel = this._lazyBarrelController.classify(module);
+		const hasLazyBarrel = this._lazyBarrels.classify(module);
 
 		/** @type {DependenciesBlock} */
 		let currentBlock;
@@ -2011,15 +2033,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 */
 		const processDependency = (dep, index) => {
 			this.moduleGraph.setParents(dep, currentBlock, module, index);
-			if (
-				hasLazyBarrel &&
-				// TODO remove in webpack 6
-				// It may be missing on custom dependency types not extending the base Dependency
-				"isLazy" in dep &&
-				dep.isLazy()
-			) {
-				return;
-			}
+			if (hasLazyBarrel && this._lazyBarrels.isLazy(dep)) return;
 
 			if (this._unsafeCache) {
 				try {
@@ -2034,7 +2048,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								dep,
 								unsafeCachedModule
 							);
-							this._lazyBarrelController.unlazyForDependency(
+							this._lazyBarrels.unlazyForDependency(
 								unsafeCachedModule,
 								dep,
 								sortedDependencies
@@ -2052,7 +2066,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								dep,
 								cachedModule
 							);
-							this._lazyBarrelController.unlazyForDependency(
+							this._lazyBarrels.unlazyForDependency(
 								cachedModule,
 								dep,
 								sortedDependencies
@@ -2117,7 +2131,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 									dep,
 									cachedModule
 								); // a3
-								this._lazyBarrelController.unlazyForDependency(
+								this._lazyBarrels.unlazyForDependency(
 									cachedModule,
 									dep,
 									sortedDependencies
@@ -2198,7 +2212,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				// mostly esm dependencies would be used
 				// so we don't allocate extra string for them
 				const cacheKey =
-					category === esmDependencyCategory
+					category === Dependency.ESM_CATEGORY
 						? resourceIdent
 						: `${category}${resourceIdent}`;
 				let list = /** @type {FactoryCacheValue} */ (factoryCacheValue).get(
@@ -2347,7 +2361,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			},
 			(err, result) => {
 				if (result) {
-					// TODO webpack 6: remove
+					// TODO in the next major release: remove
 					// For backward-compat
 					if (result.module === undefined && result instanceof Module) {
 						result = {
@@ -2467,6 +2481,30 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				context
 			},
 			(err, factoryResult) => {
+				// Loader-created modules have no origin connection to resolve again.
+				// Preserve their resolution dependencies in the caller's build snapshot.
+				if (
+					factoryResult &&
+					!connectOrigin &&
+					originModule &&
+					originModule.buildInfo &&
+					this.buildQueue.isProcessing(originModule)
+				) {
+					for (const key of /** @type {const} */ ([
+						"fileDependencies",
+						"contextDependencies",
+						"missingDependencies"
+					])) {
+						const dependencies = factoryResult[key];
+						if (dependencies) {
+							let target = originModule.buildInfo[key];
+							if (target === undefined) {
+								originModule.buildInfo[key] = target = new LazySet();
+							}
+							target.addAll(dependencies);
+						}
+					}
+				}
 				const applyFactoryResultDependencies = () => {
 					const { fileDependencies, contextDependencies, missingDependencies } =
 						/** @type {ModuleFactoryResult} */ (factoryResult);
@@ -2482,6 +2520,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				};
 				if (err) {
 					if (factoryResult) applyFactoryResultDependencies();
+					if (originModule) {
+						this._modulesWithUnresolvedDependencies.add(originModule);
+					}
 					if (dependencies.every((d) => d.optional)) {
 						this.warnings.push(err);
 						return callback();
@@ -2524,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,
@@ -2662,10 +2701,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			// lazy barrel: on the first call the module is unclassified, so this only
 			// records the ids and `processModuleDependencies` replays them. Later the
 			// module is built and never re-walked, so the targets are built here.
-			const unlazyItems = this._lazyBarrelController.request(
-				module,
-				dependencies
-			);
+			const unlazyItems = this._lazyBarrels.request(module, dependencies);
 
 			if (unlazyItems !== undefined) {
 				let inProgress = unlazyItems.length + 1; // +1 = the module's own dep processing
@@ -2783,7 +2819,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @returns {void} returns
 	 */
 	addEntry(context, entry, optionsOrName, callback) {
-		// TODO webpack 6 remove
+		// TODO in the next major release: remove
 		const options =
 			typeof optionsOrName === "object"
 				? optionsOrName
@@ -2947,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
@@ -2978,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;
 		};
 
@@ -2995,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);
@@ -3011,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} */
@@ -3019,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 {
@@ -3054,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);
@@ -3132,6 +3196,31 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		let statUnchanged = 0;
 		let statChanged = 0;
 		let statNew = 0;
+		/**
+		 * Include async state and connection activity, which can change without changing module ids.
+		 * @param {Module} module connected module
+		 * @param {readonly ModuleGraphConnection[]} connections connections to it
+		 * @returns {string} reference key
+		 */
+		const referenceKey = (module, connections) => {
+			let key = `${chunkGraph.getModuleId(module)}${moduleGraph.isAsync(module)}`;
+			for (const connection of connections) {
+				const state = connection.getActiveState(undefined);
+				key += state === true ? "T" : state === false ? "F" : "O";
+			}
+			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
@@ -3139,16 +3228,19 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 */
 		const computeReferences = (module) => {
 			const id = /** @type {ModuleId} */ (chunkGraph.getModuleId(module));
-			/** @type {Map<Module, ModuleId> | undefined} */
+			/** @type {Map<Module, string> | undefined} */
 			let modules;
 			/** @type {(ChunkId | null)[] | undefined} */
 			let blocks;
 			const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
 			if (outgoing !== undefined) {
-				for (const m of outgoing.keys()) {
-					if (!m) continue;
+				for (const [referencedModule, connections] of outgoing) {
+					if (!referencedModule) continue;
 					if (modules === undefined) modules = new Map();
-					modules.set(m, /** @type {ModuleId} */ (chunkGraph.getModuleId(m)));
+					modules.set(
+						referencedModule,
+						referenceKey(referencedModule, connections)
+					);
 				}
 			}
 			if (module.blocks.length > 0) {
@@ -3171,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)
 			};
 		};
 		/**
@@ -3179,19 +3272,27 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {Module} module module
 		 * @param {object} references references
 		 * @param {string | number} references.id id
-		 * @param {Map<Module, string | number | undefined>=} references.modules modules
+		 * @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) {
-				for (const [module, id] of modules) {
-					if (chunkGraph.getModuleId(module) !== id) return false;
+				const outgoing = moduleGraph.getOutgoingConnectionsByModule(module);
+				for (const [referencedModule, key] of modules) {
+					const connections = outgoing && outgoing.get(referencedModule);
+					if (
+						connections === undefined ||
+						referenceKey(referencedModule, connections) !== key
+					) {
+						return false;
+					}
 				}
 			}
 			if (blocks !== undefined) {
@@ -3218,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;
 		};
 
@@ -3253,6 +3355,35 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
+	/**
+	 * Returns the modules whose dependency report depends on a dependency that
+	 * failed to resolve: they must not be remembered as clean, as the target can
+	 * appear without any of them being rebuilt.
+	 * @private
+	 * @returns {Set<Module>} the modules with such a dependency and their parents
+	 */
+	_modulesReportingUnresolved() {
+		const result = new Set(this._modulesWithUnresolvedDependencies);
+		if (result.size === 0) return result;
+		const { moduleGraph } = this;
+		// as the token walk does, only a transitive connection reaches further up;
+		// a parent first reached directly may still be reached transitively later
+		const queued = new Set(result);
+		for (const module of queued) {
+			for (const [
+				referencingModule,
+				connections
+			] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+				if (!referencingModule) continue;
+				result.add(referencingModule);
+				if (reduceAffectType(connections) === Dependency.TRANSITIVE) {
+					queued.add(referencingModule);
+				}
+			}
+		}
+		return result;
+	}
+
 	/**
 	 * Assigns a fresh dependency report cache token to every module whose
 	 * dependency errors/warnings could have changed since the previous
@@ -3398,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.
@@ -3456,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",
@@ -3531,16 +3670,31 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			if (useReportCacheTokens) {
 				this._flagModulesForDependencyReporting(modules);
 			}
+			const reportsUnresolved = this._modulesReportingUnresolved();
 			for (const module of modules) {
+				const unresolved = reportsUnresolved.has(module);
 				const memCache = moduleMemCaches && moduleMemCaches.get(module);
-				if (memCache && memCache.get("noWarningsOrErrors")) continue;
+				if (!unresolved && memCache && memCache.get("noWarningsOrErrors")) {
+					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)
 					);
-					if (cleanModules !== undefined && cleanModules.has(module)) continue;
+					if (
+						!unresolved &&
+						cleanModules !== undefined &&
+						cleanModules.get(module) === clean
+					) {
+						continue;
+					}
 				}
 				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
 					module
@@ -3565,7 +3719,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						hasProblems = true;
 					}
 				}
-				if (!hasProblems) {
+				if (!hasProblems && !unresolved) {
 					if (memCache) memCache.set("noWarningsOrErrors", true);
 					if (useReportCacheTokens) {
 						let cleanModules = modulesWithoutProblems.get(
@@ -3574,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);
 					}
 				}
 			}
@@ -3623,7 +3777,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.processDependenciesQueue.clear();
 			this.addModuleQueue.clear();
 			// lazy barrel only acts during make; release its bookkeeping now
-			this._lazyBarrelController.clear();
+			this._lazyBarrels.clear();
 			// unsafe-cache restore tables are only read during make; release them
 			// so they stop pinning restored modules for the rest of the compilation
 			this._restoredUnsafeCacheModuleEntries.clear();
@@ -4026,7 +4180,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						const warning = new (getModuleDependencyWarning())(
 							module,
 							w,
-							/** @type {EXPECTED_ANY} */ (w).loc || d.loc
+							w.loc || d.loc
 						);
 						this.warnings.push(warning);
 						hasProblems = true;
@@ -4038,7 +4192,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						const error = new (getModuleDependencyError())(
 							module,
 							e,
-							/** @type {EXPECTED_ANY} */ (e).loc || d.loc
+							e.loc || d.loc
 						);
 						this.errors.push(error);
 						hasProblems = true;
@@ -4162,7 +4316,35 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			(err) => {
 				if (err) return callback(/** @type {WebpackError} */ (err));
 				const affected = new Set(pending.map(({ jobModule }) => jobModule));
-				const redo = jobs.filter(({ module }) => affected.has(module));
+				// A module referencing one of these may have copied what it generated
+				// into its own code (an analyzable `new URL`), so it goes again after.
+				/** @type {Set<Module>} */
+				const referencing = new Set();
+				for (const { info } of pending) {
+					for (const connection of this.moduleGraph.getIncomingConnections(
+						info.module
+					)) {
+						const { originModule } = connection;
+						if (originModule !== null && !affected.has(originModule)) {
+							referencing.add(originModule);
+						}
+					}
+				}
+
+				const redo = [
+					...jobs.filter(({ module }) => affected.has(module)),
+					// A referencing module concatenated into another is generated as
+					// part of it, so the job to redo is the concatenated module's.
+					...jobs.filter(({ module }) => {
+						if (affected.has(module)) return false;
+						if (referencing.has(module)) return true;
+						if (module.getRootModule() === module) return false;
+						for (const inner of module.getSourceModules()) {
+							if (referencing.has(inner)) return true;
+						}
+						return false;
+					})
+				];
 				// Generated directly rather than through the codegen cache: the module
 				// hash is unchanged, so the cache would hand back the first pass again.
 				const results =
@@ -4251,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)
 							);
 						})
 					) {
@@ -4621,9 +4802,10 @@ 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 {object} T
 	 * @param {Chunk} chunk target chunk
-	 * @param {() => Promise<EXPECTED_ANY>} load resolves the runtime module implementation
-	 * @param {(loaded: EXPECTED_ANY) => RuntimeModule} create builds the runtime module from it
+	 * @param {() => Promise<T>} load resolves the runtime module implementation
+	 * @param {(loaded: T) => RuntimeModule} create builds the runtime module from it
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @returns {void}
 	 */
@@ -4648,14 +4830,18 @@ 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
 			.then(() => this._attachPendingRuntimeModules(callback), callback);
 	}
 
-	// TODO webpack 6 make chunkGraph argument non-optional
+	// TODO in the next major release: make chunkGraph argument non-optional
 	/**
 	 * Adds runtime module.
 	 * @param {Chunk} chunk target chunk
@@ -4773,7 +4959,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		const name = options.name;
 		if (name) {
 			const entrypoint = this.namedChunkGroups.get(name);
-			if (entrypoint instanceof Entrypoint) {
+			if (entrypoint !== undefined && entrypoint.isEntrypoint()) {
 				if (module) {
 					entrypoint.addOrigin(module, loc, request);
 				}
@@ -5154,8 +5340,12 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			});
 			moduleHashDigest = moduleHash.digest(hashDigest);
 		} catch (err) {
+			// A diagnostic that already names its module says more than this wrapper
+			// would, e.g. which runtime module's `generate()` threw.
 			errors.push(
-				new (getModuleHashingError())(module, /** @type {Error} */ (err))
+				WebpackError.isWebpackError(err) && err.module
+					? err
+					: new (getModuleHashingError())(module, /** @type {Error} */ (err))
 			);
 			moduleHashDigest = "XXXXXX";
 		}
@@ -5170,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;
@@ -5313,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>} */
@@ -5923,7 +6133,7 @@ This prevents using hashes of each other and should be avoided.`);
 						);
 
 						assetCacheItem.get((err, sourceFromCache) => {
-							/** @type {string | import("./TemplatedPathPlugin").TemplatePathFn<EXPECTED_ANY>} */
+							/** @type {RenderManifestEntryTemplated["filenameTemplate"]} */
 							let filenameTemplate;
 							/** @type {string} */
 							let file;
@@ -6044,7 +6254,7 @@ This prevents using hashes of each other and should be avoided.`);
 	/**
 	 * Returns interpolated path.
 	 * @template {PathData} [T=PathData]
-	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {string | import("./template/TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
 	 * @param {T=} data context data
 	 * @returns {string} interpolated path
 	 */
@@ -6061,7 +6271,7 @@ This prevents using hashes of each other and should be avoided.`);
 	/**
 	 * Gets path with info.
 	 * @template {PathData} [T=PathData]
-	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {string | import("./template/TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
 	 * @param {T=} data context data
 	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
@@ -6078,7 +6288,7 @@ This prevents using hashes of each other and should be avoided.`);
 	/**
 	 * Returns interpolated path.
 	 * @template {PathData} [T=PathData]
-	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {string | import("./template/TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
 	 * @param {T} data context data
 	 * @returns {string} interpolated path
 	 */
@@ -6093,7 +6303,7 @@ This prevents using hashes of each other and should be avoided.`);
 	/**
 	 * Gets asset path with info.
 	 * @template {PathData} [T=PathData]
-	 * @param {string | import("./TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
+	 * @param {string | import("./template/TemplatedPathPlugin").TemplatePathFn<T>} filename used to get asset path with hash
 	 * @param {T} data context data
 	 * @returns {InterpolatedPathAndAssetInfo} interpolated path and asset info
 	 */
@@ -6267,7 +6477,7 @@ This prevents using hashes of each other and should be avoided.`);
 					reportErrors();
 
 					// for backward-compat temporary set the chunk graph
-					// TODO webpack 6
+					// TODO in the next major release: drop it
 					const old = this.chunkGraph;
 					this.chunkGraph = chunkGraph;
 					this.processRuntimeRequirements({
@@ -6542,7 +6752,7 @@ This prevents using hashes of each other and should be avoided.`);
 		const usedIds = new Set();
 
 		for (const module of this.modules) {
-			if (module.type === WEBPACK_MODULE_TYPE_RUNTIME) continue;
+			if (module.is("runtime")) continue;
 			const moduleId = chunkGraph.getModuleId(module);
 			if (moduleId === null) continue;
 			if (usedIds.has(moduleId)) {
@@ -6598,7 +6808,7 @@ This prevents using hashes of each other and should be avoided.`);
 // Hide from typescript
 const compilationPrototype = Compilation.prototype;
 
-// TODO webpack 6 remove
+// TODO in the next major release: remove
 Object.defineProperty(compilationPrototype, "modifyHash", {
 	writable: false,
 	enumerable: false,
@@ -6610,7 +6820,7 @@ Object.defineProperty(compilationPrototype, "modifyHash", {
 	}
 });
 
-// TODO webpack 6 remove
+// TODO in the next major release: remove
 Object.defineProperty(compilationPrototype, "cache", {
 	enumerable: false,
 	configurable: false,
@@ -6629,7 +6839,7 @@ Object.defineProperty(compilationPrototype, "cache", {
 	set: util.deprecate(
 		/**
 		 * Handles the value callback for this hook.
-		 * @param {EXPECTED_ANY} _v value
+		 * @param {Cache} _v value
 		 */
 		(_v) => {},
 		"Compilation.cache was removed in favor of Compilation.getCache()",