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

package/lib/MultiCompiler.js

@@ -5,13 +5,13 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const { MultiHook, SyncHook } = require("tapable");
 
 const MultiStats = require("./MultiStats");
 const MultiWatching = require("./MultiWatching");
 const WebpackError = require("./errors/WebpackError");
 const ArrayQueue = require("./util/ArrayQueue");
+const asyncLib = require("./util/async");
 const memoize = require("./util/memoize");
 
 const getConcurrentCompilationError = memoize(() =>
@@ -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/MultiWatching.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
+const asyncLib = require("./util/async");
 
 /** @import MultiCompiler from "./MultiCompiler" */
 /** @import Watching from "./Watching" */

package/lib/NormalModule.js

@@ -8,9 +8,9 @@
 const querystring = require("querystring");
 const {
 	AsyncSeriesBailHook,
+	AsyncSeriesWaterfallHook,
 	HookMap,
-	SyncHook,
-	SyncWaterfallHook
+	SyncHook
 } = require("tapable");
 const {
 	CachedSource,
@@ -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");
@@ -33,6 +34,7 @@ const {
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
+const { getBuildDiagnostics } = require("./util/buildDiagnostics");
 const {
 	concatComparators,
 	keepOriginalOrder,
@@ -67,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"));
@@ -79,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"
@@ -109,7 +111,6 @@ const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
  * 	BuildMeta,
  * 	CodeGenerationContext,
  * 	CodeGenerationResult,
- * 	CodeGenerationResultData,
  * 	ConcatenationBailoutReasonContext,
  * 	KnownBuildInfo,
  * 	LibIdentOptions,
@@ -119,7 +120,6 @@ const getModuleBuildError = memoize(() => require("./errors/ModuleBuildError"));
  * 	NeedBuildCallback,
  * 	BuildCallback,
  * 	RuntimeRequirements,
- * 	Sources,
  * 	SourceType,
  * 	SourceTypes
  * } from "./Module"
@@ -138,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,
@@ -156,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 */
@@ -184,7 +242,9 @@ const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
 		.getOptimizationBailout(mod)
 		.push(
 			() =>
-				`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`
+				`Dependency (${dep.type}) with side effects at ${formatLocation(
+					dep.loc
+				)}`
 		);
 };
 
@@ -347,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);
 				}
@@ -542,10 +601,12 @@ const createCompilationHooks = () => {
 		 */
 		beforeSnapshot: new SyncHook(["module"]),
 		/**
-		 * @type {SyncWaterfallHook<[Result, NormalModule]>}
+		 * Async since 5.111.0, so a tap can await work of its own — minifying an
+		 * asset, say, which before only a loader could do. `tap` keeps working.
+		 * @type {AsyncSeriesWaterfallHook<[Result, NormalModule]>}
 		 * @since 5.99.0
 		 */
-		processResult: new SyncWaterfallHook(["result", "module"]),
+		processResult: new AsyncSeriesWaterfallHook(["result", "module"]),
 		/**
 		 * @type {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>}
 		 * @since 5.49.0
@@ -728,11 +789,6 @@ class NormalModule extends Module {
 		this._sideEffectsStateGraph = undefined;
 		/** @type {ConnectionState | undefined} */
 		this._sideEffectsStateValue = undefined;
-		/**
-		 * @private
-		 * @type {CodeGenerationResultData}
-		 */
-		this._codeGeneratorData = new Map();
 	}
 
 	/**
@@ -954,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;
@@ -1052,7 +1108,9 @@ class NormalModule extends Module {
 								(parseJson(options));
 						} catch (err) {
 							throw new Error(
-								`Cannot parse string options: ${/** @type {Error} */ (err).message}`,
+								`Cannot parse string options: ${
+									/** @type {Error} */ (err).message
+								}`,
 								{ cause: err }
 							);
 						}
@@ -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(
@@ -1305,11 +1354,30 @@ class NormalModule extends Module {
 				});
 				return callback(error);
 			}
-			const result = hooks.processResult.call(
+			hooks.processResult.callAsync(
 				/** @type {Result} */
 				(result_),
-				this
+				this,
+				(hookErr, hookResult) => {
+					if (hookErr) {
+						// Named, so a tap's failure is not read as a loader's.
+						return callback(
+							new (getModuleBuildError())(toError(hookErr), {
+								from: "processResult hook"
+							})
+						);
+					}
+
+					finishResult(/** @type {Result} */ (hookResult));
+				}
 			);
+		};
+
+		/**
+		 * @param {Result} result the result the hook settled on
+		 * @returns {void}
+		 */
+		const finishResult = (result) => {
 			const source = result[0];
 			const sourceMap = result.length >= 1 ? result[1] : null;
 			const extraInfo = result.length >= 2 ? result[2] : null;
@@ -1441,7 +1509,9 @@ class NormalModule extends Module {
 												})
 										).catch((err) => {
 											throw new Error(
-												`Failed to parse source map. ${/** @type {Error} */ (err).message}`
+												`Failed to parse source map. ${
+													/** @type {Error} */ (err).message
+												}`
 											);
 										})
 								);
@@ -1501,7 +1571,8 @@ class NormalModule extends Module {
 				}
 				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
 				if (result.notCacheableReasons.length > 0) {
-					buildInfo.notCacheableReasons = result.notCacheableReasons;
+					getBuildDiagnostics(buildInfo).notCacheableReasons =
+						result.notCacheableReasons;
 				}
 				processResult(err, result.result);
 			}
@@ -1509,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);
 	}
 
 	/**
@@ -1609,7 +1682,6 @@ class NormalModule extends Module {
 		};
 		this.buildInfo = {
 			cacheable: false,
-			notCacheableReasons: undefined,
 			parsed: true,
 			fileDependencies: undefined,
 			contextDependencies: undefined,
@@ -1627,6 +1699,8 @@ class NormalModule extends Module {
 			pureFunctions: undefined,
 			inlineExports: undefined,
 			moduleConcatenationBailout: undefined,
+			moduleConcatenationRootBailout: undefined,
+			diagnostics: undefined,
 			needCreateRequire: undefined,
 			usesTopLevelUsingDeclaration: undefined
 		};
@@ -1682,7 +1756,7 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(/** @type {Error} */ (err));
+					this.markModuleAsErrored(err);
 					return callback();
 				}
 
@@ -1776,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();
 			}
@@ -1892,10 +1966,19 @@ class NormalModule extends Module {
 			runtimeRequirements.add(RuntimeGlobals.thisAsExports);
 		}
 
-		const getData = () => this._codeGeneratorData;
+		/** @type {CodeGenerationResult} */
+		const resultEntry = {
+			sources: new Map(),
+			runtimeRequirements,
+			data: undefined,
+			hash: undefined
+		};
+
+		const getData = () => {
+			if (resultEntry.data === undefined) resultEntry.data = new Map();
+			return resultEntry.data;
+		};
 
-		/** @type {Sources} */
-		const sources = new Map();
 		for (const type of sourceTypes || chunkGraph.getModuleSourceTypes(this)) {
 			// TODO webpack@6 make generateError required
 			const generator =
@@ -1915,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,
@@ -1930,17 +2019,10 @@ class NormalModule extends Module {
 					});
 
 			if (source) {
-				sources.set(type, new CachedSource(source));
+				resultEntry.sources.set(type, new CachedSource(source));
 			}
 		}
 
-		/** @type {CodeGenerationResult} */
-		const resultEntry = {
-			sources,
-			runtimeRequirements,
-			data: this._codeGeneratorData,
-			hash: undefined
-		};
 		return resultEntry;
 	}
 
@@ -2088,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()) {
@@ -2116,7 +2196,6 @@ class NormalModule extends Module {
 		write(this.error);
 		write(this._lastSuccessfulBuildMeta);
 		write(this._forceBuild);
-		write(this._codeGeneratorData);
 		write(this.hot);
 		super.serialize(context);
 	}
@@ -2143,7 +2222,7 @@ class NormalModule extends Module {
 			parserOptions: /** @type {EXPECTED_ANY} */ (null),
 			generator: /** @type {EXPECTED_ANY} */ (null),
 			generatorOptions: /** @type {EXPECTED_ANY} */ (null),
-			resolveOptions: /** @type {EXPECTED_ANY} */ (null),
+			resolveOptions: undefined,
 			extractSourceMap: /** @type {EXPECTED_ANY} */ (null)
 		});
 		obj.deserialize(context);
@@ -2160,7 +2239,6 @@ class NormalModule extends Module {
 		this.error = read();
 		this._lastSuccessfulBuildMeta = read();
 		this._forceBuild = read();
-		this._codeGeneratorData = read();
 		this.hot = read();
 		super.deserialize(context);
 	}

package/lib/NormalModuleFactory.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const {
 	AsyncSeriesBailHook,
 	AsyncSeriesHook,
@@ -30,6 +29,7 @@ const RuleSetCompiler = require("./rules/RuleSetCompiler");
 const UseEffectRulePlugin = require("./rules/UseEffectRulePlugin");
 const LazySet = require("./util/LazySet");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
+const asyncLib = require("./util/async");
 const { cachedCleverMerge, cachedSetProperty } = require("./util/cleverMerge");
 const {
 	applyCaseCorrections,

package/lib/RuntimeGlobals.js

@@ -15,13 +15,6 @@ module.exports.amdDefine = "__webpack_require__.amdD";
  */
 module.exports.amdOptions = "__webpack_require__.amdO";
 
-/**
- * analyzable single-chunk `import()` that keeps `ensureChunk` timing and deduplication:
- * resolves immediately for an installed chunk, else runs the literal import and installs it
- * Signature: (chunkId, () => Promise) => Promise
- */
-module.exports.analyzableChunkImport = "__webpack_require__.ei";
-
 /**
  * Creates an async module. The body function must be a async function.
  * "module.exports" will be decorated with an AsyncModulePromise.
@@ -254,12 +247,28 @@ module.exports.hasCssModules = "has css modules";
  */
 module.exports.hasFetchPriority = "has fetch priority";
 
+/**
+ * a flag when a deferred startup callback carries a priority
+ */
+module.exports.hasChunkPriority = "has chunk priority";
+
 /**
  * the shorthand for Object.prototype.hasOwnProperty
  * using of it decreases the compiled bundle size
  */
 module.exports.hasOwnProperty = "__webpack_require__.o";
 
+/**
+ * a flag when a deferred namespace is built from a known export list
+ */
+module.exports.hasSealedDeferredNamespace = "has sealed deferred namespace";
+
+/**
+ * a flag when a deferred namespace is synthesized from the module's exports
+ */
+module.exports.hasSynthesizedDeferredNamespace =
+	"has synthesized deferred namespace";
+
 /**
  * function downloading the update manifest
  */
@@ -447,6 +456,11 @@ module.exports.setAnonymousDefaultName = "__webpack_require__.dn";
  */
 module.exports.shareScopeMap = "__webpack_require__.S";
 
+/**
+ * wrap an exports object in a spec Module Namespace Exotic Object
+ */
+module.exports.specNamespaceObject = "__webpack_require__.ns";
+
 /**
  * startup signal from runtime
  * This will be called when the runtime chunk has been loaded.

package/lib/RuntimeModule.js

@@ -136,22 +136,31 @@ class RuntimeModule extends Module {
 	updateHash(hash, context) {
 		hash.update(this.name);
 		hash.update(`${this.stage}`);
-		try {
-			const code =
-				this.fullHash || this.dependentHash
-					? // Do not use getGeneratedCode here, because i. e. compilation hash might be not
-						// ready at this point. We will cache it later instead.
-						this.generate()
-					: this.getGeneratedCode();
-			if (code !== null && code !== undefined) {
-				hash.update(code);
-			}
-		} catch (err) {
-			hash.update(/** @type {Error} */ (err).message);
+		// A failing `generate()` propagates: hashing its message instead pins the etag
+		// of the code generation cache to a constant, which then serves stale code.
+		const code =
+			this.fullHash || this.dependentHash
+				? // Do not use getGeneratedCode here, because i. e. compilation hash might be not
+					// ready at this point. We will cache it later instead.
+					this.generate()
+				: this.getGeneratedCode();
+		if (code !== null && code !== undefined) {
+			hash.update(code);
 		}
 		super.updateHash(hash, context);
 	}
 
+	/**
+	 * 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() {
+		// Answering `null` rather than "none" keeps a module that never heard of this
+		// out of a dispatch that would skip the handler it installs.
+		return null;
+	}
+
 	/**
 	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
@@ -244,6 +253,13 @@ class RuntimeModule extends Module {
 	}
 }
 
+/**
+ * The answer a runtime module gives when it installs no chunk handler at all
+ */
+RuntimeModule.NO_CHUNK_HANDLERS =
+	/** @type {[string, string][]} */
+	([]);
+
 /**
  * Runtime modules without any dependencies to other runtime modules
  */