webpack 5.111.0 → 5.111.1

package/lib/RuntimeTemplate.js

@@ -745,8 +745,7 @@ class RuntimeTemplate {
 				: undefined;
 		// A reassigned `__webpack_public_path__` cannot reach a baked literal, and `.p`
 		// belongs to a runtime, so only the runtimes it reaches keep the runtime form.
-		// `url-inline` is unaffected: that form falls back to `.p + <file>`, which reads
-		// the reassigned value at the call site rather than through the wrapper.
+		// `url-inline` is unaffected: it reads the value at the call site.
 		if (
 			form !== "url-inline" &&
 			APIPlugin.runtimeUsesPublicPathOverride(
@@ -774,12 +773,13 @@ class RuntimeTemplate {
 			return true;
 		}
 
-		// `url-inline` asks whether the file can be named at the call site at all, and
-		// its `.p + <file>` fallback spells that without `import.meta` — so the gate
-		// below does not rule it out, and the asset's javascript wrapper stays dropped.
+		// `url-inline` asks only whether the file can be named at the call site, and
+		// its `.p + <file>` fallback spells that without `import.meta`, so the gate
+		// below does not rule it out.
+
 		// `environment.module` is deliberately not consulted: ESM output writes
-		// `import.meta` regardless (the public path, the chunk loader), so the url forms
-		// only match what the rest of the bundle already assumes the target reads.
+		// `import.meta` regardless, so the url forms match what the rest of the
+		// bundle already assumes the target reads.
 		if (form === "url-inline") return true;
 		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
 		// syntax error. Runtime modules are emitted beside them, never wrapped.
@@ -1124,10 +1124,9 @@ class RuntimeTemplate {
 		const chunks = this._moduleChunks(module, chunkGraph);
 		const parts = this._resolvePublicPathPrefix(publicPath);
 		if (parts === null) return null;
-		// A protocol-relative base names a host but no scheme, and the runtime reads it
-		// against the chunk's own url to get one — the very url this literal is
-		// resolved against — so it may stay protocol-relative instead of being settled
-		// here. Nothing walks back to the output root first: the base replaces it.
+		// A protocol-relative base names a host but no scheme, and the runtime reads
+		// it against the very url this literal resolves against, so it may stay that
+		// way. Nothing walks back to the output root: the base replaces it.
 		if (base.startsWith("//")) {
 			return this._specifierOf(
 				[["literal", base], ...rootedParts(parts), ["literal", filename]],
@@ -1192,10 +1191,9 @@ class RuntimeTemplate {
 		let base;
 		let found = false;
 		for (const chunk of this.compilation.chunks) {
-			// What a literal has to agree with is the one value `BaseUriRuntimeModule`
-			// writes out, and it reads the entry options off the chunk it is emitted into
-			// — so only a chunk carrying a runtime has a say. Entries sharing one runtime
-			// chunk already share the base it sets, however their descriptors differ.
+			// A literal must agree with the one value `BaseUriRuntimeModule` writes, and
+			// that reads the entry options off the chunk it is emitted into, so only a
+			// chunk carrying a runtime has a say.
 			if (!chunk.hasRuntime()) continue;
 			const entryOptions = chunk.getEntryOptions();
 			// An entry this code cannot run under has no say in the base it resolves to.
@@ -1483,14 +1481,13 @@ class RuntimeTemplate {
 		}
 		if (!this.supportTemplateLiteral()) return this._es5Concatenation(args);
 
-		// cost comparison between template literal and concatenation:
-		// both need equal surroundings: `xxx` vs "xxx"
-		// template literal has constant cost of 3 chars for each expression
-		// es5 concatenation has cost of 3 + n chars for n expressions in row
-		// when a es5 concatenation ends with an expression it reduces cost by 3
-		// when a es5 concatenation starts with an single expression it reduces cost by 3
-		// e. g. `${a}${b}${c}` (3*3 = 9) is longer than ""+a+b+c ((3+3)-3 = 3)
-		// e. g. `x${a}x${b}x${c}x` (3*3 = 9) is shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12)
+		// WHY: cost comparison between a template literal and a concatenation, both
+		// needing equal surroundings (`xxx` against "xxx"). A template literal costs
+		// a constant 3 chars per expression; an es5 concatenation costs 3 + n chars
+		// for n expressions in a row, and reduces by 3 where it ends with an
+		// expression or starts with a single one. So `${a}${b}${c}` (3*3 = 9) is
+		// longer than ""+a+b+c ((3+3)-3 = 3), while `x${a}x${b}x${c}x` (3*3 = 9) is
+		// shorter than "x"+a+"x"+b+"x"+c+"x" (4+4+4 = 12).
 
 		let templateCost = 0;
 		let concatenationCost = 0;
@@ -2353,10 +2350,9 @@ class RuntimeTemplate {
 			request,
 			weak
 		});
-		// Harmony imports may be wrapped in runtime-condition `if` blocks
-		// but referenced outside those blocks (e.g. by harmony reexport),
-		// so they must remain function-scoped (`var`) rather than
-		// block-scoped (`let`/`const`).
+		// A harmony import may sit inside a runtime-condition `if` block yet be
+		// referenced outside it, so it stays function-scoped with `var` rather than
+		// block-scoped.
 		const optDeclaration = update ? "" : "var ";
 
 		const exportsType = module.getExportsType(
@@ -2495,10 +2491,8 @@ class RuntimeTemplate {
 				}
 				// accessing the .default property is same thing as `require()` the module.
 
-				// For example:
-				// import mod from "cjs";    mod.default.x;
-				// is translated to
-				// var mod = require("cjs"); mod.x;
+				// So `import mod from "cjs"; mod.default.x` translates to
+				// `var mod = require("cjs"); mod.x`.
 				switch (exportsType) {
 					case "dynamic":
 						if (isCall) {
@@ -2538,10 +2532,9 @@ class RuntimeTemplate {
 				exportsType === "default-only" ||
 				exportsType === "default-with-named"
 			) {
-				// now exportName.length is 0, which means the namespace object is used in an unknown way
-				// for example:
-				// import * as ns from "cjs"; console.log(ns);
-				// we will need to createFakeNamespaceObject that simulates ES Module namespace object
+				// `exportName.length` is 0, so the namespace object is used in an unknown
+				// way — `import * as ns from "cjs"; console.log(ns)` — and needs
+				// `createFakeNamespaceObject` to simulate an ES module namespace.
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				initFragments.push(
 					new InitFragment(
@@ -3443,9 +3436,8 @@ class RuntimeTemplate {
 		// emitted and filled in once the hash exists.
 		const deferred = template === undefined || HASH_IN_FILENAME.test(template);
 		// An id names the chunk in the stand-in, and one nothing could resolve would
-		// reach the bundle verbatim. The whole name is re-resolved later rather than
-		// carrying a stand-in of its own, so any hash spelling is fine here.
-		// One of the two always names where the reference goes.
+		// reach the bundle verbatim. The whole name is re-resolved later, so any hash
+		// spelling is fine here; one of the two always names the destination.
 		const chunks =
 			consumingChunks ||
 			this._moduleChunks(/** @type {Module} */ (consumingModule), chunkGraph);
@@ -4355,11 +4347,9 @@ class RuntimeTemplate {
 			compilation.hooks.processAssets.tapPromise(
 				{
 					name: PASS_NAME,
-					// Before source maps are written and before a minifier runs: both read
-					// the asset, and a stand-in is a different length than what replaces it.
-					// Every hash it reads is already settled — `createHash` runs ahead of
-					// every `processAssets` stage — and `RealContentHashPlugin` still repairs
-					// the names afterwards.
+					// Before source maps are written and before a minifier runs, since both
+					// read the asset and a stand-in differs in length from what replaces it.
+					// Every hash it reads is settled: `createHash` precedes every stage.
 					stage: getCompilation().PROCESS_ASSETS_STAGE_DERIVED
 				},
 				async () => {

package/lib/SourceMapDevToolPlugin.js

@@ -152,11 +152,9 @@ const extractSourceAndMap = (file, asset, options, registry) => {
 		if (!registry.has(file)) registry.set(file, asset);
 		return { source, sourceMap, mapSource: asset };
 	}
-	// The current asset (typically a `RawSource` left by an earlier
-	// SourceMapDevToolPlugin instance) has no internal map. Re-extract
-	// the map from the original Source we pinned earlier. We keep using
-	// `source` from the current asset so that any prior wrappers (e.g.
-	// appended sourceMappingURL comments) are preserved.
+	// The current asset, typically a `RawSource` an earlier instance left, has no
+	// internal map, so re-extract one from the pinned original. `source` still
+	// comes from the current asset, preserving any wrappers it gained.
 	const original = registry.get(file);
 	if (!original) return;
 	sourceMap = original.sourceAndMap
@@ -262,12 +260,9 @@ class SourceMapDevToolPlugin {
 		this.namespace = options.namespace || "";
 		/** @type {SourceMapDevToolPluginOptions} */
 		this.options = options;
-		// Cache salt derived from output-affecting options, so that two
-		// SourceMapDevToolPlugin instances (or `devtool` + a plugin) operating
-		// on the same asset don't share a cache entry. We serialize via
-		// `JSON.stringify` rather than a homemade separator so that any
-		// special characters (e.g. `|` inside a publicPath or sourceRoot)
-		// can't accidentally make two different option sets collide.
+		// Salt from the output-affecting options, so two instances on the same asset
+		// never share a cache entry. Serialized with `JSON.stringify` rather than a
+		// separator, which a `|` in a publicPath could collide through.
 		/** @type {string} */
 		this._cacheSalt = JSON.stringify([
 			toCacheKeyValue(options.filename),
@@ -326,12 +321,9 @@ class SourceMapDevToolPlugin {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
 			new SourceMapDevToolModuleOptionsPlugin(options).apply(compilation);
 
-			// All SourceMapDevToolPlugin instances on the same compilation share
-			// a registry of pristine asset sources, so the second instance to
-			// run can still recover the original map after the first instance
-			// has replaced the asset with a `RawSource`. The registry lives on a
-			// module-scoped `WeakMap` keyed by compilation so it is released
-			// automatically and never pollutes the compilation object.
+			// Every instance on a compilation shares this registry of pristine
+			// sources, so a later one still recovers the original map after the first
+			// replaced the asset. Keyed by compilation, so it releases on its own.
 			const originalSources = getOriginalSourceRegistry(compilation);
 
 			compilation.hooks.processAssets.tapAsync(
@@ -372,23 +364,12 @@ class SourceMapDevToolPlugin {
 					const tasks = [];
 					let fileIndex = 0;
 
-					// Shared deduplication set for `Source#clearCache` calls below.
-					// Webpack chunks routinely share module-level `CachedSource`
-					// instances. A per-call WeakSet would re-walk those shared
-					// subtrees once per chunk — 50 chunks × thousands of shared
-					// modules in dev/non-minified setups — and worse, every
-					// chunk's `sourceAndMap` would have to recompute the cleared
-					// caches, churning allocations (measured: +700 MB peak RSS,
-					// +6 s wall time on a 50×1000 synthetic build).
-					//
-					// Sharing one set lets each shared subtree be walked exactly
-					// once. The trade-off is that subsequent chunks' `sourceAndMap`
-					// calls can repopulate a shared module's `_cachedMaps` after
-					// its own clear was skipped (because the module is already in
-					// the visited set), leaving at most one populated cache entry
-					// per shared module at the end of the run — bounded to a few
-					// MB even at the scale of #20961. That's strictly preferable
-					// to the alternative's hundreds of MB of transient peak RSS.
+					// WHY: chunks share module-level `CachedSource` instances, so a
+					// per-call set re-walks each shared subtree once per chunk and every
+					// `sourceAndMap` then recomputes the cleared caches — measured at
+					// +700 MB peak RSS and +6 s on a 50×1000 build. One shared set walks
+					// each subtree once, at the cost of leaving at most one populated
+					// cache entry per shared module, a few MB even at #20961's scale.
 					const clearCacheVisited = new WeakSet();
 
 					asyncLib.each(
@@ -403,14 +384,12 @@ class SourceMapDevToolPlugin {
 								chunk
 							});
 
-							// The cache item identifier must include the per-instance
-							// salt so two SourceMapDevToolPlugin instances that target
-							// the same `file` don't collide in the persistent cache —
-							// they'd otherwise write different content to the same key
-							// and invalidate every pack on each build. We encode via
-							// `JSON.stringify` so that special characters (e.g. `|`)
-							// in an asset filename can't be spoofed to collide with the
-							// salt portion of the identifier.
+							// WHY: the cache item identifier carries the per-instance salt, or
+							// two SourceMapDevToolPlugin instances targeting the same `file`
+							// would write different content to one key and invalidate every pack
+							// on each build. `JSON.stringify` encodes it, so a special character
+							// such as `|` in an asset filename cannot be spoofed to collide with
+							// the salt portion.
 							const cacheItem = cache.getItemCache(
 								JSON.stringify([file, this._cacheSalt]),
 								cache.mergeEtags(
@@ -427,12 +406,9 @@ class SourceMapDevToolPlugin {
 								 * If presented in cache, reassigns assets. Cache assets already have source maps.
 								 */
 								if (cacheEntry) {
-									// Pin the still-unwrapped asset source in the registry
-									// before `compilation.updateAsset` replaces it. This is a
-									// pointer assignment — no source-map extraction work — and
-									// it lets a subsequent SourceMapDevToolPlugin instance
-									// extract the original map on demand even though the
-									// persistent cache hit lets us skip processing here.
+									// Pin the still-unwrapped source before `updateAsset` replaces
+									// it — a pointer assignment, no extraction — so a later
+									// instance can still reach the original map past this cache hit.
 									if (!originalSources.has(file)) {
 										originalSources.set(file, asset.source);
 									}
@@ -489,33 +465,21 @@ class SourceMapDevToolPlugin {
 									originalSources
 								);
 
-								// Release the per-instance caches that `sourceAndMap`
-								// just populated. The composed map (and, for
-								// `SourceMapSource`, the parsed `_sourceMapAsObject` /
-								// `_innerSourceMapAsObject`) otherwise sit on the
-								// CachedSource — and every shared child — until phase
-								// 2 replaces the asset, which is what causes the OOM
-								// spike on builds with thousands of chunks
-								// (webpack#20961). Keep `source` since downstream
-								// consumers reading the original asset still need it;
-								// `hash`/`size` default to retained because they're
-								// cheap to keep but expensive to rebuild.
-								// `clearCacheVisited` is shared across every call (see
-								// its declaration above for the rationale).
+								// WHY: the map `sourceAndMap` just composed otherwise sits on
+								// the CachedSource and every shared child until phase 2
+								// replaces the asset, which is the OOM spike of webpack#20961
+								// on builds with thousands of chunks. `source` is kept for
+								// downstream consumers, `hash` and `size` because they are
+								// cheap to hold and expensive to rebuild.
 								//
-								// Target `task.mapSource` (not `asset.source`): when
-								// `extractSourceAndMap` falls back to the pinned
-								// original (the current asset is a `RawSource` left
-								// by an earlier plugin instance), the `sourceAndMap`
-								// call populated the original's caches, not the
-								// current asset's.
-								//
-								// Feature-detected: `clearCache` landed in
-								// `webpack-sources` 3.5, but `compilation.assets` may
-								// hold `Source`-like instances from a third-party
-								// plugin built against an older copy of
-								// `webpack-sources` (or a hand-rolled implementation).
-								// Calling it unconditionally would throw on those.
+								// `task.mapSource`, not `asset.source`: where the fallback to
+								// the pinned original ran — the current asset being a
+								// `RawSource` an earlier instance left — the original's caches
+								// are the ones `extractSourceAndMap` populated.
+
+								// Feature-detected, since `clearCache` landed in
+								// `webpack-sources` 3.5 and a third-party plugin may hand us a
+								// `Source` built against an older copy.
 								if (task && typeof task.mapSource.clearCache === "function") {
 									task.mapSource.clearCache(
 										{
@@ -660,14 +624,9 @@ class SourceMapDevToolPlugin {
 									const moduleFilenames =
 										/** @type {string[]} */
 										(modules.map((m) => moduleToSourceNameMapping.get(m)));
-									// We deliberately do NOT mutate `sourceMap` in place: the
-									// task's `sourceMap` reference may be shared with a
-									// `SourceMapSource` whose internal map cache is the same
-									// object (webpack-sources keeps it cached). A second
-									// `SourceMapDevToolPlugin` instance that reads the original
-									// source through the registry would otherwise see our
-									// rewrites. Instead we build a fresh `outputSourceMap` for
-									// the .map file and leave the original alone.
+									// `sourceMap` is never mutated in place: the reference may be
+									// the same object a `SourceMapSource` has cached, so a second
+									// instance reading through the registry would see the rewrites.
 									/** @type {number[] | undefined} */
 									let ignoreList;
 									if (options.ignoreList) {
@@ -736,10 +695,9 @@ class SourceMapDevToolPlugin {
 										} else if (
 											typeof currentSourceMappingURLComment === "function"
 										) {
-											// Wrap the user's append function so the debug-id
-											// comment is prepended at call time. Template-string
-											// concatenation would coerce the function to a string
-											// and lose its dynamic behavior.
+											// Wrap the user's append function so the debug-id comment is
+											// prepended at call time; concatenating would coerce the
+											// function to a string and lose its behavior.
 											const wrappedFn = currentSourceMappingURLComment;
 											currentSourceMappingURLComment = (pathData, assetInfo) =>
 												`${debugIdComment}${wrappedFn(pathData, assetInfo)}`;
@@ -766,14 +724,9 @@ class SourceMapDevToolPlugin {
 									}
 
 									if (sourceMapFilename) {
-										// External `.map` file: hold the serialized map as a
-										// `Buffer` instead of a V8 string. `RawSource` accepts
-										// a buffer directly, and the emitted asset stays in
-										// `compilation.assets` until the build finishes — so
-										// storing the bytes off the V8 heap (where Buffers
-										// live, accounted as `external` memory) avoids keeping
-										// a large V8 string alive for the rest of the build
-										// and reduces heap pressure on `--max-old-space-size`.
+										// Hold the serialized map as a `Buffer`, which `RawSource`
+										// takes directly: the asset lives in `compilation.assets`
+										// until the build ends, and these bytes stay off the V8 heap.
 										const sourceMapBuffer = Buffer.from(
 											JSON.stringify(outputSourceMap),
 											"utf8"
@@ -820,10 +773,9 @@ class SourceMapDevToolPlugin {
 												})
 											);
 										}
-										// Preserve any existing related.sourceMap entries from
-										// earlier SourceMapDevToolPlugin runs on the same asset so
-										// that all generated maps remain discoverable via asset
-										// info (the schema allows string or string[]).
+										// Preserve the `related.sourceMap` entries earlier runs left on
+										// this asset, so every generated map stays discoverable; the
+										// schema allows a string or an array.
 										const existingSourceMap =
 											task.assetInfo.related &&
 											task.assetInfo.related.sourceMap;
@@ -879,11 +831,9 @@ class SourceMapDevToolPlugin {
 												`${PLUGIN_NAME}: append can't be a function when no filename is provided`
 											);
 										}
-										// Inline data-URL form: `[map]` gets the raw JSON, `[url]`
-										// gets the same JSON base64-encoded. `URL_COMMENT_REGEXP`
-										// is a `/g` regex, so a user `append` template with more
-										// than one `[url]` placeholder would otherwise re-encode
-										// the same JSON per match. Pre-compute both once.
+										// Inline data-URL form: `[map]` takes the raw JSON and `[url]`
+										// the same base64-encoded. Both are precomputed, or a template
+										// with two `[url]`s would re-encode per match.
 										const sourceMapString = JSON.stringify(outputSourceMap);
 										const sourceMapBase64 = Buffer.from(
 											sourceMapString,

package/lib/TemplatedPathPlugin.js

@@ -77,10 +77,9 @@ const getPresentKinds = (path) => {
 	return kinds;
 };
 
-// `[fullhash:<digest>]`/`[hash:<digest>]` — a non-numeric first argument is a digest
-// (a numeric one is just a length). A digest re-encodes the hash rather than reading
-// it, so no stand-in or runtime expression can take its place: the settled value has
-// to be inlined instead.
+// In `[fullhash:<arg>]` a non-numeric argument names a digest, a numeric one just
+// a length. A digest re-encodes the hash rather than reading it, so no stand-in
+// can stand for it and the settled value must be inlined.
 const FULL_HASH_DIGEST_REGEXP = /\[(?:fullhash|hash):(?!\d+\])\w/;
 
 /**
@@ -408,11 +407,9 @@ const interpolate = (path, data, assetInfo) => {
 		return path;
 	}
 
-	// Only build replacers for placeholders the template actually uses — most
-	// templates reference a handful, so building the whole table per call is
-	// wasted work. Replacer construction has no side effects (those fire only
-	// when a replacer is invoked, which happens for present kinds), so this is
-	// output-identical.
+	// Build replacers only for the placeholders a template uses, since most use a
+	// handful. Construction has no side effects — those fire on invocation — so
+	// the output is identical either way.
 	const presentKinds = getPresentKinds(path);
 
 	const chunkGraph = data.chunkGraph;
@@ -422,21 +419,9 @@ const interpolate = (path, data, assetInfo) => {
 	/** @type {Map<string, Replacer>} */
 	const replacements = new Map();
 
-	// Filename context
-	//
-	// Placeholders
-	//
-	// for /some/path/file.js?query#fragment:
-	// [file] - /some/path/file.js
-	// [query] - ?query
-	// [fragment] - #fragment
-	// [base] - file.js
-	// [path] - /some/path/
-	// [name] - file
-	// [ext] - .js
-	//
-	// [containedfile] and [containedpath] are [file] and [path] kept inside
-	// `output.path`
+	// Filename context. Of `/some/path/file.js?query#fragment`, `[file]` is the
+	// path without query or fragment, `[base]` its basename, `[path]` its
+	// directory, `[name]`/`[ext]` its halves; `contained*` stay under `output.path`.
 	if (
 		typeof data.filename === "string" &&
 		(presentKinds.has("file") ||
@@ -534,15 +519,7 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Compilation context
-	//
-	// Placeholders
-	//
-	// [fullhash] - data.hash (3a4b5c6e7f)
-	//
-	// Legacy Placeholders
-	//
-	// [hash] - data.hash (3a4b5c6e7f)
+	// Compilation context: `[fullhash]`, with `[hash]` as its legacy spelling.
 	if (data.hash && (presentKinds.has("fullhash") || presentKinds.has("hash"))) {
 		const hashReplacer = hashLength(
 			replacer(data.hash),
@@ -574,14 +551,8 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Chunk Context
-	//
-	// Placeholders
-	//
-	// [id] - chunk.id (0.js)
-	// [name] - chunk.name (app.js)
-	// [chunkhash] - chunk.hash (7823t4t4.js)
-	// [contenthash] - chunk.contentHash[type] (3256u3zg.js)
+	// Chunk context: `[id]`, `[name]`, `[chunkhash]`, and `[contenthash]` for the
+	// chunk's content hash of the requested type.
 	if (data.chunk) {
 		const chunk = data.chunk;
 
@@ -638,17 +609,8 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Module Context
-	//
-	// Placeholders
-	//
-	// [id] - module.id (2.png)
-	// [hash] - module.hash (6237543873.png)
-	//
-	// Legacy Placeholders
-	//
-	// [moduleid] - module.id (2.png)
-	// [modulehash] - module.hash (6237543873.png)
+	// Module context: `[id]` and `[hash]`, with `[moduleid]` and `[modulehash]` as
+	// their legacy spellings.
 	if (data.module) {
 		const module = data.module;
 		const needId = presentKinds.has("id");
@@ -739,13 +701,8 @@ const interpolate = (path, data, assetInfo) => {
 		}
 	}
 
-	// Other things
-	//
-	// Placeholders
-	//
-	// [url] - data.url
-	// [uniqueName] - data.uniqueName (output.uniqueName)
-	// [uniquename] - alias of [uniqueName]
+	// Everything else: `[url]`, and `[uniqueName]` from `output.uniqueName`, which
+	// `[uniquename]` aliases.
 	if (data.url && presentKinds.has("url")) {
 		replacements.set("url", replacer(data.url));
 	}

package/lib/asset/AssetBytesGenerator.js

@@ -114,7 +114,13 @@ class AssetBytesGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			default:
 				return null;

package/lib/asset/AssetGenerator.js

@@ -791,10 +791,21 @@ class AssetGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case "asset": {
-				return new RawSource(error.message);
+				return new RawSource(
+					Generator.buildErrorMessage(
+						error,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			default:
 				return null;
@@ -836,13 +847,14 @@ class AssetGenerator extends Generator {
 				/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl
 			) && this.emit !== false;
 
-		// Only analyzable ESM output can drop a bare `new URL()` to an asset-url; without
-		// it every JS consumer needs the wrapper, so skip the per-connection dependency
-		// probe entirely and keep the pre-existing cheap path. Must match the condition
-		// `URLDependency` uses to emit the literal, or the wrapper is dropped while the
-		// call site still requires the module — except where the fallback spells the name
-		// itself (`.p + <file>`), which needs no wrapper to read it out of.
-		// Build-time execution instead emulates the wrapper (`AssetModulesPlugin`).
+		// WHY: only analyzable ESM output can drop a bare `new URL()` to an asset
+		// url; without it every JS consumer needs the wrapper, so the per-connection
+		// dependency probe is skipped entirely and the cheap path stands. This must
+		// match the condition `URLDependency` emits the literal under, or the wrapper
+		// is dropped while the call site still requires the module — except where the
+		// fallback spells the name itself (`.p + <file>`), which needs no wrapper to
+		// read it out of. Build-time execution emulates the wrapper instead
+		// (`AssetModulesPlugin`).
 		const isModule = Boolean(
 			this._compilation &&
 			this._compilation.runtimeTemplate.supportsAnalyzable(
@@ -874,9 +886,8 @@ class AssetGenerator extends Generator {
 				hasUrl = true;
 			} else if (
 				// Only a bare `new URL()` becomes the analyzable literal; a relative ref
-				// keeps the runtime form and still needs the wrapper. Prefetch/preload
-				// refs don't: their `<link>` is emitted at chunk startup, which resolves
-				// the href from the asset filename when there is no wrapper.
+				// keeps the runtime form and its wrapper. A prefetch or preload ref needs
+				// none: its `<link>` resolves the href at chunk startup.
 				isModule &&
 				dependency instanceof URLDependency &&
 				!dependency.relative
@@ -961,10 +972,8 @@ class AssetGenerator extends Generator {
 						return 0;
 					}
 
-					// roughly for data url
-					// Example: m.exports="data:image/png;base64,ag82/f+2=="
-					// 4/3 = base64 encoding
-					// 34 = ~ data url header + footer + rounding
+					// Rough data-url size: 4/3 for the base64 encoding, plus about 34 bytes
+					// of header, footer and rounding.
 					return originalSource.size() * 1.34 + 36;
 				}
 				// it's only estimated so this number is probably fine

package/lib/asset/AssetSourceGenerator.js

@@ -158,7 +158,13 @@ class AssetSourceGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			default:
 				return null;