@depup/webpack 5.110.3-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 {
@@ -92,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
@@ -104,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
@@ -156,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`.
@@ -179,13 +179,6 @@ const DEFER_BAILOUT =
  * @property {boolean | null} loaded whether the chunk loader fetched the chunk
  */
 
-/**
- * @typedef {object} AnalyzableChunkUrls
- * @property {Map<ChunkId, string>} urls the urls that could be written, by chunk id
- * @property {boolean} complete false when some chunk kept the runtime form, whose
- * ids the consumer then still resolves through the runtime name lookup
- */
-
 /**
  * @typedef {object} WasmGroups
  * @property {(key: string) => string} groupOf the group a runtime key answers with
@@ -217,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 {
@@ -238,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 */
 
@@ -251,7 +250,8 @@ 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.
@@ -262,7 +262,10 @@ const CHUNK_SPECIFIER_PART_KINDS = new Set(["chunk", "cssChunk"]);
 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.
@@ -305,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" */
@@ -428,6 +430,43 @@ 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.
@@ -447,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>} */
@@ -467,10 +506,18 @@ 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 {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;
 	}
@@ -569,6 +616,10 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.generator;
 	}
 
+	supportsTopLevelAwait() {
+		return this.outputOptions.environment.topLevelAwait;
+	}
+
 	supportsOptionalChaining() {
 		return this.outputOptions.environment.optionalChaining;
 	}
@@ -617,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:
@@ -659,14 +745,14 @@ 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
 			)
 		) {
 			return this._analyzableBailout(
@@ -678,57 +764,31 @@ class RuntimeTemplate {
 
 		if (form === "import") {
 			// Read through a native `import()`, or it is not this feature at all.
-			if (outputOptions.chunkFormat !== "module") {
-				return this._analyzableBailout(
-					module,
-					`output.chunkFormat is ${JSON.stringify(outputOptions.chunkFormat)}, so chunks are not read through a native import()`,
-					false
-				);
-			}
-			if (outputOptions.importFunctionName !== "import") {
-				return this._analyzableBailout(
-					module,
-					`output.importFunctionName is ${JSON.stringify(outputOptions.importFunctionName)}, so the call site is not a native import()`,
-					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") {
-					return this._analyzableBailout(
-						module,
-						`this worker loads its chunks with ${JSON.stringify(entryOptions.chunkLoading)}, not "import"`,
-						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 the gate
-		// below does not rule it out, and the asset's javascript wrapper stays dropped.
+		// `url-inline` asks only whether the file can be named at the call site, and
+		// its `.p + <file>` fallback spells that without `import.meta`, so the gate
+		// below does not rule it out.
+
 		// `environment.module` is deliberately not consulted: ESM output writes
-		// `import.meta` regardless (the public path, the chunk loader), so the url forms
-		// only match what the rest of the bundle already assumes the target reads.
+		// `import.meta` regardless, so the url forms match what the rest of the
+		// bundle already assumes the target reads.
 		if (form === "url-inline") return true;
 		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
 		// syntax error. Runtime modules are emitted beside them, never wrapped.
-		const { devtool } = this.compilation.options;
-		if (
-			form !== "url-runtime" &&
-			typeof devtool === "string" &&
-			devtool.includes("eval")
-		) {
+		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
 			);
 		}
@@ -746,14 +806,14 @@ class RuntimeTemplate {
 
 		// 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 (
@@ -767,17 +827,6 @@ class RuntimeTemplate {
 				);
 			}
 		}
-		// 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;
 	}
 
@@ -796,38 +845,97 @@ class RuntimeTemplate {
 	 */
 	_analyzableBailout(module, reason, answer) {
 		if (module !== undefined && this.outputOptions.module) {
-			const text = `Analyzable ESM bailout: ${reason}`;
+			// 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(module);
+				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;
 	}
 
 	/**
-	 * 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
+	 * 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}
 	 */
-	_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
-				);
+	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 reason of reasons) {
+			const text = `${ANALYZABLE_BAILOUT_PREFIX}${reason}`;
+			if (!bailouts.includes(text)) bailouts.push(text);
+		}
+	}
+
+	/**
+	 * 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
+	 */
+	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;
@@ -838,15 +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;
-		return this._analyzableBailout(module, DEFER_BAILOUT, false);
+	_needsRepair(chunks) {
+		return !this._canDeferAnalyzableName(chunks);
 	}
 
 	/**
@@ -854,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;
 	}
 
 	/**
@@ -1023,17 +1122,15 @@ class RuntimeTemplate {
 			);
 		}
 		const chunks = this._moduleChunks(module, chunkGraph);
-		const parts = this._resolvePublicPathPrefix(publicPath, module, chunks);
+		const parts = this._resolvePublicPathPrefix(publicPath);
 		if (parts === null) return null;
-		// A protocol-relative base names a host but no scheme, and the runtime reads it
-		// against the chunk's own url to get one — the very url this literal is
-		// resolved against — so it may stay protocol-relative instead of being settled
-		// here. Nothing walks back to the output root first: the base replaces it.
+		// A protocol-relative base names a host but no scheme, and the runtime reads
+		// it against the very url this literal resolves against, so it may stay that
+		// way. Nothing walks back to the output root: the base replaces it.
 		if (base.startsWith("//")) {
 			return this._specifierOf(
 				[["literal", base], ...rootedParts(parts), ["literal", filename]],
-				chunks,
-				module
+				chunks
 			);
 		}
 		if (!isAbsoluteBaseUri(base)) {
@@ -1065,13 +1162,14 @@ class RuntimeTemplate {
 			);
 		}
 		if (text !== null) return toJsStringLiteral(resolved.href);
-		if (!this._canDeferOrBail(chunks, module)) return null;
 		return toJsStringLiteral(
-			this._reserveAnalyzableSpecifier([
-				["base", base],
-				...parts,
-				["literal", filename]
-			])
+			this._reserveAnalyzableSpecifier(
+				this._markedForRepair(this._needsRepair(chunks), [
+					["base", base],
+					...parts,
+					["literal", filename]
+				])
+			)
 		);
 	}
 
@@ -1093,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.
@@ -1384,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;
@@ -1868,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)`;
@@ -1984,6 +2087,21 @@ 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),
@@ -2027,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};`
@@ -2047,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 */
@@ -2101,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;
 			}
 		}
@@ -2209,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(
@@ -2351,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) {
@@ -2394,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(
@@ -2407,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);
@@ -2461,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"
@@ -2490,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;
 	}
 
@@ -2570,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({
@@ -2600,156 +2779,32 @@ class RuntimeTemplate {
 			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()})`;
-	}
-
-	/**
-	 * Whether any module of `chunk` carries a source type with a chunk handler of its
-	 * own, which `.ei` dispatches alongside the javascript one.
-	 * @param {Chunk} chunk the chunk being imported
-	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {boolean} true when a handler beyond the javascript one is reached
-	 */
-	_chunkLoadsBeyondJs(chunk, chunkGraph) {
-		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-			for (const type of chunkGraph.getModuleSourceTypes(module)) {
-				if (!TYPES_WITHOUT_CHUNK_HANDLER.has(type)) return true;
+		// 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);
 			}
 		}
-		return false;
-	}
-
-	/**
-	 * 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;
+		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);
 		}
-		// `.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)) {
-			return this._analyzableBailout(
-				originModule,
-				"this compilation emits no javascript for the chunk, so there is nothing to import",
-				null
-			);
+		if (chunks.length === 1) {
+			const chunkId = JSON.stringify(chunks[0].id);
+			return `${RuntimeGlobals.ensureChunk}(${comment}${chunkId}${priorityArg})`;
 		}
-		// Relative to the consuming chunk (`import.meta.url`) for `auto`, else an
-		// absolute publicPath prefix.
-		const specifier = this._getAnalyzableChunkSpecifier(
-			undefined,
-			chunk,
-			originModule,
-			chunkGraph
+		const items = chunks.map(
+			(chunk) =>
+				`${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${priorityArg})`
 		);
-		if (specifier === null) {
-			return null;
-		}
-		// `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);
-		// Prefetch/preload children and every non-javascript source type are loaded by a
-		// `.f` handler, which `.ei` dispatches — but they attach to `.f`, so it has to
-		// exist. The runtime `ensureChunk` around it does not.
-		if (
-			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
-			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
-			chunk.hasChildByOrder(chunkGraph, "cssPreload", true) ||
-			this._chunkLoadsBeyondJs(chunk, chunkGraph)
-		) {
-			runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
-		}
-		// 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})`)})`;
+		return `Promise.all(${comment.trim()}[${items.join(", ")}])`;
 	}
 
 	/**
@@ -2785,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);
@@ -2807,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
@@ -3068,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
@@ -3212,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
@@ -3243,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)
+		);
 	}
 
 	/**
@@ -3262,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} */
@@ -3275,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;
@@ -3301,16 +3382,9 @@ class RuntimeTemplate {
 	 * @param {Chunk} chunk the worker's entry chunk
 	 * @param {Module} module the module the reference is emitted into
 	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @param {RuntimeRequirements} runtimeRequirements what the consuming chunk needs
 	 * @returns {string | null} a quoted literal, or `null` to fall back
 	 */
-	getAnalyzableWorkerUrl(
-		overridePublicPath,
-		chunk,
-		module,
-		chunkGraph,
-		runtimeRequirements
-	) {
+	getAnalyzableWorkerUrl(overridePublicPath, chunk, module, chunkGraph) {
 		// Without an id nothing can name the chunk in a stand-in.
 		if (
 			chunk.id === null ||
@@ -3322,8 +3396,7 @@ class RuntimeTemplate {
 			overridePublicPath,
 			chunk,
 			module,
-			chunkGraph,
-			runtimeRequirements
+			chunkGraph
 		);
 	}
 
@@ -3336,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(
@@ -3349,117 +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);
-		const namesFirst = 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. A pair naming each other is fine here:
-		// `RealContentHashPlugin`, which deferring requires, re-hashes the pair as one
-		// group, so neither hash chases the other.
-		const canReserve =
-			chunk.id !== null && 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 — and
-		// a pair that reaches back has no fold order, so only the one hashing first does.
-		const canFold = !canReserve && namesFirst;
-		/**
-		 * @returns {null} always, having recorded why no stand-in may be reserved
-		 */
-		const cannotReserve = () =>
-			this._analyzableBailout(
-				consumingModule,
-				!namesFirst && this._reachesAny(chunk, chunks)
-					? "this chunk and the one it references name each other, which only optimization.realContentHash could settle"
-					: DEFER_BAILOUT,
-				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
-				});
+		// 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 &&
+			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);
+		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.
@@ -3473,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();
@@ -3518,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;
@@ -3534,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]];
 	}
 
 	/**
@@ -3640,7 +3701,7 @@ class RuntimeTemplate {
 				relativeBase
 			);
 			if (prefix === null) return null;
-			return this._specifierOf([...prefix, ...file], chunks, module);
+			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
@@ -3650,23 +3711,22 @@ class RuntimeTemplate {
 		const parts = [undo === null ? ["undo", ""] : ["literal", undo]];
 		if (relativeBase !== undefined) parts.push(["literal", relativeBase]);
 		parts.push(...file);
-		return this._specifierOf(parts, chunks, module);
+		return this._specifierOf(parts, chunks);
 	}
 
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
-	 * keyed by chunk id — one that cannot be named leaves the map incomplete, and its
-	 * id keeps the runtime `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
+	 * 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
 	 * @param {Module=} consumingModule the runtime module, where one exists to report against
-	 * @returns {AnalyzableChunkUrls | null} the urls, or `null` to keep the runtime form
+	 * @returns {Map<ChunkId, string> | null} the urls, or `null` to keep the runtime form
 	 */
 	analyzableCssChunkUrls(
 		runtimeChunk,
@@ -3698,14 +3758,14 @@ 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 — one that cannot be named leaves the map incomplete, and its id keeps the
-	 * runtime `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
+	 * 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
 	 * @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 {AnalyzableChunkUrls | null} the urls, or `null` to keep the runtime form
+	 * @returns {Map<ChunkId, string> | null} the urls, or `null` to keep the runtime form
 	 */
 	analyzableChunkScriptUrls(
 		runtimeChunk,
@@ -3742,17 +3802,156 @@ 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. A chunk that cannot be named here leaves the map incomplete rather
-	 * than losing it — the consumer keeps the runtime form for the ids the map lacks.
+	 * chunk id, or `null` as soon as one of them cannot be named here.
 	 * @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 urls are written into
 	 * @param {string} sourceType which asset of each chunk to name
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements what the runtime chunk needs
-	 * @returns {AnalyzableChunkUrls | null} the urls, or `null` to keep the runtime form
+	 * @returns {Map<ChunkId, string> | null} the urls, or `null` to keep the runtime form
 	 */
 	_analyzableChunkUrls(
 		chunks,
@@ -3762,17 +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();
-		let complete = true;
+		const specifiers = new Map();
 		for (const chunk of chunks) {
 			if (chunk.id === null) continue;
 			const specifier = this._getAnalyzableChunkSpecifier(
@@ -3780,18 +4013,74 @@ class RuntimeTemplate {
 				chunk,
 				consumingModule,
 				chunkGraph,
-				undefined,
 				consumingChunks,
-				sourceType
+				sourceType,
+				hot
 			);
-			// `_getAnalyzableChunkSpecifier` has already recorded why.
-			if (specifier === null) {
-				complete = false;
+			if (specifier === null) return null;
+			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;
 			}
-			urls.set(chunk.id, `${this.importMetaUrl(specifier)}.href`);
+			if (!CHUNK_SPECIFIER_PART_KINDS.has(kind)) return false;
 		}
-		return urls.size > 0 ? { urls, complete } : null;
+		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"
+			);
+		}
+		const undo = getUndoPath(
+			this.compilation.getPath(this._hotUpdateShapeText, { chunk }),
+			/** @type {string} */ (outputOptions.path),
+			true
+		);
+		this._hotUpdateUndoByChunk.set(chunk, undo);
+		return undo;
 	}
 
 	/**
@@ -3997,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, "_")
@@ -4058,16 +4347,18 @@ 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} */
@@ -4122,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;
@@ -4193,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}`
 						);
@@ -4246,6 +4539,8 @@ class RuntimeTemplate {
 
 						tasks.push({ name, source, replacements });
 					}
+					compilation.runtimeTemplate._analyzableRepairedAssets =
+						repairedAssets;
 					if (tasks.length === 0) return;
 
 					await Promise.all(