webpack 5.111.0 → 5.111.1

package/lib/ExternalModule.js

@@ -348,10 +348,9 @@ const getSourceForImportExternal = (
 	}
 	const phase = dependencyMeta && dependencyMeta.phase;
 	checkPhaseIsSupported(phase, runtimeTemplate);
-	// `import.defer(…)` and `import.source(…)` are only valid forms of the
-	// native `import(…)` function, so we only emit the phase suffix when the
-	// importFunctionName is the default `"import"`. Anything else has no phase
-	// form at all, and dropping it would silently import eagerly instead.
+	// `import.defer(…)` and `import.source(…)` are forms of the native `import(…)`
+	// alone, so the phase suffix is emitted only for the default name. Anything
+	// else has no phase form, and dropping it would import eagerly instead.
 	if (
 		baseImportName !== "import" &&
 		(ImportPhaseUtils.isDefer(phase) || ImportPhaseUtils.isSource(phase))
@@ -695,10 +694,9 @@ const getSourceForModuleExternal = (
 		imported = true;
 	}
 
-	// `import defer …` is only valid as `import defer * as ns from "…"`, so
-	// keep the namespace form even if usage analysis would otherwise narrow
-	// the import down to specific names. Defer + concatenation is semantically
-	// at odds (lazy vs. eager), so we preserve the user-written shape here.
+	// `import defer` is valid only as `import defer * as ns from "…"`, so the
+	// namespace form is kept even where usage analysis would narrow it: defer and
+	// concatenation are at odds, lazy against eager.
 	if (ImportPhaseUtils.isDefer(phase)) {
 		imported = true;
 	}

package/lib/FlagDependencyExportsPlugin.js

@@ -138,9 +138,8 @@ class FlagDependencyExportsPlugin {
 								hashFunction
 							);
 							// validated by the still-lazy request keys: reference-change
-							// detection cannot invalidate the mem cache when the un-lazied
-							// connections are unsafe-cached (they are skipped when comparing
-							// references)
+							// detection cannot invalidate the mem cache while the un-lazied
+							// connections are unsafe-cached, being skipped in the comparison
 							if (memCacheEntry !== undefined && memCacheEntry.etag === etag) {
 								statRestoredFromMemCache++;
 								exportsInfo.restoreProvided(memCacheEntry.data);
@@ -172,16 +171,12 @@ class FlagDependencyExportsPlugin {
 							logger.timeEnd("restore cached provided exports");
 							if (err) return callback(err);
 
-							// Seed the queue with targets before the modules that read
-							// them. Enqueueing at the two branches above ordered the work by
-							// how fast each cache lookup answered — one is synchronous, the
-							// other a `cache.get` callback — so the persistent cache decided
-							// it. A module analysed before the module it re-exports from
-							// reads exports that are not determined yet and over-estimates,
-							// and this loop can add exports info but never retract it, so
-							// the over-estimate survives the pass that corrects it. The
-							// roots are sorted so the walk is stable, and post-order visits
-							// each module after everything it points at.
+							// WHY: enqueueing at the branches above ordered the work by how
+							// fast each cache lookup answered, letting the persistent cache
+							// decide it. A module analyzed before the one it re-exports from
+							// over-estimates its exports, and this loop can add exports info
+							// but never retract it, so that over-estimate would survive. Sorted
+							// roots and post-order visit each module after what it points at.
 							/** @type {Set<Module>} */
 							const visited = new Set();
 							/** @type {Module[]} */

package/lib/FlagDependencyUsagePlugin.js

@@ -93,10 +93,9 @@ class FlagDependencyUsagePlugin {
 					const processReferencedModule = (module, usedExports, runtime) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
 						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
-							// The whole namespace object escapes via a reference that codegen
-							// can materialize as a decoupled namespace object. When all exports
-							// are statically known we keep them mangleable instead of marking
-							// them used-in-unknown-way.
+							// The namespace object escapes through a reference codegen can
+							// materialize, so with every export statically known they stay
+							// mangleable rather than used-in-unknown-way.
 							if (
 								this.mangleEscapingNamespaces &&
 								module.buildMeta &&
@@ -237,10 +236,9 @@ class FlagDependencyUsagePlugin {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
-						// Modules whose whole namespace object escapes in a mangleable way.
-						// Tracked separately so specific member references are still merged
-						// (and marked used) instead of being dropped by the escape marker.
-						// Lazily allocated — usually empty.
+						// Modules whose whole namespace escapes but stays mangleable, kept
+						// apart so specific member references are still merged and marked
+						// used rather than dropped by the escape marker. Usually empty.
 						/** @type {Set<Module> | undefined} */
 						let mangleableEscapeModules;
 
@@ -289,11 +287,9 @@ class FlagDependencyUsagePlugin {
 									}
 									continue;
 								}
-								// A mangleable whole-object escape keeps the module's exports
-								// mangleable (applied after the merge). Unlike the conservative
-								// marker it must not drop specific member references: those still
-								// need their own (possibly non-existent) export marked used so
-								// they render as a qualified access, not a bare `undefined`.
+								// A mangleable escape keeps the exports mangleable, applied after
+								// the merge. It must not drop specific member references: each
+								// still needs marking, or it renders as a bare `undefined`.
 								if (
 									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
 								) {

package/lib/Generator.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const { contextifyStackFrames } = require("./ErrorHelpers");
 const { JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 const memoize = require("./util/memoize");
 
@@ -23,6 +24,7 @@ const memoize = require("./util/memoize");
  * } from "./Module"
  */
 /** @import ModuleGraph from "./ModuleGraph" */
+/** @import RequestShortener from "./RequestShortener" */
 /** @import NormalModule from "./NormalModule" */
 /** @import RuntimeTemplate from "./RuntimeTemplate" */
 /** @import Hash from "./util/Hash" */
@@ -73,18 +75,38 @@ class Generator {
 		return new ByTypeGenerator(map);
 	}
 
+	/**
+	 * Returns what a module that failed to build says about it in the output.
+	 * The stack it carries is written relative to the context, keeping a
+	 * position only where a second build names the same one.
+	 * @param {Error} error the build error
+	 * @param {RequestShortener=} requestShortener request shortener, absolute paths are kept without one
+	 * @returns {string} message to emit
+	 */
+	static buildErrorMessage(error, requestShortener) {
+		return requestShortener
+			? contextifyStackFrames(error.message, requestShortener)
+			: error.message;
+	}
+
 	/**
 	 * Returns the statement a module that failed to build throws when executed.
 	 * @param {Error} error the build error
 	 * @param {string=} parseErrorConstructor constructor for a rejected source, defaults to `SyntaxError` (WebAssembly rejects with `WebAssembly.CompileError` instead)
+	 * @param {RequestShortener=} requestShortener request shortener for the stack the message carries
 	 * @returns {string} javascript statement
 	 */
-	static throwBuildErrorCode(error, parseErrorConstructor = "SyntaxError") {
+	static throwBuildErrorCode(
+		error,
+		parseErrorConstructor = "SyntaxError",
+		requestShortener = undefined
+	) {
 		// A source the parser rejected throws what a native load of it would.
 		const name =
 			error instanceof getModuleParseError() ? parseErrorConstructor : "Error";
+		const message = Generator.buildErrorMessage(error, requestShortener);
 
-		return `throw new ${name}(${JSON.stringify(error.message)});`;
+		return `throw new ${name}(${JSON.stringify(message)});`;
 	}
 
 	/* istanbul ignore next */

package/lib/HotModuleReplacementPlugin.js

@@ -76,6 +76,8 @@ const {
 /** @typedef {{ updatedChunkIds: ChunkIds, removedChunkIds: ChunkIds, removedModules: ModuleSet, forceLoadChunkIds: ChunkIds, filename: string, assetInfo: AssetInfo }} HotUpdateMainContentByRuntimeItem */
 /** @typedef {Map<string, HotUpdateMainContentByRuntimeItem>} HotUpdateMainContentByRuntime */
 
+/** @typedef {{ hot?: boolean }} HotModuleReplacementPluginLoaderContext */
+
 /**
  * Whether a filename template reads any hash, so the name it gives a chunk can move
  * between two builds.

package/lib/IgnorePlugin.js

@@ -15,7 +15,7 @@ const EntryDependency = require("./dependencies/EntryDependency");
  */
 /** @import Compiler from "./Compiler" */
 /** @import { ResolveData } from "./NormalModuleFactory" */
-/** @import { BeforeContextResolveData } from "./ContextModuleFactory" */
+/** @import { BeforeContextResolveData } from "./context/ContextModuleFactory" */
 
 /** @typedef {(resource: string, context: string) => boolean} CheckResourceFn */
 

package/lib/LoaderOptionsPlugin.js

@@ -19,7 +19,7 @@ const NormalModule = require("./NormalModule");
 /**
  * Defines the loader context type used by this module.
  * @template T
- * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ * @typedef {import("./NormalModule").LoaderContext<T>} LoaderContext
  */
 
 const PLUGIN_NAME = "LoaderOptionsPlugin";

package/lib/Module.js

@@ -129,6 +129,9 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {Set<string>} freeNames free identifier names in the rendered source for javascript modules
  * @property {InitFragment<EXPECTED_ANY>[]} chunkInitFragments chunk init fragments for javascript modules
  * @property {string} externalReexport native external reexport source and attributes
+ * @property {string} exportsSource export definitions left out of a javascript module's source on demand (see `KnownMeta.onDemandExports`), to be placed before its body where it is wrapped
+ * @property {string} exportsBindingSource export definitions left out on demand that read the module's own declarations, to be placed after its body where it is wrapped
+ * @property {Record<string, string>} exportsFinalName final name of each used export of a concatenated module whose definitions were left out on demand
  * @property {{ javascript?: string, ["asset-url"]?: string }} url url for asset modules
  * @property {string} filename a filename for asset modules
  * @property {AssetInfo} assetInfo an asset info for asset modules
@@ -182,9 +185,6 @@ const makeSerializable = require("./util/makeSerializable");
  * @property {(false | "redirect" | "redirect-warn")=} defaultObject
  * @property {boolean=} async
  * @property {boolean=} sideEffectFree
- * @property {Map<string, Record<string, string>>=} exportsFinalNameByRuntime using in ModuleLibraryPlugin
- * @property {Map<string, string>=} exportsSourceByRuntime using in ModuleLibraryPlugin
- * @property {Map<string, string>=} exportsBindingSourceByRuntime export definitions `ModuleLibraryPlugin` took over, re-emitted only where the module is wrapped
  */
 
 /**

package/lib/ModuleGraph.js

@@ -143,6 +143,7 @@ class ModuleGraphModule {
  * @typedef {object} KnownMeta
  * @property {Map<Module, string>=} importVarMap
  * @property {Map<Module, string>=} deferredImportVarMap
+ * @property {boolean=} onDemandExports generate export definitions on demand
  */
 
 /** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | HarmonyImportSpecifierDependencyIDsSymbol | HarmonyExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
@@ -342,10 +343,8 @@ class ModuleGraph {
 		}
 		const originDependency = connection.dependency;
 
-		// src/index.js
-		// import { c } from "lib/c" -> c = 0
-		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
-		// import { d } from "lib/d" -> d = 2
+		// Specifiers of one import statement share its source order, so `a` and `b`
+		// of `import { a, b } from "lib"` both take the statement's index.
 		const currentSourceOrder =
 			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
 			(dependency).sourceOrder;
@@ -360,11 +359,9 @@ class ModuleGraph {
 			typeof currentSourceOrder === "number" &&
 			typeof originSourceOrder === "number"
 		) {
-			// src/index.js
-			// import { c } from "lib/c" -> c = 0
-			// import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub)
-			// import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub)
-			// import { d } from "lib/d" -> d = 2
+			// A re-exported specifier keeps the importing statement's order as `main`
+			// and its own position as `sub`, so the pair orders it within that
+			// statement without disturbing the statements around it.
 			this._dependencySourceOrderMap.set(dependency, {
 				main: currentSourceOrder,
 				sub: originSourceOrder

package/lib/MultiCompiler.js

@@ -158,11 +158,9 @@ module.exports = class MultiCompiler {
 					doneCompilers--;
 				}
 			});
-			// Release fields on this child's Compilation once it's done. The
-			// stage: Infinity tap runs after every afterDone tap at a lower
-			// stage, so plugins observing compilation state in afterDone still
-			// see it intact. Stats remains usable; only fields Stats never reads
-			// (and that the persistent cache never serializes) are dropped.
+			// Release this child's Compilation fields once it is done. The
+			// `stage: Infinity` tap runs last, so a plugin watching in afterDone still
+			// sees it intact, and only fields Stats never reads are dropped.
 
 			compiler.hooks.afterDone.tap(
 				{ name: CLASS_NAME, stage: Infinity },
@@ -478,17 +476,9 @@ module.exports = class MultiCompiler {
 	_runGraph(setup, run, callback) {
 		/** @typedef {{ compiler: Compiler, setupResult: undefined | SetupResult, result: undefined | Stats, state: "pending" | "blocked" | "queued" | "starting" | "running" | "running-outdated" | "done", children: Node[], parents: Node[] }} Node */
 
-		// State transitions for nodes:
-		// -> blocked (initial)
-		// blocked -> starting [running++] (when all parents done)
-		// queued -> starting [running++] (when processing the queue)
-		// starting -> running (when run has been called)
-		// running -> done [running--] (when compilation is done)
-		// done -> pending (when invalidated from file change)
-		// pending -> blocked [add to queue] (when invalidated from aggregated changes)
-		// done -> blocked [add to queue] (when invalidated, from parent invalidation)
-		// running -> running-outdated (when invalidated, either from change or parent invalidation)
-		// running-outdated -> blocked [running--] (when compilation is done)
+		// A node starts blocked and reaches `starting` once its parents are done or
+		// the queue reaches it, then `running`, then `done`. Invalidation sends it
+		// back to `blocked`, or to `running-outdated` if it is mid-compilation.
 
 		/** @type {Node[]} */
 		const nodes = this.compilers.map((compiler) => ({

package/lib/NormalModule.js

@@ -19,6 +19,7 @@ const {
 	SourceMapSource
 } = require("webpack-sources");
 const Dependency = require("./Dependency");
+const { toError } = require("./ErrorHelpers");
 const Module = require("./Module");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
@@ -68,10 +69,6 @@ const getUnhandledSchemeError = memoize(() =>
 	require("./errors/UnhandledSchemeError")
 );
 
-const getNonErrorEmittedError = memoize(() =>
-	require("./errors/NonErrorEmittedError")
-);
-
 const getModuleWarning = memoize(() => require("./errors/ModuleWarning"));
 
 const getModuleParseError = memoize(() => require("./errors/ModuleParseError"));
@@ -80,17 +77,21 @@ const getModuleError = memoize(() => require("./errors/ModuleError"));
 
 const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
 
-/** @import { ResolveContext, ResolveRequest } from "enhanced-resolve" */
+/** @import { ResolveContext, ResolveRequest, Resolver } from "enhanced-resolve" */
 /** @import { Source, RawSourceMap } from "webpack-sources" */
 /**
  * @import {
  * 	ResolveOptions,
  * 	NoParse,
- * 	HashFunction
+ * 	HashFunction,
+ * 	HashDigest,
+ * 	HashDigestLength,
+ * 	HashSalt
  * } from "../declarations/WebpackOptions"
  */
 /**
  * @import Compilation, {
+ * 	AssetInfo,
  * 	FileSystemDependencies,
  * 	UnsafeCacheData
  * } from "./Compilation"
@@ -137,7 +138,14 @@ const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
  */
 /** @import Parser, { PreparsedAst } from "./Parser" */
 /** @import RequestShortener from "./RequestShortener" */
-/** @import { ResolverWithOptions } from "./ResolverFactory" */
+/** @import Compiler from "./Compiler" */
+/** @import { Logger } from "./logging/Logger" */
+/**
+ * @import {
+ * 	ResolverWithOptions,
+ * 	ResolveOptionsWithDependencyType
+ * } from "./ResolverFactory"
+ */
 /**
  * @import {
  * 	ObjectDeserializerContext,
@@ -155,14 +163,65 @@ const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
 /** @typedef {{ [k: string]: EXPECTED_ANY }} ParserOptions */
 /** @typedef {{ [k: string]: EXPECTED_ANY }} GeneratorOptions */
 
+/** @typedef {Parameters<Resolver["resolve"]>[4]} ResolveCallback */
+/** @typedef {Parameters<typeof import("schema-utils").validate>[0]} Schema */
+
 /**
- * @template T
- * @typedef {import("../declarations/LoaderContext").LoaderContext<T>} LoaderContext
+ * `getOptions` validates against a schema when given one, and TypeScript reads
+ * an intersection of call signatures as an overload set
+ * @template OptionsType
+ * @typedef {{ (): OptionsType } & { (schema: Schema): OptionsType }} GetOptionsMethod
+ */
+
+/**
+ * @typedef {((context: string, request: string, callback: ResolveCallback) => void) & ((context: string, request: string) => Promise<string>)} DualModeResolve
+ */
+
+/**
+ * @typedef {object} LoaderContextUtils
+ * @property {(context: string, request: string) => string} absolutify returns a new request string using absolute paths when possible
+ * @property {(context: string, request: string) => string} contextify returns a new request string avoiding absolute paths when possible
+ * @property {(algorithm?: string | typeof Hash) => Hash} createHash creates a hash with the compilation's function
+ */
+
+/**
+ * These properties are added by the NormalModule
+ * @template OptionsType
+ * @typedef {object} NormalModuleLoaderContext
+ * @property {number} version
+ * @property {GetOptionsMethod<OptionsType>} getOptions Extracts and parses the options of the current loader.
+ * Parses string options as JSON or a query string.
+ * @property {(warning: Error | string) => void} emitWarning Emits a warning for this module.
+ * The warning will be displayed to the user during compilation.
+ * @property {(error: Error | string) => void} emitError Emits an error for this module.
+ * The error will be displayed to the user and typically causes the compilation to fail.
+ * @property {(name?: string) => Logger} getLogger Gets a logger instance scoped to this loader and module.
+ * Useful for emitting debug or compilation information in a structured way.
+ * @property {(context: string, request: string, callback: ResolveCallback) => void} resolve Resolves a module request (e.g., a relative path or module name) to an absolute file path.
+ * It uses Webpack's internal resolver, taking into account configured aliases and extensions.
+ * @property {(options?: ResolveOptionsWithDependencyType) => DualModeResolve} getResolve Creates a resolve function with specific options.
+ * The returned function can be used as a Promise-based resolver or a callback-based resolver.
+ * @property {(name: string, content: string | Buffer, sourceMap?: string, assetInfo?: AssetInfo) => void} emitFile Emits a new file (asset) to the compilation output directory.
+ * This allows loaders to generate additional files alongside the main module output.
+ * @property {(dep: string) => void} addBuildDependency
+ * @property {LoaderContextUtils} utils
+ * @property {string} rootContext
+ * @property {InputFileSystem} fs
+ * @property {boolean=} sourceMap
+ * @property {"development" | "production" | "none"} mode
+ * @property {boolean=} webpack
+ * @property {HashFunction} hashFunction
+ * @property {HashDigest} hashDigest
+ * @property {HashDigestLength} hashDigestLength
+ * @property {HashSalt=} hashSalt
+ * @property {NormalModule=} _module
+ * @property {Compilation=} _compilation
+ * @property {Compiler=} _compiler
  */
 
 /**
  * @template T
- * @typedef {import("../declarations/LoaderContext").NormalModuleLoaderContext<T>} NormalModuleLoaderContext
+ * @typedef {NormalModuleLoaderContext<T> & import("./loaders/LoaderRunner").LoaderRunnerLoaderContext<T> & import("./dependencies/LoaderPlugin").LoaderPluginLoaderContext & import("./HotModuleReplacementPlugin").HotModuleReplacementPluginLoaderContext} LoaderContext
  */
 
 /** @typedef {(content: string) => boolean} NoParseFn */
@@ -348,10 +407,9 @@ const walkSideEffects = (rootMod, moduleGraph, SideEffectDep) => {
 						}
 					}
 				} else {
-					// Non-NormalModule (e.g. ConcatenatedModule delegating back
-					// through here) resolves via a re-entrant walk that may see our
-					// in-progress modules as circular, so taint this chain: never
-					// memoize it.
+					// A non-NormalModule resolves through a re-entrant walk that may read
+					// our in-progress modules as circular, so this chain is tainted and
+					// never memoized.
 					state = refModule.getSideEffectsConnectionState(moduleGraph);
 					lowOf.set(mod, -1);
 				}
@@ -952,7 +1010,7 @@ class NormalModule extends Module {
 	 * @param {Compilation} compilation the compilation
 	 * @param {InputFileSystem} fs file system from reading
 	 * @param {NormalModuleCompilationHooks} hooks the hooks
-	 * @returns {import("../declarations/LoaderContext").LoaderContext<T>} loader context
+	 * @returns {LoaderContext<T>} loader context
 	 */
 	_createLoaderContext(resolver, options, compilation, fs, hooks) {
 		const { requestShortener } = compilation.runtimeTemplate;
@@ -1085,22 +1143,16 @@ class NormalModule extends Module {
 			},
 			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
-				if (!(warning instanceof Error)) {
-					warning = new (getNonErrorEmittedError())(warning);
-				}
 				this.addWarning(
-					new (getModuleWarning())(warning, {
+					new (getModuleWarning())(toError(warning), {
 						from: getCurrentLoaderName()
 					})
 				);
 			},
 			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
-				if (!(error instanceof Error)) {
-					error = new (getNonErrorEmittedError())(error);
-				}
 				this.addError(
-					new (getModuleError())(error, {
+					new (getModuleError())(toError(error), {
 						from: getCurrentLoaderName()
 					})
 				);
@@ -1124,7 +1176,7 @@ class NormalModule extends Module {
 			/** @type {LoaderContext<EXPECTED_ANY>["getResolve"]} */
 			getResolve(options) {
 				const child = options ? resolver.withOptions(options) : resolver;
-				return /** @type {ReturnType<import("../declarations/LoaderContext").NormalModuleLoaderContext<T>["getResolve"]>} */ (
+				return /** @type {ReturnType<NormalModuleLoaderContext<T>["getResolve"]>} */ (
 					(context, request, callback) => {
 						if (callback) {
 							child.resolve(
@@ -1292,11 +1344,8 @@ class NormalModule extends Module {
 		 */
 		const processResult = (err, result_) => {
 			if (err) {
-				if (!(err instanceof Error)) {
-					err = new (getNonErrorEmittedError())(err);
-				}
 				const currentLoader = this.getCurrentLoader(loaderContext);
-				const error = new (getModuleBuildError())(err, {
+				const error = new (getModuleBuildError())(toError(err), {
 					from:
 						currentLoader &&
 						compilation.runtimeTemplate.requestShortener.shorten(
@@ -1313,12 +1362,9 @@ class NormalModule extends Module {
 					if (hookErr) {
 						// Named, so a tap's failure is not read as a loader's.
 						return callback(
-							new (getModuleBuildError())(
-								hookErr instanceof Error
-									? hookErr
-									: new (getNonErrorEmittedError())(hookErr),
-								{ from: "processResult hook" }
-							)
+							new (getModuleBuildError())(toError(hookErr), {
+								from: "processResult hook"
+							})
 						);
 					}
 
@@ -1534,14 +1580,16 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {Error} error the error
+	 * Marks the module as failed, so what it generates says so. A tap or a
+	 * loader may fail with anything, and what reads the failure expects an error.
+	 * @param {EXPECTED_ANY} error what the module failed with
 	 * @returns {void}
 	 */
 	markModuleAsErrored(error) {
 		// Restore build meta from successful build to keep importing state
 		this.buildMeta = { ...this._lastSuccessfulBuildMeta };
-		this.error = error;
-		this.addError(error);
+		this.error = toError(error);
+		this.addError(this.error);
 	}
 
 	/**
@@ -1708,7 +1756,7 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(/** @type {Error} */ (err));
+					this.markModuleAsErrored(err);
 					return callback();
 				}
 
@@ -1802,7 +1850,7 @@ class NormalModule extends Module {
 			try {
 				hooks.beforeParse.call(this);
 			} catch (err) {
-				this.markModuleAsErrored(/** @type {Error} */ (err));
+				this.markModuleAsErrored(err);
 				this._initBuildHash(compilation);
 				return callback();
 			}
@@ -1950,7 +1998,13 @@ class NormalModule extends Module {
 							getData,
 							type
 						})
-					: new RawSource(getGenerator().throwBuildErrorCode(this.error))
+					: new RawSource(
+							getGenerator().throwBuildErrorCode(
+								this.error,
+								undefined,
+								runtimeTemplate.requestShortener
+							)
+						)
 				: generator.generate(this, {
 						dependencyTemplates,
 						runtimeTemplate,
@@ -2116,10 +2170,8 @@ class NormalModule extends Module {
 			/** @type {string} */
 			(buildInfo.hash)
 		);
-		// Clear cached source types and re-compute so that changes in incoming
-		// connections (e.g. asset module newly referenced from JS via lazy
-		// compilation) are reflected in the hash and trigger code generation
-		// cache invalidation.
+		// Recompute the source types, so a change in the incoming connections reaches
+		// the hash and invalidates the code-generation cache.
 		// https://github.com/webpack/webpack/issues/20800
 		this._sourceTypes = undefined;
 		for (const type of this.getSourceTypes()) {