@depup/webpack 5.110.3-depup.0 → 5.111.1-depup.0

package/lib/serialization/ObjectMiddleware.js

@@ -2,6 +2,28 @@
 	MIT License http://www.opensource.org/licenses/mit-license.php
 */
 
+/*
+
+Format:
+
+File -> Section*
+Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
+
+ObjectSection -> ESCAPE (
+	number:relativeOffset (number > 0) |
+	string:request (string|null):export
+) Section:value* ESCAPE ESCAPE_END_OBJECT
+ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
+EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
+EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
+OtherSection -> any (except ESCAPE)
+
+Why using null as escape value?
+Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
+Technically any value can be used.
+
+*/
+
 "use strict";
 
 const { DEFAULTS } = require("../config/defaults");
@@ -29,28 +51,6 @@ const SetObjectSerializer = require("./SetObjectSerializer");
 
 /** @typedef {new (...params: EXPECTED_ANY[]) => EXPECTED_ANY} Constructor */
 
-/*
-
-Format:
-
-File -> Section*
-Section -> ObjectSection | ReferenceSection | EscapeSection | OtherSection
-
-ObjectSection -> ESCAPE (
-	number:relativeOffset (number > 0) |
-	string:request (string|null):export
-) Section:value* ESCAPE ESCAPE_END_OBJECT
-ReferenceSection -> ESCAPE number:relativeOffset (number < 0)
-EscapeSection -> ESCAPE ESCAPE_ESCAPE_VALUE (escaped value ESCAPE)
-EscapeSection -> ESCAPE ESCAPE_UNDEFINED (escaped value ESCAPE)
-OtherSection -> any (except ESCAPE)
-
-Why using null as escape value?
-Multiple null values can merged by the BinaryMiddleware, which makes it very efficient
-Technically any value can be used.
-
-*/
-
 /**
  * Defines the object serializer snapshot type used by this module.
  * @typedef {object} ObjectSerializerSnapshot
@@ -107,21 +107,6 @@ Technically any value can be used.
  * @property {(context: ObjectDeserializerContext<EXPECTED_ANY>) => EXPECTED_ANY} deserialize
  */
 
-/**
- * Updates set size using the provided set.
- * @template T
- * @param {Set<T>} set set
- * @param {number} size count of items to keep
- */
-const setSetSize = (set, size) => {
-	let i = 0;
-	for (const item of set) {
-		if (i++ >= size) {
-			set.delete(item);
-		}
-	}
-};
-
 /**
  * Updates map size using the provided map.
  * @template K, X
@@ -149,6 +134,9 @@ const toHash = (buffer, hashFunction) => {
 	return hash.digest("latin1");
 };
 
+/** Marks an object whose children are still being written; never a real position. */
+const IN_PROGRESS = -1;
+
 const ESCAPE = null;
 const ESCAPE_ESCAPE_VALUE = null;
 const ESCAPE_END_OBJECT = true;
@@ -195,9 +183,8 @@ if (typeof AggregateError !== "undefined") {
 	);
 }
 
-// If in a sandboxed environment (e.g. jest), this escapes the sandbox and registers
-// real Object and Array types to. These types may occur in the wild too, e.g. when
-// using Structured Clone in postMessage.
+// In a sandboxed environment such as jest, this escapes the sandbox to register
+// the real Object and Array too, which reach us through a structured clone.
 // eslint-disable-next-line n/exports-style
 if (exports.constructor !== Object) {
 	// eslint-disable-next-line n/exports-style
@@ -463,16 +450,22 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let currentPosTypeLookup = 0;
 		/** @type {Map<SerializerConfigWithSerializer, number>} */
 		let objectTypeLookup = new Map();
-		/** @type {Set<ComplexSerializableType>} */
-		const cycleStack = new Set();
+		/**
+		 * One-entry cache in front of `objectTypeLookup`, since runs of one class are common.
+		 * @type {SerializerConfigWithSerializer | undefined}
+		 */
+		let lastConfig;
+		/** @type {number} */
+		let lastConfigIndex = 0;
+		/** @type {ComplexSerializableType[]} */
+		const cycleStack = [];
 		/**
 		 * Returns stack.
 		 * @param {ComplexSerializableType} item item to stack
 		 * @returns {string} stack
 		 */
 		const stackToString = (item) => {
-			const arr = [...cycleStack];
-			arr.push(item);
+			const arr = [...cycleStack, item];
 			return arr
 				.map((item) => {
 					if (typeof item === "string") {
@@ -528,63 +521,35 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
-		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
-		let ctx = {
-			write(value) {
-				try {
-					process(/** @type {ComplexSerializableType} */ (value));
-				} catch (err) {
-					if (err !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined) {
-							hasDebugInfoAttached = new WeakSet();
-						}
-						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
-							/** @type {Error} */
-							(err).message +=
-								`\nwhile serializing ${stackToString(/** @type {ComplexSerializableType} */ (value))}`;
-							hasDebugInfoAttached.add(/** @type {Error} */ (err));
-						}
-					}
-					throw err;
-				}
-				return ctx;
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			snapshot() {
-				return {
-					length: result.length,
-					cycleStackSize: cycleStack.size,
-					referenceableSize: referenceable.size,
-					currentPos,
-					objectTypeLookupSize: objectTypeLookup.size,
-					currentPosTypeLookup
-				};
-			},
-			rollback(snapshot) {
-				result.length = snapshot.length;
-				setSetSize(cycleStack, snapshot.cycleStackSize);
-				setMapSize(referenceable, snapshot.referenceableSize);
-				currentPos = snapshot.currentPos;
-				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
-				currentPosTypeLookup = snapshot.currentPosTypeLookup;
-			},
-			...context
+		/**
+		 * Appends the path from the root to `item`, once per error.
+		 * @param {Error} err error thrown while writing `item`
+		 * @param {ComplexSerializableType} item item being written
+		 * @returns {Error} err
+		 */
+		const attachSerializationPath = (err, item) => {
+			if (hasDebugInfoAttached === undefined) {
+				hasDebugInfoAttached = new WeakSet();
+			}
+			if (!hasDebugInfoAttached.has(err)) {
+				err.message += `\nwhile serializing ${stackToString(item)}`;
+				hasDebugInfoAttached.add(err);
+			}
+			return err;
 		};
-		this.extendContext(ctx);
 		// Dispatched on `typeof` first: two thirds of the items are numbers,
 		// booleans and `undefined`, and only 3% are buffers.
 		/**
-		 * Processes the provided item.
+		 * Writes one item into the output; the context is returned so writes chain.
 		 * @param {ComplexSerializableType} item item to serialize
+		 * @returns {ObjectSerializerContext<EXPECTED_ANY>} context
 		 */
 		const process = (item) => {
 			switch (typeof item) {
 				case "number":
 				case "boolean":
 					result.push(item);
-					return;
+					return ctx;
 				case "string": {
 					if (item.length > 1) {
 						// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
@@ -602,10 +567,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 							) {
 								// A back-reference is `null` + the offset.
 								result.push(ESCAPE, offset);
-								return;
+								return ctx;
 							}
 						}
-						addReferenceable(item);
+						referenceable.set(item, currentPos++);
 					}
 
 					if (item.length > 102400 && context.logger) {
@@ -617,87 +582,115 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 
 					result.push(item);
-					return;
+					return ctx;
 				}
 				case "undefined":
 					result.push(ESCAPE, ESCAPE_UNDEFINED);
-					return;
+					return ctx;
 				case "object": {
 					// ESCAPE is null, so this covers null too
 					if (item === ESCAPE) {
 						result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-						return;
+						return ctx;
 					}
 
-					if (Buffer.isBuffer(item)) {
-						// check if we can emit a reference
-						const ref = referenceable.get(item);
-						if (ref !== undefined) {
-							result.push(ESCAPE, ref - currentPos);
-							return;
+					// buffers and objects share one reference table, so a single
+					// lookup answers both before the costlier buffer test
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						if (ref === IN_PROGRESS) {
+							throw attachSerializationPath(
+								new Error(
+									"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
+								),
+								item
+							);
 						}
+						result.push(ESCAPE, ref - currentPos);
+						return ctx;
+					}
+
+					if (Buffer.isBuffer(item)) {
 						const alreadyUsedBuffer = dedupeBuffer(item);
 						if (alreadyUsedBuffer !== item) {
 							const ref = referenceable.get(alreadyUsedBuffer);
 							if (ref !== undefined) {
 								referenceable.set(item, ref);
 								result.push(ESCAPE, ref - currentPos);
-								return;
+								return ctx;
 							}
 							item = alreadyUsedBuffer;
 						}
-						addReferenceable(item);
+						referenceable.set(item, currentPos++);
 
 						result.push(/** @type {Buffer} */ (item));
-						return;
-					}
-
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-
-					if (cycleStack.has(item)) {
-						throw new Error(
-							"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
-						);
+						return ctx;
 					}
 
 					// Keyed by the registration itself: one per class, so it stands in for
 					// `${request}/${name}` without building that string per object.
-					const config = ObjectMiddleware.getSerializerFor(
-						/** @type {Constructor} */
-						(item)
+					const proto = Object.getPrototypeOf(item);
+					const registered = serializers.get(
+						proto === null ? null : proto.constructor
 					);
+					/** @type {SerializerConfigWithSerializer} */
+					let config;
+					if (registered !== undefined && registered.serializer !== undefined) {
+						config = /** @type {SerializerConfigWithSerializer} */ (registered);
+					} else {
+						try {
+							// re-resolved so the miss reports which class is unregistered
+							config = ObjectMiddleware.getSerializerFor(
+								/** @type {Constructor} */
+								(item)
+							);
+						} catch (err) {
+							if (err === NOT_SERIALIZABLE) throw err;
+							throw attachSerializationPath(/** @type {Error} */ (err), item);
+						}
+					}
 					const { request, name, serializer } = config;
-					const lastIndex = objectTypeLookup.get(config);
+					const lastIndex =
+						config === lastConfig
+							? lastConfigIndex
+							: objectTypeLookup.get(config);
 
 					if (lastIndex === undefined) {
-						objectTypeLookup.set(config, currentPosTypeLookup++);
+						lastConfigIndex = currentPosTypeLookup++;
+						objectTypeLookup.set(config, lastConfigIndex);
 
 						result.push(ESCAPE, request, name);
 					} else {
+						lastConfigIndex = lastIndex;
 						result.push(ESCAPE, currentPosTypeLookup - lastIndex);
 					}
+					lastConfig = config;
 
-					cycleStack.add(item);
+					referenceable.set(item, IN_PROGRESS);
+					cycleStack.push(item);
 
 					try {
 						serializer.serialize(item, ctx);
-					} finally {
-						cycleStack.delete(item);
+					} catch (err) {
+						cycleStack.pop();
+						if (err !== NOT_SERIALIZABLE) {
+							attachSerializationPath(/** @type {Error} */ (err), item);
+						}
+						throw err;
 					}
+					cycleStack.pop();
 
 					result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-					addReferenceable(item);
-					return;
+					referenceable.set(item, currentPos++);
+					return ctx;
 				}
 				case "function": {
 					if (!SerializerMiddleware.isLazy(item)) {
-						throw new Error(`Unexpected function ${item}`);
+						throw attachSerializationPath(
+							new Error(`Unexpected function ${item}`),
+							item
+						);
 					}
 
 					/** @type {SerializedType | undefined} */
@@ -708,10 +701,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 						if (typeof serializedData === "function") {
 							result.push(serializedData);
 						} else {
-							throw new Error("Not implemented");
+							throw attachSerializationPath(new Error("Not implemented"), item);
 						}
 					} else if (SerializerMiddleware.isLazy(item, this)) {
-						throw new Error("Not implemented");
+						throw attachSerializationPath(new Error("Not implemented"), item);
 					} else {
 						const data =
 							/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
@@ -723,12 +716,50 @@ class ObjectMiddleware extends SerializerMiddleware {
 						SerializerMiddleware.setLazySerializedValue(item, data);
 						result.push(data);
 					}
-					return;
+					return ctx;
 				}
 				default:
 					result.push(item);
 			}
+			return ctx;
+		};
+		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
+		let ctx = {
+			write: process,
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			snapshot() {
+				return {
+					length: result.length,
+					cycleStackSize: cycleStack.length,
+					referenceableSize: referenceable.size,
+					currentPos,
+					objectTypeLookupSize: objectTypeLookup.size,
+					currentPosTypeLookup
+				};
+			},
+			rollback(snapshot) {
+				result.length = snapshot.length;
+				cycleStack.length = snapshot.cycleStackSize;
+				// a `setCircularReference` since the snapshot replaced a marker on an
+				// item already keyed here, which `setMapSize` cannot undo
+				for (let i = 0; i < cycleStack.length; i++) {
+					const item = /** @type {ReferenceableItem} */ (cycleStack[i]);
+					const ref = referenceable.get(item);
+					if (ref !== undefined && ref >= snapshot.currentPos) {
+						referenceable.set(item, IN_PROGRESS);
+					}
+				}
+				setMapSize(referenceable, snapshot.referenceableSize);
+				currentPos = snapshot.currentPos;
+				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
+				lastConfig = undefined;
+				currentPosTypeLookup = snapshot.currentPosTypeLookup;
+			},
+			...context
 		};
+		this.extendContext(ctx);
 
 		try {
 			for (const item of data) {
@@ -740,10 +771,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 
 			throw err;
 		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.write" method so it will reference
-			// it from e. g. Dependency.prototype.serialize -(IC)-> ctx.write
+			// Drop these references, which would otherwise leak: v8 optimizes the
+			// generated code for this `ctx.write`, so an inline cache on
+			// `Dependency.prototype.serialize` keeps pointing at it.
 			data =
 				result =
 				referenceable =
@@ -942,10 +972,9 @@ class ObjectMiddleware extends SerializerMiddleware {
 			}
 			return result;
 		} finally {
-			// Get rid of these references to avoid leaking memory
-			// This happens because the optimized code v8 generates
-			// is optimized for our "ctx.read" method so it will reference
-			// it from e. g. Dependency.prototype.deserialize -(IC)-> ctx.read
+			// Drop these references, which would otherwise leak: v8 optimizes the
+			// generated code for this `ctx.read`, so an inline cache on
+			// `Dependency.prototype.deserialize` keeps pointing at it.
 			result =
 				referenceable =
 				data =

package/lib/sharing/ConsumeSharedPlugin.js

@@ -15,6 +15,7 @@ const ConsumeSharedFallbackDependency = require("./ConsumeSharedFallbackDependen
 const ConsumeSharedModule = require("./ConsumeSharedModule");
 const ConsumeSharedRuntimeModule = require("./ConsumeSharedRuntimeModule");
 const ProvideForSharedDependency = require("./ProvideForSharedDependency");
+const { addDeclaredShared } = require("./declaredShared");
 const { resolveMatchedConfigs } = require("./resolveMatchedConfigs");
 const {
 	getDescriptionFile,
@@ -137,6 +138,17 @@ class ConsumeSharedPlugin {
 					normalModuleFactory
 				);
 
+				// A key ending in a slash shares everything under it, and the
+				// modules then carry the remainder appended to the share key.
+				addDeclaredShared(
+					compilation,
+					consumes.map(([key, config]) => ({
+						name: key,
+						shareKey: config.shareKey,
+						prefix: key.endsWith("/")
+					}))
+				);
+
 				/** @typedef {Map<string, ConsumeOptions>} Consumes */
 
 				/** @type {Consumes} */

package/lib/sharing/ConsumeSharedRuntimeModule.js

@@ -33,6 +33,17 @@ class ConsumeSharedRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return this._runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers)
+			? [[RuntimeGlobals.ensureChunkHandlers, "consumes"]]
+			: [];
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/sharing/ShareRuntimeModule.js

@@ -23,6 +23,15 @@ class ShareRuntimeModule extends RuntimeModule {
 		super("sharing");
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/sharing/declaredShared.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Compilation from "../Compilation" */
+
+/**
+ * @typedef {object} SharedDeclaration
+ * @property {string} name the config key, as the config spells it
+ * @property {string} shareKey the key the modules created for it carry
+ * @property {boolean} prefix whether it shares everything under the key
+ */
+
+/** @type {WeakMap<Compilation, SharedDeclaration[]>} */
+const DECLARED_SHARED = new WeakMap();
+
+/**
+ * What this build declared as shared, one entry per config key, since several
+ * may name one share key. `performance.unusedConfig` matches modules on the
+ * share key and reports the config key.
+ * @param {Compilation} compilation the compilation
+ * @returns {SharedDeclaration[] | undefined} the declarations, when any were made
+ */
+const getDeclaredShared = (compilation) => DECLARED_SHARED.get(compilation);
+
+/**
+ * Records declarations, appending when a build applies the plugin more than
+ * once, as `ModuleFederationPlugin` and `SharePlugin` do.
+ * @param {Compilation} compilation the compilation
+ * @param {SharedDeclaration[]} declarations what this application declared
+ * @returns {void}
+ */
+const addDeclaredShared = (compilation, declarations) => {
+	const declared = DECLARED_SHARED.get(compilation);
+
+	if (declared === undefined) {
+		DECLARED_SHARED.set(compilation, [...declarations]);
+	} else {
+		for (const declaration of declarations) declared.push(declaration);
+	}
+};
+
+module.exports.addDeclaredShared = addDeclaredShared;
+module.exports.getDeclaredShared = getDeclaredShared;

package/lib/stats/DefaultStatsFactoryPlugin.js

@@ -1274,10 +1274,9 @@ const SIMPLE_EXTRACTORS = {
 			{ name, chunkGroup },
 			{ compilation }
 		) => {
-			// SSR frameworks consume this to inject the initial-chunk +
-			// URL-asset `<link>` tags into their server-rendered HTML without
-			// having to walk the chunk graph themselves. Only entrypoints
-			// carry hints; split-chunk / async chunk groups are skipped.
+			// An SSR framework reads this to inject the `<link>` tags into its own
+			// HTML without walking the chunk graph. Only entrypoints carry hints, so
+			// split-chunk and async groups are skipped.
 			if (!compilation.entrypoints.get(name)) return;
 
 			const ResourceHintPlugin = require("../prefetch/ResourceHintPlugin");
@@ -1340,9 +1339,11 @@ const SIMPLE_EXTRACTORS = {
 			const warnings = module.getWarnings();
 			const warningsCount =
 				warnings !== undefined ? countIterable(warnings) : 0;
-			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
+			const { cacheable, diagnostics } = /** @type {BuildInfo} */ (
 				module.buildInfo
 			);
+			const notCacheableReasons =
+				diagnostics === undefined ? undefined : diagnostics.notCacheableReasons;
 			const preOrderIndex = /** @type {number} */ (
 				moduleGraph.getPreOrderIndex(module)
 			);

package/lib/stats/DefaultStatsPrinterPlugin.js

@@ -460,6 +460,8 @@ const ASSET_SIMPLE_PRINTERS = {
 		javascriptModule ? formatFlag("javascript module") : undefined,
 	"asset.info.sourceFilename": (sourceFilename, { formatFlag }) =>
 		sourceFilename ? formatFlag(`from: ${sourceFilename}`) : undefined,
+	"asset.info.copied": (copied, { green, formatFlag }) =>
+		copied ? green(formatFlag("copied")) : undefined,
 	"asset.info.development": (development, { green, formatFlag }) =>
 		development ? green(formatFlag("dev")) : undefined,
 	"asset.info.hotModuleReplacement": (
@@ -1045,6 +1047,7 @@ const PREFERRED_ORDERS = {
 	"asset.info": [
 		"immutable",
 		"sourceFilename",
+		"copied",
 		"javascriptModule",
 		"development",
 		"hotModuleReplacement"

package/lib/typescript/TypeScriptPlugin.js

@@ -122,9 +122,8 @@ const composeWithLoaderSourceMap = (
  */
 const stripTypes = (input) => {
 	try {
-		// Pass only `mode`. `sourceUrl` would emit a `//# sourceURL=…` pragma
-		// into the output (V8 debugger hint), and `sourceMap: true` is
-		// rejected in strip mode — we build the source map by hand instead.
+		// Only `mode`: `sourceUrl` would emit a `//# sourceURL=` pragma, and
+		// `sourceMap: true` is rejected in strip mode, so the map is built by hand.
 		// eslint-disable-next-line n/no-unsupported-features/node-builtins
 		return mod.stripTypeScriptTypes(input, { mode: "strip" });
 	} catch (err) {

package/lib/url/URLParserPlugin.js

@@ -257,10 +257,9 @@ class URLParserPlugin {
 					relative
 				);
 				dep.loc = parser.getLocation(expr);
-				// `parser.javascript.urlHints` provides project-wide defaults
-				// (resolved per-request, with `test` / `include` / `exclude`
-				// matching); a per-URL magic comment for the same hint wins
-				// when both are set.
+				// `parser.javascript.urlHints` gives the project-wide defaults,
+				// resolved per request; a per-URL magic comment for the same hint
+				// wins where both are set.
 				ResourceHintPlugin.applyResourceHints(
 					dep,
 					this.options.urlHints,
@@ -270,10 +269,9 @@ class URLParserPlugin {
 					parser.getLocation(expr)
 				);
 				parser.state.current.addDependency(dep);
-				// For ESM module output the template embeds the asset's resolved
-				// filename, so the asset must be code-generated first. Only added in
-				// that mode — a code-gen dependency on an asset that a later watch
-				// rebuild leaves unaffected can otherwise deadlock the scheduler.
+				// The ESM template embeds the asset's resolved filename, so the asset
+				// must be code-generated first. Added in that mode only: elsewhere the
+				// extra code-gen dependency can deadlock a watch rebuild.
 				if (parser.state.compilation.options.output.module) {
 					parser.state.module.addCodeGenerationDependency(dep);
 				}