@depup/webpack 5.109.2-depup.0 → 5.110.3-depup.0

package/lib/RuntimeTemplate.js

@@ -5,23 +5,28 @@
 
 "use strict";
 
+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 {
-	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE,
-	WEBPACK_MODULE_TYPE_FALLBACK,
-	WEBPACK_MODULE_TYPE_PROVIDE,
-	WEBPACK_MODULE_TYPE_REMOTE
-} = require("./ModuleTypeConstants");
+const { WEBASSEMBLY_MODULE_TYPE_ASYNC } = require("./ModuleTypeConstants");
 const RuntimeGlobals = require("./RuntimeGlobals");
 const Template = require("./Template");
 const {
 	getOutgoingAsyncModules
 } = require("./async-modules/AsyncModuleHelpers");
+const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
+const ImportDependency = require("./dependencies/ImportDependency");
 const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
+const JavascriptModulesPlugin = require("./javascript/JavascriptModulesPlugin");
 const { InlinedUsedName } = require("./optimize/InlineExports");
 const {
 	getDeferredCycleModuleIds,
@@ -29,56 +34,340 @@ const {
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("./runtime/MakeDeferredNamespaceObjectRuntime");
+const {
+	isAbsoluteBaseUri,
+	isChunkRelativeBaseUri
+} = require("./runtime/baseUri");
 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 memoize = require("./util/memoize");
 const { propertyAccess, propertyName } = require("./util/property");
-const { forEachRuntime, subtractRuntime } = require("./util/runtime");
+const {
+	forEachRuntime,
+	getRuntimeKey,
+	intersectRuntime,
+	subtractRuntime
+} = require("./util/runtime");
 
-const getHarmonyImportDependency = memoize(() =>
-	require("./dependencies/HarmonyImportDependency")
-);
-const getImportDependency = memoize(() =>
-	require("./dependencies/ImportDependency")
-);
-const getJavascriptModulesPlugin = memoize(() =>
-	require("./javascript/JavascriptModulesPlugin")
-);
-const getModuleHotAcceptDependency = memoize(() =>
-	require("./dependencies/ModuleHotAcceptDependency")
-);
-const getAPIPlugin = memoize(() => require("./APIPlugin"));
+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"));
 
-// Module-federation module types whose chunks load through the federation runtime.
-/** @type {Set<string>} */
-const FEDERATION_MODULE_TYPES = new Set([
-	WEBPACK_MODULE_TYPE_REMOTE,
-	WEBPACK_MODULE_TYPE_PROVIDE,
-	WEBPACK_MODULE_TYPE_CONSUME_SHARED_MODULE,
-	WEBPACK_MODULE_TYPE_FALLBACK
+/**
+ * @typedef {object} ChunkAssetNaming
+ * @property {(chunk: Chunk, outputOptions: OutputOptions) => ChunkFilenameTemplate} template what names the asset
+ * @property {SpecifierPartKind} standIn the stand-in kind that spells it once the hashes exist
+ */
+
+/**
+ * What names the asset a chunk emits for one source type. Keyed rather than branched
+ * on, so a type nothing here answers for keeps the runtime form instead of silently
+ * taking another type's name and hash. A plugin emitting a new kind of chunk asset
+ * registers it here to have its urls baked.
+ * @type {Map<string, ChunkAssetNaming>}
+ */
+const CHUNK_ASSET_NAMING = new Map([
+	[
+		JAVASCRIPT_TYPE,
+		{
+			template: (chunk, outputOptions) =>
+				JavascriptModulesPlugin.getChunkFilenameTemplate(chunk, outputOptions),
+			standIn: "chunk"
+		}
+	],
+	[
+		CSS_TYPE,
+		{
+			template: (chunk, outputOptions) =>
+				getCssModulesPlugin().getChunkFilenameTemplate(chunk, outputOptions),
+			standIn: "cssChunk"
+		}
+	]
 ]);
+const getTemplatedPathPlugin = memoize(() => require("./TemplatedPathPlugin"));
+const getConcatenatedModule = memoize(() =>
+	require("./optimize/ConcatenatedModule")
+);
 
 // Any `[hash]`/`[fullhash]`/`[chunkhash]`/`[contenthash]` token, incl. a `:<length>`
 // or `:<digest>[:<length>]` suffix (e.g. `[contenthash:base64:8]`). Its value is only
 // resolved after code generation, so a filename using one can't be an inline literal.
 const HASH_IN_FILENAME = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/;
+// Two stand-ins for every hash a filename function might read: a name built from one
+// is hash-dependent exactly when the two calls disagree.
+const HASH_PROBE = "0123456789abcdef0123";
+// Reversed, so the two differ at every position and no slice of one equals the other.
+const HASH_PROBE_ALTERNATE = "3210fedcba9876543210";
 const HASH_IN_FILENAME_GLOBAL = /\[(?:full|chunk|content)?hash(?::[^\]]+)?\]/g;
 
-/** @typedef {import("./config/defaults").OutputNormalizedWithDefaults} OutputOptions */
-/** @typedef {import("./AsyncDependenciesBlock")} AsyncDependenciesBlock */
-/** @typedef {import("./Chunk")} Chunk */
-/** @typedef {import("./ChunkGraph")} ChunkGraph */
-/** @typedef {import("./Compilation")} Compilation */
-/** @typedef {import("./Dependency")} Dependency */
-/** @typedef {import("./Module")} Module */
-/** @typedef {import("./Module").BuildMeta} BuildMeta */
-/** @typedef {import("./Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("./ModuleGraph")} ModuleGraph */
-/** @typedef {import("./RequestShortener")} RequestShortener */
-/** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
-/** @typedef {import("./dependencies/ImportPhase").ImportPhaseType} ImportPhaseType */
-/** @typedef {import("./NormalModuleFactory").ModuleDependency} ModuleDependency */
+/**
+ * @param {SpecifierPart} part one piece of a reserved name
+ * @returns {boolean} true when it is text the deferred pass adds nothing to
+ */
+const isLiteralPart = (part) => part[0] === "literal";
+
+/**
+ * The text these parts spell, or `null` when one of them is a stand-in that only
+ * the deferred pass can fill in.
+ * @param {SpecifierPart[] | null} parts pieces of a name
+ * @returns {string | null} the text, or `null` when they are not all literal
+ */
+const literalText = (parts) => {
+	if (parts === null) return null;
+	// Built in one pass rather than tested and then joined: every specifier asks, and
+	// a stand-in in the first part answers without reading the rest.
+	let text = "";
+	for (const part of parts) {
+		if (!isLiteralPart(part)) return null;
+		text += part[1];
+	}
+	return text;
+};
+
+/**
+ * Whether a public path reaches the same place from any base. A relative one does
+ * not, and is equivalent only behind the `../` path back to the output root.
+ * @param {string} publicPath the resolved public path, or the shape of one
+ * @returns {boolean} true when no base is needed
+ */
+const isBaseIndependent = (publicPath) =>
+	publicPath.startsWith("/") || getScheme(publicPath) !== undefined;
+
+/**
+ * Drops the `./` a public path may open with: what follows it is already walked back
+ * to the output root, so it would only lengthen the name.
+ * @param {SpecifierPart[]} parts a public path's pieces
+ * @returns {SpecifierPart[]} them, without that `./`
+ */
+const rootedParts = (parts) =>
+	parts.length > 0 &&
+	isLiteralPart(parts[0]) &&
+	/** @type {string} */ (parts[0][1]).startsWith("./")
+		? [
+				/** @type {SpecifierPart} */ ([
+					"literal",
+					/** @type {string} */ (parts[0][1]).slice(2)
+				]),
+				...parts.slice(1)
+			]
+		: 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`.
+ * @typedef {object} Placement
+ * @property {string | null} undo the path back to the output root
+ * @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
+ * @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 };
+
+/**
+ * Which of `createHash`'s four rounds settles this chunk's hash. A hash may only be
+ * read from an earlier round, which is what lets one chunk's name be folded into
+ * another's hash.
+ * @param {Chunk} chunk the chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {number} the round, ascending
+ */
+const hashRound = (chunk, chunkGraph) => {
+	if (chunk.hasRuntime()) return 2;
+	if (chunkGraph.getNumberOfEntryModules(chunk) > 0) return 3;
+	return chunk.canBeInitial() ? 1 : 0;
+};
+
+// The round runtime chunks are settled in, ordered by references between them rather
+// than by id, so id says nothing about the order inside it.
+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";
+
+/**
+ * @import {
+ * 	OutputNormalizedWithDefaults as OutputOptions
+ * } from "./config/defaults"
+ */
+/** @import { PublicPath, WasmLoading } from "../declarations/WebpackOptions" */
+/** @import ModuleDependency from "./dependencies/ModuleDependency" */
+/**
+ * @import Module, {
+ * 	ReadOnlyRuntimeRequirements,
+ * 	BuildMeta,
+ * 	RuntimeRequirements
+ * } from "./Module"
+ */
+/** @typedef {"import" | "url" | "url-runtime" | "url-inline" | "wasm" | "wasm-relative"} AnalyzableForm */
+/**
+ * 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
+ */
+/** @typedef {[SpecifierPartKind, string | number]} SpecifierPart */
+
+const SPECIFIER_PART_KINDS = new Set([
+	"literal",
+	"undo",
+	"template",
+	"publicPath",
+	"unserved",
+	"base",
+	"chunk",
+	"cssChunk"
+]);
+
+// 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_REGEXP = /\.\/@@webpackAnalyzableChunk:([\w-]+)@@/g;
+
+// Stands in for the compilation hash inside an otherwise resolved filename, with the
+// requested length when the placeholder asked for one.
+const FULL_HASH_TOKEN_REGEXP = /@@webpackFullHash(?:-(\d+))?@@/g;
+
+const FULL_HASH_TOKEN_PREFIX = "@@webpackFullHash";
+
+/**
+ * @param {number=} length how many characters the placeholder asked for
+ * @returns {string} the stand-in to emit
+ */
+const reserveFullHash = (length) =>
+	`${FULL_HASH_TOKEN_PREFIX}${length === undefined ? "" : `-${length}`}@@`;
+
+// `getPath` data that leaves every compilation-hash placeholder as a stand-in while the
+// rest of the name resolves — a module's own hash and id are settled during code
+// generation, the compilation's is not. Shared: it closes over nothing.
+const DEFERRED_FULL_HASH_PATH_DATA = {
+	hash: reserveFullHash(),
+	hashWithLength: reserveFullHash
+};
+
+// The same table read by stand-in, for the pass that spells one: a chunk's content hash
+// is keyed by source type, so the type it is keyed under here is the hash to read.
+const CHUNK_ASSET_NAMING_BY_STAND_IN = new Map(
+	[...CHUNK_ASSET_NAMING].map(([contentHashType, naming]) => [
+		naming.standIn,
+		{ template: naming.template, contentHashType }
+	])
+);
+
+/**
+ * first character, last character, replacement.
+ * @typedef {[number, number, string]} Replacement
+ */
+
+const PASS_NAME = "analyzableChunkNaming";
+
+/** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
+/** @import { Source } from "webpack-sources" */
+/** @import Compiler from "./Compiler" */
+/** @import Chunk, { ChunkFilenameTemplate, ChunkId } from "./Chunk" */
+/** @import ChunkGroup from "./ChunkGroup" */
+/** @import ChunkGraph from "./ChunkGraph" */
+/** @import Compilation from "./Compilation" */
+/** @import Dependency from "./Dependency" */
+/** @import ModuleGraph from "./ModuleGraph" */
+/** @import RequestShortener from "./RequestShortener" */
+/** @import Hash from "./util/Hash" */
+/** @import CodeGenerationResults from "./CodeGenerationResults" */
+/** @import { RuntimeSpec } from "./util/runtime" */
+
+/**
+ * A stand-in whose every hash reads back as `hash`. Which content hashes a chunk
+ * carries is settled after code generation, so `present` makes the two probes disagree
+ * about that too — a name built by enumerating them then reads as hash-dependent.
+ * Shadows the chunk rather than mutating it, so a filename function still reads every
+ * other field and method straight off it.
+ * @param {Chunk} chunk the chunk being referenced
+ * @param {string} hash the stand-in hash
+ * @param {boolean} present whether the chunk is claimed to carry content hashes
+ * @returns {Chunk} the stand-in chunk
+ */
+const createHashProbeChunk = (chunk, hash, present) => {
+	const probeChunk = Object.create(chunk);
+	probeChunk.hash = hash;
+	probeChunk.renderedHash = hash;
+	probeChunk.contentHash = new Proxy(
+		present ? { [JAVASCRIPT_TYPE]: hash } : {},
+		{
+			// Any content-hash type, not only the ones this chunk happens to carry.
+			get: (target, key) => (typeof key === "string" ? hash : undefined),
+			has: () => present,
+			getOwnPropertyDescriptor: () =>
+				present
+					? {
+							value: hash,
+							writable: true,
+							enumerable: true,
+							configurable: true
+						}
+					: undefined
+		}
+	);
+	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.
@@ -107,6 +396,10 @@ Module has these incoming connections: ${Array.from(
 		}`
 ).join("")}`;
 
+// `this` as a value, not as a property name or part of a longer identifier
+// (identifier characters per `getGlobalObject` below, so `globalThis` is not one)
+const THIS_REFERENCE_REGEXP = /(?:^|[^\p{L}\p{N}_$.])this(?![\p{L}\p{N}_$])/u;
+
 /**
  * Gets global object.
  * @param {string | undefined} definition global object definition
@@ -130,6 +423,11 @@ 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();
+
 class RuntimeTemplate {
 	/**
 	 * Creates an instance of RuntimeTemplate.
@@ -149,12 +447,47 @@ class RuntimeTemplate {
 			(getGlobalObject(outputOptions.globalObject));
 		/** @type {string} */
 		this.contentHashReplacement = "X".repeat(outputOptions.hashDigestLength);
+		/** @type {boolean | undefined} */
+		this._javascriptNamedWithoutContent = undefined;
+		/** @type {WeakMap<Chunk, boolean>} */
+		this._chunkNamedWithoutContent = new WeakMap();
+		/** @type {WeakMap<Chunk, string>} */
+		this._foldedAnalyzableNames = new WeakMap();
+		/** @type {WeakMap<Chunk, Map<string, string>>} */
+		this._analyzableAssetNames = new WeakMap();
+		/** @type {Map<Chunk, Set<string>> | undefined} */
+		this._namesBakedInto = undefined;
+		/** @type {Map<string, Chunk> | undefined} */
+		this._chunksByIdForFold = undefined;
+		/** @type {Set<Chunk> | undefined} */
+		this._chunksBakingFullHash = undefined;
+		/** @type {string | false | undefined} */
+		this._publicPathShapeText = undefined;
+		/** @type {string | null | undefined} */
+		this._publicPathClimbText = undefined;
+		/** @type {WeakMap<Chunk, Placement>} */
+		this._placementByChunk = new WeakMap();
+		/** @type {Map<string, string | null | undefined>} */
+		this._entryBaseUriByRuntime = new Map();
+		/** @type {WasmGroups | undefined} */
+		this._wasmGroupsValue = undefined;
+		/** @type {Map<string, boolean> | undefined} */
+		this._wasmAnchorKnownByGroup = undefined;
 	}
 
 	isIIFE() {
 		return this.outputOptions.iife;
 	}
 
+	/**
+	 * Whether the global object expression reads the `this` binding, which only
+	 * refers to the global object outside of strict mode.
+	 * @returns {boolean} true, when it reads `this`
+	 */
+	globalObjectUsesThis() {
+		return THIS_REFERENCE_REGEXP.test(this.globalObject);
+	}
+
 	isModule() {
 		return this.outputOptions.module;
 	}
@@ -191,8 +524,10 @@ class RuntimeTemplate {
 
 	/**
 	 * Expression for the global registry that collects CSS server-side when there
-	 * is no DOM (SSR). An SSR host reads it from `globalThis`; it is keyed by the
-	 * style/chunk identifier and namespaced by `output.uniqueName`.
+	 * is no DOM (SSR). Read it with `__webpack_css_server_styles__`; it is keyed
+	 * by the style/chunk identifier and namespaced by `output.uniqueName`.
+	 * Targets without `globalThis` go through the `__webpack_require__.g`
+	 * polyfill, so consumers must also require `RuntimeGlobals.global`.
 	 * @returns {string} runtime expression evaluating to the registry object
 	 */
 	cssServerStyleRegistry() {
@@ -200,7 +535,10 @@ class RuntimeTemplate {
 		const key = JSON.stringify(
 			name ? `__webpack_css__${name}` : "__webpack_css__"
 		);
-		return `(${this.assignOr(`globalThis[${key}]`, "{}")})`;
+		const global = this.outputOptions.environment.globalThis
+			? "globalThis"
+			: RuntimeGlobals.global;
+		return `(${this.assignOr(`${global}[${key}]`, "{}")})`;
 	}
 
 	supportsConst() {
@@ -267,168 +605,855 @@ class RuntimeTemplate {
 		return this.outputOptions.environment.module;
 	}
 
+	supportsDeferImport() {
+		return this.outputOptions.environment.deferImport;
+	}
+
+	supportsSourceImport() {
+		return this.outputOptions.environment.sourceImport;
+	}
+
 	supportsModulePreload() {
 		return this.outputOptions.environment.modulePreload;
 	}
 
-	supportsAnalyzableEsm() {
+	/**
+	 * 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:
+	 *
+	 * - `"import"` — a literal `import("./chunk.js")` in place of `ensureChunk(id)`
+	 * - `"url"` — a literal `new URL(<file>, import.meta.url)`
+	 * - `"url-runtime"` — the same, written into a runtime module rather than a module
+	 * - `"url-inline"` — whether such a reference names the file at the call site
+	 * - `"wasm"` — the same, fully baked for a wasm binary the runtime would name
+	 * - `"wasm-relative"` — a wasm path built at runtime under an `import.meta.url` base
+	 *
+	 * `"url-inline"` differs from `"url"` only in taking the `.p + <file>` fallback as
+	 * an answer too — both name the file where it is used rather than through the
+	 * asset's javascript wrapper, which is what decides whether that wrapper is emitted.
+	 *
+	 * A name code generation cannot settle may still be baked, through a stand-in the
+	 * deferred pass fills in. Not covered here, because only the reference can tell: a
+	 * chunk with no id, and one this compilation emits no javascript for.
+	 * @param {AnalyzableForm} form which reference is being emitted
+	 * @param {ChunkGraph=} chunkGraph the chunk graph, to place `module` in its runtimes
+	 * @param {Module=} module the module the reference is emitted into
+	 * @param {RuntimeSpec=} runtime the runtime the reference is emitted for; the wasm forms answer for the loader it shares rather than for every loader in the compilation
+	 * @returns {boolean} true when the literal form may be emitted
+	 */
+	supportsAnalyzable(form, chunkGraph, module, runtime) {
+		// Analyzable output is ESM output — anything else is a different feature.
+		if (!this.isModule()) return false;
+		// Build-time execution keeps the runtime form — `import.meta` does not parse in its
+		// vm wrapper. Unreported on purpose: its chunk graph shares the real module graph.
+		if (chunkGraph && chunkGraph.buildTimeExecution) return false;
+		const { outputOptions } = this;
+		// One loader per runtime serves every wasm module in it, so the answer has to
+		// hold compilation-wide — else a baked url reaches the id-and-hash signature.
+		const scoped = form !== "wasm" && form !== "wasm-relative";
+		// Resolved once: concatenation may have absorbed the module that wrote the
+		// reference, and both the scope below and the worker loop ask about the same one.
+		const placedModule =
+			scoped && module !== undefined
+				? getConcatenatedModule().getChunkGraphModule(this.compilation, module)
+				: 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.
+		if (
+			form !== "url-inline" &&
+			APIPlugin.runtimeUsesPublicPathOverride(
+				this.compilation,
+				scoped ? chunkGraph : undefined,
+				placedModule
+			)
+		) {
+			return this._analyzableBailout(
+				module,
+				"__webpack_public_path__ is reassigned in a runtime this module belongs to",
+				false
+			);
+		}
+
+		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
+					);
+				}
+			}
+			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.
+		// `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.
+		if (form === "url-inline") return true;
 		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
-		// syntax error, so the literal `new URL(…, import.meta.url)` form can't be used.
+		// syntax error. Runtime modules are emitted beside them, never wrapped.
 		const { devtool } = this.compilation.options;
-		return (
-			this.isModule() &&
-			this.supportsEcmaScriptModuleSyntax() &&
-			!(typeof devtool === "string" && devtool.includes("eval")) &&
-			// A runtime `__webpack_public_path__` override can't be reflected in a
-			// baked literal, so keep the runtime form that reads `__webpack_require__.p`.
-			!getAPIPlugin().usesRuntimePublicPathOverride(this.compilation)
-		);
-	}
-
-	supportTemplateLiteral() {
-		return this.outputOptions.environment.templateLiteral;
-	}
+		if (
+			form !== "url-runtime" &&
+			typeof devtool === "string" &&
+			devtool.includes("eval")
+		) {
+			return this._analyzableBailout(
+				module,
+				`devtool ${JSON.stringify(devtool)} wraps the module in eval(), where import.meta does not parse`,
+				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;
+			return this._analyzableBailout(
+				module,
+				"output.publicPath is set, so a bare relative url no longer means what the public path would have resolved to",
+				false
+			);
+		}
 
-	supportNodePrefixForCoreModules() {
-		return this.outputOptions.environment.nodePrefixForCoreModules;
+		// 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;
+		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) {
+					return false;
+				}
+			} else if (
+				this._anyWasmChunkFetches(runtime) &&
+				!this._wasmFetchAnchorIsKnown(runtime)
+			) {
+				return this._analyzableBailout(
+					module,
+					"output.publicPath needs a base, and no one path back to the document fits every chunk `fetch` reads it from",
+					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;
 	}
 
 	/**
-	 * Renders node prefix for core module.
-	 * @param {string} mod a module
-	 * @returns {string} a module with `node:` prefix when supported, otherwise an original name
+	 * Records why a reference kept the runtime form, on the module that wrote it —
+	 * 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
 	 */
-	renderNodePrefixForCoreModule(mod) {
-		return this.outputOptions.environment.nodePrefixForCoreModules
-			? `"node:${mod}"`
-			: `"${mod}"`;
+	_analyzableBailout(module, reason, answer) {
+		if (module !== undefined && this.outputOptions.module) {
+			const text = `Analyzable ESM bailout: ${reason}`;
+			const bailouts =
+				this.compilation.moduleGraph.getOptimizationBailout(module);
+			if (!bailouts.includes(text)) bailouts.push(text);
+		}
+		return answer;
 	}
 
 	/**
-	 * Renders return const when it is supported, otherwise let when supported, otherwise var.
-	 * @returns {"const" | "let" | "var"} return `const` when it is supported, otherwise `let` when supported, otherwise `var`
+	 * 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
 	 */
-	renderConst() {
-		return this.supportsConst() ? "const" : this.supportsLet() ? "let" : "var";
+	_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
+				);
+			}
+			return this._javascriptNamedWithoutContent;
+		}
+		let found = false;
+		for (const chunk of chunks) {
+			found = true;
+			if (!this._chunkNameIndependentOfContent(chunk)) return false;
+		}
+		// None at all names nothing to reason about — the asset is unknown, not safe.
+		return found;
 	}
 
 	/**
-	 * Renders return let when it is supported, otherwise var.
-	 * @returns {"let" | "var"} return `let` when it is supported, otherwise `var`
+	 * `_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
 	 */
-	renderLet() {
-		return this.supportsLet() ? "let" : "var";
+	_canDeferOrBail(chunks, module) {
+		if (this._canDeferAnalyzableName(chunks)) return true;
+		return this._analyzableBailout(module, DEFER_BAILOUT, false);
 	}
 
 	/**
-	 * Returning function.
-	 * @param {string} returnValue return value
-	 * @param {string} args arguments
-	 * @returns {string} returning function
+	 * These parts as a quoted specifier: the text itself where they spell one already,
+	 * 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
 	 */
-	returningFunction(returnValue, args = "") {
-		return this.supportsArrowFunction()
-			? `(${args}) => (${returnValue})`
-			: `function(${args}) { return ${returnValue}; }`;
+	_specifierOf(parts, chunks, module) {
+		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));
 	}
 
 	/**
-	 * Returns basic function.
-	 * @param {string} args arguments
-	 * @param {string | string[]} body body
-	 * @returns {string} basic function
+	 * `_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
 	 */
-	basicFunction(args, body) {
-		return this.supportsArrowFunction()
-			? `(${args}) => {\n${Template.indent(body)}\n}`
-			: `function(${args}) {\n${Template.indent(body)}\n}`;
+	_canDeferOrBakeFullHash(carriesFullHash, chunks, module) {
+		return carriesFullHash || this._canDeferOrBail(chunks, module);
 	}
 
 	/**
-	 * Returns result expression.
-	 * @param {(string | { expr: string })[]} args args
-	 * @returns {string} result expression
+	 * Whether the fill will build these parts out of the compilation hash — the same
+	 * question `_markChunksBakingFullHash` asks of what was generated, so a stand-in this
+	 * says yes to is one that moves its chunk into the round after that hash.
+	 * @param {SpecifierPart[]} parts what the stand-in resolves to
+	 * @returns {boolean} true when that hash reaches the text
 	 */
-	concatenation(...args) {
-		const len = args.length;
-
-		if (len === 2) return this._es5Concatenation(args);
-		if (len === 0) return '""';
-		if (len === 1) {
-			return typeof args[0] === "string"
-				? JSON.stringify(args[0])
-				: `"" + ${args[0].expr}`;
-		}
-		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)
-
-		let templateCost = 0;
-		let concatenationCost = 0;
-
-		let lastWasExpr = false;
-		for (const arg of args) {
-			const isExpr = typeof arg !== "string";
-			if (isExpr) {
-				templateCost += 3;
-				concatenationCost += lastWasExpr ? 1 : 4;
+	_partsBakeFullHash(parts) {
+		for (const [kind, value] of parts) {
+			if (FULL_HASH_PART_KINDS.has(kind)) return true;
+			if (kind === "literal" && this._hasReservedFullHash(String(value))) {
+				return true;
 			}
-			lastWasExpr = isExpr;
-		}
-		if (lastWasExpr) concatenationCost -= 3;
-		if (typeof args[0] !== "string" && typeof args[1] === "string") {
-			concatenationCost -= 3;
 		}
-
-		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
-
-		return `\`${args
-			.map((arg) => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
-			.join("")}\``;
+		return false;
 	}
 
 	/**
-	 * Returns result expression.
-	 * @param {(string | { expr: string })[]} args args (len >= 2)
-	 * @returns {string} result expression
-	 * @private
+	 * Whether the name this chunk is emitted under is settled before its own content
+	 * is, which is what leaves it right after a later rewrite. A filename function is
+	 * asked rather than assumed to read a hash — the same two probes the chunk
+	 * specifier is resolved with. Memoized per chunk: answering calls that function
+	 * twice, and a reference asks once for every chunk it is written into.
+	 * @param {Chunk} chunk a chunk the stand-in is written into
+	 * @returns {boolean} true when the name does not move with the content
 	 */
-	_es5Concatenation(args) {
-		const str = args
-			.map((arg) => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
-			.join(" + ");
-
-		// when the first two args are expression, we need to prepend "" + to force string
-		// concatenation instead of number addition.
-		return typeof args[0] !== "string" && typeof args[1] !== "string"
-			? `"" + ${str}`
-			: str;
+	_chunkNameIndependentOfContent(chunk) {
+		const cached = this._chunkNamedWithoutContent.get(chunk);
+		if (cached !== undefined) return cached;
+		const template = this._resolveChunkFilenameTemplate(
+			JavascriptModulesPlugin.getChunkFilenameTemplate(
+				chunk,
+				this.outputOptions
+			),
+			chunk,
+			JAVASCRIPT_TYPE
+		);
+		let independent = false;
+		if (typeof template === "string") {
+			const kinds = getTemplatedPathPlugin().getPresentKinds(template);
+			// `[chunkhash]` is taken from this chunk's own modules and nothing repairs it
+			// afterwards, so such a name stays put while the reference it holds moves.
+			independent =
+				!kinds.has("chunkhash") &&
+				(!kinds.has("contenthash") ||
+					Boolean(this.compilation.options.optimization.realContentHash));
+		}
+		this._chunkNamedWithoutContent.set(chunk, independent);
+		return independent;
 	}
 
 	/**
-	 * Expression function.
-	 * @param {string} expression expression
-	 * @param {string} args arguments
-	 * @returns {string} expression function code
+	 * Builds the analyzable `new URL(specifier, import.meta.url)` expression the ESM
+	 * wasm/asset loader backends use to reference an emitted binary relative to the
+	 * current module (via `output.importMetaName`) instead of the runtime public-path
+	 * global — the form other bundlers and webpack itself can statically follow.
+	 * @param {string} specifier already-rendered URL argument (a literal or expression)
+	 * @returns {string} the `new URL(...)` expression
 	 */
-	expressionFunction(expression, args = "") {
-		return this.supportsArrowFunction()
-			? `(${args}) => (${expression})`
-			: `function(${args}) { ${expression}; }`;
+	importMetaUrl(specifier) {
+		return `new URL(${specifier}, ${this.outputOptions.importMetaName}.url)`;
 	}
 
 	/**
-	 * Returns empty function code.
-	 * @returns {string} empty function code
+	 * Whether a baked asset url resolves against the entry `baseUri` at all. A public
+	 * path that reaches the same place from any base never reads `.b` — and `auto`
+	 * resolves to an absolute url too — while output with no baked form has nothing to
+	 * resolve. Where this is false, what `baseUri` is set to cannot reach the generated
+	 * code, so it must not reach the module hash either: `URLDependency.updateHash`
+	 * asks this before contributing one.
+	 * @returns {boolean} true when the base can change what is generated
+	 */
+	analyzableUrlReadsBaseUri() {
+		if (!this.isModule()) return false;
+		const { publicPath } = this.outputOptions;
+		if (publicPath === "auto") return false;
+		return !this._publicPathNeedsNoBase();
+	}
+
+	/**
+	 * Whether `output.publicPath` reaches the same place from any base, so a literal may
+	 * carry it without walking back to the output root first. One whose shape nothing
+	 * answers needs a base as far as anything here can tell. Never asked of `auto`,
+	 * which is no path of its own.
+	 * @returns {boolean} true when no base is needed
+	 */
+	_publicPathNeedsNoBase() {
+		const shape = this._publicPathShape();
+		return shape !== undefined && isBaseIndependent(shape);
+	}
+
+	/**
+	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
+	 * an asset reference bakes to, or `null` to keep the runtime form. Unlike a wasm
+	 * binary, the runtime resolves an asset url against `__webpack_require__.b` — the
+	 * output root, or an entry `baseUri` where one is set — so that base is settled here
+	 * before the rest of the name is.
+	 * @param {Module} module the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {string} filename the asset's name, relative to the output root
+	 * @param {RuntimeSpec} runtime the runtime the code is generated for
+	 * @returns {string | null} a quoted literal, or `null` to fall back
+	 */
+	getAnalyzableAssetUrl(module, chunkGraph, filename, runtime) {
+		const { publicPath } = this.outputOptions;
+		const base = this.analyzableUrlReadsBaseUri()
+			? this.entryBaseUri(runtime)
+			: undefined;
+		// 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, module, chunks);
+		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.
+		if (base.startsWith("//")) {
+			return this._specifierOf(
+				[["literal", base], ...rootedParts(parts), ["literal", filename]],
+				chunks,
+				module
+			);
+		}
+		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);
+		if (!this._canDeferOrBail(chunks, module)) return null;
+		return toJsStringLiteral(
+			this._reserveAnalyzableSpecifier([
+				["base", base],
+				...parts,
+				["literal", filename]
+			])
+		);
+	}
+
+	/**
+	 * The `baseUri` the entries this code runs under agree on, which replaces the output
+	 * root an asset url resolves against. Asked per runtime, because that is what the
+	 * module is generated for: two entries with different bases each get their own
+	 * source. `undefined` when none of them sets one, `null` when they disagree — an
+	 * entry that omits it disagrees with one that sets it.
+	 * @param {RuntimeSpec} runtime the runtime the code is generated for
+	 * @returns {string | null | undefined} the base those entries agree on
+	 */
+	entryBaseUri(runtime) {
+		const key = getRuntimeKey(runtime);
+		if (this._entryBaseUriByRuntime.has(key)) {
+			return this._entryBaseUriByRuntime.get(key);
+		}
+		/** @type {string | null | undefined} */
+		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.
+			if (!chunk.hasRuntime()) continue;
+			const entryOptions = chunk.getEntryOptions();
+			// An entry this code cannot run under has no say in the base it resolves to.
+			if (
+				!entryOptions ||
+				intersectRuntime(chunk.runtime, runtime) === undefined
+			) {
+				continue;
+			}
+			if (found && base !== entryOptions.baseUri) {
+				base = null;
+				break;
+			}
+			base = entryOptions.baseUri;
+			found = true;
+		}
+		this._entryBaseUriByRuntime.set(key, base);
+		return base;
+	}
+
+	/**
+	 * `output.publicPath` as the constant it will be, for code that would otherwise read
+	 * `__webpack_require__.p` for a value that never changes. `undefined` when only the
+	 * hash could say, or when a runtime reassigns `__webpack_public_path__` — then the
+	 * global is the only thing that knows.
+	 * @returns {string | undefined} the settled public path
+	 */
+	constantPublicPath() {
+		const { publicPath } = this.outputOptions;
+		if (
+			publicPath === "auto" ||
+			APIPlugin.usesRuntimePublicPathOverride(this.compilation)
+		) {
+			return undefined;
+		}
+		if (typeof publicPath === "function") {
+			const resolved = this._resolveHashIndependent(
+				publicPath,
+				this._publicPathShape()
+			);
+			return resolved === null ? undefined : resolved;
+		}
+		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 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 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._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;
+		return this._wasmGroupsOf(runtime).some((group) => fetching.has(group));
+	}
+
+	/**
+	 * Whether a public path needing a base can be spelled from the chunk every binary of
+	 * a runtime sits in — `fetch` reads it against the document, so a literal climbs back
+	 * there first. Per group, as `_anyWasmChunkFetches` is, since the two ends must agree.
+	 * @param {RuntimeSpec=} runtime the runtime being asked about
+	 * @returns {boolean} true when every binary of that group can be spelled
+	 */
+	_wasmFetchAnchorIsKnown(runtime) {
+		if (this._wasmAnchorKnownByGroup === undefined) {
+			const { chunkGraph, modules } = this.compilation;
+			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._getAnalyzableFileSpecifier(
+						module,
+						/** @type {ChunkGraph} */ (chunkGraph),
+						[["literal", "x"]],
+						true
+					) !== null;
+				for (const moduleRuntime of chunkGraph.getModuleRuntimes(module)) {
+					forEachRuntime(moduleRuntime, (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 onlyFetching) {
+				if (!only) known.set(group, false);
+			}
+			this._wasmAnchorKnownByGroup = known;
+		}
+		const known = this._wasmAnchorKnownByGroup;
+		// No runtime to place it in leaves every group answering, so one that cannot be
+		// spelled speaks for all of them.
+		if (runtime === undefined) {
+			for (const value of known.values()) if (!value) return false;
+			return known.size > 0;
+		}
+		return this._wasmGroupsOf(runtime).every(
+			(group) => known.get(group) === true
+		);
+	}
+
+	supportTemplateLiteral() {
+		return this.outputOptions.environment.templateLiteral;
+	}
+
+	supportNodePrefixForCoreModules() {
+		return this.outputOptions.environment.nodePrefixForCoreModules;
+	}
+
+	/**
+	 * Renders node prefix for core module.
+	 * @param {string} mod a module
+	 * @returns {string} a module with `node:` prefix when supported, otherwise an original name
+	 */
+	renderNodePrefixForCoreModule(mod) {
+		return this.outputOptions.environment.nodePrefixForCoreModules
+			? `"node:${mod}"`
+			: `"${mod}"`;
+	}
+
+	/**
+	 * Renders return const when it is supported, otherwise let when supported, otherwise var.
+	 * @returns {"const" | "let" | "var"} return `const` when it is supported, otherwise `let` when supported, otherwise `var`
+	 */
+	renderConst() {
+		return this.supportsConst() ? "const" : this.supportsLet() ? "let" : "var";
+	}
+
+	/**
+	 * Renders return let when it is supported, otherwise var.
+	 * @returns {"let" | "var"} return `let` when it is supported, otherwise `var`
+	 */
+	renderLet() {
+		return this.supportsLet() ? "let" : "var";
+	}
+
+	/**
+	 * Returning function.
+	 * @param {string} returnValue return value
+	 * @param {string} args arguments
+	 * @returns {string} returning function
+	 */
+	returningFunction(returnValue, args = "") {
+		return this.supportsArrowFunction()
+			? `(${args}) => (${returnValue})`
+			: `function(${args}) { return ${returnValue}; }`;
+	}
+
+	/**
+	 * Returns basic function.
+	 * @param {string} args arguments
+	 * @param {string | string[]} body body
+	 * @returns {string} basic function
+	 */
+	basicFunction(args, body) {
+		return this.supportsArrowFunction()
+			? `(${args}) => {\n${Template.indent(body)}\n}`
+			: `function(${args}) {\n${Template.indent(body)}\n}`;
+	}
+
+	/**
+	 * Returns result expression.
+	 * @param {(string | { expr: string })[]} args args
+	 * @returns {string} result expression
+	 */
+	concatenation(...args) {
+		const len = args.length;
+
+		if (len === 2) return this._es5Concatenation(args);
+		if (len === 0) return '""';
+		if (len === 1) {
+			return typeof args[0] === "string"
+				? JSON.stringify(args[0])
+				: `"" + ${args[0].expr}`;
+		}
+		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)
+
+		let templateCost = 0;
+		let concatenationCost = 0;
+
+		let lastWasExpr = false;
+		for (const arg of args) {
+			const isExpr = typeof arg !== "string";
+			if (isExpr) {
+				templateCost += 3;
+				concatenationCost += lastWasExpr ? 1 : 4;
+			}
+			lastWasExpr = isExpr;
+		}
+		if (lastWasExpr) concatenationCost -= 3;
+		if (typeof args[0] !== "string" && typeof args[1] === "string") {
+			concatenationCost -= 3;
+		}
+
+		if (concatenationCost <= templateCost) return this._es5Concatenation(args);
+
+		return `\`${args
+			.map((arg) => (typeof arg === "string" ? arg : `\${${arg.expr}}`))
+			.join("")}\``;
+	}
+
+	/**
+	 * Returns result expression.
+	 * @param {(string | { expr: string })[]} args args (len >= 2)
+	 * @returns {string} result expression
+	 * @private
+	 */
+	_es5Concatenation(args) {
+		const str = args
+			.map((arg) => (typeof arg === "string" ? JSON.stringify(arg) : arg.expr))
+			.join(" + ");
+
+		// when the first two args are expression, we need to prepend "" + to force string
+		// concatenation instead of number addition.
+		return typeof args[0] !== "string" && typeof args[1] !== "string"
+			? `"" + ${str}`
+			: str;
+	}
+
+	/**
+	 * Expression function.
+	 * @param {string} expression expression
+	 * @param {string} args arguments
+	 * @returns {string} expression function code
+	 */
+	expressionFunction(expression, args = "") {
+		return this.supportsArrowFunction()
+			? `(${args}) => (${expression})`
+			: `function(${args}) { ${expression}; }`;
+	}
+
+	/**
+	 * Returns empty function code.
+	 * @returns {string} empty function code
 	 */
 	emptyFunction() {
+		// `x => {}` over `() => {}`: a minifier keeps the parameter, so the named
+		// one is a byte shorter.
 		return this.supportsArrowFunction() ? "x => {}" : "function() {}";
 	}
 
@@ -462,6 +1487,19 @@ class RuntimeTemplate {
 		return `typeof process !== "undefined" && typeof process.getBuiltinModule === "function" && ${getter}`;
 	}
 
+	/**
+	 * Renders a `then` callback calling `fn` with `args`. An arrow keeps the `this`
+	 * a method call gives; the bound form is shorter without arrows.
+	 * @param {string} fn callee, a member of `__webpack_require__` or itself
+	 * @param {string} args arguments
+	 * @returns {string} callback expression
+	 */
+	deferredCall(fn, args) {
+		return this.supportsArrowFunction()
+			? this.returningFunction(`${fn}(${args})`)
+			: `${fn}.bind(${RuntimeGlobals.require}, ${args})`;
+	}
+
 	/**
 	 * Renders an object-literal method, using method shorthand when supported
 	 * and falling back to a `prop: function/arrow` property otherwise.
@@ -936,8 +1974,8 @@ class RuntimeTemplate {
 		const exportsType = module.getExportsType(chunkGraph.moduleGraph, strict);
 
 		const isModuleDeferred =
-			(dependency instanceof getHarmonyImportDependency() ||
-				dependency instanceof getImportDependency()) &&
+			(dependency instanceof HarmonyImportDependency ||
+				dependency instanceof ImportDependency) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
 			!(/** @type {BuildMeta} */ (module.buildMeta).async);
 
@@ -952,6 +1990,9 @@ class RuntimeTemplate {
 				(m) => chunkGraph.getModuleId(m)
 			).filter((id) => id !== null);
 			if (asyncDeps.length) {
+				runtimeRequirements.add(
+					RuntimeGlobals.deferredModuleAsyncTransitiveDependencies
+				);
 				if (header) {
 					appending = `.then(${this.basicFunction(
 						"",
@@ -967,7 +2008,10 @@ class RuntimeTemplate {
 						}(${JSON.stringify(asyncDeps)})`
 					)})`;
 				}
-				appending += `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+				appending += `.then(${this.deferredCall(
+					RuntimeGlobals.makeDeferredNamespaceObject,
+					`${comment}${idExpr}, ${mode}`
+				)})`;
 			} else if (header) {
 				appending = `.then(${this.basicFunction(
 					"",
@@ -975,7 +2019,10 @@ class RuntimeTemplate {
 				)})`;
 			} else {
 				runtimeRequirements.add(RuntimeGlobals.require);
-				appending = `.then(${RuntimeGlobals.makeDeferredNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${mode}))`;
+				appending = `.then(${this.deferredCall(
+					RuntimeGlobals.makeDeferredNamespaceObject,
+					`${comment}${idExpr}, ${mode}`
+				)})`;
 			}
 		} else {
 			let fakeType = 16;
@@ -995,7 +2042,10 @@ class RuntimeTemplate {
 						)})`;
 					} else {
 						runtimeRequirements.add(RuntimeGlobals.require);
-						appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+						appending = `.then(${this.deferredCall(
+							RuntimeGlobals.require,
+							`${comment}${idExpr}`
+						)})`;
 					}
 					break;
 				case "dynamic":
@@ -1021,7 +2071,10 @@ class RuntimeTemplate {
 							)})`;
 						} else {
 							runtimeRequirements.add(RuntimeGlobals.require);
-							appending = `.then(${RuntimeGlobals.require}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}))`;
+							appending = `.then(${this.deferredCall(
+								RuntimeGlobals.require,
+								`${comment}${idExpr}`
+							)})`;
 						}
 						appending += `.then(${this.returningFunction(
 							`${RuntimeGlobals.createFakeNamespaceObject}(m, ${fakeType})`,
@@ -1042,7 +2095,10 @@ class RuntimeTemplate {
 								`${header}return ${returnExpression};`
 							)})`;
 						} else {
-							appending = `.then(${RuntimeGlobals.createFakeNamespaceObject}.bind(${RuntimeGlobals.require}, ${comment}${idExpr}, ${fakeType}))`;
+							appending = `.then(${this.deferredCall(
+								RuntimeGlobals.createFakeNamespaceObject,
+								`${comment}${idExpr}, ${fakeType}`
+							)})`;
 						}
 					}
 					break;
@@ -1170,14 +2226,17 @@ class RuntimeTemplate {
 		let importContent;
 
 		const isModuleDeferred =
-			(dependency instanceof getHarmonyImportDependency() ||
-				dependency instanceof getImportDependency()) &&
+			(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,
@@ -1259,10 +2318,10 @@ class RuntimeTemplate {
 		);
 
 		const isModuleDeferred =
-			(dependency instanceof getHarmonyImportDependency() ||
-				dependency instanceof getImportDependency()) &&
+			(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),
@@ -1416,7 +2475,6 @@ class RuntimeTemplate {
 		if (
 			exportsType === "namespace" &&
 			mangleableNamespace &&
-			this.compilation &&
 			this.compilation.options.optimization.mangleExports
 		) {
 			const materialized = this._materializedNamespaceObject({
@@ -1542,19 +2600,20 @@ class RuntimeTemplate {
 			message,
 			chunkName: block.chunkName
 		});
-		// A `fetchPriority` hint rides on the runtime `ensureChunk(id, priority)` call;
-		// the analyzable literal `import()` can't carry it, so keep the runtime form.
+		// `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 = fetchPriority
-				? null
-				: this._analyzableChunkImport(
-						chunks[0],
-						comment,
-						runtimeRequirements,
-						originModule,
-						chunkGraph
-					);
+			const analyzable = this.analyzableChunkImport(
+				chunks[0],
+				comment,
+				runtimeRequirements,
+				originModule,
+				chunkGraph
+			);
 			if (analyzable !== null) {
 				return analyzable;
 			}
@@ -1569,10 +2628,6 @@ class RuntimeTemplate {
 				fetchPriority ? `, ${JSON.stringify(fetchPriority)}` : ""
 			})`;
 		} else if (chunks.length > 0) {
-			if (fetchPriority) {
-				runtimeRequirements.add(RuntimeGlobals.hasFetchPriority);
-			}
-
 			let needEnsureChunk = false;
 			/**
 			 * Analyzable `import()` for a solely-owned JS chunk, else runtime ensureChunk.
@@ -1580,15 +2635,13 @@ class RuntimeTemplate {
 			 * @returns {string} require chunk id code
 			 */
 			const requireChunkId = (chunk) => {
-				const analyzable = fetchPriority
-					? null
-					: this._analyzableChunkImport(
-							chunk,
-							"",
-							runtimeRequirements,
-							originModule,
-							chunkGraph
-						);
+				const analyzable = this.analyzableChunkImport(
+					chunk,
+					"",
+					runtimeRequirements,
+					originModule,
+					chunkGraph
+				);
 				if (analyzable !== null) return analyzable;
 				needEnsureChunk = true;
 				return `${RuntimeGlobals.ensureChunk}(${JSON.stringify(chunk.id)}${
@@ -1598,12 +2651,32 @@ class RuntimeTemplate {
 			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;
+			}
+		}
+		return false;
+	}
+
 	/**
 	 * For ESM module output, load a single statically-named chunk through the
 	 * `analyzableChunkImport` helper — a literal `import("./chunk.js")` other bundlers
@@ -1612,75 +2685,34 @@ class RuntimeTemplate {
 	 * @param {Chunk} chunk the chunk to load
 	 * @param {string} comment leading comment (chunk name / message)
 	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
-	 * @param {Module=} originModule the module the `import()` is emitted into
-	 * @param {ChunkGraph=} chunkGraph the chunk graph
+	 * @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(
+	analyzableChunkImport(
 		chunk,
 		comment,
 		runtimeRequirements,
 		originModule,
 		chunkGraph
 	) {
-		const { outputOptions } = this;
+		// `blockPromise` has already dropped any chunk without an id. Without an origin
+		// there is nothing the specifier could be relative to.
 		if (
-			!outputOptions.module ||
-			outputOptions.chunkFormat !== "module" ||
-			outputOptions.importFunctionName !== "import" ||
-			chunk.id === null ||
 			!originModule ||
-			!chunkGraph
+			!this.supportsAnalyzable("import", chunkGraph, originModule)
 		) {
 			return null;
 		}
-		// HMR wraps `ensureChunk` (`.e`) to track in-flight loads and relies on it being
-		// present in the runtime; the analyzable `import()` (`.ei`) replaces `.e` and would
-		// leave a lazy-compilation proxy's own `.e` call undefined, so keep the runtime form.
-		// A runtime `__webpack_public_path__` override likewise can't reach a baked literal.
-		if (
-			this.compilation.dependencyFactories.has(
-				getModuleHotAcceptDependency()
-			) ||
-			getAPIPlugin().usesRuntimePublicPathOverride(this.compilation)
-		) {
-			return null;
-		}
-		// A worker entry loads its own chunks through the worker runtime; keep that path.
-		for (const originChunk of chunkGraph.getModuleChunksIterable(
-			originModule
-		)) {
-			const entryOptions = originChunk.getEntryOptions();
-			if (entryOptions && entryOptions.worker) {
-				return null;
-			}
-		}
-		// Only a chunk that is loaded solely through this `import()` and holds pure JS:
-		// a shared chunk (splitChunks / module federation) or one with css/wasm/other
-		// assets needs the runtime's deduplication and per-type loaders, so keep it.
-		if (chunk.getNumberOfGroups() !== 1) {
-			return null;
-		}
-		// Prefetch/preload children (incl. CSS-only preload) are injected by the runtime
-		// `.f` handlers when the chunk loads, which the analyzable `import()` bypasses —
-		// keep the runtime form for them.
-		if (
-			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
-			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
-			chunk.hasChildByOrder(chunkGraph, "cssPreload", true)
-		) {
-			return null;
-		}
-		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-			// Module federation (remote/shared/provide) loads through its own runtime.
-			if (FEDERATION_MODULE_TYPES.has(module.type)) {
-				return null;
-			}
-			for (const type of chunkGraph.getModuleSourceTypes(module)) {
-				if (type !== JAVASCRIPT_TYPE && type !== RUNTIME_TYPE) {
-					return null;
-				}
-			}
+		// `.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
+			);
 		}
 		// Relative to the consuming chunk (`import.meta.url`) for `auto`, else an
 		// absolute publicPath prefix.
@@ -1690,60 +2722,609 @@ class RuntimeTemplate {
 			originModule,
 			chunkGraph
 		);
+		if (specifier === null) {
+			return null;
+		}
 		// `import()` needs a resolvable specifier — relative (`./`, `../`), absolute (`/`)
-		// or a URL scheme. A bare one (empty/relative publicPath) is treated as a package,
-		// so keep the runtime form. (`new URL(...)` callers accept bare, resolving vs base.)
+		// 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 (
-			specifier === null ||
-			!/^"(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(specifier)
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
+			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
+			chunk.hasChildByOrder(chunkGraph, "cssPreload", true) ||
+			this._chunkLoadsBeyondJs(chunk, chunkGraph)
 		) {
-			return null;
+			runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
 		}
-		runtimeRequirements.add(RuntimeGlobals.analyzableChunkImport);
 		// 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
-		)}, () => import(${comment}${specifier}))`;
+		)}, ${this.returningFunction(`import(${comment}${resolvableSpecifier})`)})`;
+	}
+
+	/**
+	 * Whether this chunk's hash settles before every chunk a stand-in would land in.
+	 * That is what makes a baked name readable from the consuming chunk's own hash, and
+	 * it is the tie-break that lets one direction of a cycle bake — `createHash` fixes a
+	 * total order, so the answer is the same in every build.
+	 * @param {Chunk} chunk the referenced chunk
+	 * @param {Iterable<Chunk>} targets the chunks the stand-in is written into
+	 * @returns {boolean} true when this one may bake and the others may not
+	 */
+	_namesBeforeAll(chunk, targets) {
+		if (chunk.id === null) return false;
+		for (const target of targets) {
+			if (!this._hashesBefore(chunk, target)) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * Whether `createHash` settles `chunk`'s hash before `target`'s: rounds first, then
+	 * id inside a round. The runtime round is ordered by references between its chunks
+	 * rather than by id, which the guard below sidesteps by reading no hash from one.
+	 * @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
+	 */
+	_hashesBefore(chunk, target) {
+		if (chunk === target || target.id === null) return false;
+		// One settling after the compilation hash is read only by one settling later.
+		// Before the marks exist, the answer is the one the marking will bring about.
+		if (this._chunksBakingFullHash !== undefined) {
+			const late = this._settlesLate(chunk);
+			if (late !== this._settlesLate(target)) return !late;
+		}
+		const chunkGraph = /** @type {ChunkGraph} */ (this.compilation.chunkGraph);
+		const round = hashRound(chunk, chunkGraph);
+		const targetRound = hashRound(target, chunkGraph);
+		if (round !== targetRound) return round < targetRound;
+		// The runtime round is ordered by references between its chunks rather than by
+		// id: an async entrypoint the target reaches is settled before it, which is the
+		// only order that round fixes — a worker's chunk against the one spawning it.
+		if (round === RUNTIME_HASH_ROUND) {
+			for (const entrypoint of target.getAllReferencedAsyncEntrypoints()) {
+				const { chunks } = entrypoint;
+				if (chunks[chunks.length - 1] === chunk) return true;
+			}
+			return false;
+		}
+		return (
+			compareIds(
+				/** @type {ChunkId} */ (chunk.id),
+				/** @type {ChunkId} */ (target.id)
+			) < 0
+		);
+	}
+
+	/**
+	 * 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
+	 * graph, which by then says so exactly: a chunk reaches that round by carrying a
+	 * full-hash runtime module, or by being put there by `_markChunksSettlingLate`.
+	 * @param {Chunk} chunk the chunk
+	 * @returns {boolean} true when its hash is taken last
+	 */
+	_settlesLate(chunk) {
+		return (
+			/** @type {ChunkGraph} */
+			(this.compilation.chunkGraph).getChunkFullHashModulesIterable(chunk) !==
+			undefined
+		);
 	}
 
 	/**
-	 * Computes the `../`-path from the consuming module's chunk(s) back to the output
-	 * root, so a chunk or asset can be referenced relative to `import.meta.url`. Returns
-	 * `null` when the module lives in chunks of different depths (no single path works).
-	 * @param {Module} module the consuming module
+	 * Whether this chunk's name is settled only once the compilation hash exists, because
+	 * the deferred pass writes that hash into its bytes. Marking it puts it in
+	 * `createHash`'s full-hash round, where the name is taken again afterwards — which is
+	 * what a chunk needing `__webpack_require__.p` gets for free, and what one that bakes
+	 * the same text instead has to be given.
+	 * @param {Chunk} chunk the chunk
+	 * @returns {boolean} true when it was marked
+	 */
+	_bakesFullHash(chunk) {
+		return (
+			this._chunksBakingFullHash !== undefined &&
+			this._chunksBakingFullHash.has(chunk)
+		);
+	}
+
+	/**
+	 * Finds the chunks whose bytes will carry the compilation hash and puts each in
+	 * `createHash`'s full-hash round, so its name is taken after that hash exists rather
+	 * than before. Read off what was generated rather than off what asked for it: a
+	 * module restored from the persistent cache carries a stand-in without being
+	 * generated again, and the token it carries is the whole question.
+	 * @returns {void}
+	 */
+	_markChunksSettlingLate() {
+		this._chunksBakingFullHash = new Set();
+		const { compilation } = this;
+		const chunkGraph = /** @type {ChunkGraph} */ (compilation.chunkGraph);
+		const results = compilation.codeGenerationResults;
+		if (results === undefined) return;
+		/** @type {Map<Chunk, Set<string>>} */
+		const namesBaked = new Map();
+		this._namesBakedInto = namesBaked;
+		/** @type {Map<string, Chunk>} */
+		const chunksById = new Map();
+		this._chunksByIdForFold = chunksById;
+		for (const chunk of compilation.chunks) {
+			if (chunk.id !== null) chunksById.set(String(chunk.id), chunk);
+		}
+		for (const chunk of compilation.chunks) {
+			// One whose name does not move with its content has nothing to settle late.
+			if (this._chunkNameIndependentOfContent(chunk)) continue;
+			const demand = this._analyzableDemandOf(chunk, results, chunkGraph);
+			if (demand === null) continue;
+			if (demand.carriesFullHash) {
+				this._chunksBakingFullHash.add(chunk);
+				chunkGraph.attachFullHashModules(chunk, []);
+			}
+			if (demand.names.size > 0) namesBaked.set(chunk, demand.names);
+		}
+		// A late name makes the name it is baked into late too, and that one may be
+		// baked further up — so this runs to a fixed point.
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const [chunk, names] of namesBaked) {
+				if (this._settlesLate(chunk)) continue;
+				for (const id of names) {
+					const other = chunksById.get(id);
+					if (other === undefined || !this._settlesLate(other)) continue;
+					chunkGraph.attachFullHashModules(chunk, []);
+					changed = true;
+					break;
+				}
+			}
+		}
+	}
+
+	/**
+	 * What the deferred pass will write into this chunk: whether any of it is built from
+	 * the compilation hash, and which chunks it names. Read off what was generated rather
+	 * than off what asked for it — a module restored from the persistent cache carries a
+	 * stand-in without being generated again, and the stand-in spells its own recipe.
+	 * @param {Chunk} chunk the chunk
+	 * @param {CodeGenerationResults} results this compilation's generated code
 	 * @param {ChunkGraph} chunkGraph the chunk graph
-	 * @returns {string | null} relative undo path, or `null` when ambiguous
+	 * @returns {{ carriesFullHash: boolean, names: Set<string> } | null} what it writes,
+	 * or `null` where nothing is written
 	 */
-	_getModuleUndoPath(module, chunkGraph) {
+	_analyzableDemandOf(chunk, results, chunkGraph) {
+		const modules = chunkGraph.getChunkModulesIterableBySourceType(
+			chunk,
+			JAVASCRIPT_TYPE
+		);
+		if (modules === undefined) return null;
+		let carriesFullHash = false;
+		/** @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);
+			const content = source && source.source();
+			if (typeof content !== "string") continue;
+			if (this._hasReservedFullHash(content)) {
+				carriesFullHash = true;
+				found = true;
+			}
+			/** @type {RegExpExecArray | null} */
+			let match;
+			while ((match = regexp.exec(content)) !== null) {
+				const parts = RuntimeTemplate._readAnalyzableSpecifier(match[1]);
+				if (parts === null) continue;
+				found = true;
+				for (const [kind, value] of parts) {
+					if (FULL_HASH_PART_KINDS.has(kind)) {
+						carriesFullHash = true;
+					} else if (CHUNK_SPECIFIER_PART_KINDS.has(kind)) {
+						names.add(String(value));
+					}
+				}
+			}
+		}
+		return found ? { carriesFullHash, names } : null;
+	}
+
+	/**
+	 * Whether everything in front of a chunk's filename is text the fold can account for.
+	 * `literal` is already in the chunk's modules, and `undo` is the `../` depth of the
+	 * asset it lands in, which `_chunkPlacement` reads off the filename template with the
+	 * hashes neutralized — so both are known while that chunk is hashed. A public path or
+	 * a template is not: it resolves against the compilation hash, which by then is still
+	 * being built out of this very hash.
+	 * @param {SpecifierPart[]} prefix what goes in front of the filename
+	 * @param {Iterable<Chunk>} chunks the chunks the stand-in is written into
+	 * @returns {boolean} true when the filename is all that is left to account for
+	 */
+	_foldsWholeName(prefix, chunks) {
+		for (const [kind] of prefix) {
+			if (kind === "literal") continue;
+			if (kind !== "undo") return false;
+			// An `undo` resolves to each asset's own depth, so every chunk it may land in
+			// has to have one this can be sure of.
+			for (const chunk of chunks) {
+				if (this._chunkPlacement(chunk).undo === null) return false;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Folds the names this chunk will have filled in by the deferred pass into its own
+	 * hash, so a name taken from that hash already stands for the bytes the fill leaves
+	 * behind — what lets a chunk named by `[chunkhash]`, or by `[contenthash]` with
+	 * nothing to repair it afterwards, hold a baked reference at all. The same thing
+	 * `RuntimeModule.dependentHash` does for the runtime form of the reference.
+	 *
+	 * Asked of every chunk whose name could move, and answered from the chunk graph
+	 * rather than from what was generated: a module restored from the persistent cache
+	 * carries a stand-in without being generated again. That over-counts a chunk whose
+	 * reference kept the runtime form, which costs a hash that changes when it needn't —
+	 * never a name that stays put while the bytes move.
+	 * Memoized because `createHash` asks twice — once for `chunk.hash` and once for
+	 * `chunk.contentHash` — and nothing an earlier chunk contributes moves between the
+	 * two, while the walk behind the answer is over everything the chunk reaches.
+	 * @param {Chunk} chunk the chunk being hashed
+	 * @param {Hash} hash its hash
+	 * @returns {void}
+	 */
+	_foldAnalyzableNames(chunk, hash) {
+		// Nothing to bring back in line where the name does not move with the content,
+		// and folding there would move hashes that are settled correctly today.
+		if (this._chunkNameIndependentOfContent(chunk)) return;
+		// A chunk baking the compilation hash is asked twice with different answers —
+		// once before that hash exists and once in the round that follows it — so the
+		// memo would hand back the first one.
+		const bakesFullHash = this._bakesFullHash(chunk);
+		// A chunk settling late is asked once in its normal round and again in that one,
+		// where what it reads has moved on, so the memo would hand back the first answer.
+		const late = bakesFullHash || this._settlesLate(chunk);
+		let folded = late ? undefined : this._foldedAnalyzableNames.get(chunk);
+		if (folded === undefined) {
+			const { compilation } = this;
+			const { outputOptions } = compilation;
+			// Read back off what was generated: walking the graph would fold in whatever
+			// the group reaches, moving a split chunk that references nothing.
+			const named = this._namesBakedInto && this._namesBakedInto.get(chunk);
+			/** @type {Set<Chunk>} */
+			const reachable = new Set();
+			for (const id of named || []) {
+				const referenced =
+					this._chunksByIdForFold && this._chunksByIdForFold.get(id);
+				if (referenced !== undefined) reachable.add(referenced);
+			}
+			// Its own `../` depth, which an `undo` stand-in in it resolves to. Constant per
+			// chunk, but the bytes still move with it, so the name has to as well.
+			const { undo } = this._chunkPlacement(chunk);
+			const names = [undo === null ? "" : undo];
+			// What the fill will write in place of every compilation-hash stand-in. Read
+			// here rather than folded in as text elsewhere, because this is the one round
+			// where it exists before the name is taken.
+			if (bakesFullHash && compilation.hash !== undefined) {
+				names.push(compilation.hash);
+			}
+			for (const referenced of reachable) {
+				if (!this._hashesBefore(referenced, chunk)) continue;
+				let byType = this._analyzableAssetNames.get(referenced);
+				if (byType === undefined) {
+					byType = new Map();
+					this._analyzableAssetNames.set(referenced, byType);
+				}
+				for (const [contentHashType, naming] of CHUNK_ASSET_NAMING) {
+					// No hash of that type is no asset of that type, so nothing names one.
+					if (referenced.contentHash[contentHashType] === undefined) continue;
+					let name = byType.get(contentHashType);
+					if (name === undefined) {
+						// The very call the fill makes, so what is folded in is what lands
+						// there — a filename function included, which resolves to a name here
+						// either way. Settled once: the hash it reads is, by `_hashesBefore`.
+						name = compilation.getPath(
+							naming.template(referenced, outputOptions),
+							{
+								chunk: referenced,
+								runtime: referenced.runtime,
+								contentHashType
+							}
+						);
+						byType.set(contentHashType, name);
+					}
+					names.push(name);
+				}
+			}
+			folded = names.join("\n");
+			if (!late) this._foldedAnalyzableNames.set(chunk, folded);
+		}
+		if (folded !== "") hash.update(folded);
+	}
+
+	/**
+	 * Drops what the fold cached, once `createHash` is done and nothing reads it again.
+	 * Replaced rather than emptied: a `WeakMap` has no `clear`.
+	 * @returns {void}
+	 */
+	_releaseAnalyzableNameCaches() {
+		this._foldedAnalyzableNames = new WeakMap();
+		this._analyzableAssetNames = new WeakMap();
+		this._namesBakedInto = undefined;
+		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
+	 * stale in. Resolved through concatenation first: it may have absorbed the module
+	 * that wrote the reference, and an absorbed one is in no chunk at all.
+	 * @param {Module} module the module a reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {Iterable<Chunk>} the chunks holding it
+	 */
+	_moduleChunks(module, chunkGraph) {
+		return chunkGraph.getModuleChunksIterable(
+			getConcatenatedModule().getChunkGraphModule(this.compilation, module)
+		);
+	}
+
+	/**
+	 * The `../` path back out of a public path that needs a base, which is where the
+	 * chunk loader puts what it fetches. Reads nothing but `output`, so it is answered
+	 * once: `""` where the path adds no depth, `null` where its shape is unknown.
+	 * @returns {string | null} the path back out of it
+	 */
+	_publicPathClimb() {
+		if (this._publicPathClimbText === undefined) {
+			const shape = this._publicPathShape();
+			const undo =
+				shape === undefined
+					? null
+					: getUndoPath(
+							`${shape}x`,
+							/** @type {string} */ (this.outputOptions.path),
+							true
+						);
+			this._publicPathClimbText = undo === "./" ? "" : undo;
+		}
+		return this._publicPathClimbText;
+	}
+
+	/**
+	 * Where a literal emitted into a chunk is read from: the `../` path back to the
+	 * output root, and whether the chunk loader fetched the chunk through
+	 * `output.publicPath` — such a chunk sits one public path below the root the runtime
+	 * resolves against, where an initial chunk the host fetched does not. Reads only the
+	 * chunk, so it is memoized on it and shared by every module in it.
+	 * @param {Chunk} chunk a chunk a reference is written into
+	 * @returns {Placement} where a literal in it is read from
+	 */
+	_chunkPlacement(chunk) {
+		const cached = this._placementByChunk.get(chunk);
+		if (cached !== undefined) return cached;
 		const { compilation } = this;
 		const { outputOptions } = compilation;
-		const outputPath = /** @type {string} */ (outputOptions.path);
-		/** @type {string | null} */
-		let result = null;
-		let found = false;
-		for (const chunk of chunkGraph.getModuleChunksIterable(module)) {
-			const template = getJavascriptModulesPlugin().getChunkFilenameTemplate(
+		const shape = this._chunkNameShape(chunk);
+		const chunkName =
+			shape === null
+				? null
+				: compilation.getPath(shape, {
+						chunk,
+						runtime: chunk.runtime,
+						contentHashType: JAVASCRIPT_TYPE
+					});
+		const placement = {
+			// A name whose shape is unknown has an unknown depth, and the deferred pass
+			// reads the real one off the asset it lands in.
+			undo:
+				chunkName === null
+					? null
+					: getUndoPath(
+							chunkName,
+							/** @type {string} */ (outputOptions.path),
+							true
+						),
+			// A chunk in an initial group and an async one both is served at two urls,
+			// one public path apart, so no one literal in it is right for both.
+			loaded: chunk.isOnlyInitial() ? false : chunk.canBeInitial() ? null : true
+		};
+		this._placementByChunk.set(chunk, placement);
+		return placement;
+	}
+
+	/**
+	 * The chunk's filename with every hash neutralized, which is all the `../` depth
+	 * needs — hashes are not settled when this is asked and sit in the basename anyway.
+	 * A function is asked for the template it returns rather than handed to `getPath`,
+	 * which would have to resolve a placeholder in it against a hash that does not exist
+	 * yet; one that builds the name out of a hash itself gets a stand-in to build from.
+	 * @param {Chunk} chunk the chunk
+	 * @returns {string | null} the shape, or `null` where it cannot be known
+	 */
+	_chunkNameShape(chunk) {
+		const template = JavascriptModulesPlugin.getChunkFilenameTemplate(
+			chunk,
+			this.outputOptions
+		);
+		if (typeof template === "string") {
+			return template.replace(HASH_IN_FILENAME_GLOBAL, "x");
+		}
+		try {
+			return probeTemplateName(
+				template,
 				chunk,
-				outputOptions
-			);
-			const chunkName = compilation.getPath(
-				// Hashes aren't known during code generation and only sit in the basename
-				// (never a directory), so neutralize them — only the `../` depth matters.
-				typeof template === "string"
-					? template.replace(HASH_IN_FILENAME_GLOBAL, "x")
-					: template,
-				{ chunk, contentHashType: JAVASCRIPT_TYPE }
-			);
-			const undo = getUndoPath(chunkName, outputPath, true);
-			if (!found) {
-				result = undo;
-				found = true;
-			} else if (result !== undo) {
-				return null;
+				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.
+			return null;
+		}
+	}
+
+	/**
+	 * 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.
+	 * @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
+	 */
+	chunkRootOutputDir(chunk, enforceRelative) {
+		const shape = this._chunkNameShape(chunk);
+		const name = this.compilation.getPath(
+			shape === null
+				? JavascriptModulesPlugin.getChunkFilenameTemplate(
+						chunk,
+						this.outputOptions
+					)
+				: shape,
+			{ chunk, contentHashType: JAVASCRIPT_TYPE }
+		);
+		return getUndoPath(
+			name,
+			/** @type {string} */ (this.outputOptions.path),
+			enforceRelative
+		);
+	}
+
+	/**
+	 * The one answer every chunk holding a reference agrees on, with either half `null`
+	 * where they do not — then no one literal is right for all of them.
+	 * @param {Module} module the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {Placement} where a literal in it is read from
+	 */
+	_modulePlacement(module, chunkGraph) {
+		return this._placementOf(this._moduleChunks(module, chunkGraph));
+	}
+
+	/**
+	 * Whether each of these chunks is served one way — either the host fetched it or the
+	 * loader did, not both. One that is both is at two urls a public path apart with no
+	 * answer of its own, which no per-asset stand-in can supply.
+	 * @param {Iterable<Chunk>} chunks the chunks a literal is written into
+	 * @returns {boolean} true when each has an answer to give
+	 */
+	_eachChunkServedOneWay(chunks) {
+		for (const chunk of chunks) {
+			if (this._chunkPlacement(chunk).loaded === null) return false;
+		}
+		return true;
+	}
+
+	/**
+	 * The one answer every chunk in `chunks` agrees on, with either half `null` where
+	 * they do not.
+	 * @param {Iterable<Chunk>} chunks the chunks a literal is written into
+	 * @returns {Placement} where a literal in them is read from
+	 */
+	_placementOf(chunks) {
+		/** @type {Placement | undefined} */
+		let first;
+		/** @type {string | null} */
+		let undo = null;
+		/** @type {boolean | null} */
+		let loaded = null;
+		for (const chunk of chunks) {
+			const own = this._chunkPlacement(chunk);
+			if (first === undefined) {
+				first = own;
+				undo = own.undo;
+				loaded = own.loaded;
+				continue;
 			}
+			if (undo !== own.undo) undo = null;
+			if (loaded !== own.loaded) loaded = null;
 		}
-		return found ? result : null;
+		if (first === undefined) return NO_PLACEMENT;
+		// A module in one chunk — nearly all of them — hands back what that chunk said,
+		// so the common answer costs no object of its own.
+		return undo === first.undo && loaded === first.loaded
+			? first
+			: { 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
+	 * @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
+	) {
+		// 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,
+			runtimeRequirements
+		);
 	}
 
 	/**
@@ -1752,47 +3333,583 @@ class RuntimeTemplate {
 	 * statically — a content hash in the filename, or a dynamic/templated publicPath.
 	 * @param {string | undefined} overridePublicPath per-dependency public path (wins over `output.publicPath`)
 	 * @param {Chunk} chunk the chunk to reference
-	 * @param {Module} consumingModule the module the reference is emitted into
+	 * @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
-	 * @returns {string | null} a JS string literal, or `null` to fall back to the runtime form
+	 * @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
+	 * @returns {string | null} a JS string literal or expression, or `null` to fall back to the runtime form
 	 */
 	_getAnalyzableChunkSpecifier(
 		overridePublicPath,
 		chunk,
 		consumingModule,
-		chunkGraph
+		chunkGraph,
+		runtimeRequirements,
+		consumingChunks,
+		sourceType = JAVASCRIPT_TYPE
 	) {
 		const { compilation } = this;
 		const { outputOptions } = compilation;
-		const filenameTemplate =
-			getJavascriptModulesPlugin().getChunkFilenameTemplate(
-				chunk,
-				outputOptions
+		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
+		);
+		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.
+		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
+				});
+		/**
+		 * @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
+		 */
+		const specifier = (prefix) => {
+			if (!deferred) {
+				const text = literalText(prefix);
+				if (text !== null) return toJsStringLiteral(text + filename);
+			}
+			if (!canReserve && !(canFold && this._foldsWholeName(prefix, chunks))) {
+				return cannotReserve();
+			}
+			return toJsStringLiteral(
+				this._reserveAnalyzableSpecifier([
+					...prefix,
+					[naming.standIn, /** @type {ChunkId} */ (chunk.id)]
+				])
+			);
+		};
+		if (overridePublicPath) {
+			const resolved = this._resolvePublicPathPrefix(
+				overridePublicPath,
+				consumingModule,
+				chunks
 			);
+			return resolved === null ? null : specifier(resolved);
+		}
+		const { publicPath } = outputOptions;
+		if (publicPath === "auto") {
+			const { undo } = this._placementOf(chunks);
+			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)}`;
+		}
+		const prefix = this._analyzablePathPrefix(
+			consumingModule,
+			chunkGraph,
+			chunks
+		);
+		return prefix === null ? null : specifier(prefix);
+	}
+
+	/**
+	 * 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.
+	 * One that needs a base is read from the output root, so the `../` path back there
+	 * comes first — and is the whole answer again where the chunk loader fetched this
+	 * chunk through that same path, since climbing out of it only to spell it again
+	 * names the place it started from. An entry `baseUri` sits between the two, so
+	 * there both are written. Never asked of an `auto` public path, which is no path
+	 * to walk back over.
+	 * @param {Module | undefined} module the module the reference is emitted into
+	 * @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
+	 * @returns {SpecifierPart[] | null} the parts, or `null` having recorded why not
+	 */
+	_analyzablePathPrefix(module, chunkGraph, chunks, relativeBase) {
+		const publicPath = /** @type {PublicPath} */ (
+			this.outputOptions.publicPath
+		);
+		const shape = this._publicPathShape();
+		if (shape === undefined) return null;
+		const resolve = () =>
+			this._resolvePublicPathPrefix(publicPath, module, chunks);
+		if (isBaseIndependent(shape)) return resolve();
+		const { undo, loaded } = this._placementOf(chunks);
+		// 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();
+		const climb =
+			loaded === null ? (served === "" ? "" : null) : loaded ? served : "";
+		/** @type {SpecifierPart[]} */
+		const head = [undo === null ? ["undo", ""] : ["literal", undo]];
+		if (climb === null) {
+			// 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)) {
+				return this._analyzableBailout(module, SERVED_BAILOUT, null);
+			}
+			return [...head, ["unserved", ""]];
+		}
+		if (climb !== "" && relativeBase === undefined) return head;
+		const resolved = resolve();
+		if (resolved === null) return null;
+		if (climb !== "") head.push(["literal", climb]);
+		if (relativeBase !== undefined) head.push(["literal", relativeBase]);
+		head.push(...rootedParts(resolved));
+		return head;
+	}
+
+	/**
+	 * What a public path puts in front of a filename, as the parts it is built from.
+	 * A plain one is literal text. A templated one is resolved as far as code
+	 * generation can, leaving the compilation hash it may carry as a stand-in exactly
+	 * as `PublicPathRuntimeModule` resolves the same string once that hash exists — and
+	 * a hash re-encoded to another digest, which no stand-in can carry, is handed to
+	 * 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) {
+		if (typeof publicPath === "function") {
+			// One that answers nothing to a probe cannot be placed, absolute or not.
+			if (this._publicPathShape() === undefined) return null;
+			const resolved = this._resolveHashIndependent(
+				publicPath,
+				this._publicPathShape()
+			);
+			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;
+		}
+		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;
+		}
+		const literal = this.compilation.getPath(
+			publicPath,
+			this._deferredFullHashPathData()
+		);
+		return this._canDeferOrBakeFullHash(
+			this._hasReservedFullHash(literal),
+			chunks,
+			module
+		)
+			? [["literal", literal]]
+			: null;
+	}
+
+	/**
+	 * `output.publicPath` as the text it will have the shape of — a function's answer to
+	 * a stand-in hash, which says whether it is absolute even when its value is not
+	 * settled yet. `"auto"` reads as the empty string, which needs a base and so takes
+	 * the path that needs no answer; a function that answers nothing says nothing about
+	 * its shape either, and nothing may be built on it.
+	 * @returns {string | undefined} the shape of the public path
+	 */
+	_publicPathShape() {
+		if (this._publicPathShapeText === undefined) {
+			const { publicPath } = this.outputOptions;
+			if (typeof publicPath !== "function") {
+				this._publicPathShapeText = publicPath === "auto" ? "" : publicPath;
+			} else {
+				try {
+					this._publicPathShapeText = this.compilation.getPath(publicPath, {
+						hash: HASH_PROBE
+					});
+				} catch (_error) {
+					this._publicPathShapeText = false;
+				}
+			}
+		}
+		return this._publicPathShapeText === false
+			? undefined
+			: this._publicPathShapeText;
+	}
+
+	/**
+	 * A path built by a function, resolved to the value it will have — or `null` when
+	 * it moves with the compilation hash, which code generation does not know.
+	 * @param {import("./TemplatedPathPlugin").TemplatePathFn<EXPECTED_ANY>} fn the function
+	 * @param {string | undefined} value its answer to the first probe, or `undefined`
+	 * when it answered nothing
+	 * @returns {string | null} the settled value, or `null` when it is hash-dependent
+	 */
+	_resolveHashIndependent(fn, value) {
+		// The shape is this function's answer to the first probe, already taken and
+		// memoized, so only the second one is new here.
+		if (value === undefined) return null;
+		try {
+			return this.compilation.getPath(fn, { hash: HASH_PROBE_ALTERNATE }) ===
+				value
+				? value
+				: null;
+		} catch (_error) {
+			// One that needs more than a hash can't be resolved here.
+			return null;
+		}
+	}
+
+	/**
+	 * Static literal specifier (already quoted) for a `new URL(<here>, import.meta.url)`
+	 * pointing at an emitted file — an asset, or a wasm binary. The base is the asset the
+	 * reference sits in; the runtime form resolves against the output root instead, so a
+	 * public path that needs a base is put behind the `../` path back to that root rather
+	 * than baked as the whole prefix.
+	 * @param {Module} module the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {SpecifierPart[]} file the emitted file's name, relative to the output root
+	 * @param {boolean} bakePublicPath whether the public path belongs in the literal
+	 * @param {string=} relativeBase an entry `baseUri` the runtime reads against the
+	 * chunk, so it belongs between the path back to the output root and the public path
+	 * @returns {string | null} a quoted literal, or `null` to fall back
+	 */
+	_getAnalyzableFileSpecifier(
+		module,
+		chunkGraph,
+		file,
+		bakePublicPath,
+		relativeBase
+	) {
+		const { publicPath } = this.outputOptions;
+		const chunks = this._moduleChunks(module, chunkGraph);
+		if (bakePublicPath && publicPath !== "auto") {
+			const prefix = this._analyzablePathPrefix(
+				module,
+				chunkGraph,
+				chunks,
+				relativeBase
+			);
+			if (prefix === null) return null;
+			return this._specifierOf([...prefix, ...file], chunks, module);
+		}
+		// 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);
+		/** @type {SpecifierPart[]} */
+		const parts = [undo === null ? ["undo", ""] : ["literal", undo]];
+		if (relativeBase !== undefined) parts.push(["literal", relativeBase]);
+		parts.push(...file);
+		return this._specifierOf(parts, chunks, module);
+	}
+
+	/**
+	 * 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
+	 * 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.
+	 * @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
+	 */
+	analyzableCssChunkUrls(
+		runtimeChunk,
+		chunkGraph,
+		runtimeRequirements,
+		consumingModule
+	) {
+		const { chunkHasCss } = getCssModulesPlugin();
+		// An initial stylesheet is already in the document, but the hot path re-loads it
+		// by id like any other, so it needs a url here too.
+		const reachable = new Set([
+			...runtimeChunk.getAllReferencedChunks(),
+			...runtimeChunk.getAllInitialChunks()
+		]);
+		const chunks = [];
+		for (const chunk of reachable) {
+			if (chunkHasCss(chunk, chunkGraph)) chunks.push(chunk);
+		}
+		return this._analyzableChunkUrls(
+			chunks,
+			chunkGraph,
+			consumingModule,
+			[runtimeChunk],
+			CSS_TYPE,
+			runtimeRequirements
+		);
+	}
+
+	/**
+	 * 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
+	 * 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
+	 */
+	analyzableChunkScriptUrls(
+		runtimeChunk,
+		chunkGraph,
+		runtimeRequirements,
+		consumingModule
+	) {
+		// Only a child some order names reaches a handler. Every order counts, not the
+		// two that reach javascript today: an unknown one costs bytes, not a missing url.
+		const orders = runtimeChunk.getChildIdsByOrdersMap(
+			chunkGraph,
+			true,
+			JavascriptModulesPlugin.chunkHasJs
+		);
+		/** @type {Set<ChunkId>} */
+		const hinted = new Set();
+		for (const byParent of Object.values(orders)) {
+			for (const ids of Object.values(byParent)) {
+				for (const id of ids) hinted.add(id);
+			}
+		}
+		/** @type {Chunk[]} */
+		const chunks = [];
+		for (const chunk of runtimeChunk.getAllReferencedChunks()) {
+			if (hinted.has(/** @type {ChunkId} */ (chunk.id))) chunks.push(chunk);
+		}
+		return this._analyzableChunkUrls(
+			chunks,
+			chunkGraph,
+			consumingModule,
+			[runtimeChunk],
+			JAVASCRIPT_TYPE,
+			runtimeRequirements
+		);
+	}
+
+	/**
+	 * 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.
+	 * @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
+	 */
+	_analyzableChunkUrls(
+		chunks,
+		chunkGraph,
+		consumingModule,
+		consumingChunks,
+		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 (
-			typeof filenameTemplate !== "string" ||
-			HASH_IN_FILENAME.test(filenameTemplate)
+			runtimeRequirements.has(RuntimeGlobals.hmrDownloadUpdateHandlers) ||
+			!this.supportsAnalyzable("url-runtime", chunkGraph, consumingModule)
 		) {
 			return null;
 		}
-		const filename = compilation.getPath(filenameTemplate, {
-			chunk,
-			contentHashType: JAVASCRIPT_TYPE
-		});
-		if (overridePublicPath) {
-			return overridePublicPath.includes("[")
-				? null
-				: toJsStringLiteral(overridePublicPath + filename);
+		/** @type {Map<ChunkId, string>} */
+		const urls = new Map();
+		let complete = true;
+		for (const chunk of chunks) {
+			if (chunk.id === null) continue;
+			const specifier = this._getAnalyzableChunkSpecifier(
+				undefined,
+				chunk,
+				consumingModule,
+				chunkGraph,
+				undefined,
+				consumingChunks,
+				sourceType
+			);
+			// `_getAnalyzableChunkSpecifier` has already recorded why.
+			if (specifier === null) {
+				complete = false;
+				continue;
+			}
+			urls.set(chunk.id, `${this.importMetaUrl(specifier)}.href`);
 		}
-		const { publicPath } = outputOptions;
-		if (publicPath === "auto") {
-			const undo = this._getModuleUndoPath(consumingModule, chunkGraph);
-			return undo === null ? null : toJsStringLiteral(undo + filename);
+		return urls.size > 0 ? { urls, complete } : null;
+	}
+
+	/**
+	 * Static `new URL(<file>, import.meta.url)` for the binary emitted for an async wasm
+	 * module. Only called when `supportsAnalyzable("wasm")` holds.
+	 * @param {Module} module the async wasm module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @param {RuntimeSpec} runtime the runtime
+	 * @param {RuntimeRequirements} runtimeRequirements runtime requirements
+	 * @returns {string} expression evaluating to the binary's URL
+	 */
+	getAnalyzableWasmUrl(module, chunkGraph, runtime, runtimeRequirements) {
+		const { compilation } = this;
+		const template = /** @type {string} */ (
+			this.outputOptions.webassemblyModuleFilename
+		);
+		// The module's own hash and id are settled here, the compilation's is not — and
+		// a placeholder nothing answers is left in the name, so what comes back is either
+		// the final name or a template carrying only `[fullhash]`.
+		const filename = compilation.getPath(template, {
+			module,
+			runtime,
+			chunkGraph
+		});
+		// Only a fetched binary carries the public path: `readFile` addresses it relative
+		// to the chunk anyway. One needing a base is spelled as an asset url is.
+		const specifier = this._getAnalyzableFileSpecifier(
+			module,
+			chunkGraph,
+			[[filename.includes("[") ? "template" : "literal", filename]],
+			this._wasmModuleFetches(module, chunkGraph)
+		);
+		if (specifier !== null) return this.importMetaUrl(specifier);
+		// No bundler follows a concatenation, but this still sheds the module id and
+		// hash the runtime form would need.
+		runtimeRequirements.add(RuntimeGlobals.publicPath);
+		return this.importMetaUrl(
+			`${RuntimeGlobals.publicPath} + ${toJsStringLiteral(
+				compilation.getPath(template, {
+					module,
+					runtime,
+					chunkGraph,
+					...this._deferredFullHashPathData()
+				})
+			)}`
+		);
+	}
+
+	/**
+	 * The chunk filename template as a plain string. A function is called twice, with
+	 * a different stand-in hash each time; disagreeing answers mean the name depends on
+	 * a hash, which is not knowable during code generation, so it is left to the
+	 * deferred pass to ask again once the hashes are settled.
+	 * @param {ChunkFilenameTemplate} filenameTemplate the configured template
+	 * @param {Chunk} chunk the chunk being referenced
+	 * @param {string} contentHashType which of the chunk's hashes the name reads
+	 * @returns {string | undefined | null} the template, `undefined` to defer, or
+	 * `null` to fall back
+	 */
+	_resolveChunkFilenameTemplate(filenameTemplate, chunk, contentHashType) {
+		if (typeof filenameTemplate === "string") return filenameTemplate;
+		try {
+			// Everything the naming call is given except the hashes, so only a hash can
+			// make the two answers differ.
+			const template = probeTemplateName(
+				filenameTemplate,
+				chunk,
+				contentHashType,
+				HASH_PROBE,
+				true
+			);
+			const probe = probeTemplateName(
+				filenameTemplate,
+				chunk,
+				contentHashType,
+				HASH_PROBE_ALTERNATE,
+				false
+			);
+			return template === probe ? template : undefined;
+		} catch (_error) {
+			// Nothing to report: the probe is given strictly more than the naming call,
+			// so one that throws here throws there too and fails the build regardless.
+			return null;
 		}
-		if (typeof publicPath === "string" && !publicPath.includes("[")) {
-			return toJsStringLiteral(publicPath + filename);
+	}
+
+	/**
+	 * Whether `module`'s binary is read through `fetch`, the one loader the public path
+	 * reaches. Asked of its runtimes, not its chunks: only an entry names a loader.
+	 * @param {Module} module the async wasm module
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {boolean} true when every runtime reaching it fetches
+	 */
+	_wasmModuleFetches(module, chunkGraph) {
+		const { onlyFetching } = this._wasmGroups();
+		let placed = false;
+		for (const moduleRuntime of chunkGraph.getModuleRuntimes(module)) {
+			for (const group of this._wasmGroupsOf(moduleRuntime)) {
+				placed = true;
+				if (!onlyFetching.get(group)) return false;
+			}
 		}
-		return null;
+		// In no runtime at all nothing named a loader, so `output` answers.
+		return placed || this.outputOptions.wasmLoading === "fetch";
+	}
+
+	/**
+	 * The loader a chunk's WebAssembly is read with. An entry names one, and every
+	 * other chunk of the runtime is served by the one its entry asked for — so one
+	 * that is no entry answers with what `output` says.
+	 * @param {Chunk} chunk the chunk
+	 * @returns {WasmLoading} the loader it is served by
+	 */
+	_chunkWasmLoading(chunk) {
+		const entryOptions = chunk.getEntryOptions();
+		return entryOptions && entryOptions.wasmLoading !== undefined
+			? entryOptions.wasmLoading
+			: this.outputOptions.wasmLoading;
 	}
 
 	/**
@@ -1802,16 +3919,24 @@ class RuntimeTemplate {
 	 * @param {ChunkGraph} options.chunkGraph the chunk graph
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @param {string=} options.request request string used originally
+	 * @param {Module=} options.originModule the module the factory is emitted into
 	 * @returns {string} expression
 	 */
-	asyncModuleFactory({ block, chunkGraph, runtimeRequirements, request }) {
+	asyncModuleFactory({
+		block,
+		chunkGraph,
+		runtimeRequirements,
+		request,
+		originModule
+	}) {
 		const dep = block.dependencies[0];
 		const module = chunkGraph.moduleGraph.getModule(dep);
 		const ensureChunk = this.blockPromise({
 			block,
 			message: "",
 			chunkGraph,
-			runtimeRequirements
+			runtimeRequirements,
+			originModule
 		});
 		const factory = this.returningFunction(
 			this.moduleRaw({
@@ -1862,6 +3987,326 @@ class RuntimeTemplate {
 		runtimeRequirements.add(RuntimeGlobals.exports);
 		return `${RuntimeGlobals.makeNamespaceObject}(${exportsArgument});\n`;
 	}
+
+	/**
+	 * Reserves a name only the deferred pass can spell, as a stand-in that looks like a
+	 * relative specifier so the code around it needs no special case. It carries what it
+	 * resolves to rather than an index into per-build state — a module restored from the
+	 * persistent cache is never generated again.
+	 * @param {SpecifierPart[]} parts what the stand-in resolves to, in order
+	 * @returns {string} the stand-in to emit
+	 */
+	_reserveAnalyzableSpecifier(parts) {
+		return `./@@webpackAnalyzableChunk:${Buffer.from(JSON.stringify(parts))
+			.toString("base64")
+			.replace(/\+/g, "-")
+			.replace(/\//g, "_")
+			.replace(/[=]/g, "")}@@`;
+	}
+
+	/**
+	 * Whether text still carries a compilation-hash stand-in, so nothing may be resolved
+	 * against it here — the fill would land inside an already-resolved result.
+	 * @param {string} value text that may carry one
+	 * @returns {boolean} true when one is present
+	 */
+	_hasReservedFullHash(value) {
+		return value.includes(FULL_HASH_TOKEN_PREFIX);
+	}
+
+	/**
+	 * `getPath` data that leaves every compilation-hash placeholder as a stand-in while
+	 * the rest of the name resolves.
+	 * @returns {typeof DEFERRED_FULL_HASH_PATH_DATA} the path data
+	 */
+	_deferredFullHashPathData() {
+		return DEFERRED_FULL_HASH_PATH_DATA;
+	}
+
+	/**
+	 * Fills in the names reserved during code generation, once the hashes they are built
+	 * from exist: a chunk's own filename, and the compilation hash inside any other
+	 * emitted asset's. Replaces in place so the asset keeps its mappings, and runs before
+	 * anything reads it — `RealContentHashPlugin` still repairs each rewritten chunk's own
+	 * name later. Registered wherever `output.module` is read, since nothing reserves a
+	 * stand-in without it — a reservation cannot arrange this itself, as a module restored
+	 * from the cache carries one without being generated again.
+	 * @param {Compiler} compiler the compiler
+	 * @returns {void}
+	 */
+	static fillReservedNames(compiler) {
+		compiler.hooks.compilation.tap(PASS_NAME, (compilation) => {
+			const cache = compilation.getCache(PASS_NAME);
+			// Code generation is over, so what carries the compilation hash is settled and
+			// each such chunk can be moved into the round that follows that hash.
+			compilation.hooks.beforeHash.tap(PASS_NAME, () => {
+				compilation.runtimeTemplate._markChunksSettlingLate();
+			});
+			// Reaches both `chunk.hash` and `chunk.contentHash.javascript`, the two a
+			// filled-in name can leave behind.
+			JavascriptModulesPlugin.getCompilationHooks(compilation).chunkHash.tap(
+				PASS_NAME,
+				(chunk, hash) => {
+					compilation.runtimeTemplate._foldAnalyzableNames(chunk, hash);
+				}
+			);
+			// Nothing past hashing reads what the fold cached, and it holds a name per
+			// edge between chunks, so it is dropped rather than kept until seal.
+			compilation.hooks.afterHash.tap(PASS_NAME, () => {
+				compilation.runtimeTemplate._releaseAnalyzableNameCaches();
+			});
+			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.
+					stage: getCompilation().PROCESS_ASSETS_STAGE_DERIVED
+				},
+				async () => {
+					const { outputOptions } = compilation;
+					const fullHash = compilation.hash;
+					/** @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
+					 */
+					const chunkOf = (name) => {
+						if (chunkByAsset === undefined) {
+							chunkByAsset = new Map();
+							for (const chunk of compilation.chunks) {
+								for (const file of chunk.files) chunkByAsset.set(file, chunk);
+							}
+						}
+						return chunkByAsset.get(name);
+					};
+					/**
+					 * @param {string} value text that may carry compilation-hash stand-ins
+					 * @returns {string} the text with each of them filled in
+					 */
+					const fillFullHash = (value) => {
+						if (fullHash === undefined) return value;
+						FULL_HASH_TOKEN_REGEXP.lastIndex = 0;
+						return value.replace(FULL_HASH_TOKEN_REGEXP, (_match, length) =>
+							length === undefined
+								? fullHash
+								: fullHash.slice(0, Number(length))
+						);
+					};
+					/**
+					 * @param {string} payload the encoded half of a stand-in
+					 * @param {string} assetName name of the asset the stand-in sits in
+					 * @returns {string | null} the specifier, or `null` if unresolvable
+					 */
+					const resolve = (payload, assetName) => {
+						const parts = RuntimeTemplate._readAnalyzableSpecifier(payload);
+						if (parts === null) return null;
+						/** @type {string | undefined} */
+						let base;
+						let specifier = "";
+						for (const [kind, value] of parts) {
+							if (kind === "base") {
+								base = /** @type {string} */ (value);
+							} else if (kind === "literal") {
+								specifier += value;
+							} else if (kind === "undo") {
+								specifier += getUndoPath(
+									assetName,
+									/** @type {string} */ (outputOptions.path),
+									true
+								);
+							} else if (kind === "template") {
+								specifier += compilation.getPath(
+									/** @type {string} */ (value),
+									{}
+								);
+							} else if (kind === "publicPath") {
+								specifier += resolvedPublicPath();
+							} else if (kind === "unserved") {
+								const holder = chunkOf(assetName);
+								if (holder === undefined) return null;
+								// Only an asset the host fetched needs the public path put in
+								// front. One the loader fetched already sits under it, and the
+								// `../` ahead of this walked back to exactly there.
+								if (
+									compilation.runtimeTemplate._chunkPlacement(holder).loaded ===
+									false
+								) {
+									const path = resolvedPublicPath();
+									// The `../` already reached the root this is read from.
+									specifier += path.startsWith("./") ? path.slice(2) : path;
+								}
+							} else {
+								const naming = CHUNK_ASSET_NAMING_BY_STAND_IN.get(kind);
+								// Nothing reserves a kind this pass cannot spell, so one arriving
+								// here was written by something else and names no asset of ours.
+								if (naming === undefined) return null;
+								if (chunksById === undefined) {
+									chunksById = new Map();
+									for (const chunk of compilation.chunks) {
+										if (chunk.id !== null) {
+											chunksById.set(String(chunk.id), chunk);
+										}
+									}
+								}
+								const chunk = chunksById.get(String(value));
+								if (chunk === undefined) return null;
+								specifier += compilation.getPath(
+									naming.template(chunk, outputOptions),
+									// Matches what names the asset, or a placeholder resolved here would
+									// not be the one on disk.
+									{
+										chunk,
+										runtime: chunk.runtime,
+										contentHashType: naming.contentHashType
+									}
+								);
+							}
+						}
+						if (base !== undefined) {
+							// An entry base replaces the output root, so the rest is read against it
+							// here exactly as the runtime would have read it against `.b`.
+							try {
+								return new URL(fillFullHash(specifier), base).href;
+							} catch (_error) {
+								return null;
+							}
+						}
+						// A bare specifier is a package name, so make it explicitly relative the way
+						// 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)
+								? specifier
+								: `./${specifier}`
+						);
+					};
+					/** @type {{ name: string, source: Source, replacements: Replacement[] }[]} */
+					const tasks = [];
+
+					for (const name of Object.keys(compilation.assets)) {
+						const source = compilation.assets[name];
+						const content = source.source();
+						if (typeof content !== "string") continue;
+						ANALYZABLE_TOKEN_REGEXP.lastIndex = 0;
+						FULL_HASH_TOKEN_REGEXP.lastIndex = 0;
+						const hasChunkToken = ANALYZABLE_TOKEN_REGEXP.test(content);
+						const hasFullHashToken =
+							fullHash !== undefined && FULL_HASH_TOKEN_REGEXP.test(content);
+						if (!hasChunkToken && !hasFullHashToken) continue;
+						/** @type {Replacement[]} */
+						const replacements = [];
+						/**
+						 * @param {RegExp} pattern what to look for
+						 * @param {(match: string, group: string) => string | null} fill what to put there
+						 * @returns {void}
+						 */
+						const collect = (pattern, fill) => {
+							// Its own instance: `fill` may run the shared one over what it
+							// returns, and a `replace` there would rewind this scan.
+							const regexp = new RegExp(pattern.source, pattern.flags);
+							/** @type {RegExpExecArray | null} */
+							let match;
+							while ((match = regexp.exec(content)) !== null) {
+								const value = fill(match[0], match[1]);
+								if (value === null) continue;
+								replacements.push([
+									match.index,
+									match.index + match[0].length - 1,
+									value
+								]);
+							}
+						};
+						if (hasChunkToken) {
+							collect(ANALYZABLE_TOKEN_REGEXP, (_match, payload) =>
+								resolve(payload, name)
+							);
+						}
+						if (hasFullHashToken) {
+							collect(FULL_HASH_TOKEN_REGEXP, (match) => fillFullHash(match));
+						}
+						if (replacements.length === 0) continue;
+
+						tasks.push({ name, source, replacements });
+					}
+					if (tasks.length === 0) return;
+
+					await Promise.all(
+						tasks.map(async ({ name, source, replacements }) => {
+							const replaced = await cache.providePromise(
+								name,
+								cache.mergeEtags(
+									cache.getLazyHashedEtag(source),
+									JSON.stringify(replacements)
+								),
+								() => {
+									const replacedSource = new ReplaceSource(source);
+									for (const [start, end, value] of replacements) {
+										replacedSource.replace(start, end, value);
+									}
+									return new CachedSource(replacedSource);
+								}
+							);
+							compilation.updateAsset(name, replaced);
+						})
+					);
+				}
+			);
+		});
+	}
+
+	/**
+	 * Reads back what `_reserveAnalyzableSpecifier` wrote. Source of our own can spell the
+	 * token too, so nothing about a payload is given and every shape it does not produce
+	 * is refused rather than reached for.
+	 * @param {string} payload the encoded half of a stand-in
+	 * @returns {SpecifierPart[] | null} what it resolves to, or `null` if unreadable
+	 */
+	static _readAnalyzableSpecifier(payload) {
+		/** @type {EXPECTED_ANY} */
+		let decoded;
+		try {
+			decoded = JSON.parse(
+				Buffer.from(
+					payload.replace(/-/g, "+").replace(/_/g, "/"),
+					"base64"
+				).toString()
+			);
+		} catch (_error) {
+			return null;
+		}
+		if (!Array.isArray(decoded)) return null;
+		for (const part of decoded) {
+			if (!Array.isArray(part) || part.length !== 2) return null;
+			if (!SPECIFIER_PART_KINDS.has(part[0])) return null;
+			// Only a chunk id may be a number; the rest are read as text.
+			if (
+				typeof part[1] !== "string" &&
+				(!CHUNK_SPECIFIER_PART_KINDS.has(part[0]) ||
+					typeof part[1] !== "number")
+			) {
+				return null;
+			}
+		}
+		return decoded;
+	}
 }
 
 module.exports = RuntimeTemplate;