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

package/lib/RuntimeTemplate.js

@@ -9,14 +9,7 @@ const { CachedSource, ReplaceSource } = require("webpack-sources");
 const APIPlugin = require("./APIPlugin");
 
 const InitFragment = require("./InitFragment");
-const {
-	ASSET_TYPE,
-	ASSET_URL_TYPE,
-	CSS_TYPE,
-	HTML_TYPE,
-	JAVASCRIPT_TYPE,
-	RUNTIME_TYPE
-} = require("./ModuleSourceTypeConstants");
+const { CSS_TYPE, JAVASCRIPT_TYPE } = require("./ModuleSourceTypeConstants");
 const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
@@ -31,6 +24,7 @@ const { InlinedUsedName } = require("./optimize/InlineExports");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
+	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("./runtime/MakeDeferredNamespaceObjectRuntime");
@@ -42,7 +36,11 @@ const { equals } = require("./util/ArrayHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const { compareIds } = require("./util/comparators");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
-const { getUndoPath, toJsStringLiteral } = require("./util/identifier");
+const {
+	RESOLVABLE_SPECIFIER_REGEXP,
+	getUndoPath,
+	toJsStringLiteral
+} = require("./util/identifier");
 const memoize = require("./util/memoize");
 const { propertyAccess, propertyName } = require("./util/property");
 const {
@@ -55,6 +53,7 @@ const {
 const getCssModulesPlugin = memoize(() => require("./css/CssModulesPlugin"));
 // `Compilation` requires this module, so its stage constants are read lazily.
 const getCompilation = memoize(() => require("./Compilation"));
+const getExternalModule = memoize(() => require("./ExternalModule"));
 
 /**
  * @typedef {object} ChunkAssetNaming
@@ -91,6 +90,20 @@ const getTemplatedPathPlugin = memoize(() => require("./TemplatedPathPlugin"));
 const getConcatenatedModule = memoize(() =>
 	require("./optimize/ConcatenatedModule")
 );
+const getNormalModule = memoize(() => require("./NormalModule"));
+
+/**
+ * Whether a hot update can re-run the module a reference is emitted into: the HMR
+ * plugin marks every normal module, and a concatenated one is read through its root.
+ * @param {Module | undefined} module the module a reference is emitted into
+ * @returns {boolean} true under HMR
+ */
+const isHotModule = (module) => {
+	if (module === undefined) return false;
+	const normal =
+		module instanceof getConcatenatedModule() ? module.rootModule : module;
+	return normal instanceof getNormalModule() && normal.hot;
+};
 
 // Any `[hash]`/`[fullhash]`/`[chunkhash]`/`[contenthash]` token, incl. a `:<length>`
 // or `:<digest>[:<length>]` suffix (e.g. `[contenthash:base64:8]`). Its value is only
@@ -103,6 +116,9 @@ const HASH_PROBE = "0123456789abcdef0123";
 const HASH_PROBE_ALTERNATE = "3210fedcba9876543210";
 const HASH_IN_FILENAME_GLOBAL = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/g;
 
+// What a recorded reason is prefixed with in `stats.optimizationBailout`.
+const ANALYZABLE_BAILOUT_PREFIX = "Analyzable ESM bailout: ";
+
 /**
  * @param {SpecifierPart} part one piece of a reserved name
  * @returns {boolean} true when it is text the deferred pass adds nothing to
@@ -155,21 +171,6 @@ const rootedParts = (parts) =>
 			]
 		: parts;
 
-// Types that ride the chunk itself or render their own asset, so no `.f` handler
-// fetches them; every other type may install one, so the map has to exist for it.
-/** @type {Set<string>} */
-const TYPES_WITHOUT_CHUNK_HANDLER = new Set([
-	JAVASCRIPT_TYPE,
-	RUNTIME_TYPE,
-	ASSET_TYPE,
-	ASSET_URL_TYPE,
-	HTML_TYPE
-]);
-
-// Why a name only the deferred pass could settle was not deferred.
-const DEFER_BAILOUT =
-	"a hashed name needs optimization.realContentHash, or no emitted javascript named by its content";
-
 /**
  * Where a literal is read from — the `../` path back to the output root, and whether
  * the chunk loader fetched the chunk it sits in through `output.publicPath`.
@@ -178,6 +179,13 @@ const DEFER_BAILOUT =
  * @property {boolean | null} loaded whether the chunk loader fetched the chunk
  */
 
+/**
+ * @typedef {object} WasmGroups
+ * @property {(key: string) => string} groupOf the group a runtime key answers with
+ * @property {Set<string>} fetching groups an entry of which reads binaries with `fetch`
+ * @property {Map<string, boolean>} onlyFetching groups every entry of which fetches
+ */
+
 // A reference in no chunk at all: nothing is known about where it is read from.
 /** @type {Placement} */
 const NO_PLACEMENT = { undo: null, loaded: null };
@@ -202,7 +210,12 @@ const RUNTIME_HASH_ROUND = 2;
 
 // Why a public path needing a base could not be spelled from the chunk holding it.
 const SERVED_BAILOUT =
-	"this module is in a chunk webpack loads through output.publicPath and in one it does not, so no one path back to the output root fits both";
+	'this module is in a chunk webpack loads through output.publicPath and in one it does not, so no one path back to the output root fits both (a root-absolute or absolute output.publicPath, or "auto", is read the same from both)';
+
+// Why a runtime's url map kept the runtime form under HMR: an update re-ships the
+// runtime module only when its own code changes.
+const HOT_NAME_BAILOUT =
+	"a hot update can move this name without changing the runtime module that spells it, so the update would not carry the new one";
 
 /**
  * @import {
@@ -223,8 +236,9 @@ const SERVED_BAILOUT =
  * One piece of a name only the deferred pass can spell: text as it stands, the `../`
  * path from the asset it sits in to the output root, a template or `output.publicPath`
  * resolved once the hashes exist, one of the assets the chunk with this id emits, or
- * the base everything else is resolved against once it is spelled.
- * @typedef {"literal" | "undo" | "template" | "publicPath" | "unserved" | "chunk" | "cssChunk" | "base"} SpecifierPartKind
+ * the base everything else is resolved against once it is spelled. A `repair` part
+ * spells nothing: it marks a name the repair pass has to bring back in line.
+ * @typedef {"literal" | "undo" | "template" | "publicPath" | "unserved" | "chunk" | "cssChunk" | "base" | "repair"} SpecifierPartKind
  */
 /** @typedef {[SpecifierPartKind, string | number]} SpecifierPart */
 
@@ -236,14 +250,22 @@ const SPECIFIER_PART_KINDS = new Set([
 	"unserved",
 	"base",
 	"chunk",
-	"cssChunk"
+	"cssChunk",
+	"repair"
 ]);
 
 // Only these carry a chunk id, which is the one part value that may be a number.
 const CHUNK_SPECIFIER_PART_KINDS = new Set(["chunk", "cssChunk"]);
 
+// Only these are spelled out of the compilation hash, so a stand-in holding one moves
+// the chunk it lands in into the round after that hash settles.
+const FULL_HASH_PART_KINDS = new Set(["publicPath", "template", "unserved"]);
+
 // What the deferred pass scans for — the other half of what the class spells.
+const ANALYZABLE_TOKEN_PREFIX = "./@@webpackAnalyzableChunk:";
 const ANALYZABLE_TOKEN_REGEXP = /\.\/@@webpackAnalyzableChunk:([\w-]+)@@/g;
+// The same token read back out of one quoted specifier.
+const ANALYZABLE_TOKEN_PAYLOAD = /@@webpackAnalyzableChunk:([\w-]+)@@/;
 
 // Stands in for the compilation hash inside an otherwise resolved filename, with the
 // requested length when the placeholder asked for one.
@@ -286,8 +308,7 @@ const PASS_NAME = "analyzableChunkNaming";
 /** @import { Source } from "webpack-sources" */
 /** @import Compiler from "./Compiler" */
 /** @import Chunk, { ChunkFilenameTemplate, ChunkId } from "./Chunk" */
-/** @import ChunkGroup from "./ChunkGroup" */
-/** @import ChunkGraph from "./ChunkGraph" */
+/** @import ChunkGraph, { ModuleId } from "./ChunkGraph" */
 /** @import Compilation from "./Compilation" */
 /** @import Dependency from "./Dependency" */
 /** @import ModuleGraph from "./ModuleGraph" */
@@ -331,6 +352,25 @@ const createHashProbeChunk = (chunk, hash, present) => {
 	return probeChunk;
 };
 
+/**
+ * A filename function's answer to the stand-in hash, which says what shape the name
+ * has before any real hash exists.
+ * @param {Exclude<ChunkFilenameTemplate, string>} template the filename function
+ * @param {Chunk} chunk the chunk being referenced
+ * @param {string} contentHashType which of the chunk's hashes the name reads
+ * @param {string} hash the stand-in hash
+ * @param {boolean} present whether the chunk is claimed to carry content hashes
+ * @returns {string} what the function names it
+ */
+const probeTemplateName = (template, chunk, contentHashType, hash, present) =>
+	template({
+		chunk: createHashProbeChunk(chunk, hash, present),
+		runtime: chunk.runtime,
+		contentHashType,
+		hash,
+		contentHash: hash
+	});
+
 /**
  * No module id error message.
  * @param {Module} module the module
@@ -385,6 +425,48 @@ function getGlobalObject(definition) {
 	return `Object(${trimmed})`;
 }
 
+// An async external is a promise, not a module record with an evaluating state.
+const isAsyncExternal = (/** @type {Module} */ module) =>
+	Boolean(/** @type {BuildMeta} */ (module.buildMeta).async) &&
+	module instanceof getExternalModule();
+
+// `createFakeNamespaceObject`'s "merge all properties" bit, the only one that
+// changes which names the namespace it builds carries.
+const MERGE_PROPERTIES_MODE = 2;
+
+/**
+ * The imported module decides, never the importer: two importers of one
+ * module have to be handed the same namespace object.
+ * @param {Module} module the imported module
+ * @returns {boolean} true when its namespace has to be a spec exotic object
+ */
+const usesSpecNamespaceObject = (module) =>
+	Boolean(module.buildInfo && module.buildInfo.specNamespaceObject);
+
+/**
+ * A module with no ESM namespace of its own — JSON, text, CommonJS — has one
+ * synthesized at each import site, so there the importer decides.
+ * @param {Module=} originModule the module the import is emitted into
+ * @returns {boolean} true when a namespace synthesized here has to be a spec object
+ */
+const synthesizesSpecNamespaceObject = (originModule) =>
+	originModule !== undefined && usesSpecNamespaceObject(originModule);
+
+/**
+ * Names the record a synthesized namespace belongs to and the shape it is built in,
+ * so every importer of one module reaches the same object and a reloaded module is
+ * not handed the namespace of the exports it replaced.
+ * @param {ModuleId | null} moduleId id of the imported module
+ * @param {number} mode the createFakeNamespaceObject mode the namespace is built with
+ * @returns {string} the arguments identifying it, ready to append to the call
+ */
+const synthesizedNamespaceOwner = (moduleId, mode) =>
+	moduleId === null
+		? ""
+		: `, ${RuntimeGlobals.moduleCache}[${JSON.stringify(moduleId)}], ${
+				mode & MERGE_PROPERTIES_MODE
+			}`;
+
 class RuntimeTemplate {
 	/**
 	 * Creates an instance of RuntimeTemplate.
@@ -404,8 +486,8 @@ class RuntimeTemplate {
 			(getGlobalObject(outputOptions.globalObject));
 		/** @type {string} */
 		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
-		/** @type {boolean | undefined} */
-		this._javascriptNamedWithoutContent = undefined;
+		/** @type {Set<string>} */
+		this._analyzableRepairedAssets = new Set();
 		/** @type {WeakMap<Chunk, boolean>} */
 		this._chunkNamedWithoutContent = new WeakMap();
 		/** @type {WeakMap<Chunk, string>} */
@@ -424,16 +506,20 @@ class RuntimeTemplate {
 		this._publicPathClimbText = undefined;
 		/** @type {WeakMap<Chunk, Placement>} */
 		this._placementByChunk = new WeakMap();
+		/** @type {WeakMap<Chunk, string>} */
+		this._hotUpdateUndoByChunk = new WeakMap();
+		/** @type {string | undefined} */
+		this._hotUpdateShapeText = undefined;
 		/** @type {Map<string, string | null | undefined>} */
 		this._entryBaseUriByRuntime = new Map();
-		/** @type {Map<string, string> | undefined} */
-		this._wasmRuntimeGroupsByKey = undefined;
-		/** @type {Set<string> | false | undefined} */
-		this._wasmFetchingGroupSet = undefined;
+		/** @type {WasmGroups | undefined} */
+		this._wasmGroupsValue = undefined;
+		/** @type {string[] | undefined} */
+		this._analyzableBailoutSink = undefined;
+		/** @type {Module | undefined} */
+		this._analyzableGeneratingModule = undefined;
 		/** @type {Map<string, boolean> | undefined} */
 		this._wasmAnchorKnownByGroup = undefined;
-		/** @type {Map<string, boolean> | undefined} */
-		this._wasmGroupOnlyFetchesMap = undefined;
 	}
 
 	isIIFE() {
@@ -530,6 +616,10 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.generator;
 	}
 
+	supportsTopLevelAwait() {
+		return this.outputOptions.environment.topLevelAwait;
+	}
+
 	supportsOptionalChaining() {
 		return this.outputOptions.environment.optionalChaining;
 	}
@@ -578,6 +668,41 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.modulePreload;
 	}
 
+	/**
+	 * Whether the deferred fill rewrote a chunk whose hashed name would otherwise go
+	 * stale, which `RealContentHashPlugin` reads to run — and to repair `[chunkhash]`
+	 * names — where `optimization.realContentHash` did not ask for it.
+	 * @returns {boolean} true once the fill has marked such a chunk
+	 */
+	needsAnalyzableRepair() {
+		return this._analyzableRepairedAssets.size > 0;
+	}
+
+	/**
+	 * The assets the deferred fill rewrote under a name that has to be repaired: an
+	 * on-demand repair renames only these and whatever names them.
+	 * @returns {ReadonlySet<string>} their names
+	 */
+	analyzableRepairedAssets() {
+		return this._analyzableRepairedAssets;
+	}
+
+	/**
+	 * The `devtool` value wrapping a javascript module in `eval(...)`, read through both
+	 * spellings — a plain string, and the per-asset-type array.
+	 * @returns {string | undefined} the value, or undefined when no devtool wraps modules
+	 */
+	_evalWrappingDevtool() {
+		const { devtool } = this.compilation.options;
+		const items = Array.isArray(devtool)
+			? devtool
+			: [{ type: "all", use: devtool }];
+		for (const { type, use } of items) {
+			if (type !== "all" && type !== "javascript") continue;
+			if (typeof use === "string" && use.includes("eval")) return use;
+		}
+	}
+
 	/**
 	 * Whether a reference a foreign bundler can follow without running webpack's runtime
 	 * may be emitted — the one question every caller asks, in the form it is asking for:
@@ -620,131 +745,88 @@ 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(
 				this.compilation,
 				scoped ? chunkGraph : undefined,
-				placedModule
+				placedModule,
+				runtime
 			)
 		) {
-			this._analyzableBailout(
+			return this._analyzableBailout(
 				module,
-				"__webpack_public_path__ is reassigned in a runtime this module belongs to"
+				"__webpack_public_path__ is reassigned in a runtime this module belongs to",
+				false
 			);
-			return false;
 		}
 
 		if (form === "import") {
 			// Read through a native `import()`, or it is not this feature at all.
-			if (outputOptions.chunkFormat !== "module") {
-				this._analyzableBailout(
-					module,
-					`output.chunkFormat is ${JSON.stringify(outputOptions.chunkFormat)}, so chunks are not read through a native import()`
-				);
-				return false;
-			}
-			if (outputOptions.importFunctionName !== "import") {
-				this._analyzableBailout(
-					module,
-					`output.importFunctionName is ${JSON.stringify(outputOptions.importFunctionName)}, so the call site is not a native import()`
-				);
-				return false;
-			}
-			// A worker loading its own chunks some other way keeps that runtime; one on
-			// `import` uses the same ESM loader as the main graph, so it can be analyzable.
-			for (const originChunk of /** @type {ChunkGraph} */ (
-				chunkGraph
-			).getModuleChunksIterable(/** @type {Module} */ (placedModule))) {
-				const entryOptions = originChunk.getEntryOptions();
-				if (!entryOptions || !entryOptions.worker) continue;
-				// `WorkerAndWorkletPlugin` always seeds this from `output.workerChunkLoading`.
-				if (entryOptions.chunkLoading !== "import") {
-					this._analyzableBailout(
-						module,
-						`this worker loads its chunks with ${JSON.stringify(entryOptions.chunkLoading)}, not "import"`
-					);
-					return false;
-				}
+			const outputReason = this._chunkImportOutputReason();
+			if (outputReason !== null) {
+				return this._analyzableBailout(module, outputReason, false);
 			}
+			// A worker loading its own chunks some other way needs no answer here: it gets
+			// a chunk loader of its own, and only the ESM one asks this.
 			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 neither gate
-		// below rules 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, so the url forms match what the rest of the
+		// bundle already assumes the target reads.
 		if (form === "url-inline") return true;
-		// `import.meta` is ESM syntax the target has to read. A chunk `import()` is
-		// emitted by the module chunk loader either way, so only the url forms check.
-		if (!this.supportsEcmaScriptModuleSyntax()) {
-			this._analyzableBailout(
-				module,
-				"output.environment.module is false, so the target does not read the import.meta this form needs"
-			);
-			return false;
-		}
 		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
 		// syntax error. Runtime modules are emitted beside them, never wrapped.
-		const { devtool } = this.compilation.options;
-		if (
-			form !== "url-runtime" &&
-			typeof devtool === "string" &&
-			devtool.includes("eval")
-		) {
-			this._analyzableBailout(
+		const evalDevtool =
+			form === "url-runtime" ? undefined : this._evalWrappingDevtool();
+		if (evalDevtool !== undefined) {
+			return this._analyzableBailout(
 				module,
-				`devtool ${JSON.stringify(devtool)} wraps the module in eval(), where import.meta does not parse`
+				`devtool ${JSON.stringify(evalDevtool)} wraps the module in eval(), where import.meta does not parse`,
+				false
 			);
-			return false;
 		}
 		if (form === "url" || form === "url-runtime") return true;
 		// A bare relative URL is what `__webpack_require__.p + path` means only under an
 		// `auto` public path; anything else has to be baked, which is the "wasm" form.
 		if (form === "wasm-relative") {
 			if (outputOptions.publicPath === "auto") return true;
-			this._analyzableBailout(
+			return this._analyzableBailout(
 				module,
-				"output.publicPath is set, so a bare relative url no longer means what the public path would have resolved to"
+				"output.publicPath is set, so a bare relative url no longer means what the public path would have resolved to",
+				false
 			);
-			return false;
 		}
 
 		// The rest is the `"wasm"` form: whether the whole binary url can be spelled
 		// here, rather than built at runtime under an `import.meta.url` base.
-		const { publicPath, webassemblyModuleFilename } = outputOptions;
+		const { publicPath } = outputOptions;
 		if (publicPath !== "auto") {
 			// A public path that needs no base names the same place from the chunk as from
 			// the document, so a literal spells what `fetch` would have reached.
 			if (this._publicPathNeedsNoBase()) {
 				// Settled no earlier than the hash it reads or is called with, so it is
 				// baked only where the deferred pass may finish it.
-				if (this._resolvePublicPathPrefix(publicPath, module) === null) {
+				if (this._resolvePublicPathPrefix(publicPath) === null) {
 					return false;
 				}
 			} else if (
 				this._anyWasmChunkFetches(runtime) &&
 				!this._wasmFetchAnchorIsKnown(runtime)
 			) {
-				this._analyzableBailout(
+				return this._analyzableBailout(
 					module,
-					"output.publicPath needs a base, and no one path back to the document fits every chunk `fetch` reads it from"
+					"output.publicPath needs a base, and no one path back to the document fits every chunk `fetch` reads it from",
+					false
 				);
-				return false;
 			}
 		}
-		// The compilation hash is settled after code generation, so a name carrying one
-		// is baked only where the deferred pass can fill it in. `[hash]` is the module's
-		// own here, which code generation already knows.
-		if (
-			getTemplatedPathPlugin()
-				.getPresentKinds(/** @type {string} */ (webassemblyModuleFilename))
-				.has("fullhash") &&
-			!this._canDeferOrBakeFullHash(true, undefined, module)
-		) {
-			return false;
-		}
 		return true;
 	}
 
@@ -753,45 +835,107 @@ class RuntimeTemplate {
 	 * the channel `ModuleConcatenationPlugin` already reports through, so it reaches
 	 * `stats.optimizationBailout`. Silent unless the build asked for ESM output, where
 	 * alone the answer is actionable; deduplicated because a module may write many.
+	 * Answers with `answer` so a caller states the refusal and its reason at once —
+	 * `false` where it answers a question, `null` where it was building a specifier.
+	 * @template {false | null} T
 	 * @param {Module | undefined} module the module the reference is emitted into
 	 * @param {string} reason why no literal could be baked
+	 * @param {T} answer what the caller hands back
+	 * @returns {T} that answer
+	 */
+	_analyzableBailout(module, reason, answer) {
+		if (module !== undefined && this.outputOptions.module) {
+			// Recorded on the module whose code is being generated, which is the one a
+			// cached result is restored for — an inner module of a concatenation is not.
+			const target = this._analyzableGeneratingModule || module;
+			const text = `${ANALYZABLE_BAILOUT_PREFIX}${reason}`;
+			const bailouts =
+				this.compilation.moduleGraph.getOptimizationBailout(target);
+			if (!bailouts.includes(text)) bailouts.push(text);
+			// Each generation records its own: another runtime's result may be all the
+			// cache restores later, so what the graph holds must not hide a reason.
+			if (this._analyzableGeneratingModule !== undefined) {
+				// The sink exists only once a reason is recorded, so a module that
+				// bakes every reference — nearly all of them — allocates nothing here.
+				const sink =
+					this._analyzableBailoutSink || (this._analyzableBailoutSink = []);
+				if (!sink.includes(reason)) sink.push(reason);
+			}
+		}
+		return answer;
+	}
+
+	/**
+	 * Names the module whose code generation starts, so the reasons its references
+	 * record are handed back by `finishAnalyzableBailouts` and attributed to it.
+	 * @param {Module} module the module being generated
 	 * @returns {void}
 	 */
-	_analyzableBailout(module, reason) {
-		if (module === undefined || !this.outputOptions.module) return;
-		const text = `Analyzable ESM bailout: ${reason}`;
+	beginAnalyzableBailouts(module) {
+		this._analyzableGeneratingModule = module;
+	}
+
+	/**
+	 * Ends the collection `beginAnalyzableBailouts` started, so the reasons can be
+	 * stored beside the result and reapplied when the cache restores it.
+	 * @returns {string[] | undefined} the reasons recorded since, or undefined for none
+	 */
+	finishAnalyzableBailouts() {
+		const sink = this._analyzableBailoutSink;
+		this._analyzableGeneratingModule = undefined;
+		this._analyzableBailoutSink = undefined;
+		return sink;
+	}
+
+	/**
+	 * Reapplies the bailouts a cached code generation result was stored with, so a
+	 * restored module reports the same reasons a generated one does.
+	 * @param {Module} module the module the result was restored for
+	 * @param {string[]} reasons the reasons stored beside it
+	 * @returns {void}
+	 */
+	restoreAnalyzableBailouts(module, reasons) {
 		const bailouts =
 			this.compilation.moduleGraph.getOptimizationBailout(module);
-		for (const existing of bailouts) {
-			if (existing === text) return;
+		for (const reason of reasons) {
+			const text = `${ANALYZABLE_BAILOUT_PREFIX}${reason}`;
+			if (!bailouts.includes(text)) bailouts.push(text);
 		}
-		bailouts.push(text);
 	}
 
 	/**
-	 * Whether a name that code generation cannot settle may be reserved as a stand-in
-	 * and filled in once the hashes exist. Substituting rewrites a chunk after its own
-	 * content hash was taken, so either `RealContentHashPlugin` has to bring the two
-	 * back in line, or no emitted javascript may be named by its content in the first
-	 * place — with a name like `[name].js` there is nothing to go stale. Asked of the
-	 * names the chunks actually carry rather than of `output`, so a template nothing is
-	 * emitted under does not rule the rewrite out and a `chunk.filenameTemplate` does
-	 * not slip past it.
-	 * @param {Iterable<Chunk>=} chunks the chunks the stand-in is written into; omit
-	 * where the answer has to hold for the whole compilation, as it does for a gate a
-	 * runtime module asks from the other end
-	 * @returns {boolean} true when deferring is safe
+	 * The reasons a module's references keep the runtime form, as recorded while its
+	 * code was generated.
+	 * @param {Module} module the module, a runtime module included
+	 * @returns {string[]} the reasons, none where every reference bakes
 	 */
-	_canDeferAnalyzableName(chunks) {
-		if (chunks === undefined) {
-			// Memoized: the chunk graph is settled before any caller asks compilation-wide.
-			if (this._javascriptNamedWithoutContent === undefined) {
-				this._javascriptNamedWithoutContent = this._canDeferAnalyzableName(
-					this.compilation.chunks
-				);
+	analyzableBailoutsOf(module) {
+		/** @type {string[]} */
+		const reasons = [];
+		for (const text of this.compilation.moduleGraph.getOptimizationBailout(
+			module
+		)) {
+			if (
+				typeof text === "string" &&
+				text.startsWith(ANALYZABLE_BAILOUT_PREFIX)
+			) {
+				reasons.push(text.slice(ANALYZABLE_BAILOUT_PREFIX.length));
 			}
-			return this._javascriptNamedWithoutContent;
 		}
+		return reasons;
+	}
+
+	/**
+	 * Whether a name that code generation cannot settle may be reserved as a stand-in
+	 * and filled in once the hashes exist without a repair behind it. Substituting
+	 * rewrites a chunk after its own content hash was taken, so either no emitted
+	 * javascript may be named by its content — with a name like `[name].js` there is
+	 * nothing to go stale — or `RealContentHashPlugin` has to bring the two back in
+	 * line, which is what a name this says no to gets: see `_needsRepair`.
+	 * @param {Iterable<Chunk>} chunks the chunks the stand-in is written into
+	 * @returns {boolean} true when no name moves with the bytes the fill leaves
+	 */
+	_canDeferAnalyzableName(chunks) {
 		let found = false;
 		for (const chunk of chunks) {
 			found = true;
@@ -802,16 +946,15 @@ class RuntimeTemplate {
 	}
 
 	/**
-	 * `_canDeferAnalyzableName`, recording why not when the answer is no — what every
-	 * caller with a module to report against does with it.
-	 * @param {Iterable<Chunk>=} chunks the chunks the stand-in is written into
-	 * @param {Module=} module the module the reference is emitted into
-	 * @returns {boolean} true when deferring is safe
+	 * Whether a stand-in written into `chunks` needs the repair pass behind it: their
+	 * hashed names would otherwise go stale once the fill moves their bytes. The pass
+	 * is `RealContentHashPlugin`, run on demand where `optimization.realContentHash`
+	 * did not ask for it, and repairing `[chunkhash]` names too while it is at it.
+	 * @param {Iterable<Chunk>} chunks the chunks the stand-in is written into
+	 * @returns {boolean} true when the fill has to mark the name for repair
 	 */
-	_canDeferOrBail(chunks, module) {
-		if (this._canDeferAnalyzableName(chunks)) return true;
-		this._analyzableBailout(module, DEFER_BAILOUT);
-		return false;
+	_needsRepair(chunks) {
+		return !this._canDeferAnalyzableName(chunks);
 	}
 
 	/**
@@ -819,37 +962,28 @@ class RuntimeTemplate {
 	 * and a stand-in for the deferred pass where they do not.
 	 * @param {SpecifierPart[]} parts the whole specifier
 	 * @param {Iterable<Chunk>} chunks the chunks it is written into
-	 * @param {Module=} module the module the reference is emitted into
-	 * @returns {string | null} it already quoted, or `null` when no stand-in may be
-	 * reserved
+	 * @returns {string} it already quoted
 	 */
-	_specifierOf(parts, chunks, module) {
+	_specifierOf(parts, chunks) {
 		const text = literalText(parts);
 		if (text !== null) return toJsStringLiteral(text);
-		if (
-			!this._canDeferOrBakeFullHash(
-				this._partsBakeFullHash(parts),
-				chunks,
-				module
-			)
-		) {
-			return null;
-		}
-		return toJsStringLiteral(this._reserveAnalyzableSpecifier(parts));
+		// One built out of the compilation hash moves its chunk into the round after
+		// that hash, where the name is taken from the filled bytes anyway.
+		const repair = !this._partsBakeFullHash(parts) && this._needsRepair(chunks);
+		return toJsStringLiteral(
+			this._reserveAnalyzableSpecifier(this._markedForRepair(repair, parts))
+		);
 	}
 
 	/**
-	 * `_canDeferOrBail` for a name the fill builds out of the compilation hash. Such a
-	 * stand-in settles the name it lands in for us: `_markChunksBakingFullHash` reads it
-	 * back and moves that chunk into the round after that hash, which is the same place a
-	 * chunk reaching for `__webpack_require__.p` ends up without asking.
-	 * @param {boolean} carriesFullHash whether the fill builds this one out of that hash
-	 * @param {Iterable<Chunk>=} chunks the chunks the stand-in is written into
-	 * @param {Module=} module the module the reference is emitted into
-	 * @returns {boolean} true when deferring is safe
+	 * The parts a stand-in is reserved with, marked where the name it lands in has to
+	 * be repaired after the fill.
+	 * @param {boolean} repair what `_needsRepair` answered
+	 * @param {SpecifierPart[]} parts what the stand-in resolves to
+	 * @returns {SpecifierPart[]} the parts, marked where the repair is needed
 	 */
-	_canDeferOrBakeFullHash(carriesFullHash, chunks, module) {
-		return carriesFullHash || this._canDeferOrBail(chunks, module);
+	_markedForRepair(repair, parts) {
+		return repair ? [["repair", ""], ...parts] : parts;
 	}
 
 	/**
@@ -861,9 +995,7 @@ class RuntimeTemplate {
 	 */
 	_partsBakeFullHash(parts) {
 		for (const [kind, value] of parts) {
-			if (kind === "publicPath" || kind === "template" || kind === "unserved") {
-				return true;
-			}
+			if (FULL_HASH_PART_KINDS.has(kind)) return true;
 			if (kind === "literal" && this._hasReservedFullHash(String(value))) {
 				return true;
 			}
@@ -962,95 +1094,82 @@ class RuntimeTemplate {
 		const base = this.analyzableUrlReadsBaseUri()
 			? this.entryBaseUri(runtime)
 			: undefined;
-		if (base !== undefined) {
-			if (base === null) {
-				this._analyzableBailout(
-					module,
-					"the entries this module is generated for set different baseUri values, so no one url resolves for all of them"
-				);
-				return null;
-			}
-			// A relative one is no base of its own: the runtime reads it against the
-			// chunk, so the literal spells it there rather than resolving against it.
-			if (isChunkRelativeBaseUri(base)) {
-				return this._getAnalyzableFileSpecifier(
-					module,
-					chunkGraph,
-					[["literal", filename]],
-					true,
-					base
-				);
-			}
-			const chunks = this._moduleChunks(module, chunkGraph);
-			// 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.
-			if (base.startsWith("//")) {
-				const relative = this._resolvePublicPathPrefix(
-					publicPath,
-					module,
-					chunks
-				);
-				return relative === null
-					? null
-					: this._specifierOf(
-							[
-								["literal", base],
-								...rootedParts(relative),
-								["literal", filename]
-							],
-							chunks,
-							module
-						);
-			}
-			if (!isAbsoluteBaseUri(base)) {
-				this._analyzableBailout(
-					module,
-					`an entry sets a baseUri of ${JSON.stringify(base)}, whose scheme names no base anything can be resolved against`
-				);
-				return null;
-			}
-			const parts = this._resolvePublicPathPrefix(publicPath, module, chunks);
-			if (parts === null) return null;
-			// Resolved here rather than against the output root, and only an absolute base
-			// settles it — a relative one has no base of its own to be read against.
-			const spelled = literalText(parts);
-			// A hash the deferred pass still has to fill in cannot be resolved against the
-			// base here: the fill would land inside an already-resolved url, where a hash
-			// opening with a letter reads as a scheme and drops the base entirely.
-			const text =
-				spelled !== null && !this._hasReservedFullHash(spelled)
-					? spelled
-					: null;
-			/** @type {URL} */
-			let resolved;
-			try {
-				// Empty where only the deferred pass can spell the rest, which still settles
-				// whether the base itself is one anything may be resolved against.
-				resolved = new URL(text === null ? "" : text + filename, base);
-			} catch (_error) {
-				this._analyzableBailout(
-					module,
-					`an entry sets a baseUri of ${JSON.stringify(base)}, which is not absolute, so no url can be resolved against it here`
-				);
-				return null;
-			}
-			if (text !== null) return toJsStringLiteral(resolved.href);
-			if (!this._canDeferOrBail(chunks, module)) return null;
-			return toJsStringLiteral(
-				this._reserveAnalyzableSpecifier([
+		// No base of its own: the name is spelled against the output root, as a chunk is.
+		if (base === undefined) {
+			return this._getAnalyzableFileSpecifier(
+				module,
+				chunkGraph,
+				[["literal", filename]],
+				true
+			);
+		}
+		if (base === null) {
+			return this._analyzableBailout(
+				module,
+				"the entries this module is generated for set different baseUri values, so no one url resolves for all of them",
+				null
+			);
+		}
+		// A relative one is no base of its own: the runtime reads it against the
+		// chunk, so the literal spells it there rather than resolving against it.
+		if (isChunkRelativeBaseUri(base)) {
+			return this._getAnalyzableFileSpecifier(
+				module,
+				chunkGraph,
+				[["literal", filename]],
+				true,
+				base
+			);
+		}
+		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 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]],
+				chunks
+			);
+		}
+		if (!isAbsoluteBaseUri(base)) {
+			return this._analyzableBailout(
+				module,
+				`an entry sets a baseUri of ${JSON.stringify(base)}, whose scheme names no base anything can be resolved against`,
+				null
+			);
+		}
+		// Resolved here rather than against the output root, and only an absolute base
+		// settles it — a relative one has no base of its own to be read against.
+		const spelled = literalText(parts);
+		// A hash the deferred pass still has to fill in cannot be resolved against the
+		// base here: the fill would land inside an already-resolved url, where a hash
+		// opening with a letter reads as a scheme and drops the base entirely.
+		const text =
+			spelled !== null && !this._hasReservedFullHash(spelled) ? spelled : null;
+		/** @type {URL} */
+		let resolved;
+		try {
+			// Empty where only the deferred pass can spell the rest, which still settles
+			// whether the base itself is one anything may be resolved against.
+			resolved = new URL(text === null ? "" : text + filename, base);
+		} catch (_error) {
+			return this._analyzableBailout(
+				module,
+				`an entry sets a baseUri of ${JSON.stringify(base)}, which is not absolute, so no url can be resolved against it here`,
+				null
+			);
+		}
+		if (text !== null) return toJsStringLiteral(resolved.href);
+		return toJsStringLiteral(
+			this._reserveAnalyzableSpecifier(
+				this._markedForRepair(this._needsRepair(chunks), [
 					["base", base],
 					...parts,
 					["literal", filename]
 				])
-			);
-		}
-		return this._getAnalyzableFileSpecifier(
-			module,
-			chunkGraph,
-			[["literal", filename]],
-			true
+			)
 		);
 	}
 
@@ -1072,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.
@@ -1121,55 +1239,119 @@ class RuntimeTemplate {
 		return publicPath.includes("[") ? undefined : publicPath;
 	}
 
+	/**
+	 * Runtime keys grouped by the binaries they share, with what the entries of each
+	 * group asked for. Code generation runs once for runtimes a module hashes alike in,
+	 * and nothing in a binary's hash knows which loader will read it — so a binary two
+	 * runtimes reach carries one shape into both, and a third runtime sharing another
+	 * binary with either is pulled in after them. Only an entry names a loader; every
+	 * other chunk of the runtime is served by the one its entry asked for. Asked of the
+	 * same modules the loaders are created for, and only once per compilation.
+	 * @returns {WasmGroups} the grouping, and which groups fetch
+	 */
+	_wasmGroups() {
+		if (this._wasmGroupsValue === undefined) {
+			const { chunkGraph, chunks, modules } = this.compilation;
+			/** @type {Map<string, string>} */
+			const parent = new Map();
+			/**
+			 * @param {string} key runtime key
+			 * @returns {string} the key naming its group
+			 */
+			const find = (key) => {
+				let root = key;
+				let seen = parent.get(root);
+				while (seen !== undefined && seen !== root) {
+					root = seen;
+					seen = parent.get(root);
+				}
+				// Path compression keeps a long share chain from costing more than once.
+				let walk = key;
+				let next = parent.get(walk);
+				while (next !== undefined && next !== root) {
+					parent.set(walk, root);
+					walk = next;
+					next = parent.get(walk);
+				}
+				return root;
+			};
+			/** @type {string[]} */
+			const keys = [];
+			for (const module of modules) {
+				if (module.type !== WEBASSEMBLY_MODULE_TYPE_ASYNC) continue;
+				keys.length = 0;
+				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+					forEachRuntime(runtime, (key) => {
+						keys.push(/** @type {string} */ (key));
+					});
+				}
+				for (const key of keys) if (!parent.has(key)) parent.set(key, key);
+				// Every runtime this binary reaches answers with the first one.
+				for (let i = 1; i < keys.length; i++) {
+					parent.set(find(keys[i]), find(keys[0]));
+				}
+			}
+			// Flattened once, so a lookup is a single `get` rather than a chain walk.
+			for (const key of parent.keys()) parent.set(key, find(key));
+			/**
+			 * @param {string} key a runtime key
+			 * @returns {string} the group it answers with, or itself when it shares nothing
+			 */
+			const groupOf = (key) => {
+				const group = parent.get(key);
+				// An entry named "" makes "" a runtime key, so test absence, not a falsy value.
+				return group === undefined ? key : group;
+			};
+			/** @type {Set<string>} */
+			const fetching = new Set();
+			/** @type {Map<string, boolean>} */
+			const onlyFetching = new Map();
+			for (const chunk of chunks) {
+				if (!chunk.getEntryOptions()) continue;
+				const fetches = this._chunkWasmLoading(chunk) === "fetch";
+				forEachRuntime(chunk.runtime, (key) => {
+					const group = groupOf(/** @type {string} */ (key));
+					if (fetches) fetching.add(group);
+					onlyFetching.set(group, onlyFetching.get(group) !== false && fetches);
+				});
+			}
+			this._wasmGroupsValue = { groupOf, fetching, onlyFetching };
+		}
+		return this._wasmGroupsValue;
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtime being asked about
+	 * @returns {string[]} the wasm runtime groups it reaches
+	 */
+	_wasmGroupsOf(runtime) {
+		const { groupOf } = this._wasmGroups();
+		/** @type {string[]} */
+		const reached = [];
+		forEachRuntime(runtime, (key) => {
+			reached.push(groupOf(/** @type {string} */ (key)));
+		});
+		return reached;
+	}
+
 	/**
 	 * Whether a chunk loads WebAssembly through `fetch`, which is the only loader the
 	 * public path reaches: `readFile` resolves the binary's name against the chunk it is
 	 * read from, exactly as a baked literal does, so a public path is irrelevant to it.
-	 * Answered per runtime rather than per chunk on purpose — a module's generated source
+	 * Answered per group rather than per chunk on purpose — a module's generated source
 	 * and the runtime module of every chunk holding it have to agree on the shape, and
-	 * they ask from opposite ends; one loader serves a whole runtime, so that is the
-	 * finest scope on which they can. Without a runtime, or where the runtimes cannot be
-	 * told apart, the answer covers the compilation.
+	 * they ask from opposite ends; one loader serves a whole group, so that is the finest
+	 * scope on which they can. Without a runtime the answer covers the compilation.
 	 * @param {RuntimeSpec=} runtime the runtime being asked about
 	 * @returns {boolean} true when a chunk of that runtime fetches its binaries
 	 */
 	_anyWasmChunkFetches(runtime) {
-		const fetching = this._wasmFetchingGroups();
-		if (fetching === undefined) return false;
+		const { fetching } = this._wasmGroups();
+		if (fetching.size === 0) return false;
 		// Without a runtime to place it in there is nothing to narrow by, so any chunk
 		// answers for all of them.
 		if (runtime === undefined) return true;
-		const groups = this._wasmRuntimeGroups();
-		if (typeof runtime === "string") {
-			return fetching.has(this._wasmGroupOf(groups, runtime));
-		}
-		for (const key of runtime) {
-			if (fetching.has(this._wasmGroupOf(groups, key))) return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Whether every entry of a wasm runtime group reads its binaries with `fetch`. Only
-	 * an entry names a loader, so the scan is of entries, as `_wasmFetchingGroups` is.
-	 * @returns {Map<string, boolean>} whether each group fetches and nothing else
-	 */
-	_wasmGroupOnlyFetches() {
-		if (this._wasmGroupOnlyFetchesMap === undefined) {
-			const groups = this._wasmRuntimeGroups();
-			/** @type {Map<string, boolean>} */
-			const only = new Map();
-			for (const chunk of this.compilation.chunks) {
-				if (!chunk.getEntryOptions()) continue;
-				const fetches = this._chunkWasmLoading(chunk) === "fetch";
-				forEachRuntime(chunk.runtime, (key) => {
-					const group = this._wasmGroupOf(groups, /** @type {string} */ (key));
-					only.set(group, only.get(group) !== false && fetches);
-				});
-			}
-			this._wasmGroupOnlyFetchesMap = only;
-		}
-		return this._wasmGroupOnlyFetchesMap;
+		return this._wasmGroupsOf(runtime).some((group) => fetching.has(group));
 	}
 
 	/**
@@ -1182,30 +1364,31 @@ class RuntimeTemplate {
 	_wasmFetchAnchorIsKnown(runtime) {
 		if (this._wasmAnchorKnownByGroup === undefined) {
 			const { chunkGraph, modules } = this.compilation;
-			const publicPath = /** @type {PublicPath} */ (
-				this.outputOptions.publicPath
-			);
-			const groups = this._wasmRuntimeGroups();
+			const { groupOf, onlyFetching } = this._wasmGroups();
 			/** @type {Map<string, boolean>} */
 			const known = new Map();
 			for (const module of modules) {
 				if (module.type !== WEBASSEMBLY_MODULE_TYPE_ASYNC) continue;
+				// Probed through the very builder the generator runs, so the gate is
+				// exact: a prefix it can spell — the per-asset deferrals included — is
+				// one the group may bake. The probe name stands in for the binary's.
 				const spellable =
-					this._modulePlacement(module, chunkGraph).loaded !== null &&
-					this._resolvePublicPathPrefix(publicPath, module) !== null;
+					this._getAnalyzableFileSpecifier(
+						module,
+						/** @type {ChunkGraph} */ (chunkGraph),
+						[["literal", "x"]],
+						true
+					) !== null;
 				for (const moduleRuntime of chunkGraph.getModuleRuntimes(module)) {
 					forEachRuntime(moduleRuntime, (key) => {
-						const group = this._wasmGroupOf(
-							groups,
-							/** @type {string} */ (key)
-						);
+						const group = groupOf(/** @type {string} */ (key));
 						known.set(group, known.get(group) !== false && spellable);
 					});
 				}
 			}
 			// A group one entry reads with `readFile` cannot take a prefix meant for the
 			// document, and only an entry names its loader.
-			for (const [group, only] of this._wasmGroupOnlyFetches()) {
+			for (const [group, only] of onlyFetching) {
 				if (!only) known.set(group, false);
 			}
 			this._wasmAnchorKnownByGroup = known;
@@ -1217,124 +1400,9 @@ class RuntimeTemplate {
 			for (const value of known.values()) if (!value) return false;
 			return known.size > 0;
 		}
-		const groups = this._wasmRuntimeGroups();
-		if (typeof runtime === "string") {
-			return known.get(this._wasmGroupOf(groups, runtime)) === true;
-		}
-		for (const key of runtime) {
-			if (known.get(this._wasmGroupOf(groups, key)) !== true) return false;
-		}
-		return true;
-	}
-
-	/**
-	 * The runtime groups an entry of which asked for the `fetch` loader, or `undefined`
-	 * where none did — the cheap answer for a compilation with no fetching entry at all,
-	 * which is every non-web target. Only an entry names a loader; every other chunk of
-	 * the runtime is served by the one its entry asked for.
-	 * @returns {Set<string> | undefined} the groups that fetch
-	 */
-	_wasmFetchingGroups() {
-		if (this._wasmFetchingGroupSet === undefined) {
-			/** @type {Set<string>} */
-			const fetching = new Set();
-			/** @type {Map<string, string> | undefined} */
-			let groups;
-			for (const chunk of this.compilation.chunks) {
-				// Only an entry names a loader; every other chunk of the runtime is served
-				// by the one its entry asked for, so it says nothing on its own.
-				if (!chunk.getEntryOptions()) continue;
-				if (this._chunkWasmLoading(chunk) !== "fetch") continue;
-				// Built only once something fetches, so nothing pays for the grouping.
-				if (groups === undefined) groups = this._wasmRuntimeGroups();
-				const named = /** @type {Map<string, string>} */ (groups);
-				forEachRuntime(chunk.runtime, (key) => {
-					fetching.add(this._wasmGroupOf(named, /** @type {string} */ (key)));
-				});
-			}
-			this._wasmFetchingGroupSet = fetching.size === 0 ? false : fetching;
-		}
-		return this._wasmFetchingGroupSet === false
-			? undefined
-			: this._wasmFetchingGroupSet;
-	}
-
-	/**
-	 * Runtime keys mapped to the group they answer with, named by one key of it. Code
-	 * generation runs once for runtimes a module hashes alike in, and nothing in a
-	 * binary's hash knows which loader will read it — so a binary two runtimes reach
-	 * carries one shape into both, and a third runtime sharing another binary with
-	 * either is pulled in after them. A key in no group answers as itself. Asked of the
-	 * same modules the loaders are created for, and only once per compilation.
-	 * @returns {Map<string, string>} runtime key to the group it answers with
-	 */
-	_wasmRuntimeGroups() {
-		if (this._wasmRuntimeGroupsByKey === undefined) {
-			const { chunkGraph } = this.compilation;
-			/** @type {Map<string, string>} */
-			const parent = new Map();
-			/**
-			 * @param {string} key runtime key
-			 * @returns {string} the key naming its group
-			 */
-			const find = (key) => {
-				let root = key;
-				let seen = parent.get(root);
-				while (seen !== undefined && seen !== root) {
-					root = seen;
-					seen = parent.get(root);
-				}
-				// Path compression keeps a long share chain from costing more than once.
-				let walk = key;
-				let next = parent.get(walk);
-				while (next !== undefined && next !== root) {
-					parent.set(walk, root);
-					walk = next;
-					next = parent.get(walk);
-				}
-				return root;
-			};
-			/** @type {string[]} */
-			const keys = [];
-			/**
-			 * @param {RuntimeSpec} runtime a runtime the module is generated for
-			 * @returns {void}
-			 */
-			const collectKeys = (runtime) => {
-				forEachRuntime(runtime, (key) => {
-					keys.push(/** @type {string} */ (key));
-				});
-			};
-			for (const module of this.compilation.modules) {
-				if (module.type !== WEBASSEMBLY_MODULE_TYPE_ASYNC) continue;
-				keys.length = 0;
-				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-					collectKeys(runtime);
-				}
-				for (const key of keys) {
-					if (!parent.has(key)) parent.set(key, key);
-				}
-				// Every runtime this binary reaches answers with the first one.
-				for (let i = 1; i < keys.length; i++) {
-					parent.set(find(keys[i]), find(keys[0]));
-				}
-			}
-			// Flattened once, so a lookup is a single `get` rather than a chain walk.
-			for (const key of parent.keys()) parent.set(key, find(key));
-			this._wasmRuntimeGroupsByKey = parent;
-		}
-		return this._wasmRuntimeGroupsByKey;
-	}
-
-	/**
-	 * @param {Map<string, string>} groups runtime key to the group it answers with
-	 * @param {string} key a runtime key
-	 * @returns {string} the group it answers with, or itself when it shares nothing
-	 */
-	_wasmGroupOf(groups, key) {
-		const group = groups.get(key);
-		// An entry named "" makes "" a runtime key, so test absence, not a falsy value.
-		return group === undefined ? key : group;
+		return this._wasmGroupsOf(runtime).every(
+			(group) => known.get(group) === true
+		);
 	}
 
 	supportTemplateLiteral() {
@@ -1413,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;
@@ -1897,14 +1964,21 @@ class RuntimeTemplate {
 		});
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
 		switch (exportsType) {
-			case "namespace":
-				return this.moduleRaw({
+			case "namespace": {
+				const raw = this.moduleRaw({
 					module,
 					chunkGraph,
 					request,
 					weak,
 					runtimeRequirements
 				});
+
+				if (!usesSpecNamespaceObject(module)) return raw;
+
+				runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+
+				return `${RuntimeGlobals.specNamespaceObject}(${raw})`;
+			}
 			case "default-with-named":
 				runtimeRequirements.add(RuntimeGlobals.createFakeNamespaceObject);
 				return `${RuntimeGlobals.createFakeNamespaceObject}(${moduleId}, 3)`;
@@ -2013,12 +2087,30 @@ class RuntimeTemplate {
 
 			let mode = getMakeDeferredNamespaceModeFromExportsType(exportsType);
 			if (mode) mode = `${mode} | 16`;
+			// The spec's namespace keys are the sorted exports, so hand them over
+			// when they are fully known; otherwise the runtime stays permissive.
+			const deferredExportNames = getKnownExportNames(
+				chunkGraph.moduleGraph,
+				module,
+				exportsType
+			);
+			runtimeRequirements.add(
+				deferredExportNames
+					? RuntimeGlobals.hasSealedDeferredNamespace
+					: RuntimeGlobals.hasSynthesizedDeferredNamespace
+			);
+			mode += deferredExportNames
+				? `, ${JSON.stringify(deferredExportNames)}`
+				: "";
 
 			const asyncDeps = Array.from(
 				getOutgoingAsyncModules(chunkGraph.moduleGraph, module),
 				(m) => chunkGraph.getModuleId(m)
 			).filter((id) => id !== null);
 			if (asyncDeps.length) {
+				runtimeRequirements.add(
+					RuntimeGlobals.deferredModuleAsyncTransitiveDependencies
+				);
 				if (header) {
 					appending = `.then(${this.basicFunction(
 						"",
@@ -2053,15 +2145,22 @@ class RuntimeTemplate {
 		} else {
 			let fakeType = 16;
 			switch (exportsType) {
-				case "namespace":
-					if (header) {
-						const rawModule = this.moduleRaw({
+				case "namespace": {
+					const specNamespace = usesSpecNamespaceObject(module);
+					const asyncModule = chunkGraph.moduleGraph.isAsync(module);
+					if (header || (specNamespace && !asyncModule)) {
+						let rawModule = this.moduleRaw({
 							module,
 							chunkGraph,
 							request,
 							weak,
 							runtimeRequirements
 						});
+						if (specNamespace && !asyncModule) {
+							runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+							// Wrap before promise resolution assimilates an exported `then`.
+							rawModule = `${RuntimeGlobals.specNamespaceObject}(${rawModule})`;
+						}
 						appending = `.then(${this.basicFunction(
 							"",
 							`${header}return ${rawModule};`
@@ -2073,7 +2172,14 @@ class RuntimeTemplate {
 							`${comment}${idExpr}`
 						)})`;
 					}
+
+					if (specNamespace && asyncModule) {
+						runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+						appending += `.then(${RuntimeGlobals.specNamespaceObject})`;
+					}
+
 					break;
+				}
 				case "dynamic":
 					fakeType |= 4;
 				/* fall through */
@@ -2127,6 +2233,15 @@ class RuntimeTemplate {
 							)})`;
 						}
 					}
+					if (synthesizesSpecNamespaceObject(originModule)) {
+						runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+						runtimeRequirements.add(RuntimeGlobals.moduleCache);
+						const owner = synthesizedNamespaceOwner(moduleId, fakeType);
+						appending += `.then(${this.returningFunction(
+							`${RuntimeGlobals.specNamespaceObject}(m${owner})`,
+							"m"
+						)})`;
+					}
 					break;
 			}
 		}
@@ -2235,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(
@@ -2255,11 +2369,14 @@ class RuntimeTemplate {
 			(dependency instanceof HarmonyImportDependency ||
 				dependency instanceof ImportDependency) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
-			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+			!isAsyncExternal(module);
 
 		if (isModuleDeferred) {
 			/** @type {Set<Module>} */
 			const outgoingAsyncModules = getOutgoingAsyncModules(moduleGraph, module);
+			// A module deferring itself is already evaluating, so awaiting it here
+			// would deadlock; forcing the namespace throws instead.
+			outgoingAsyncModules.delete(originModule);
 
 			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
 				moduleId,
@@ -2344,7 +2461,7 @@ class RuntimeTemplate {
 			(dependency instanceof HarmonyImportDependency ||
 				dependency instanceof ImportDependency) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
-			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+			!isAsyncExternal(module);
 
 		if (defaultInterop) {
 			// when the defaultInterop is used (when a ESM imports a CJS module),
@@ -2374,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) {
@@ -2417,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(
@@ -2430,16 +2544,38 @@ class RuntimeTemplate {
 						`${importVar}_namespace_cache`
 					)
 				);
+				const fakeMode = exportsType === "default-only" ? 0 : 2;
+				const fakeArguments = fakeMode === 0 ? "" : ", 2";
+				let fakeNamespace = `${RuntimeGlobals.createFakeNamespaceObject}(${importVar}${fakeArguments})`;
+				if (synthesizesSpecNamespaceObject(originModule)) {
+					runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+					runtimeRequirements.add(RuntimeGlobals.moduleCache);
+					const owner = synthesizedNamespaceOwner(
+						chunkGraph.getModuleId(module),
+						fakeMode
+					);
+					fakeNamespace = `${RuntimeGlobals.specNamespaceObject}(${fakeNamespace}${owner})`;
+				}
 				return `/*#__PURE__*/ ${
 					asiSafe ? "" : asiSafe === false ? ";" : "Object"
-				}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${
-					RuntimeGlobals.createFakeNamespaceObject
-				}(${importVar}${exportsType === "default-only" ? "" : ", 2"})))`;
+				}(${importVar}_namespace_cache || (${importVar}_namespace_cache = ${fakeNamespace}))`;
 			}
 		}
 
 		if (exportName.length > 0) {
 			const exportsInfo = moduleGraph.getExportsInfo(module);
+			// A name the module does not export is the namespace's to answer — reading
+			// it is undefined and writing it fails — not the exports object's.
+			if (
+				!isModuleDeferred &&
+				usesSpecNamespaceObject(module) &&
+				exportsInfo.isExportProvided(exportName) === false
+			) {
+				runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+				const ns = `${RuntimeGlobals.specNamespaceObject}(${importVar})`;
+
+				return `${ns}${propertyAccess(exportName)}`;
+			}
 			// in some case the exported item is renamed (get this by getUsedName). for example,
 			// x.default might be emitted as x.Z (default is renamed to Z)
 			const used = exportsInfo.getUsedName(exportName, runtime);
@@ -2484,9 +2620,19 @@ class RuntimeTemplate {
 			runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
 			const id = chunkGraph.getModuleId(module);
 			const type = getMakeDeferredNamespaceModeFromExportsType(exportsType);
-			const init = `${
-				RuntimeGlobals.makeDeferredNamespaceObject
-			}(${JSON.stringify(id)}, ${type})`;
+			const names = getKnownExportNames(
+				chunkGraph.moduleGraph,
+				module,
+				exportsType
+			);
+			runtimeRequirements.add(
+				names
+					? RuntimeGlobals.hasSealedDeferredNamespace
+					: RuntimeGlobals.hasSynthesizedDeferredNamespace
+			);
+			const init = `${RuntimeGlobals.makeDeferredNamespaceObject}(${JSON.stringify(
+				id
+			)}, ${type}${names ? `, ${JSON.stringify(names)}` : ""})`;
 
 			return `/*#__PURE__*/ ${
 				asiSafe ? "" : asiSafe === false ? ";" : "Object"
@@ -2513,6 +2659,16 @@ class RuntimeTemplate {
 		// if we hit here, the importVar is either
 		// - already a ES module namespace object
 		// - or imported by a way that does not need interop.
+		if (
+			exportsType === "namespace" &&
+			exportName.length === 0 &&
+			usesSpecNamespaceObject(module)
+		) {
+			runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+
+			return `${RuntimeGlobals.specNamespaceObject}(${importVar})`;
+		}
+
 		return importVar;
 	}
 
@@ -2593,7 +2749,7 @@ class RuntimeTemplate {
 	 * @param {string} options.message the message
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
-	 * @param {Module=} options.originModule the module the `import()` is emitted into
+	 * @param {Module=} options.originModule the module the `import()` is emitted into, to report against
 	 * @returns {string} expression
 	 */
 	blockPromise({
@@ -2607,165 +2763,48 @@ class RuntimeTemplate {
 			const comment = this.comment({
 				message
 			});
-			return `Promise.resolve(${comment.trim()})`;
-		}
-		const chunkGroup = chunkGraph.getBlockChunkGroup(block);
-		if (!chunkGroup || chunkGroup.chunks.length === 0) {
-			const comment = this.comment({
-				message
-			});
-			return `Promise.resolve(${comment.trim()})`;
-		}
-		const chunks = chunkGroup.chunks.filter(
-			(chunk) => !chunk.hasRuntime() && chunk.id !== null
-		);
-		const comment = this.comment({
-			message,
-			chunkName: block.chunkName
-		});
-		// `fetchPriority` is unsupported for ESM output (a native `import()` can't carry it,
-		// and the ESM chunk loader ignores the argument), so it never blocks the analyzable form.
-		// TODO recheck: browsers honor `fetchpriority` on `modulepreload` only when the
-		// preload scanner sees it, so a runtime-injected hint is inert; support it here if
-		// that changes.
-		const fetchPriority = chunkGroup.options.fetchPriority;
-		if (chunks.length === 1) {
-			const analyzable = this.analyzableChunkImport(
-				chunks[0],
-				comment,
-				runtimeRequirements,
-				originModule,
-				chunkGraph
-			);
-			if (analyzable !== null) {
-				return analyzable;
-			}
-			const chunkId = JSON.stringify(chunks[0].id);
-			runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-
-			if (fetchPriority) {
-				runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
-			}
-
-			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId}${
-				fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
-			})`;
-		} else if (chunks.length > 0) {
-			let needEnsureChunk = false;
-			/**
-			 * Analyzable `import()` for a solely-owned JS chunk, else runtime ensureChunk.
-			 * @param {Chunk} chunk chunk
-			 * @returns {string} require chunk id code
-			 */
-			const requireChunkId = (chunk) => {
-				const analyzable = this.analyzableChunkImport(
-					chunk,
-					"",
-					runtimeRequirements,
-					originModule,
-					chunkGraph
-				);
-				if (analyzable !== null) return analyzable;
-				needEnsureChunk = true;
-				return `${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
-					fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
-				})`;
-			};
-			const items = chunks.map(requireChunkId);
-			if (needEnsureChunk) {
-				runtimeRequirements.add(RuntimeGlobals.ensureChunk);
-				// Only needed when an `ensureChunk(id, priority)` call is actually emitted.
-				if (fetchPriority) {
-					runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
-				}
-			}
-			return `Promise.all(${comment.trim()}[${items.join(", ")}])`;
-		}
-		return `Promise.resolve(${comment.trim()})`;
-	}
-
-	/**
-	 * For ESM module output, load a single statically-named chunk through the
-	 * `analyzableChunkImport` helper — a literal `import("./chunk.js")` other bundlers
-	 * and webpack itself can follow, wrapped to keep `ensureChunk` timing and deduplication.
-	 * Returns `null` to fall back to the runtime `ensureChunk` form.
-	 * @param {Chunk} chunk the chunk to load
-	 * @param {string} comment leading comment (chunk name / message)
-	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
-	 * @param {Module | undefined} originModule the module the `import()` is emitted into
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {string | null} the import expression, or `null`
-	 */
-	analyzableChunkImport(
-		chunk,
-		comment,
-		runtimeRequirements,
-		originModule,
-		chunkGraph
-	) {
-		// `blockPromise` has already dropped any chunk without an id. Without an origin
-		// there is nothing the specifier could be relative to.
-		if (
-			!originModule ||
-			!this.supportsAnalyzable("import", chunkGraph, originModule)
-		) {
-			return null;
+			return `Promise.resolve(${comment.trim()})`;
 		}
-		// Prefetch/preload children are injected by the runtime `.f` handlers, which `.ei`
-		// runs too — but they attach to `.f`, so it has to exist.
-		const needsHintHandlers =
-			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
-			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
-			chunk.hasChildByOrder(chunkGraph, "cssPreload", true);
-		// `.ei` always performs the import, where `.e` only reaches the javascript
-		// loader when there is javascript to load. A module federation remote is the
-		// case that matters: its chunk is emitted by the container's build, not this one.
-		if (!JavascriptModulesPlugin.chunkHasJs(chunk, chunkGraph)) {
-			this._analyzableBailout(
-				originModule,
-				"this compilation emits no javascript for the chunk, so there is nothing to import"
-			);
-			return null;
+		const chunkGroup = chunkGraph.getBlockChunkGroup(block);
+		if (!chunkGroup || chunkGroup.chunks.length === 0) {
+			const comment = this.comment({
+				message
+			});
+			return `Promise.resolve(${comment.trim()})`;
 		}
-		let hasNonJsTypes = false;
-		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-			for (const type of chunkGraph.getModuleSourceTypes(module)) {
-				if (!TYPES_WITHOUT_CHUNK_HANDLER.has(type)) {
-					// Loaded by that type's own `.f` handler, which `.ei` still dispatches.
-					hasNonJsTypes = true;
-				}
+		const chunks = chunkGroup.chunks.filter(
+			(chunk) => !chunk.hasRuntime() && chunk.id !== null
+		);
+		const comment = this.comment({
+			message,
+			chunkName: block.chunkName
+		});
+		// An output that cannot use a native `import()` gets no ESM chunk loader to ask,
+		// so the reason is recorded here, where any build generates its imports.
+		if (this.outputOptions.module && originModule !== undefined) {
+			const outputReason = this._chunkImportOutputReason();
+			if (outputReason !== null) {
+				this._analyzableBailout(originModule, outputReason, false);
 			}
 		}
-		// Relative to the consuming chunk (`import.meta.url`) for `auto`, else an
-		// absolute publicPath prefix.
-		const specifier = this._getAnalyzableChunkSpecifier(
-			undefined,
-			chunk,
-			originModule,
-			chunkGraph
-		);
-		if (specifier === null) {
-			return null;
+		const fetchPriority = chunkGroup.options.fetchPriority;
+		const priorityArg = fetchPriority
+			? `, ${JSON.stringify(fetchPriority)}`
+			: "";
+		if (chunks.length === 0) return `Promise.resolve(${comment.trim()})`;
+		runtimeRequirements.add(RuntimeGlobals.ensureChunk);
+		if (fetchPriority) {
+			runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
 		}
-		// `import()` needs a resolvable specifier — relative (`./`, `../`), absolute (`/`)
-		// or a URL scheme. A bare one is a package name, so make it explicitly relative
-		// the way the chunk loader does. (`new URL(...)` callers accept bare vs their base.)
-		const resolvableSpecifier = /^"(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(
-			specifier
-		)
-			? specifier
-			: `"./${specifier.slice(1)}`;
-		runtimeRequirements.add(RuntimeGlobals.analyzableChunkImport);
-		if (needsHintHandlers || hasNonJsTypes) {
-			// Those handlers attach to the `.f` map, which has to exist — but the runtime
-			// `ensureChunk` around it does not, since `.ei` dispatches them itself.
-			runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
+		if (chunks.length === 1) {
+			const chunkId = JSON.stringify(chunks[0].id);
+			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId}${priorityArg})`;
 		}
-		// Drop-in for `ensureChunk(id)`: the literal `import()` can be statically
-		// followed, the helper keeps webpack's install timing and deduplication.
-		return `${RuntimeGlobals.analyzableChunkImport}(${JSON.stringify(
-			chunk.id
-		)}, ${this.returningFunction(`import(${comment}${resolvableSpecifier})`)})`;
+		const items = chunks.map(
+			(chunk) =>
+				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${priorityArg})`
+		);
+		return `Promise.all(${comment.trim()}[${items.join(", ")}])`;
 	}
 
 	/**
@@ -2801,6 +2840,17 @@ class RuntimeTemplate {
 			const late = this._settlesLate(chunk);
 			if (late !== this._settlesLate(target)) return !late;
 		}
+		return this._hashRoundBefore(chunk, target);
+	}
+
+	/**
+	 * Whether the four rounds alone settle `chunk` before `target`, leaving out what the
+	 * full-hash marks move: the order a runtime module generated in its chunk's round sees.
+	 * @param {Chunk} chunk the chunk whose hash would be read
+	 * @param {Chunk} target the chunk reading it
+	 * @returns {boolean} true when the hash exists by the time the target is hashed
+	 */
+	_hashRoundBefore(chunk, target) {
 		const chunkGraph = /** @type {ChunkGraph} */ (this.compilation.chunkGraph);
 		const round = hashRound(chunk, chunkGraph);
 		const targetRound = hashRound(target, chunkGraph);
@@ -2823,6 +2873,42 @@ class RuntimeTemplate {
 		);
 	}
 
+	/**
+	 * Whether a `[chunkhash]`/`[contenthash]` name is settled before every chunk it is
+	 * written into, so a runtime module generated in its chunk's round can spell it.
+	 * @param {Chunk} chunk the chunk named
+	 * @param {string} template what names it
+	 * @param {Iterable<Chunk>} targets the chunks the name is written into
+	 * @returns {boolean} true when the hashes it reads exist by then
+	 */
+	_hashedNameSettledBefore(chunk, template, targets) {
+		const kinds = getTemplatedPathPlugin().getPresentKinds(template);
+		// The compilation hash exists in no round a chunk is hashed in.
+		if (kinds.has("fullhash") || kinds.has("hash")) return false;
+		for (const target of targets) {
+			if (!this._hashRoundBefore(chunk, target)) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Whether the hashes a name reads are on the chunk now, which they are only once its
+	 * round of `createHash` has run — never while modules are being generated.
+	 * @param {Chunk} chunk the chunk named
+	 * @param {string} template what names it
+	 * @param {string} sourceType which asset of the chunk it names
+	 * @returns {boolean} true when the name can be resolved here
+	 */
+	_hashedNamePresent(chunk, template, sourceType) {
+		const kinds = getTemplatedPathPlugin().getPresentKinds(template);
+		return (
+			!kinds.has("fullhash") &&
+			!kinds.has("hash") &&
+			(!kinds.has("chunkhash") || chunk.hash !== undefined) &&
+			(!kinds.has("contenthash") || chunk.contentHash[sourceType] !== undefined)
+		);
+	}
+
 	/**
 	 * Whether `createHash` settles this chunk's hash in the round that runs after the
 	 * compilation hash rather than in one of the four before it. Asked of the chunk
@@ -2928,6 +3014,11 @@ class RuntimeTemplate {
 		/** @type {Set<string>} */
 		const names = new Set();
 		let found = false;
+		// Its own copy, since `lastIndex` is walked below; reset by the loop that ends it.
+		const regexp = new RegExp(
+			ANALYZABLE_TOKEN_REGEXP.source,
+			ANALYZABLE_TOKEN_REGEXP.flags
+		);
 		for (const module of modules) {
 			if (!results.has(module, chunk.runtime)) continue;
 			const source = results.getSource(module, chunk.runtime, JAVASCRIPT_TYPE);
@@ -2937,10 +3028,6 @@ class RuntimeTemplate {
 				carriesFullHash = true;
 				found = true;
 			}
-			const regexp = new RegExp(
-				ANALYZABLE_TOKEN_REGEXP.source,
-				ANALYZABLE_TOKEN_REGEXP.flags
-			);
 			/** @type {RegExpExecArray | null} */
 			let match;
 			while ((match = regexp.exec(content)) !== null) {
@@ -2948,11 +3035,7 @@ class RuntimeTemplate {
 				if (parts === null) continue;
 				found = true;
 				for (const [kind, value] of parts) {
-					if (
-						kind === "publicPath" ||
-						kind === "template" ||
-						kind === "unserved"
-					) {
+					if (FULL_HASH_PART_KINDS.has(kind)) {
 						carriesFullHash = true;
 					} else if (CHUNK_SPECIFIER_PART_KINDS.has(kind)) {
 						names.add(String(value));
@@ -3087,35 +3170,6 @@ class RuntimeTemplate {
 		this._chunksByIdForFold = undefined;
 	}
 
-	/**
-	 * Whether `chunk` can reach any of `targets` by following chunk groups, which is
-	 * what turns a baked hashed name into a hash that depends on itself.
-	 * @param {Chunk} chunk the referenced chunk
-	 * @param {Iterable<Chunk>} targets the chunks the reference is written into
-	 * @returns {boolean} true when one of them is reachable from `chunk`
-	 */
-	_reachesAny(chunk, targets) {
-		const wanted = new Set(targets);
-		if (wanted.size === 0) return false;
-		if (wanted.has(chunk)) return true;
-		/** @type {Set<ChunkGroup>} */
-		const seen = new Set();
-		/** @type {ChunkGroup[]} */
-		const queue = [...chunk.groupsIterable];
-		for (const group of queue) seen.add(group);
-		for (let i = 0; i < queue.length; i++) {
-			for (const child of queue[i].childrenIterable) {
-				if (seen.has(child)) continue;
-				seen.add(child);
-				for (const candidate of child.chunks) {
-					if (wanted.has(candidate)) return true;
-				}
-				queue.push(child);
-			}
-		}
-		return false;
-	}
-
 	/**
 	 * The chunks a reference emitted into `module` is written into — the assets a
 	 * stand-in of ours would land in, and so the only ones a deferred fill could go
@@ -3213,13 +3267,13 @@ class RuntimeTemplate {
 			return template.replace(HASH_IN_FILENAME_GLOBAL, "x");
 		}
 		try {
-			return template({
-				chunk: createHashProbeChunk(chunk, HASH_PROBE, true),
-				runtime: chunk.runtime,
-				contentHashType: JAVASCRIPT_TYPE,
-				hash: HASH_PROBE,
-				contentHash: HASH_PROBE
-			}).replace(HASH_IN_FILENAME_GLOBAL, "x");
+			return probeTemplateName(
+				template,
+				chunk,
+				JAVASCRIPT_TYPE,
+				HASH_PROBE,
+				true
+			).replace(HASH_IN_FILENAME_GLOBAL, "x");
 		} catch (_error) {
 			// Nothing to report: the naming call is given strictly less than this probe, so
 			// one that throws here fails the build where the name is actually needed.
@@ -3231,7 +3285,7 @@ class RuntimeTemplate {
 	 * The `../` path from a chunk's own asset back to the output root. Hashes are
 	 * neutralized first: a runtime module is generated once to be hashed, before any
 	 * hash exists, so resolving one there throws — and `RuntimeModule.updateHash`
-	 * swallows that, pinning the module's hash to the message.
+	 * lets that throw fail the build rather than hashing it.
 	 * @param {Chunk} chunk the chunk whose asset holds the reference
 	 * @param {boolean} enforceRelative whether the answer keeps a leading `./`
 	 * @returns {string} the path back to the output root
@@ -3262,7 +3316,10 @@ class RuntimeTemplate {
 	 * @returns {Placement} where a literal in it is read from
 	 */
 	_modulePlacement(module, chunkGraph) {
-		return this._placementOf(this._moduleChunks(module, chunkGraph));
+		return this._placementOf(
+			this._moduleChunks(module, chunkGraph),
+			isHotModule(module)
+		);
 	}
 
 	/**
@@ -3281,11 +3338,12 @@ class RuntimeTemplate {
 
 	/**
 	 * The one answer every chunk in `chunks` agrees on, with either half `null` where
-	 * they do not.
+	 * they do not — under HMR the update chunk, which re-runs the module, has a say too.
 	 * @param {Iterable<Chunk>} chunks the chunks a literal is written into
+	 * @param {boolean=} hot whether a hot update can re-run what is written
 	 * @returns {Placement} where a literal in them is read from
 	 */
-	_placementOf(chunks) {
+	_placementOf(chunks, hot = false) {
 		/** @type {Placement | undefined} */
 		let first;
 		/** @type {string | null} */
@@ -3294,13 +3352,17 @@ class RuntimeTemplate {
 		let loaded = null;
 		for (const chunk of chunks) {
 			const own = this._chunkPlacement(chunk);
+			const ownUndo =
+				hot && own.undo !== null && own.undo !== this._hotUpdateUndo(chunk)
+					? null
+					: own.undo;
 			if (first === undefined) {
 				first = own;
-				undo = own.undo;
+				undo = ownUndo;
 				loaded = own.loaded;
 				continue;
 			}
-			if (undo !== own.undo) undo = null;
+			if (undo !== ownUndo) undo = null;
 			if (loaded !== own.loaded) loaded = null;
 		}
 		if (first === undefined) return NO_PLACEMENT;
@@ -3311,6 +3373,33 @@ class RuntimeTemplate {
 			: { undo, loaded };
 	}
 
+	/**
+	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
+	 * a worker or worklet entry chunk bakes to, or `null` to keep the runtime form. The
+	 * gate and the build are asked together so every call site agrees on both — the
+	 * `new Worker(...)` emit, and the resource hint `ResourceHintPlugin` spells for it.
+	 * @param {string | undefined} overridePublicPath a `publicPath` set on the worker itself
+	 * @param {Chunk} chunk the worker's entry chunk
+	 * @param {Module} module the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {string | null} a quoted literal, or `null` to fall back
+	 */
+	getAnalyzableWorkerUrl(overridePublicPath, chunk, module, chunkGraph) {
+		// Without an id nothing can name the chunk in a stand-in.
+		if (
+			chunk.id === null ||
+			!this.supportsAnalyzable("url", chunkGraph, module)
+		) {
+			return null;
+		}
+		return this._getAnalyzableChunkSpecifier(
+			overridePublicPath,
+			chunk,
+			module,
+			chunkGraph
+		);
+	}
+
 	/**
 	 * Static literal specifier (already quoted) for a `new URL(<here>, import.meta.url)`
 	 * or `import(<here>)` pointing at `chunk`'s JS file, or `null` when it can't be known
@@ -3320,12 +3409,11 @@ class RuntimeTemplate {
 	 * @param {Module | undefined} consumingModule the module the reference is emitted
 	 * into, or `undefined` when `consumingChunks` names where it goes instead
 	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {RuntimeRequirements=} runtimeRequirements set when the caller wraps the result in
-	 * `new URL(...)` and so accepts a runtime public path prefix around the literal filename
 	 * @param {Chunk[]=} consumingChunks the chunks the reference is written into, where
 	 * they are known without a module to read them from
 	 * @param {string=} sourceType which half of the chunk is named — its javascript by
 	 * default, or its stylesheet
+	 * @param {boolean=} hot whether a hot update can re-run what is written
 	 * @returns {string | null} a JS string literal or expression, or `null` to fall back to the runtime form
 	 */
 	_getAnalyzableChunkSpecifier(
@@ -3333,120 +3421,113 @@ class RuntimeTemplate {
 		chunk,
 		consumingModule,
 		chunkGraph,
-		runtimeRequirements,
 		consumingChunks,
-		sourceType = JAVASCRIPT_TYPE
+		sourceType = JAVASCRIPT_TYPE,
+		hot = isHotModule(consumingModule)
 	) {
 		const { compilation } = this;
 		const { outputOptions } = compilation;
 		const naming = CHUNK_ASSET_NAMING.get(sourceType);
 		// Nothing here names this type's asset, so nothing can spell where it will be.
 		if (naming === undefined) return null;
-		const template = this._resolveChunkFilenameTemplate(
-			naming.template(chunk, outputOptions),
-			chunk,
-			sourceType
-		);
+		const template = this._chunkAssetTemplate(chunk, sourceType);
 		if (template === null) return null;
 		// A hashed name is settled long after this code is generated, so a stand-in is
 		// 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);
-		// Baking makes the consuming chunk's content depend on this one's hash. A pair that
-		// reaches back has no fixed point if both bake, so only the lower id's name does.
-		const cycles =
+		// An id names the chunk in the stand-in; `blockPromise` drops an id-less chunk
+		// before asking, so the guard only keeps `null` out of a name.
+		if (chunk.id === null) return null;
+		// A runtime module is generated in its chunk's round of `createHash`, where a
+		// hashed name settled earlier exists: spelled, so a hot update carries the new one.
+		const settled =
 			deferred &&
-			this._reachesAny(chunk, chunks) &&
-			!this._namesBeforeAll(chunk, chunks);
-		// An id names the chunk in the stand-in. No reference reaches here without one —
-		// `blockPromise` drops an id-less chunk before asking, and one the whole build
-		// keeps has no name to be emitted under — so the guard carries no reason of its
-		// own; it only keeps `null` out of a name.
-		const canReserve =
-			chunk.id !== null && !cycles && this._canDeferAnalyzableName(chunks);
-		// A content-named consumer bakes anyway when this chunk settles first: the fold
-		// puts the name into its hash. Only what `_foldsWholeName` covers, though.
+			template !== undefined &&
+			this._hashedNamePresent(chunk, template, sourceType) &&
+			this._namesBeforeAll(chunk, chunks);
+		const canReserve = this._canDeferAnalyzableName(chunks);
+		// A content-named consumer folds this name into its hash when it settles first;
+		// what the fold cannot cover is repaired instead.
 		const canFold = !canReserve && this._namesBeforeAll(chunk, chunks);
-		/**
-		 * @returns {null} always, having recorded why no stand-in may be reserved
-		 */
-		const cannotReserve = () => {
-			this._analyzableBailout(
-				consumingModule,
-				cycles
-					? "this chunk and the one it references name each other, so neither hash could settle"
-					: DEFER_BAILOUT
-			);
-			return null;
-		};
-		if (deferred && !canReserve && !canFold) return cannotReserve();
-		const filename = deferred
-			? ""
-			: compilation.getPath(/** @type {string} */ (template), {
-					chunk,
-					// Matches what names the asset, or a placeholder resolved here would
-					// not be the one on disk.
-					runtime: chunk.runtime,
-					contentHashType: sourceType
-				});
+		const filename =
+			deferred && !settled
+				? ""
+				: compilation.getPath(/** @type {string} */ (template), {
+						chunk,
+						// Matches what names the asset, or a placeholder resolved here would
+						// not be the one on disk.
+						runtime: chunk.runtime,
+						contentHashType: sourceType
+					});
 		/**
 		 * @param {SpecifierPart[]} prefix what goes in front of the chunk's filename
-		 * @returns {string | null} the specifier already quoted, or `null` when the
-		 * recipe needs a stand-in that cannot be reserved
+		 * @returns {string} the specifier already quoted
 		 */
 		const specifier = (prefix) => {
-			if (!deferred) {
+			if (!deferred || settled) {
 				const text = literalText(prefix);
 				if (text !== null) return toJsStringLiteral(text + filename);
 			}
-			if (!canReserve && !(canFold && this._foldsWholeName(prefix, chunks))) {
-				return cannotReserve();
-			}
+			const repair =
+				!canReserve && !(canFold && this._foldsWholeName(prefix, chunks));
 			return toJsStringLiteral(
-				this._reserveAnalyzableSpecifier([
-					...prefix,
-					[naming.standIn, /** @type {ChunkId} */ (chunk.id)]
-				])
+				this._reserveAnalyzableSpecifier(
+					this._markedForRepair(repair, [
+						...prefix,
+						// A settled name is carried as text: the fill would spell the same,
+						// but only text of its own moves the runtime module's hash.
+						settled
+							? ["literal", filename]
+							: [naming.standIn, /** @type {ChunkId} */ (chunk.id)]
+					])
+				)
 			);
 		};
 		if (overridePublicPath) {
-			const resolved = this._resolvePublicPathPrefix(
-				overridePublicPath,
-				consumingModule,
-				chunks
-			);
+			const resolved = this._resolvePublicPathPrefix(overridePublicPath);
 			return resolved === null ? null : specifier(resolved);
 		}
 		const { publicPath } = outputOptions;
 		if (publicPath === "auto") {
-			const { undo } = this._placementOf(chunks);
+			const { undo } = this._placementOf(chunks, hot);
 			if (undo !== null) return specifier([["literal", undo]]);
 			// Different depths — no one `../` path is right for every asset the reference
 			// lands in, so the deferred pass builds each asset's own.
-			const perAsset = specifier([["undo", ""]]);
-			if (perAsset !== null) return perAsset;
-			// Only a stand-in that could not be reserved reaches here, and `specifier`
-			// has already recorded why.
-			if (deferred || !runtimeRequirements) return null;
-			// No bundler follows a concatenation, but a `new URL(...)` caller still sheds
-			// the `.u(id)` lookup this way; `import()` needs a static specifier.
-			runtimeRequirements.add(RuntimeGlobals.publicPath);
-			return `${RuntimeGlobals.publicPath} + ${toJsStringLiteral(filename)}`;
+			return specifier([["undo", ""]]);
 		}
 		const prefix = this._analyzablePathPrefix(
 			consumingModule,
 			chunkGraph,
-			chunks
+			chunks,
+			undefined,
+			hot
 		);
 		return prefix === null ? null : specifier(prefix);
 	}
 
+	/**
+	 * The template this chunk's asset of `sourceType` is named by: `undefined` where a
+	 * function reads a hash, `null` where nothing here names that type or it answers nothing.
+	 * @param {Chunk} chunk the chunk
+	 * @param {string} sourceType which asset of the chunk
+	 * @returns {string | undefined | null} the template
+	 */
+	_chunkAssetTemplate(chunk, sourceType) {
+		const naming = CHUNK_ASSET_NAMING.get(sourceType);
+		if (naming === undefined) return null;
+		return this._resolveChunkFilenameTemplate(
+			naming.template(chunk, this.outputOptions),
+			chunk,
+			sourceType
+		);
+	}
+
 	/**
 	 * The parts that go in front of a name so a literal read from the chunk holding it
 	 * reaches what the runtime would. A public path needing no base is the whole answer.
@@ -3460,18 +3541,24 @@ class RuntimeTemplate {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {Iterable<Chunk>} chunks the chunks a stand-in would be written into
 	 * @param {string=} relativeBase an entry `baseUri` read against the output root
+	 * @param {boolean=} hot whether a hot update can re-run what is written
 	 * @returns {SpecifierPart[] | null} the parts, or `null` having recorded why not
 	 */
-	_analyzablePathPrefix(module, chunkGraph, chunks, relativeBase) {
+	_analyzablePathPrefix(
+		module,
+		chunkGraph,
+		chunks,
+		relativeBase,
+		hot = isHotModule(module)
+	) {
 		const publicPath = /** @type {PublicPath} */ (
 			this.outputOptions.publicPath
 		);
 		const shape = this._publicPathShape();
 		if (shape === undefined) return null;
-		const resolve = () =>
-			this._resolvePublicPathPrefix(publicPath, module, chunks);
+		const resolve = () => this._resolvePublicPathPrefix(publicPath);
 		if (isBaseIndependent(shape)) return resolve();
-		const { undo, loaded } = this._placementOf(chunks);
+		const { undo, loaded } = this._placementOf(chunks, hot);
 		// What a chunk the loader fetched climbs back out of. One of no depth leaves
 		// nothing to climb, and then both answers put the same text in front.
 		const served = this._publicPathClimb();
@@ -3483,24 +3570,17 @@ class RuntimeTemplate {
 			// Each knows its own answer, so the fill asks per asset — where each has one,
 			// and where nothing else goes between the two shapes.
 			if (relativeBase !== undefined || !this._eachChunkServedOneWay(chunks)) {
-				this._analyzableBailout(module, SERVED_BAILOUT);
-				return null;
+				return this._analyzableBailout(module, SERVED_BAILOUT, null);
 			}
 			return [...head, ["unserved", ""]];
 		}
 		if (climb !== "" && relativeBase === undefined) return head;
 		const resolved = resolve();
 		if (resolved === null) return null;
-		return [
-			...head,
-			.../** @type {SpecifierPart[]} */ (
-				climb === "" ? [] : [["literal", climb]]
-			),
-			.../** @type {SpecifierPart[]} */ (
-				relativeBase === undefined ? [] : [["literal", relativeBase]]
-			),
-			...rootedParts(resolved)
-		];
+		if (climb !== "") head.push(["literal", climb]);
+		if (relativeBase !== undefined) head.push(["literal", relativeBase]);
+		head.push(...rootedParts(resolved));
+		return head;
 	}
 
 	/**
@@ -3512,12 +3592,9 @@ class RuntimeTemplate {
 	 * the deferred pass whole instead. A function is called for its value rather than
 	 * read as a template, so one whose answer moves with the hash is called again there.
 	 * @param {PublicPath} publicPath the configured public path
-	 * @param {Module=} module the module the reference is emitted into, to record why
-	 * a name no stand-in may be reserved for kept the runtime form
-	 * @param {Iterable<Chunk>=} chunks the chunks a stand-in would be written into
 	 * @returns {SpecifierPart[] | null} the parts, or `null` when it cannot be known
 	 */
-	_resolvePublicPathPrefix(publicPath, module, chunks) {
+	_resolvePublicPathPrefix(publicPath) {
 		if (typeof publicPath === "function") {
 			// One that answers nothing to a probe cannot be placed, absolute or not.
 			if (this._publicPathShape() === undefined) return null;
@@ -3528,28 +3605,18 @@ class RuntimeTemplate {
 			if (resolved !== null) return [["literal", resolved]];
 			// Called again by the fill against the compilation hash, so what it answers
 			// there is that hash by another name.
-			return this._canDeferOrBakeFullHash(true, chunks, module)
-				? [["publicPath", ""]]
-				: null;
+			return [["publicPath", ""]];
 		}
 		if (!publicPath.includes("[")) return [["literal", publicPath]];
 		// A re-encoded digest cannot be spelled by a stand-in, so it stays a template.
 		if (getTemplatedPathPlugin().usesFullHashDigest(publicPath)) {
-			return this._canDeferOrBakeFullHash(true, chunks, module)
-				? [["template", publicPath]]
-				: null;
+			return [["template", publicPath]];
 		}
 		const literal = this.compilation.getPath(
 			publicPath,
 			this._deferredFullHashPathData()
 		);
-		return this._canDeferOrBakeFullHash(
-			this._hasReservedFullHash(literal),
-			chunks,
-			module
-		)
-			? [["literal", literal]]
-			: null;
+		return [["literal", literal]];
 	}
 
 	/**
@@ -3626,11 +3693,6 @@ class RuntimeTemplate {
 	) {
 		const { publicPath } = this.outputOptions;
 		const chunks = this._moduleChunks(module, chunkGraph);
-		/**
-		 * @param {SpecifierPart[]} parts the whole specifier
-		 * @returns {string | null} it already quoted, or `null` when no stand-in may be reserved
-		 */
-		const specifier = (parts) => this._specifierOf(parts, chunks, module);
 		if (bakePublicPath && publicPath !== "auto") {
 			const prefix = this._analyzablePathPrefix(
 				module,
@@ -3638,30 +3700,28 @@ class RuntimeTemplate {
 				chunks,
 				relativeBase
 			);
-			return prefix === null ? null : specifier([...prefix, ...file]);
+			if (prefix === null) return null;
+			return this._specifierOf([...prefix, ...file], chunks);
 		}
 		// No public path to place it against, so the `../` path back to the output root
 		// is the whole prefix. Different depths — no one is right for every asset the
 		// reference is emitted into, so the deferred pass builds each asset's own.
 		const { undo } = this._modulePlacement(module, chunkGraph);
-		return specifier([
-			undo === null ? ["undo", ""] : ["literal", undo],
-			...(relativeBase === undefined
-				? []
-				: /** @type {SpecifierPart[]} */ ([["literal", relativeBase]])),
-			...file
-		]);
+		/** @type {SpecifierPart[]} */
+		const parts = [undo === null ? ["undo", ""] : ["literal", undo]];
+		if (relativeBase !== undefined) parts.push(["literal", relativeBase]);
+		parts.push(...file);
+		return this._specifierOf(parts, chunks);
 	}
 
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
-	 * keyed by chunk id, or `null` when any of them has to keep the runtime
+	 * keyed by chunk id, or `null` when they have to keep the runtime
 	 * `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
 	 * and the plugin declaring what it needs ask this, so the two always agree. The
 	 * runtime hands an absolute url string to `link.href`, and so does this — the browser
 	 * resolves the element against the document, which is not where the chunk sits, and
-	 * the loader reads the url as text either way. Nothing is written out for a runtime
-	 * that also carries the hot handler; see below.
+	 * the loader reads the url as text either way.
 	 * @param {Chunk} runtimeChunk the chunk holding the stylesheet loader
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements what that chunk needs
@@ -3698,7 +3758,7 @@ class RuntimeTemplate {
 	/**
 	 * Static `new URL(<file>, import.meta.url).href` for every javascript chunk a
 	 * runtime can hint at with `<link rel="prefetch"/"modulepreload">`, keyed by chunk
-	 * id, or `null` when any of them has to keep the runtime
+	 * id, or `null` when they have to keep the runtime
 	 * `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
 	 * them and the plugin declaring what it needs ask this, so the two always agree.
 	 * @param {Chunk} runtimeChunk the chunk holding the hint handlers
@@ -3722,11 +3782,9 @@ class RuntimeTemplate {
 		);
 		/** @type {Set<ChunkId>} */
 		const hinted = new Set();
-		for (const order of Object.keys(orders)) {
-			for (const from of Object.keys(orders[order])) {
-				for (const id of orders[order][/** @type {ChunkId} */ (from)]) {
-					hinted.add(id);
-				}
+		for (const byParent of Object.values(orders)) {
+			for (const ids of Object.values(byParent)) {
+				for (const id of ids) hinted.add(id);
 			}
 		}
 		/** @type {Chunk[]} */
@@ -3744,6 +3802,146 @@ class RuntimeTemplate {
 		);
 	}
 
+	/**
+	 * Why no chunk import of this build can be a native `import()`, read from the
+	 * output configuration alone, or `null` when nothing in it rules one out.
+	 * @returns {string | null} the reason
+	 */
+	_chunkImportOutputReason() {
+		const { chunkFormat, importFunctionName } = this.outputOptions;
+		if (chunkFormat !== "module") {
+			return `output.chunkFormat is ${JSON.stringify(chunkFormat)}, so chunks are not read through a native import()`;
+		}
+		if (importFunctionName !== "import") {
+			return `output.importFunctionName is ${JSON.stringify(importFunctionName)}, so the call site is not a native import()`;
+		}
+		return null;
+	}
+
+	/**
+	 * Records that this runtime reads its chunks some way other than a native
+	 * `import()`, so no literal can name what it loads. Recorded on the entries that
+	 * chose it, which is where the setting behind it lives.
+	 * @param {Chunk} chunk the runtime chunk
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {void}
+	 */
+	reportChunkImportBailout(chunk, chunkGraph) {
+		if (!this.outputOptions.module) return;
+		const entryOptions = chunk.getEntryOptions();
+		const chunkLoading =
+			entryOptions && entryOptions.chunkLoading !== undefined
+				? entryOptions.chunkLoading
+				: this.outputOptions.chunkLoading;
+		if (chunkLoading === "import") return;
+		const subject = entryOptions && entryOptions.worker ? "worker" : "runtime";
+		const reason = `this ${subject} loads its chunks with ${JSON.stringify(chunkLoading)}, not "import"`;
+		for (const module of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+			this._analyzableBailout(module, reason, false);
+		}
+	}
+
+	/**
+	 * The chunks this loader can be handed an id for: the ones held by a group outside
+	 * the initial wave, which is what an `import()` or a context map turns into an id.
+	 * @param {Chunk} runtimeChunk the chunk holding the chunk loader
+	 * @returns {Set<Chunk>} the chunks reachable from here through a non-initial group
+	 */
+	_loadableChunks(runtimeChunk) {
+		const queue = new Set(runtimeChunk.groupsIterable);
+		/** @type {Set<Chunk>} */
+		const chunks = new Set();
+		for (const group of queue) {
+			if (!group.isInitial()) {
+				for (const chunk of group.chunks) chunks.add(chunk);
+			}
+			for (const child of group.childrenIterable) queue.add(child);
+		}
+		return chunks;
+	}
+
+	/**
+	 * Whether the loader still needs to build a url from a chunk id, which is the case
+	 * for a chunk it can be asked for that `analyzableChunkImports` leaves unnamed: one
+	 * carrying a runtime of its own, or one a second entrypoint has at startup.
+	 * @param {Chunk} runtimeChunk the chunk holding the chunk loader
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {boolean} true when an id the map does not hold can reach the loader
+	 */
+	chunkImportsNeedRuntimeUrl(runtimeChunk, chunkGraph) {
+		const installed = new Set(runtimeChunk.getAllInitialChunks());
+		for (const chunk of this._loadableChunks(runtimeChunk)) {
+			if (chunk === runtimeChunk) continue;
+			if (!chunk.hasRuntime() && !installed.has(chunk)) continue;
+			if (JavascriptModulesPlugin.chunkHasJs(chunk, chunkGraph)) return true;
+		}
+		return false;
+	}
+
+	/**
+	 * A literal `import()` specifier for every javascript chunk a runtime loads on
+	 * demand, keyed by chunk id, or `null` when one of them cannot be named here. The
+	 * map is written into the runtime chunk rather than at each import site, so a
+	 * hashed chunk name reaches no module that imports it.
+	 * @param {Chunk} runtimeChunk the chunk holding the chunk loader
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements what that chunk needs
+	 * @param {Module=} consumingModule the runtime module, where one exists to report against
+	 * @returns {Map<ChunkId, string> | null} the specifiers, or `null` to keep the runtime form
+	 */
+	analyzableChunkImports(
+		runtimeChunk,
+		chunkGraph,
+		runtimeRequirements,
+		consumingModule
+	) {
+		// The runtime names the scope `__webpack_public_path__` belongs to, so the
+		// answer holds whether or not a runtime module is there to ask about.
+		if (
+			!this.supportsAnalyzable(
+				"import",
+				chunkGraph,
+				consumingModule,
+				runtimeChunk.runtime
+			)
+		) {
+			return null;
+		}
+		// An initial chunk and one carrying a runtime are both reached by a static
+		// import, so naming either here would only make two hashes chase each other.
+		const installed = new Set(runtimeChunk.getAllInitialChunks());
+		/** @type {Chunk[]} */
+		const chunks = [];
+		for (const chunk of runtimeChunk.getAllReferencedChunks()) {
+			if (
+				chunk === runtimeChunk ||
+				chunk.hasRuntime() ||
+				installed.has(chunk) ||
+				!JavascriptModulesPlugin.chunkHasJs(chunk, chunkGraph)
+			) {
+				continue;
+			}
+			chunks.push(chunk);
+		}
+		const specifiers = this._analyzableChunkSpecifiers(
+			chunks,
+			chunkGraph,
+			consumingModule,
+			[runtimeChunk],
+			JAVASCRIPT_TYPE,
+			runtimeRequirements
+		);
+		if (specifiers === null) return null;
+		for (const [id, specifier] of specifiers) {
+			// A bare specifier is a package name, so spell it relative the way the
+			// runtime form's `.p + <file>` would have resolved it.
+			if (!RESOLVABLE_SPECIFIER_REGEXP.test(specifier.slice(1))) {
+				specifiers.set(id, `"./${specifier.slice(1)}`);
+			}
+		}
+		return specifiers;
+	}
+
 	/**
 	 * The urls of one asset of each of `chunks`, written out so they can be read by
 	 * chunk id, or `null` as soon as one of them cannot be named here.
@@ -3763,16 +3961,51 @@ class RuntimeTemplate {
 		sourceType,
 		runtimeRequirements
 	) {
-		// A map written now cannot answer for whatever id an update names, so it yields
-		// to HMR — analyzable output is what ships.
-		if (
-			runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers) ||
-			!this.supportsAnalyzable("url-runtime", chunkGraph, consumingModule)
-		) {
+		if (!this.supportsAnalyzable("url-runtime", chunkGraph, consumingModule)) {
 			return null;
 		}
+		const urls = this._analyzableChunkSpecifiers(
+			chunks,
+			chunkGraph,
+			consumingModule,
+			consumingChunks,
+			sourceType,
+			runtimeRequirements
+		);
+		if (urls === null) return null;
+		for (const [id, specifier] of urls) {
+			urls.set(id, `${this.importMetaUrl(specifier)}.href`);
+		}
+		return urls;
+	}
+
+	/**
+	 * The quoted specifier naming one asset of each of `chunks`, keyed by chunk id, or
+	 * `null` as soon as one of them cannot be named here. What the name is read against
+	 * is the caller's: a url resolves it, an `import()` hands it to the loader.
+	 * @param {Iterable<Chunk>} chunks the chunks whose asset is wanted
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {Module | undefined} consumingModule the runtime module, where one exists to report against
+	 * @param {Chunk[]} consumingChunks the chunks the specifiers are written into
+	 * @param {string} sourceType which asset of each chunk to name
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements what the runtime chunk needs
+	 * @returns {Map<ChunkId, string> | null} the specifiers, or `null` to keep the runtime form
+	 */
+	_analyzableChunkSpecifiers(
+		chunks,
+		chunkGraph,
+		consumingModule,
+		consumingChunks,
+		sourceType,
+		runtimeRequirements
+	) {
+		// A hot update re-ships the runtime module only when its own code changes, so
+		// each name has to be text nothing but an id joining or leaving the map can move.
+		const hot = runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
 		/** @type {Map<ChunkId, string>} */
-		const urls = new Map();
+		const specifiers = new Map();
 		for (const chunk of chunks) {
 			if (chunk.id === null) continue;
 			const specifier = this._getAnalyzableChunkSpecifier(
@@ -3780,14 +4013,74 @@ class RuntimeTemplate {
 				chunk,
 				consumingModule,
 				chunkGraph,
-				undefined,
 				consumingChunks,
-				sourceType
+				sourceType,
+				hot
 			);
 			if (specifier === null) return null;
-			urls.set(chunk.id, `${this.importMetaUrl(specifier)}.href`);
+			if (
+				hot &&
+				!this._settledUnderHot(specifier, chunk, sourceType, consumingChunks)
+			) {
+				return this._analyzableBailout(consumingModule, HOT_NAME_BAILOUT, null);
+			}
+			specifiers.set(chunk.id, specifier);
+		}
+		return specifiers.size > 0 ? specifiers : null;
+	}
+
+	/**
+	 * Whether a url a hot update re-ships moves only with the runtime module's own text:
+	 * spelled here, or a stand-in of each asset's depth and a hash-free or settled name.
+	 * @param {string} specifier the specifier already quoted
+	 * @param {Chunk} chunk the chunk it names
+	 * @param {string} sourceType which asset of the chunk it names
+	 * @param {Chunk[]} consumingChunks the chunks the map is written into
+	 * @returns {boolean} true when no update moves what the fill spells
+	 */
+	_settledUnderHot(specifier, chunk, sourceType, consumingChunks) {
+		const match = ANALYZABLE_TOKEN_PAYLOAD.exec(specifier);
+		if (match === null) return true;
+		const parts = RuntimeTemplate._readAnalyzableSpecifier(match[1]);
+		if (parts === null) return false;
+		for (const [kind, value] of parts) {
+			if (kind === "undo") continue;
+			if (kind === "literal" && !this._hasReservedFullHash(String(value))) {
+				continue;
+			}
+			if (!CHUNK_SPECIFIER_PART_KINDS.has(kind)) return false;
+		}
+		const template = this._chunkAssetTemplate(chunk, sourceType);
+		return (
+			typeof template === "string" &&
+			(!HASH_IN_FILENAME.test(template) ||
+				this._hashedNameSettledBefore(chunk, template, consumingChunks))
+		);
+	}
+
+	/**
+	 * The `../` path from a chunk's hot update file, which re-runs its modules, back to
+	 * the output root. Hashes are neutralized; the chunk's own id may add a directory.
+	 * @param {Chunk} chunk the chunk being updated
+	 * @returns {string} the path back to the output root
+	 */
+	_hotUpdateUndo(chunk) {
+		const cached = this._hotUpdateUndoByChunk.get(chunk);
+		if (cached !== undefined) return cached;
+		const { outputOptions } = this;
+		if (this._hotUpdateShapeText === undefined) {
+			this._hotUpdateShapeText = outputOptions.hotUpdateChunkFilename.replace(
+				HASH_IN_FILENAME_GLOBAL,
+				"x"
+			);
 		}
-		return urls.size > 0 ? urls : null;
+		const undo = getUndoPath(
+			this.compilation.getPath(this._hotUpdateShapeText, { chunk }),
+			/** @type {string} */ (outputOptions.path),
+			true
+		);
+		this._hotUpdateUndoByChunk.set(chunk, undo);
+		return undo;
 	}
 
 	/**
@@ -3852,20 +4145,20 @@ class RuntimeTemplate {
 		try {
 			// Everything the naming call is given except the hashes, so only a hash can
 			// make the two answers differ.
-			const template = filenameTemplate({
-				chunk: createHashProbeChunk(chunk, HASH_PROBE, true),
-				runtime: chunk.runtime,
+			const template = probeTemplateName(
+				filenameTemplate,
+				chunk,
 				contentHashType,
-				hash: HASH_PROBE,
-				contentHash: HASH_PROBE
-			});
-			const probe = filenameTemplate({
-				chunk: createHashProbeChunk(chunk, HASH_PROBE_ALTERNATE, false),
-				runtime: chunk.runtime,
+				HASH_PROBE,
+				true
+			);
+			const probe = probeTemplateName(
+				filenameTemplate,
+				chunk,
 				contentHashType,
-				hash: HASH_PROBE_ALTERNATE,
-				contentHash: HASH_PROBE_ALTERNATE
-			});
+				HASH_PROBE_ALTERNATE,
+				false
+			);
 			return template === probe ? template : undefined;
 		} catch (_error) {
 			// Nothing to report: the probe is given strictly more than the naming call,
@@ -3882,21 +4175,16 @@ class RuntimeTemplate {
 	 * @returns {boolean} true when every runtime reaching it fetches
 	 */
 	_wasmModuleFetches(module, chunkGraph) {
-		/** @type {string[]} */
-		const keys = [];
+		const { onlyFetching } = this._wasmGroups();
+		let placed = false;
 		for (const moduleRuntime of chunkGraph.getModuleRuntimes(module)) {
-			forEachRuntime(moduleRuntime, (key) => {
-				keys.push(/** @type {string} */ (key));
-			});
+			for (const group of this._wasmGroupsOf(moduleRuntime)) {
+				placed = true;
+				if (!onlyFetching.get(group)) return false;
+			}
 		}
 		// In no runtime at all nothing named a loader, so `output` answers.
-		if (keys.length === 0) return this.outputOptions.wasmLoading === "fetch";
-		const only = this._wasmGroupOnlyFetches();
-		const groups = this._wasmRuntimeGroups();
-		for (const key of keys) {
-			if (!only.get(this._wasmGroupOf(groups, key))) return false;
-		}
-		return true;
+		return placed || this.outputOptions.wasmLoading === "fetch";
 	}
 
 	/**
@@ -3998,7 +4286,7 @@ class RuntimeTemplate {
 	 * @returns {string} the stand-in to emit
 	 */
 	_reserveAnalyzableSpecifier(parts) {
-		return `./@@webpackAnalyzableChunk:${Buffer.from(JSON.stringify(parts))
+		return `${ANALYZABLE_TOKEN_PREFIX}${Buffer.from(JSON.stringify(parts))
 			.toString("base64")
 			.replace(/\+/g, "-")
 			.replace(/\//g, "_")
@@ -4059,20 +4347,34 @@ 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 () => {
 					const { outputOptions } = compilation;
 					const fullHash = compilation.hash;
+					// The assets a stand-in landed in whose hashed name has to be brought
+					// back in line, which `RealContentHashPlugin` then does.
+					/** @type {Set<string>} */
+					const repairedAssets = new Set();
 					/** @type {Map<string, Chunk> | undefined} */
 					let chunksById;
 					/** @type {Map<string, Chunk> | undefined} */
 					let chunkByAsset;
+					/** @type {string | undefined} */
+					let publicPathText;
+					// One value for the whole pass, however many stand-ins read it.
+					const resolvedPublicPath = () => {
+						if (publicPathText === undefined) {
+							publicPathText = compilation.getPath(
+								outputOptions.publicPath || "",
+								{}
+							);
+						}
+						return publicPathText;
+					};
 					/**
 					 * @param {string} name an emitted asset's name
 					 * @returns {Chunk | undefined} the chunk it was emitted for
@@ -4111,7 +4413,9 @@ class RuntimeTemplate {
 						let base;
 						let specifier = "";
 						for (const [kind, value] of parts) {
-							if (kind === "base") {
+							if (kind === "repair") {
+								repairedAssets.add(assetName);
+							} else if (kind === "base") {
 								base = /** @type {string} */ (value);
 							} else if (kind === "literal") {
 								specifier += value;
@@ -4127,10 +4431,7 @@ class RuntimeTemplate {
 									{}
 								);
 							} else if (kind === "publicPath") {
-								specifier += compilation.getPath(
-									outputOptions.publicPath || "",
-									{}
-								);
+								specifier += resolvedPublicPath();
 							} else if (kind === "unserved") {
 								const holder = chunkOf(assetName);
 								if (holder === undefined) return null;
@@ -4141,10 +4442,7 @@ class RuntimeTemplate {
 									compilation.runtimeTemplate._chunkPlacement(holder).loaded ===
 									false
 								) {
-									const path = compilation.getPath(
-										outputOptions.publicPath || "",
-										{}
-									);
+									const path = resolvedPublicPath();
 									// The `../` already reached the root this is read from.
 									specifier += path.startsWith("./") ? path.slice(2) : path;
 								}
@@ -4188,7 +4486,7 @@ class RuntimeTemplate {
 						// the chunk loader does. A literal part may still carry a stand-in of its own,
 						// so finish those here rather than scanning again.
 						return fillFullHash(
-							/^(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(specifier)
+							RESOLVABLE_SPECIFIER_REGEXP.test(specifier)
 								? specifier
 								: `./${specifier}`
 						);
@@ -4241,6 +4539,8 @@ class RuntimeTemplate {
 
 						tasks.push({ name, source, replacements });
 					}
+					compilation.runtimeTemplate._analyzableRepairedAssets =
+						repairedAssets;
 					if (tasks.length === 0) return;
 
 					await Promise.all(