webpack 5.111.0 → 5.112.0

package/lib/Compilation.js

@@ -17,36 +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 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");
@@ -103,6 +102,8 @@ const getChunkRenderError = memoize(() => require("./errors/ChunkRenderError"));
 
 const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
 
+const { toError } = ErrorHelpers;
+
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -121,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,
@@ -135,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,
@@ -148,7 +149,7 @@ const getBuildCycleError = memoize(() => require("./errors/BuildCycleError"));
  * 	SourceType,
  * 	FactoryMeta,
  * 	CodeGenerationResult
- * } from "./Module"
+ * } from "./module/Module"
  */
 /**
  * @import NormalModule, {
@@ -156,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.
@@ -199,7 +206,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.
@@ -544,9 +551,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.
@@ -554,12 +559,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
@@ -650,7 +655,7 @@ 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 }} 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 */
 
@@ -1098,7 +1103,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">>} */
@@ -1111,7 +1116,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">>} */
@@ -1122,7 +1127,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">>} */
@@ -1134,7 +1139,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">>} */
@@ -1146,10 +1151,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,
 
@@ -1461,6 +1466,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>} */
@@ -1479,7 +1488,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 }}
@@ -1513,8 +1522,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() {
@@ -1927,7 +1936,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;
@@ -2008,15 +2017,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 {
@@ -2031,7 +2032,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
@@ -2049,7 +2050,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
@@ -2114,7 +2115,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
@@ -2195,7 +2196,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(
@@ -2344,7 +2345,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 = {
@@ -2371,7 +2372,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				if (err) {
 					const notFoundError = new (getModuleNotFoundError())(
 						originModule,
-						err,
+						toError(err),
 						/** @type {DependencyLocation} */
 						(dependencies.map((d) => d.loc).find(Boolean))
 					);
@@ -2464,6 +2465,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);
@@ -2479,6 +2504,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();
@@ -2656,16 +2684,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				return;
 			}
 
-			// lazy barrel:
-			// 1. first call: barrel module is not classified yet, so this records the requested
-			//    ids and returns undefined; the targets get built below when
-			//    `processModuleDependencies` runs `_lazyBarrelController.classify` and replays them.
-			// 2. later call: barrel module is already built, so `processModuleDependencies` won't
-			//    re-walk it; the newly requested targets must be built here.
-			const unlazyItems = this._lazyBarrelController.request(
-				module,
-				dependencies
-			);
+			// 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._lazyBarrels.request(module, dependencies);
 
 			if (unlazyItems !== undefined) {
 				let inProgress = unlazyItems.length + 1; // +1 = the module's own dep processing
@@ -2783,7 +2805,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
@@ -3132,6 +3154,20 @@ 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;
+		};
 		/**
 		 * Compute references.
 		 * @param {Module} module module
@@ -3139,16 +3175,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) {
@@ -3179,7 +3218,7 @@ 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
 		 * @returns {boolean} ok?
@@ -3190,8 +3229,15 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		) => {
 			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) {
@@ -3253,6 +3299,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
@@ -3531,16 +3606,26 @@ 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;
 				if (useReportCacheTokens) {
 					token = dependencyReportCacheTokens.get(module);
 					const cleanModules = modulesWithoutProblems.get(
 						/** @type {DependencyReportCacheToken} */ (token)
 					);
-					if (cleanModules !== undefined && cleanModules.has(module)) continue;
+					if (
+						!unresolved &&
+						cleanModules !== undefined &&
+						cleanModules.has(module)
+					) {
+						continue;
+					}
 				}
 				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
 					module
@@ -3565,7 +3650,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(
@@ -3623,7 +3708,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 +4111,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 +4123,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 +4247,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 =
@@ -4187,7 +4300,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						// Reported and carried on with, as the first pass does: a throw
 						// here would leave the build with no error to show for it.
 						this.errors.push(
-							new (getCodeGenerationError())(module, /** @type {Error} */ (err))
+							new (getCodeGenerationError())(module, toError(err))
 						);
 						result = {
 							sources: new Map(),
@@ -4377,9 +4490,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					compilation: this
 				});
 			} catch (err) {
-				errors.push(
-					new (getCodeGenerationError())(module, /** @type {Error} */ (err))
-				);
+				errors.push(new (getCodeGenerationError())(module, toError(err)));
 				result = {
 					sources: new Map(),
 					runtimeRequirements: null,
@@ -4430,9 +4541,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 						result.data.set("analyzableBailouts", bailouts);
 					}
 				} catch (err) {
-					errors.push(
-						new (getCodeGenerationError())(module, /** @type {Error} */ (err))
-					);
+					errors.push(new (getCodeGenerationError())(module, toError(err)));
 					result = cachedResult = {
 						sources: new Map(),
 						runtimeRequirements: null,
@@ -4625,9 +4734,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 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}
 	 */
@@ -4659,7 +4769,7 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 			.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
@@ -4777,7 +4887,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);
 				}
@@ -5158,8 +5268,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";
 		}
@@ -5208,22 +5322,9 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 		}
 
 		this.logger.time("hashing: sort chunks");
-		/*
-		 * Chunks are hashed in 4 categories, in this order:
-		 * 1. Async chunks - no hash dependencies on other chunks
-		 * 2. Non-entry initial chunks (e.g. shared split chunks) - no hash
-		 *    dependencies on other chunks, but runtime chunks may read their
-		 *    hashes via GetChunkFilenameRuntimeModule (dependentHash)
-		 * 3. Runtime chunks - may use hashes of async and non-entry initial
-		 *    chunks (via GetChunkFilenameRuntimeModule). Ordered by references
-		 *    between each other (for async entrypoints)
-		 * 4. Entry chunks - may depend on runtimeChunk.hash (via
-		 *    createChunkHashHandler for ESM/CJS entry importing runtime)
-		 *
-		 * This ordering ensures all hash dependencies flow in one direction:
-		 * async/initial → runtime → entry, with no circular dependencies.
-		 * Chunks within each category are sorted by id for determinism.
-		 */
+		// Hashed as async, then non-entry initial, then runtime, then entry chunks,
+		// so hash dependencies flow one way between those groups. A cycle among the
+		// runtime chunks is still possible, and is warned about below.
 		/** @type {Chunk[]} */
 		const unorderedRuntimeChunks = [];
 		/** @type {Chunk[]} */
@@ -5410,9 +5511,7 @@ This prevents using hashes of each other and should be avoided.`);
 					this.hooks.contentHash.call(chunk);
 				}
 			} catch (err) {
-				this.errors.push(
-					new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
-				);
+				this.errors.push(new (getChunkRenderError())(chunk, "", toError(err)));
 			}
 			this.logger.timeAggregate("hashing: hash chunks");
 		};
@@ -5926,7 +6025,7 @@ This prevents using hashes of each other and should be avoided.`);
 					});
 				} catch (err) {
 					this.errors.push(
-						new (getChunkRenderError())(chunk, "", /** @type {Error} */ (err))
+						new (getChunkRenderError())(chunk, "", toError(err))
 					);
 					return callback();
 				}
@@ -5942,7 +6041,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;
@@ -5965,7 +6064,7 @@ This prevents using hashes of each other and should be avoided.`);
 											: "");
 
 								this.errors.push(
-									new (getChunkRenderError())(chunk, filename, err)
+									new (getChunkRenderError())(chunk, filename, toError(err))
 								);
 								inTry = false;
 								return callback();
@@ -6063,7 +6162,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
 	 */
@@ -6080,7 +6179,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
 	 */
@@ -6097,7 +6196,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
 	 */
@@ -6112,7 +6211,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
 	 */
@@ -6286,7 +6385,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({
@@ -6561,7 +6660,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)) {
@@ -6617,7 +6716,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,
@@ -6629,7 +6728,7 @@ Object.defineProperty(compilationPrototype, "modifyHash", {
 	}
 });
 
-// TODO webpack 6 remove
+// TODO in the next major release: remove
 Object.defineProperty(compilationPrototype, "cache", {
 	enumerable: false,
 	configurable: false,
@@ -6648,7 +6747,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()",