webpack 5.112.0 → 5.112.1

package/lib/dependencies/esm/ESMModulesPlugin.js

@@ -36,7 +36,6 @@ const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
  */
 /** @import Compiler from "../../Compiler" */
 /** @import Parser from "../../javascript/JavascriptParser" */
-/** @import { BuildInfo } from "../../module/Module" */
 
 /**
  * Defines the harmony modules plugin options type used by this module.
@@ -179,8 +178,7 @@ class ESMModulesPlugin {
 						// Recorded on the module, because an importer asks the module it
 						// imports whether its namespace is a spec exotic object.
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
-							/** @type {BuildInfo} */
-							(parser.state.module.buildInfo).specNamespaceObject = true;
+							parser.state.module.buildInfo.specNamespaceObject = true;
 						});
 					}
 

package/lib/dependencies/esm/TopLevelAwaitDependency.js

@@ -11,7 +11,6 @@ const NullDependency = require("../core/NullDependency");
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import Dependency from "../../graph/Dependency" */
 /** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
-/** @import Module from "../../module/Module" */
 /** @import { Range } from "../../javascript/JavascriptParser" */
 /**
  * @import {
@@ -80,13 +79,7 @@ TopLevelAwaitDependency.Template = class TopLevelAwaitDependencyTemplate extends
 		// Only rewrite when the body is a generator (no `async`/`await`, but
 		// generators). `await` and `yield` differ in precedence, so wrap the
 		// whole expression: `await X` -> `(yield X)`.
-		if (
-			!isGeneratorLowered(
-				/** @type {Module} */ (module),
-				moduleGraph,
-				runtimeTemplate
-			)
-		) {
+		if (!isGeneratorLowered(module, moduleGraph, runtimeTemplate)) {
 			return;
 		}
 		const dep = /** @type {TopLevelAwaitDependency} */ (dependency);

package/lib/dependencies/helpers/DynamicExports.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-/** @import { BuildMeta } from "../../module/Module" */
 /** @import { JavascriptParserState } from "../../javascript/JavascriptParser" */
 
 /** @type {WeakMap<JavascriptParserState, boolean>} */
@@ -20,7 +19,7 @@ module.exports.bailout = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	parserStateExportsState.set(parserState, false);
 	if (value === true) {
-		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		const buildMeta = parserState.module.buildMeta;
 		buildMeta.exportsType = undefined;
 		buildMeta.defaultObject = false;
 	}
@@ -36,7 +35,7 @@ module.exports.enable = (parserState) => {
 	if (value === false) return;
 	parserStateExportsState.set(parserState, true);
 	if (value !== true) {
-		const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+		const buildMeta = parserState.module.buildMeta;
 		buildMeta.exportsType = "default";
 		buildMeta.defaultObject = "redirect";
 	}
@@ -60,8 +59,7 @@ module.exports.isEnabled = (parserState) => {
 module.exports.setDynamic = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	if (value !== true) return;
-	/** @type {BuildMeta} */
-	(parserState.module.buildMeta).exportsType = "dynamic";
+	parserState.module.buildMeta.exportsType = "dynamic";
 };
 
 /**
@@ -72,7 +70,7 @@ module.exports.setDynamic = (parserState) => {
 module.exports.setFlagged = (parserState) => {
 	const value = parserStateExportsState.get(parserState);
 	if (value !== true) return;
-	const buildMeta = /** @type {BuildMeta} */ (parserState.module.buildMeta);
+	const buildMeta = parserState.module.buildMeta;
 	if (buildMeta.exportsType === "dynamic") return;
 	buildMeta.exportsType = "flagged";
 };

package/lib/dependencies/html/HtmlEntryDependency.js

@@ -192,7 +192,7 @@ class HtmlEntryDependency extends ModuleDependency {
  * HTML contains tags for both the leader and the dependant entries.
  */
 const getEntrypointChunksInLoadOrder = (entrypoint) => {
-	const entryChunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
+	const entryChunk = entrypoint.getEntrypointChunk();
 	const runtimeChunk = entrypoint.getRuntimeChunk();
 
 	/** @type {Set<Chunk>} */
@@ -679,9 +679,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 
 		const { chunkGraph } = compilation;
 		const { crossOriginLoading } = compilation.outputOptions;
-		const entrypoint = /** @type {Entrypoint | undefined} */ (
-			compilation.entrypoints.get(dep.entryName)
-		);
+		const entrypoint = compilation.entrypoints.get(dep.entryName);
 
 		if (!entrypoint) {
 			source.replace(dep.range[0], dep.range[1] - 1, "data:,");
@@ -783,9 +781,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 		// Only inline when the HTML module is emitted as a standalone page (extract mode).
 		// If it's exported as a JS string, sentinels would end up embedded in the JS chunk.
 		const isExtractedHtml = chunkGraph
-			.getModuleSourceTypes(
-				/** @type {import("../../module/Module")} */ (templateContext.module)
-			)
+			.getModuleSourceTypes(templateContext.module)
 			.has("html");
 		const entryInlined =
 			isExtractedHtml &&
@@ -956,10 +952,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 					if (hasCss) {
 						cssChunks.push(chunk);
 					}
-					// Anything not CSS-only stays on the JS lane in `orderedChunks` order,
-					// preserving the runtime-first invariant. A chunk emitting neither
-					// `.js` nor `.css` still gets a clone, as it always has.
-					if (hasJs || !hasCss) jsChunks.push(chunk);
+					if (hasJs) jsChunks.push(chunk);
 				}
 				// When the entry chunk carries CSS itself, fold it into the same
 				// ordering so its `<link>` lands in the right cascade position
@@ -1113,9 +1106,7 @@ HtmlEntryDependency.Template = class HtmlEntryDependencyTemplate extends (
 						// `<script>` entry — that's what users key on.
 						let entryName = dep.entryName;
 						for (const c of chunkGraph.getModuleChunks(
-							/** @type {import("../../module/Module")} */ (
-								templateContext.module
-							)
+							templateContext.module
 						)) {
 							if (c.name) {
 								entryName = c.name;

package/lib/dependencies/html/HtmlInlineHtmlDependency.js

@@ -9,7 +9,6 @@ const makeSerializable = require("../../util/makeSerializable");
 const ModuleDependency = require("../core/ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import CodeGenerationResults from "../../module/CodeGenerationResults" */
 /** @import Dependency, { UpdateHashContext } from "../../graph/Dependency" */
 /** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
 /** @import Module from "../../module/Module" */
@@ -83,9 +82,7 @@ HtmlInlineHtmlDependency.Template = class HtmlInlineHtmlDependencyTemplate exten
 		const dep = /** @type {HtmlInlineHtmlDependency} */ (dependency);
 		// The module is guaranteed — it is registered as a code-generation dependency.
 		const module = /** @type {Module} */ (moduleGraph.getModule(dep));
-		const codeGen =
-			/** @type {CodeGenerationResults} */
-			(codeGenerationResults).get(module, runtime);
+		const codeGen = codeGenerationResults.get(module, runtime);
 		const htmlSource = codeGen.sources.get(HTML_TYPE);
 
 		// The attribute value was entity-decoded before parsing, so re-escape the

package/lib/dependencies/html/HtmlInlineScriptDependency.js

@@ -12,10 +12,8 @@ const ModuleDependency = require("../core/ModuleDependency");
 const getHtmlGenerator = memoize(() => require("../../html/HtmlGenerator"));
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import Chunk from "../../graph/Chunk" */
 /** @import Dependency from "../../graph/Dependency" */
 /** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
-/** @import Entrypoint from "../../graph/Entrypoint" */
 /** @import { Range } from "../../javascript/JavascriptParser" */
 /** @typedef {import("../../serialization/ObjectMiddleware").ObjectDeserializerContext<[number, Range, string, string, Range | undefined, boolean]>} ObjectDeserializerContext */
 /** @typedef {import("../../serialization/ObjectMiddleware").ObjectSerializerContext<[number, Range, string, string, Range | undefined, boolean]>} ObjectSerializerContext */
@@ -124,15 +122,13 @@ HtmlInlineScriptDependency.Template = class HtmlInlineScriptDependencyTemplate e
 			return;
 		}
 		const compilation = runtimeTemplate.compilation;
-		const entrypoint = /** @type {Entrypoint | undefined} */ (
-			compilation.entrypoints.get(dep.entryName)
-		);
+		const entrypoint = compilation.entrypoints.get(dep.entryName);
 
 		/** @type {string} */
 		let url = "data:,";
 
 		if (entrypoint) {
-			const chunk = /** @type {Chunk} */ (entrypoint.getEntrypointChunk());
+			const chunk = entrypoint.getEntrypointChunk();
 			// A sentinel only resolves in a page webpack emits; exported as a JS
 			// string it would ride along unresolved.
 			const isExtractedHtml = chunkGraph

package/lib/dependencies/html/HtmlInlineStyleDependency.js

@@ -9,7 +9,6 @@ const makeSerializable = require("../../util/makeSerializable");
 const ModuleDependency = require("../core/ModuleDependency");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import CodeGenerationResults from "../../module/CodeGenerationResults" */
 /** @import Dependency, { UpdateHashContext } from "../../graph/Dependency" */
 /** @import { DependencyTemplateContext } from "../../template/DependencyTemplate" */
 /** @import Module from "../../module/Module" */
@@ -141,9 +140,7 @@ HtmlInlineStyleDependency.Template = class HtmlInlineStyleDependencyTemplate ext
 		let cssText = "";
 
 		if (module) {
-			const codeGen =
-				/** @type {CodeGenerationResults} */
-				(codeGenerationResults).get(module, runtime);
+			const codeGen = codeGenerationResults.get(module, runtime);
 			const cssTextSource = codeGen.sources.get(CSS_TEXT_TYPE);
 			if (cssTextSource) {
 				cssText = /** @type {string} */ (cssTextSource.source());

package/lib/dependencies/import/ImportParserPlugin.js

@@ -47,7 +47,6 @@ const getCommentCompilationWarning = memoize(() =>
 /** @import { RawChunkGroupOptions } from "../../graph/ChunkGroup" */
 /** @import { ContextMode } from "../../context/ContextModule" */
 /** @import { RawReferencedExports } from "../../graph/Dependency" */
-/** @import { BuildMeta } from "../../module/Module" */
 /**
  * @import JavascriptParser, {
  * 	ImportExpression,
@@ -660,11 +659,9 @@ class ImportParserPlugin {
 						include,
 						exclude,
 						mode,
-						namespaceObject:
-							/** @type {BuildMeta} */
-							(parser.state.module.buildMeta).strictHarmonyModule
-								? "strict"
-								: true,
+						namespaceObject: parser.state.module.buildMeta.strictHarmonyModule
+							? "strict"
+							: true,
 						typePrefix: "import()",
 						category: "esm",
 						referencedExports: exports,

package/lib/dependencies/import-meta/ImportMetaPlugin.js

@@ -55,7 +55,7 @@ const WEBPACK_VERSION = Number.parseInt(
 /** @import Compiler from "../../Compiler" */
 /** @import { MergedDefinitionNode } from "../../define/DefinePlugin" */
 /** @import { ValueCacheVersion } from "../../module/Module" */
-/** @import NormalModule, { NormalModuleBuildInfo } from "../../module/NormalModule" */
+/** @import NormalModule from "../../module/NormalModule" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo
@@ -320,7 +320,7 @@ class ImportMetaPlugin {
 							.for(IMPORT_META)
 							.tap(PLUGIN_NAME, (metaProperty) => {
 								const dep = new ConstDependency(
-									/** @type {string} */ (importMetaName),
+									importMetaName,
 									/** @type {Range} */ (metaProperty.range)
 								);
 								dep.loc = parser.getLocation(metaProperty);
@@ -381,9 +381,7 @@ class ImportMetaPlugin {
 					 */
 					const addDefinitionValueDependencies = () => {
 						if (definitionValueDependencies.size === 0) return;
-						const buildInfo = /** @type {NormalModuleBuildInfo} */ (
-							parser.state.module.buildInfo
-						);
+						const buildInfo = parser.state.module.buildInfo;
 						const valueDependencies =
 							buildInfo.valueDependencies ||
 							(buildInfo.valueDependencies = new Map());
@@ -708,7 +706,7 @@ class ImportMetaPlugin {
 						parser.hooks.call
 							.for(IMPORT_META_RESOLVE)
 							.tap(PLUGIN_NAME, (expr) => {
-								const call = /** @type {CallExpression} */ (expr);
+								const call = expr;
 								// Non-static forms are left untouched for runtime evaluation.
 								const request = getImportMetaResolveRequest(call, parser);
 								if (request === undefined) return;

package/lib/dependencies/url/URLParserPlugin.js

@@ -182,7 +182,7 @@ class URLParserPlugin {
 				.setRange(/** @type {Range} */ (expr.range));
 		});
 		parser.hooks.new.for("URL").tap(PLUGIN_NAME, (_expr) => {
-			const expr = /** @type {NewExpressionNode} */ (_expr);
+			const expr = _expr;
 			const { options: importOptions, errors: commentErrors } =
 				parser.parseCommentOptions(/** @type {Range} */ (expr.range));
 

package/lib/dependencies/worker/WorkerAndWorkletPlugin.js

@@ -464,10 +464,10 @@ class WorkerAndWorkletPlugin {
 					/**
 					 * Handles a matched `new Worker(...)` expression.
 					 * @param {CallExpression} expr expression
-					 * @param {boolean=} isGlobalWorker matched the global `new Worker()` syntax (eligible for universal rewrite)
+					 * @param {string=} workerSyntax matched global constructor syntax
 					 * @returns {boolean | void} true when handled
 					 */
-					const handleNewWorker = (expr, isGlobalWorker = false) => {
+					const handleNewWorker = (expr, workerSyntax) => {
 						const parsedUrl = resolveWorkerUrl(expr);
 						if (!parsedUrl) return;
 						const { url, range, needNewUrl, arg1, arg2 } = parsedUrl;
@@ -547,9 +547,10 @@ class WorkerAndWorkletPlugin {
 						const dep = new WorkerDependency(url, range, {
 							publicPath: this._workerPublicPath,
 							needNewUrl,
-							workerConstructorRange: isGlobalWorker
-								? /** @type {Range} */ (expr.callee.range)
-								: undefined,
+							workerConstructorRange:
+								workerSyntax === "Worker"
+									? /** @type {Range} */ (expr.callee.range)
+									: undefined,
 							resourceHint
 						});
 						dep.loc = parser.getLocation(expr);
@@ -588,18 +589,48 @@ class WorkerAndWorkletPlugin {
 							const type = this._module ? '"module"' : "undefined";
 							// `{ ...(opts), type }` is equivalent to `Object.assign({}, opts, { type })`
 							const useSpread = compilation.outputOptions.environment.spread;
-							const dep1 = new ConstDependency(
-								useSpread ? "{ ...(" : "Object.assign({}, ",
-								/** @type {Range} */ (insertLocation)[0]
-							);
-							const dep2 = new ConstDependency(
-								useSpread ? `), type: ${type} }` : `, { type: ${type} })`,
-								/** @type {Range} */ (insertLocation)[1]
-							);
-							dep1.loc = parser.getLocation(expr);
-							dep2.loc = parser.getLocation(expr);
-							parser.state.module.addPresentationalDependency(dep1);
-							parser.state.module.addPresentationalDependency(dep2);
+							let prefix = useSpread ? "{ ...(" : "Object.assign({}, ";
+							let suffix = useSpread
+								? `), type: ${type} }`
+								: `, { type: ${type} })`;
+							if (
+								workerSyntax !== undefined &&
+								(workerSyntax === "SharedWorker" ||
+									workerSyntax.endsWith(".SharedWorker"))
+							) {
+								const optionsExpression = /** @type {Expression} */ (arg2);
+								if (
+									optionsExpression.type === "Literal" &&
+									typeof optionsExpression.value === "string"
+								) {
+									prefix = this._module ? "{ name: " : "";
+									suffix = this._module ? `, type: ${type} }` : "";
+								} else {
+									const stringOptions = this._module
+										? `{ name: options, type: ${type} }`
+										: "options";
+									// Evaluate the argument once, outside the wrapper's scope.
+									prefix = `(${compilation.runtimeTemplate.returningFunction(
+										`typeof options === "string" ? ${stringOptions} : ${prefix}options${suffix}`,
+										"options"
+									)})((`;
+									suffix = "))";
+								}
+							}
+							if (prefix) {
+								const dep1 = new ConstDependency(
+									prefix,
+									/** @type {Range} */ (insertLocation)[0]
+								);
+								const dep2 = new ConstDependency(
+									suffix,
+									/** @type {Range} */ (insertLocation)[1]
+								);
+								dep1.loc = parser.getLocation(expr);
+								dep2.loc = parser.getLocation(expr);
+								parser.state.module.addPresentationalDependency(dep1);
+								parser.state.module.addPresentationalDependency(dep2);
+							}
 						} else if (insertType === "argument" && this._module) {
 							const dep = new ConstDependency(
 								', { type: "module" }',
@@ -687,7 +718,7 @@ class WorkerAndWorkletPlugin {
 					/**
 					 * Registers the parser hooks matching a single syntax item.
 					 * @param {string} item item
-					 * @param {(expr: CallExpression, isGlobalWorker?: boolean) => boolean | void} handle handler invoked on a match
+					 * @param {(expr: CallExpression, workerSyntax?: string) => boolean | void} handle handler invoked on a match
 					 * @param {symbol} specifierTag tag used for `*variable` syntax
 					 */
 					const processItem = (item, handle, specifierTag) => {
@@ -752,7 +783,7 @@ class WorkerAndWorkletPlugin {
 							} else {
 								parser.hooks.new
 									.for(item)
-									.tap(PLUGIN_NAME, (expr) => handle(expr, item === "Worker"));
+									.tap(PLUGIN_NAME, (expr) => handle(expr, item));
 							}
 						}
 					};
@@ -761,7 +792,7 @@ class WorkerAndWorkletPlugin {
 					 * Expands and registers a syntax list.
 					 * @param {string[]} syntaxList syntax list (may contain "...")
 					 * @param {string[]} defaultSyntax default syntax used for "..."
-					 * @param {(expr: CallExpression, isGlobalWorker?: boolean) => boolean | void} handle handler
+					 * @param {(expr: CallExpression, workerSyntax?: string) => boolean | void} handle handler
 					 * @param {symbol} specifierTag tag used for `*variable` syntax
 					 */
 					const processList = (

package/lib/devtool/ModuleFilenameHelpers.js

@@ -280,7 +280,7 @@ ModuleFilenameHelpers.createFilename = (
 	]);
 
 	// TODO in the next major release: consider removing weird double placeholders
-	return /** @type {string} */ (opts.moduleFilenameTemplate)
+	return opts.moduleFilenameTemplate
 		.replace(ModuleFilenameHelpers.REGEXP_ALL_LOADERS_RESOURCE, "[identifier]")
 		.replace(
 			ModuleFilenameHelpers.REGEXP_LOADERS_RESOURCE,

package/lib/devtool/SourceMapDevToolPlugin.js

@@ -296,7 +296,7 @@ const getTaskForFile = (
 
 	return {
 		file,
-		source: /** @type {string} */ (source),
+		source,
 		assetInfo,
 		sourceMap,
 		mapSource,

package/lib/dll/DelegatedModule.js

@@ -326,9 +326,9 @@ class DelegatedModule extends Module {
 	 */
 	cleanupForCache() {
 		super.cleanupForCache();
-		this.delegateData =
-			/** @type {EXPECTED_ANY} */
-			(undefined);
+		this.delegateData = /** @type {DelegatedModuleData} */ (
+			/** @type {DelegatedModuleData | undefined} */ (undefined)
+		);
 	}
 }
 

package/lib/dll/DllModule.js

@@ -187,7 +187,9 @@ class DllModule extends Module {
 	 */
 	cleanupForCache() {
 		super.cleanupForCache();
-		this.dependencies = /** @type {EXPECTED_ANY} */ (undefined);
+		this.dependencies = /** @type {Dependency[]} */ (
+			/** @type {Dependency[] | undefined} */ (undefined)
+		);
 	}
 }
 

package/lib/dll/DllReferencePlugin.js

@@ -179,10 +179,7 @@ class DllReferencePlugin {
 						try {
 							data.data =
 								/** @type {DllReferencePluginOptionsManifest} */
-								(
-									/** @type {unknown} */
-									(parseJson(/** @type {Buffer} */ (result).toString("utf8")))
-								);
+								(parseJson(/** @type {Buffer} */ (result).toString("utf8")));
 						} catch (parseErr) {
 							// Store the error in the params so that it can
 							// be added as a compilation error later on.

package/lib/errors/AbstractMethodError.js

@@ -31,7 +31,7 @@ function Message() {
 	/** @type {RegExpMatchArray | null} */
 	const match =
 		/** @type {string} */
-		(/** @type {unknown} */ (this.stack))
+		(/** @type {string | undefined} */ (this.stack))
 			.split("\n")[3]
 			.match(CURRENT_METHOD_REGEXP);
 

package/lib/errors/ErrorHelpers.js

@@ -134,7 +134,8 @@ const cutOffWrappingFrames = (stack) => {
 /**
  * Returns the value as an error, naming whatever a tap, a loader or a plugin
  * failed with when that is not one. Everything reading a failure expects one.
- * @param {EXPECTED_ANY} value value something failed with
+ * @template T
+ * @param {T} value value something failed with
  * @returns {Error} the value, or an error naming it
  */
 const toError = (value) => {

package/lib/errors/HookWebpackError.js

@@ -68,7 +68,8 @@ makeSerializable(HookWebpackError, "webpack/lib/errors/HookWebpackError");
 
 /**
  * Creates webpack error.
- * @param {EXPECTED_ANY} error what a plugin failed with
+ * @template T
+ * @param {T} error what a plugin failed with
  * @param {string} hook name of the hook
  * @returns {WebpackError} a webpack error
  */

package/lib/errors/JSONParseError.js

@@ -4,8 +4,8 @@
 
 "use strict";
 
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error, EXPECTED_ANY, string]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error, EXPECTED_ANY, string]>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[Error, string | Buffer, string]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[Error, string | Buffer, string]>} ObjectSerializerContext */
 
 const makeSerializable = require("../util/makeSerializable");
 
@@ -14,7 +14,7 @@ const CONTEXT = 20;
 class JSONParseError extends SyntaxError {
 	/**
 	 * @param {Error} err err
-	 * @param {EXPECTED_ANY} raw raw
+	 * @param {string | Buffer} raw the text `parseJson` was handed, before its byte order mark is stripped
 	 * @param {string} txt text
 	 */
 	constructor(err, raw, txt) {
@@ -80,7 +80,7 @@ class JSONParseError extends SyntaxError {
 		this.stack = undefined;
 		/** @type {Error} */
 		this.systemError = err;
-		/** @type {EXPECTED_ANY} */
+		/** @type {string | Buffer} */
 		this.raw = raw;
 		/** @type {string} */
 		this.txt = txt;

package/lib/errors/WebpackError.js

@@ -43,8 +43,9 @@ class WebpackError extends Error {
 
 	/**
 	 * Whether an error is a webpack error rather than any other thrown value.
-	 * @param {unknown} value an error
-	 * @returns {value is WebpackError} true when the value is a webpack error
+	 * @template T
+	 * @param {T} value an error
+	 * @returns {value is T & WebpackError} true when the value is a webpack error
 	 */
 	static isWebpackError(value) {
 		return value instanceof WebpackError;

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -103,6 +103,33 @@ function getChunkNamedImport(index) {
 	return `__webpack_chunk_${index}__`;
 }
 
+/**
+ * Returns the chunks, other than the runtime chunk, whose files the startup of an entry chunk imports.
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {Iterable<Chunk>} the imported chunks
+ */
+function getImportedChunks(chunk, chunkGraph) {
+	if (chunk.hasRuntime()) {
+		return chunkGraph.getNumberOfEntryModules(chunk) > 0
+			? chunkGraph.getChunkEntryDependentChunksIterable(chunk)
+			: [];
+	}
+	const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
+	/** @type {Set<Chunk>} */
+	const chunks = new Set();
+	for (const [, entrypoint] of entries) {
+		for (const c of getAllChunks(
+			/** @type {Entrypoint} */ (entrypoint),
+			chunk,
+			runtimeChunk
+		)) {
+			chunks.add(c);
+		}
+	}
+	return chunks;
+}
+
 const PLUGIN_NAME = "ModuleChunkFormatPlugin";
 
 class ModuleChunkFormatPlugin {
@@ -259,7 +286,7 @@ class ModuleChunkFormatPlugin {
 						const chunks = getAllChunks(
 							/** @type {Entrypoint} */ (entrypoint),
 							chunk,
-							/** @type {Chunk} */ (runtimeChunk)
+							runtimeChunk
 						);
 						/** @type {Set<Chunk>} */
 						const processChunks = new Set();
@@ -343,6 +370,14 @@ class ModuleChunkFormatPlugin {
 				return source;
 			});
 			hooks.chunkHash.tap(PLUGIN_NAME, createChunkHashHandler(PLUGIN_NAME));
+			hooks.chunkHash.tap(PLUGIN_NAME, (chunk, hash, { chunkGraph }) => {
+				// WHY: the startup imports these chunks by their hashed filenames, so a
+				// cached render keyed by this hash must not outlive one of them;
+				// `Compilation#createHash` hashes them before this chunk.
+				for (const c of getImportedChunks(chunk, chunkGraph)) {
+					if (chunkHasJs(c, chunkGraph)) hash.update(`${c.hash}`);
+				}
+			});
 		});
 	}
 }

package/lib/externals/ExternalModule.js

@@ -59,7 +59,6 @@ const getEnvironmentNotSupportAsyncWarning = memoize(() =>
 /** @import Compilation, { UnsafeCacheData } from "../Compilation" */
 /** @import { UpdateHashContext } from "../graph/Dependency" */
 /** @import ExportsInfo from "../graph/ExportsInfo" */
-/** @import { GenerateContext } from "../module/Generator" */
 /**
  * @import {
  * 	BuildMeta,
@@ -88,7 +87,8 @@ const getEnvironmentNotSupportAsyncWarning = memoize(() =>
 /** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /**
  * @import {
- * 	ChunkRenderContext
+ * 	ChunkRenderContext,
+ * 	ChunkRenderContext as GenerateContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
 /** @import { ImportAttributes } from "../javascript/JavascriptParser" */
@@ -766,9 +766,7 @@ const getSourceForModuleExternal = (
 		runtimeRequirements: moduleRemapping
 			? RUNTIME_REQUIREMENTS_FOR_MODULE
 			: undefined,
-		chunkInitFragments: [
-			/** @type {InitFragment<EXPECTED_ANY>} */ (initFragment)
-		]
+		chunkInitFragments: [initFragment]
 	};
 };
 
@@ -1364,7 +1362,8 @@ class ExternalModule extends Module {
 				const { node } = runtimeTemplate.compilation.options.externalsPresets;
 				// ESM has no `require`; load via `createRequire` when the target is node
 				const createRequireInModule =
-					/** @type {BuildInfo} */ (this.buildInfo).javascriptModule &&
+					/** @type {ExternalModuleBuildInfo} */ (this.buildInfo)
+						.javascriptModule &&
 					(externalType === "node-commonjs" || Boolean(node));
 				if (!createRequireInModule) {
 					return getSourceForCommonJsExternal(request);
@@ -1401,7 +1400,12 @@ class ExternalModule extends Module {
 			case "script":
 				return getSourceForScriptExternal(request, runtimeTemplate);
 			case "module": {
-				if (!(/** @type {BuildInfo} */ (this.buildInfo).javascriptModule)) {
+				if (
+					!(
+						/** @type {ExternalModuleBuildInfo} */ (this.buildInfo)
+							.javascriptModule
+					)
+				) {
 					if (!runtimeTemplate.supportsDynamicImport()) {
 						throw new Error(
 							`The target environment doesn't support dynamic import() syntax so it's not possible to use external type 'module' within a script${
@@ -1511,8 +1515,7 @@ class ExternalModule extends Module {
 				// renders the plain `module.exports =` form: its exports are read
 				// through the wrapper accessor, not through a shared-scope binding.
 				const wrapped = Boolean(
-					concatenationScope &&
-					/** @type {ConcatenationScope} */ (concatenationScope).isWrapped()
+					concatenationScope && concatenationScope.isWrapped()
 				);
 				const sourceData = this._getSourceData(
 					request,