webpack 5.107.2 → 5.108.0

package/lib/Compilation.js

@@ -28,6 +28,7 @@ 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");
@@ -108,6 +109,7 @@ const { isSourceEqual } = require("./util/source");
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
 /** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
+/** @typedef {import("./Module").SourceTypes} SourceTypes */
 /** @typedef {import("./NormalModule").NormalModuleCompilationHooks} NormalModuleCompilationHooks */
 /** @typedef {import("./Module").FactoryMeta} FactoryMeta */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
@@ -212,8 +214,10 @@ const { isSourceEqual } = require("./util/source");
  * @property {string=} name
  * @property {string} hash
  * @property {HashWithLengthFunction=} hashWithLength
+ * @property {HashWithDigestFunction=} hashWithDigest builds `[chunkhash:<digest>]` per chunk in the runtime chunk-filename map
  * @property {(Record<string, string>)=} contentHash
  * @property {(Record<string, HashWithLengthFunction>)=} contentHashWithLength
+ * @property {(Record<string, HashWithDigestFunction>)=} contentHashWithDigest builds `[contenthash:<digest>]` per chunk in the runtime chunk-filename map
  */
 
 /**
@@ -318,6 +322,7 @@ const { isSourceEqual } = require("./util/source");
  * @property {string | string[]=} chunkhash the value(s) of the chunk hash used for this asset
  * @property {string | string[]=} modulehash the value(s) of the module hash used for this asset
  * @property {string | string[]=} contenthash the value(s) of the content hash used for this asset
+ * @property {Record<string, string>=} contenthashDigest maps a `[contenthash:<digest>]` value to its digest, so `RealContentHashPlugin` re-encodes the recomputed hash in it
  * @property {string=} sourceFilename when asset was created from a source file (potentially transformed), the original filename relative to compilation context
  * @property {number=} size size in bytes, only set after asset has been emitted
  * @property {boolean=} development true, when asset is only used for development and doesn't count towards user-facing assets
@@ -341,6 +346,8 @@ const { isSourceEqual } = require("./util/source");
 
 /** @typedef {(length: number) => string} HashWithLengthFunction */
 
+/** @typedef {(digest: string, length?: number) => string} HashWithDigestFunction */
+
 /**
  * Defines the module path data type used by this module.
  * @typedef {object} ModulePathData
@@ -356,7 +363,10 @@ const { isSourceEqual } = require("./util/source");
  * @typedef {object} PathData
  * @property {ChunkGraph=} chunkGraph
  * @property {string=} hash
+ * @property {string=} fullHash untruncated compilation hash, for re-encoding `[fullhash:<digest>]`
+ * @property {string=} fullHashDigest digest `fullHash` is encoded in (defaults to `hashDigest`)
  * @property {HashWithLengthFunction=} hashWithLength
+ * @property {HashWithDigestFunction=} hashWithDigest builds `[fullhash:<digest>]`/`[hash:<digest>]` in the runtime chunk-filename context, where it throws because a runtime `getFullHash()` expression cannot be re-encoded
  * @property {(Chunk | ChunkPathData)=} chunk
  * @property {(Module | ModulePathData)=} module
  * @property {RuntimeSpec=} runtime
@@ -365,10 +375,15 @@ const { isSourceEqual } = require("./util/source");
  * @property {string=} query
  * @property {string=} contentHashType
  * @property {string=} contentHash
+ * @property {string=} contentHashFull untruncated module/asset content hash, for re-encoding `[contenthash:<digest>]` from full entropy
  * @property {HashWithLengthFunction=} contentHashWithLength
+ * @property {string=} hashDigest digest the stored hashes are encoded in (for `[hash:<digest>]`)
+ * @property {boolean=} realContentHash whether `optimization.realContentHash` recomputes content hashes (records an inline `[contenthash:<digest>]` so it re-encodes in that digest)
+ * @property {boolean=} hashAsFullHash treat `[hash]` as `[fullhash]` rather than the module hash (CSS local idents)
  * @property {boolean=} noChunkHash
  * @property {string=} url
  * @property {string=} local
+ * @property {string=} uniqueName
  * @property {PrepareIdFunction=} prepareId
  */
 
@@ -545,7 +560,38 @@ const unsafeCacheDependencies = new WeakMap();
 /** @type {WeakMap<ModuleWithRestoreFromUnsafeCache, UnsafeCacheData>} */
 const unsafeCacheData = new WeakMap();
 
-/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[] }} References */
+/** @typedef {EXPECTED_OBJECT} DependencyReportCacheToken */
+
+/**
+ * Renewed when the module or a transitively referenced module is rebuilt.
+ * @type {WeakMap<Module, DependencyReportCacheToken>}
+ */
+const dependencyReportCacheTokens = new WeakMap();
+
+/**
+ * Modules known to have no dependency errors/warnings, per cache token.
+ * @type {WeakMap<DependencyReportCacheToken, WeakSet<Module>>}
+ */
+const modulesWithoutProblems = new WeakMap();
+
+/**
+ * Reduce affect type.
+ * @param {Readonly<ModuleGraphConnection[]>} connections connections
+ * @returns {symbol | boolean} result
+ */
+const reduceAffectType = (connections) => {
+	let affected = false;
+	for (const { dependency } of connections) {
+		if (!dependency) continue;
+		const type = dependency.couldAffectReferencingModule();
+		if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
+		if (type === false) continue;
+		affected = true;
+	}
+	return affected;
+};
+
+/** @typedef {{ id: ModuleId, modules?: Map<Module, ModuleId>, blocks?: (ChunkId | null)[], sourceTypes?: SourceTypes }} References */
 /** @typedef {Map<Module, WeakTupleMap<EXPECTED_ANY[], EXPECTED_ANY>>} ModuleMemCaches */
 
 class Compilation {
@@ -555,6 +601,7 @@ class Compilation {
 	 * @param {CompilationParams} params the compilation parameters
 	 */
 	constructor(compiler, params) {
+		/** @type {boolean} */
 		this._backCompat = compiler._backCompat;
 
 		const getNormalModuleLoader = () => deprecatedNormalModuleLoaderHook(this);
@@ -1115,6 +1162,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.inputFileSystem =
 			/** @type {InputFileSystem} */
 			(compiler.inputFileSystem);
+		/** @type {FileSystemInfo} */
 		this.fileSystemInfo = new FileSystemInfo(this.inputFileSystem, {
 			unmanagedPaths: compiler.unmanagedPaths,
 			managedPaths: compiler.managedPaths,
@@ -1133,7 +1181,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		}
 		/** @type {ValueCacheVersions} */
 		this.valueCacheVersions = new Map();
+		/** @type {RequestShortener} */
 		this.requestShortener = compiler.requestShortener;
+		/** @type {string} */
 		this.compilerPath = compiler.compilerPath;
 
 		this.logger = this.getLogger("webpack.Compilation");
@@ -1148,9 +1198,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {boolean} */
 		this.profile = (options && options.profile) || false;
 
+		/** @type {CompilationParams} */
 		this.params = params;
+		/** @type {MainTemplate} */
 		this.mainTemplate = new MainTemplate(this.outputOptions, this);
+		/** @type {ChunkTemplate} */
 		this.chunkTemplate = new ChunkTemplate(this.outputOptions, this);
+		/** @type {RuntimeTemplate} */
 		this.runtimeTemplate = new RuntimeTemplate(
 			this,
 			this.outputOptions,
@@ -1260,6 +1314,10 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.assetsInfo = new Map();
 		/** @type {Map<string, Map<string, Set<string>>>} */
 		this._assetsRelatedIn = new Map();
+		/** @type {Map<string, Set<Chunk>> | undefined} */
+		this._assetToChunkIndex = undefined;
+		/** @type {Map<string, Set<Chunk>> | undefined} */
+		this._assetToChunkAuxiliaryIndex = undefined;
 		/** @type {Error[]} */
 		this.errors = [];
 		/** @type {Error[]} */
@@ -1322,8 +1380,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			)
 		};
 
+		/** @type {CacheFacade} */
 		this._modulesCache = this.getCache("Compilation/modules");
+		/** @type {CacheFacade} */
 		this._assetsCache = this.getCache("Compilation/assets");
+		/** @type {CacheFacade} */
 		this._codeGenerationCache = this.getCache("Compilation/codeGeneration");
 
 		const unsafeCache = options.module.unsafeCache;
@@ -1332,6 +1393,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		/** @type {UnsafeCachePredicate} */
 		this._unsafeCachePredicate =
 			typeof unsafeCache === "function" ? unsafeCache : () => true;
+
+		/**
+		 * @private
+		 * @type {LazyBarrelController}
+		 */
+		this._lazyBarrelController = new LazyBarrelController(this);
 	}
 
 	getStats() {
@@ -1451,7 +1518,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						typeof console.profileEnd === "function"
 					) {
 						console.profileEnd(
-							`[${name}] ${/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]}`
+							`[${name}] ${
+								/** @type {NonNullable<LogEntry["args"]>} */ (logEntry.args)[0]
+							}`
 						);
 					}
 					if (logEntries === undefined) {
@@ -1739,6 +1808,9 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			Dependency.isLowPriorityDependency
 		);
 
+		// lazy barrel: defer re-export targets of side-effect-free modules
+		const hasLazyBarrel = this._lazyBarrelController.classify(module);
+
 		/** @type {DependenciesBlock} */
 		let currentBlock;
 
@@ -1818,6 +1890,16 @@ 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 (this._unsafeCache) {
 				try {
 					const unsafeCachedModule = unsafeCacheDependencies.get(dep);
@@ -1831,6 +1913,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								dep,
 								unsafeCachedModule
 							);
+							this._lazyBarrelController.unlazyForDependency(
+								unsafeCachedModule,
+								dep,
+								sortedDependencies
+							);
 							return;
 						}
 						const identifier = unsafeCachedModule.identifier();
@@ -1844,6 +1931,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 								dep,
 								cachedModule
 							);
+							this._lazyBarrelController.unlazyForDependency(
+								cachedModule,
+								dep,
+								sortedDependencies
+							);
 							return;
 						}
 						inProgressSorting++;
@@ -1904,6 +1996,11 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 									dep,
 									cachedModule
 								); // a3
+								this._lazyBarrelController.unlazyForDependency(
+									cachedModule,
+									dep,
+									sortedDependencies
+								);
 							} catch (err) {
 								if (inProgressSorting <= 0) return;
 								inProgressSorting = -1;
@@ -2070,6 +2167,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			module,
 			true,
 			false,
+			[dependency],
 			callback
 		);
 	}
@@ -2352,6 +2450,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						module,
 						recursive,
 						checkCycle,
+						dependencies,
 						callback
 					);
 				});
@@ -2366,6 +2465,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 	 * @param {Module} module module
 	 * @param {boolean} recursive true if make it recursive, otherwise false
 	 * @param {boolean} checkCycle true if need to check cycle, otherwise false
+	 * @param {Dependency[]} dependencies the dependencies that resolved to the module (lazy barrel)
 	 * @param {ModuleCallback} callback callback
 	 * @returns {void}
 	 */
@@ -2374,6 +2474,7 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		module,
 		recursive,
 		checkCycle,
+		dependencies,
 		callback
 	) {
 		// Check for cycles when build is trigger inside another build
@@ -2438,17 +2539,55 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				return;
 			}
 
-			// This avoids deadlocks for circular dependencies
-			if (this.processDependenciesQueue.isProcessing(module)) {
-				return callback(null, module);
-			}
+			// 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
+			);
 
-			this.processModuleDependencies(module, (err) => {
-				if (err) {
-					return callback(err);
+			if (unlazyItems !== undefined) {
+				let inProgress = unlazyItems.length + 1; // +1 = the module's own dep processing
+				let errored = false;
+				/**
+				 * @param {(WebpackError | null)=} err error
+				 * @returns {void}
+				 */
+				const onJobDone = (err) => {
+					if (errored) return;
+					if (err) {
+						errored = true;
+						return callback(err);
+					}
+					if (--inProgress === 0) callback(null, module);
+				};
+				for (const item of unlazyItems) {
+					this.handleModuleCreation(item, (err) => {
+						onJobDone(err && this.bail ? err : null);
+					});
 				}
-				callback(null, module);
-			});
+				if (this.processDependenciesQueue.isProcessing(module)) {
+					onJobDone();
+				} else {
+					this.processModuleDependencies(module, onJobDone);
+				}
+			} else {
+				// This avoids deadlocks for circular dependencies
+				if (this.processDependenciesQueue.isProcessing(module)) {
+					return callback(null, module);
+				}
+
+				this.processModuleDependencies(module, (err) => {
+					if (err) {
+						return callback(err);
+					}
+					callback(null, module);
+				});
+			}
 		});
 	}
 
@@ -2809,22 +2948,6 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			}
 		}
 
-		/**
-		 * Reduce affect type.
-		 * @param {Readonly<ModuleGraphConnection[]>} connections connections
-		 * @returns {symbol | boolean} result
-		 */
-		const reduceAffectType = (connections) => {
-			let affected = false;
-			for (const { dependency } of connections) {
-				if (!dependency) continue;
-				const type = dependency.couldAffectReferencingModule();
-				if (type === Dependency.TRANSITIVE) return Dependency.TRANSITIVE;
-				if (type === false) continue;
-				affected = true;
-			}
-			return affected;
-		};
 		/** @type {Set<Module>} */
 		const directOnlyInfectedModules = new Set();
 		for (const module of infectedModules) {
@@ -2927,7 +3050,12 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 					queue.push.apply(queue, block.blocks);
 				}
 			}
-			return { id, modules, blocks };
+			return {
+				id,
+				modules,
+				blocks,
+				sourceTypes: module.getReferencedSourceTypes()
+			};
 		};
 		/**
 		 * Compares references.
@@ -2936,9 +3064,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		 * @param {string | number} references.id id
 		 * @param {Map<Module, string | number | undefined>=} references.modules modules
 		 * @param {(string | number | null)[]=} references.blocks blocks
+		 * @param {SourceTypes=} references.sourceTypes connection-dependent source types
 		 * @returns {boolean} ok?
 		 */
-		const compareReferences = (module, { id, modules, blocks }) => {
+		const compareReferences = (
+			module,
+			{ id, modules, blocks, sourceTypes }
+		) => {
 			if (id !== chunkGraph.getModuleId(module)) return false;
 			if (modules !== undefined) {
 				for (const [module, id] of modules) {
@@ -2962,6 +3094,13 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 				}
 				if (i !== blocks.length) return false;
 			}
+			// getReferencedSourceTypes() returns interned type sets, compare by reference. #20800
+			if (
+				sourceTypes !== undefined &&
+				module.getReferencedSourceTypes() !== sourceTypes
+			) {
+				return false;
+			}
 			return true;
 		};
 
@@ -2997,6 +3136,57 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		);
 	}
 
+	/**
+	 * Assigns a fresh dependency report cache token to every module whose
+	 * dependency errors/warnings could have changed since the previous
+	 * compilation: built modules and their (transitive) parents.
+	 * @private
+	 * @param {Set<Module>} modules modules
+	 * @returns {void}
+	 */
+	_flagModulesForDependencyReporting(modules) {
+		/** @type {DependencyReportCacheToken} */
+		const token = {};
+		const { moduleGraph, builtModules } = this;
+		/** @type {Set<Module>} */
+		const updatedModules = new Set();
+		for (const module of modules) {
+			if (
+				builtModules.has(module) ||
+				!dependencyReportCacheTokens.has(module)
+			) {
+				updatedModules.add(module);
+			}
+		}
+		// skip the parent walk when everything is updated anyway (initial build)
+		if (updatedModules.size !== modules.size) {
+			/** @type {Set<Module>} */
+			const directOnlyUpdatedModules = new Set();
+			for (const module of updatedModules) {
+				for (const [
+					referencingModule,
+					connections
+				] of moduleGraph.getIncomingConnectionsByOriginModule(module)) {
+					if (!referencingModule) continue;
+					if (updatedModules.has(referencingModule)) continue;
+					const type = reduceAffectType(connections);
+					if (!type) continue;
+					if (type === true) {
+						directOnlyUpdatedModules.add(referencingModule);
+					} else {
+						updatedModules.add(referencingModule);
+					}
+				}
+			}
+			for (const module of directOnlyUpdatedModules) {
+				updatedModules.add(module);
+			}
+		}
+		for (const module of updatedModules) {
+			dependencyReportCacheTokens.set(module, token);
+		}
+	}
+
 	/**
 	 * Processes the provided callback.
 	 * @param {Callback} callback callback
@@ -3135,16 +3325,18 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						if (d === 0 || p === 0) continue;
 						const t = d / p;
 						innerSum += t;
-						if (t <= 10) continue;
-						logByValue(
-							t,
-							` |  | ${Math.round(t)} ms${
-								p >= 1.1 ? ` (parallelism ${Math.round(p * 10) / 10})` : ""
-							} ${category} > ${module.readableIdentifier(
-								this.requestShortener
-							)}`
-						);
-						innerMax = Math.max(innerMax, t);
+						/* 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
+								)}`
+							);
+							innerMax = Math.max(innerMax, t);
+						}
 					}
 					sum += innerSum;
 					if (innerSum <= 10) continue;
@@ -3215,15 +3407,24 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 
 			// extract warnings and errors from modules
 			this.moduleGraph.freeze("dependency errors");
-			// TODO keep a cacheToken (= {}) for each module in the graph
-			// create a new one per compilation and flag all updated files
-			// and parents with it
 			this.logger.time("report dependency errors and warnings");
+			// moduleMemCaches has its own invalidation (incl. reference changes),
+			// so cache tokens are only used without it
+			const useReportCacheTokens = moduleMemCaches === undefined;
+			if (useReportCacheTokens) {
+				this._flagModulesForDependencyReporting(modules);
+			}
 			for (const module of modules) {
-				// TODO only run for modules with changed cacheToken
-				// global WeakMap<CacheToken, WeakSet<Module>> to keep modules without errors/warnings
 				const memCache = moduleMemCaches && moduleMemCaches.get(module);
 				if (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;
+				}
 				let hasProblems = this.reportDependencyErrorsAndWarnings(module, [
 					module
 				]);
@@ -3247,7 +3448,21 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 						hasProblems = true;
 					}
 				}
-				if (!hasProblems && memCache) memCache.set("noWarningsOrErrors", true);
+				if (!hasProblems) {
+					if (memCache) memCache.set("noWarningsOrErrors", true);
+					if (useReportCacheTokens) {
+						let cleanModules = modulesWithoutProblems.get(
+							/** @type {DependencyReportCacheToken} */ (token)
+						);
+						if (cleanModules === undefined) {
+							modulesWithoutProblems.set(
+								/** @type {DependencyReportCacheToken} */ (token),
+								(cleanModules = new WeakSet())
+							);
+						}
+						cleanModules.add(module);
+					}
+				}
 			}
 			this.moduleGraph.unfreeze();
 			this.logger.timeEnd("report dependency errors and warnings");
@@ -3266,6 +3481,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 		this.additionalChunkAssets.length = 0;
 		this.assets = {};
 		this.assetsInfo.clear();
+		this._assetToChunkIndex = undefined;
+		this._assetToChunkAuxiliaryIndex = undefined;
 		this.moduleGraph.removeAllModuleAttributes();
 		this.moduleGraph.unfreeze();
 		this.moduleMemCaches2 = undefined;
@@ -3288,6 +3505,8 @@ BREAKING CHANGE: Asset processing hooks in Compilation has been merged into a si
 			this.rebuildQueue.clear();
 			this.processDependenciesQueue.clear();
 			this.addModuleQueue.clear();
+			// lazy barrel only acts during make; release its bookkeeping now
+			this._lazyBarrelController.clear();
 			return callback(err);
 		};
 
@@ -3675,7 +3894,14 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const warnings = d.getWarnings(this.moduleGraph);
 				if (warnings) {
 					for (const w of warnings) {
-						const warning = new ModuleDependencyWarning(module, w, d.loc);
+						// A consolidated dependency (e.g. CssIcssExportDependency) carries
+						// per-item locations on the error itself; fall back to the
+						// dependency loc for the usual one-loc-per-dependency case.
+						const warning = new ModuleDependencyWarning(
+							module,
+							w,
+							/** @type {EXPECTED_ANY} */ (w).loc || d.loc
+						);
 						this.warnings.push(warning);
 						hasProblems = true;
 					}
@@ -3683,7 +3909,11 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 				const errors = d.getErrors(this.moduleGraph);
 				if (errors) {
 					for (const e of errors) {
-						const error = new ModuleDependencyError(module, e, d.loc);
+						const error = new ModuleDependencyError(
+							module,
+							e,
+							/** @type {EXPECTED_ANY} */ (e).loc || d.loc
+						);
 						this.errors.push(error);
 						hasProblems = true;
 					}
@@ -3905,7 +4135,8 @@ Or do you want to use the entrypoints '${name}' and '${runtime}' independently o
 					);
 					result = cachedResult = {
 						sources: new Map(),
-						runtimeRequirements: null
+						runtimeRequirements: null,
+						data: undefined
 					};
 				}
 			} else {
@@ -4896,6 +5127,11 @@ This prevents using hashes of each other and should be avoided.`);
 	 * @returns {void}
 	 */
 	emitAsset(file, source, assetInfo = {}) {
+		// A file may be attached to a chunk right after any emit (including the
+		// re-emit path for assets shared across chunks in createChunkAssets), so
+		// the lazily-built reverse index is stale after every emitAsset.
+		this._assetToChunkIndex = undefined;
+		this._assetToChunkAuxiliaryIndex = undefined;
 		if (this.assets[file]) {
 			if (!isSourceEqual(this.assets[file], source)) {
 				this.errors.push(
@@ -5077,22 +5313,95 @@ This prevents using hashes of each other and should be avoided.`);
 		this._setAssetInfo(newFile, assetInfo);
 		delete this.assets[file];
 		this.assets[newFile] = source;
+		this._buildAssetToChunkIndex();
+		const index = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkIndex
+		);
+		const auxiliaryIndex = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkAuxiliaryIndex
+		);
+		const chunks = index.get(file);
+		const auxiliaryChunks = auxiliaryIndex.get(file);
+		if (chunks === undefined && auxiliaryChunks === undefined) {
+			// Not tracked in either index: chunk sets may have been mutated
+			// directly (bypassing emitAsset), so scan all chunks to stay correct.
+			for (const chunk of this.chunks) {
+				this._renameAssetInChunk(chunk, chunk.files, index, file, newFile);
+				this._renameAssetInChunk(
+					chunk,
+					chunk.auxiliaryFiles,
+					auxiliaryIndex,
+					file,
+					newFile
+				);
+			}
+			return;
+		}
+		if (chunks !== undefined) {
+			index.delete(file);
+			for (const chunk of chunks) {
+				this._renameAssetInChunk(chunk, chunk.files, index, file, newFile);
+			}
+		}
+		if (auxiliaryChunks !== undefined) {
+			auxiliaryIndex.delete(file);
+			for (const chunk of auxiliaryChunks) {
+				this._renameAssetInChunk(
+					chunk,
+					chunk.auxiliaryFiles,
+					auxiliaryIndex,
+					file,
+					newFile
+				);
+			}
+		}
+	}
+
+	// Lazily build the reverse index file -> chunks. emitAsset() invalidates
+	// it, so chunk.files / chunk.auxiliaryFiles entries added alongside a newly
+	// emitted asset are always picked up on the next rebuild.
+	/**
+	 * @private
+	 * @returns {void}
+	 */
+	_buildAssetToChunkIndex() {
+		if (this._assetToChunkIndex !== undefined) return;
+		/** @type {Map<string, Set<Chunk>>} */
+		const filesIndex = new Map();
+		/** @type {Map<string, Set<Chunk>>} */
+		const auxiliaryIndex = new Map();
 		for (const chunk of this.chunks) {
-			{
-				const size = chunk.files.size;
-				chunk.files.delete(file);
-				if (size !== chunk.files.size) {
-					chunk.files.add(newFile);
-				}
+			for (const file of chunk.files) {
+				let set = filesIndex.get(file);
+				if (set === undefined) filesIndex.set(file, (set = new Set()));
+				set.add(chunk);
 			}
-			{
-				const size = chunk.auxiliaryFiles.size;
-				chunk.auxiliaryFiles.delete(file);
-				if (size !== chunk.auxiliaryFiles.size) {
-					chunk.auxiliaryFiles.add(newFile);
-				}
+			for (const file of chunk.auxiliaryFiles) {
+				let set = auxiliaryIndex.get(file);
+				if (set === undefined) auxiliaryIndex.set(file, (set = new Set()));
+				set.add(chunk);
 			}
 		}
+		this._assetToChunkIndex = filesIndex;
+		this._assetToChunkAuxiliaryIndex = auxiliaryIndex;
+	}
+
+	/**
+	 * @private
+	 * @param {Chunk} chunk the chunk owning the set
+	 * @param {Set<string>} set chunk.files or chunk.auxiliaryFiles
+	 * @param {Map<string, Set<Chunk>>} index matching reverse index
+	 * @param {string} file old file name
+	 * @param {string} newFile new file name
+	 * @returns {void}
+	 */
+	_renameAssetInChunk(chunk, set, index, file, newFile) {
+		// Only carry the rename to chunks that actually held the old name.
+		if (!set.delete(file)) return;
+		set.add(newFile);
+		let target = index.get(newFile);
+		if (target === undefined) index.set(newFile, (target = new Set()));
+		target.add(chunk);
 	}
 
 	/**
@@ -5128,11 +5437,31 @@ This prevents using hashes of each other and should be avoided.`);
 				}
 			}
 		}
-		// TODO If this becomes a performance problem
-		// store a reverse mapping from asset to chunk
-		for (const chunk of this.chunks) {
-			chunk.files.delete(file);
-			chunk.auxiliaryFiles.delete(file);
+		this._buildAssetToChunkIndex();
+		const index = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkIndex
+		);
+		const auxiliaryIndex = /** @type {Map<string, Set<Chunk>>} */ (
+			this._assetToChunkAuxiliaryIndex
+		);
+		const chunks = index.get(file);
+		const auxiliaryChunks = auxiliaryIndex.get(file);
+		if (chunks === undefined && auxiliaryChunks === undefined) {
+			// Not tracked in either index: chunk sets may have been mutated
+			// directly (bypassing emitAsset), so scan all chunks to stay correct.
+			for (const chunk of this.chunks) {
+				chunk.files.delete(file);
+				chunk.auxiliaryFiles.delete(file);
+			}
+			return;
+		}
+		if (chunks !== undefined) {
+			for (const chunk of chunks) chunk.files.delete(file);
+			index.delete(file);
+		}
+		if (auxiliaryChunks !== undefined) {
+			for (const chunk of auxiliaryChunks) chunk.auxiliaryFiles.delete(file);
+			auxiliaryIndex.delete(file);
 		}
 	}
 
@@ -5170,6 +5499,8 @@ This prevents using hashes of each other and should be avoided.`);
 			chunk.files.clear();
 			chunk.auxiliaryFiles.clear();
 		}
+		this._assetToChunkIndex = undefined;
+		this._assetToChunkAuxiliaryIndex = undefined;
 	}
 
 	createModuleAssets() {