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

package/lib/RuntimeTemplate.js

@@ -55,6 +55,7 @@ const {
 const getCssModulesPlugin = memoize(() => require("./css/CssModulesPlugin"));
 // `Compilation` requires this module, so its stage constants are read lazily.
 const getCompilation = memoize(() => require("./Compilation"));
+const getExternalModule = memoize(() => require("./ExternalModule"));
 
 /**
  * @typedef {object} ChunkAssetNaming
@@ -178,6 +179,20 @@ const DEFER_BAILOUT =
  * @property {boolean | null} loaded whether the chunk loader fetched the chunk
  */
 
+/**
+ * @typedef {object} AnalyzableChunkUrls
+ * @property {Map<ChunkId, string>} urls the urls that could be written, by chunk id
+ * @property {boolean} complete false when some chunk kept the runtime form, whose
+ * ids the consumer then still resolves through the runtime name lookup
+ */
+
+/**
+ * @typedef {object} WasmGroups
+ * @property {(key: string) => string} groupOf the group a runtime key answers with
+ * @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 };
@@ -242,6 +257,10 @@ const SPECIFIER_PART_KINDS = new Set([
 // 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;
 
@@ -331,6 +350,25 @@ const createHashProbeChunk = (chunk, hash, present) => {
 	return probeChunk;
 };
 
+/**
+ * A filename function's answer to the stand-in hash, which says what shape the name
+ * has before any real hash exists.
+ * @param {Exclude<ChunkFilenameTemplate, string>} template the filename function
+ * @param {Chunk} chunk the chunk being referenced
+ * @param {string} contentHashType which of the chunk's hashes the name reads
+ * @param {string} hash the stand-in hash
+ * @param {boolean} present whether the chunk is claimed to carry content hashes
+ * @returns {string} what the function names it
+ */
+const probeTemplateName = (template, chunk, contentHashType, hash, present) =>
+	template({
+		chunk: createHashProbeChunk(chunk, hash, present),
+		runtime: chunk.runtime,
+		contentHashType,
+		hash,
+		contentHash: hash
+	});
+
 /**
  * No module id error message.
  * @param {Module} module the module
@@ -385,6 +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.
@@ -426,14 +469,10 @@ class RuntimeTemplate {
 		this._placementByChunk = new WeakMap();
 		/** @type {Map<string, string | null | undefined>} */
 		this._entryBaseUriByRuntime = new Map();
-		/** @type {Map<string, string> | undefined} */
-		this._wasmRuntimeGroupsByKey = undefined;
-		/** @type {Set<string> | false | undefined} */
-		this._wasmFetchingGroupSet = undefined;
+		/** @type {WasmGroups | undefined} */
+		this._wasmGroupsValue = undefined;
 		/** @type {Map<string, boolean> | undefined} */
 		this._wasmAnchorKnownByGroup = undefined;
-		/** @type {Map<string, boolean> | undefined} */
-		this._wasmGroupOnlyFetchesMap = undefined;
 	}
 
 	isIIFE() {
@@ -630,28 +669,28 @@ class RuntimeTemplate {
 				placedModule
 			)
 		) {
-			this._analyzableBailout(
+			return this._analyzableBailout(
 				module,
-				"__webpack_public_path__ is reassigned in a runtime this module belongs to"
+				"__webpack_public_path__ is reassigned in a runtime this module belongs to",
+				false
 			);
-			return false;
 		}
 
 		if (form === "import") {
 			// Read through a native `import()`, or it is not this feature at all.
 			if (outputOptions.chunkFormat !== "module") {
-				this._analyzableBailout(
+				return this._analyzableBailout(
 					module,
-					`output.chunkFormat is ${JSON.stringify(outputOptions.chunkFormat)}, so chunks are not read through a native import()`
+					`output.chunkFormat is ${JSON.stringify(outputOptions.chunkFormat)}, so chunks are not read through a native import()`,
+					false
 				);
-				return false;
 			}
 			if (outputOptions.importFunctionName !== "import") {
-				this._analyzableBailout(
+				return this._analyzableBailout(
 					module,
-					`output.importFunctionName is ${JSON.stringify(outputOptions.importFunctionName)}, so the call site is not a native import()`
+					`output.importFunctionName is ${JSON.stringify(outputOptions.importFunctionName)}, so the call site is not a native import()`,
+					false
 				);
-				return false;
 			}
 			// A worker loading its own chunks some other way keeps that runtime; one on
 			// `import` uses the same ESM loader as the main graph, so it can be analyzable.
@@ -662,29 +701,23 @@ class RuntimeTemplate {
 				if (!entryOptions || !entryOptions.worker) continue;
 				// `WorkerAndWorkletPlugin` always seeds this from `output.workerChunkLoading`.
 				if (entryOptions.chunkLoading !== "import") {
-					this._analyzableBailout(
+					return this._analyzableBailout(
 						module,
-						`this worker loads its chunks with ${JSON.stringify(entryOptions.chunkLoading)}, not "import"`
+						`this worker loads its chunks with ${JSON.stringify(entryOptions.chunkLoading)}, not "import"`,
+						false
 					);
-					return 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 neither gate
-		// below rules it out, and the asset's javascript wrapper stays dropped.
+		// 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;
-		// `import.meta` is ESM syntax the target has to read. A chunk `import()` is
-		// emitted by the module chunk loader either way, so only the url forms check.
-		if (!this.supportsEcmaScriptModuleSyntax()) {
-			this._analyzableBailout(
-				module,
-				"output.environment.module is false, so the target does not read the import.meta this form needs"
-			);
-			return false;
-		}
 		// `eval` devtool wraps each module in `eval(...)`, where `import.meta` is a
 		// syntax error. Runtime modules are emitted beside them, never wrapped.
 		const { devtool } = this.compilation.options;
@@ -693,22 +726,22 @@ class RuntimeTemplate {
 			typeof devtool === "string" &&
 			devtool.includes("eval")
 		) {
-			this._analyzableBailout(
+			return this._analyzableBailout(
 				module,
-				`devtool ${JSON.stringify(devtool)} wraps the module in eval(), where import.meta does not parse`
+				`devtool ${JSON.stringify(devtool)} wraps the module in eval(), where import.meta does not parse`,
+				false
 			);
-			return false;
 		}
 		if (form === "url" || form === "url-runtime") return true;
 		// A bare relative URL is what `__webpack_require__.p + path` means only under an
 		// `auto` public path; anything else has to be baked, which is the "wasm" form.
 		if (form === "wasm-relative") {
 			if (outputOptions.publicPath === "auto") return true;
-			this._analyzableBailout(
+			return this._analyzableBailout(
 				module,
-				"output.publicPath is set, so a bare relative url no longer means what the public path would have resolved to"
+				"output.publicPath is set, so a bare relative url no longer means what the public path would have resolved to",
+				false
 			);
-			return false;
 		}
 
 		// The rest is the `"wasm"` form: whether the whole binary url can be spelled
@@ -727,11 +760,11 @@ class RuntimeTemplate {
 				this._anyWasmChunkFetches(runtime) &&
 				!this._wasmFetchAnchorIsKnown(runtime)
 			) {
-				this._analyzableBailout(
+				return this._analyzableBailout(
 					module,
-					"output.publicPath needs a base, and no one path back to the document fits every chunk `fetch` reads it from"
+					"output.publicPath needs a base, and no one path back to the document fits every chunk `fetch` reads it from",
+					false
 				);
-				return false;
 			}
 		}
 		// The compilation hash is settled after code generation, so a name carrying one
@@ -753,19 +786,22 @@ class RuntimeTemplate {
 	 * the channel `ModuleConcatenationPlugin` already reports through, so it reaches
 	 * `stats.optimizationBailout`. Silent unless the build asked for ESM output, where
 	 * alone the answer is actionable; deduplicated because a module may write many.
+	 * Answers with `answer` so a caller states the refusal and its reason at once —
+	 * `false` where it answers a question, `null` where it was building a specifier.
+	 * @template {false | null} T
 	 * @param {Module | undefined} module the module the reference is emitted into
 	 * @param {string} reason why no literal could be baked
-	 * @returns {void}
+	 * @param {T} answer what the caller hands back
+	 * @returns {T} that answer
 	 */
-	_analyzableBailout(module, reason) {
-		if (module === undefined || !this.outputOptions.module) return;
-		const text = `Analyzable ESM bailout: ${reason}`;
-		const bailouts =
-			this.compilation.moduleGraph.getOptimizationBailout(module);
-		for (const existing of bailouts) {
-			if (existing === text) return;
+	_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);
 		}
-		bailouts.push(text);
+		return answer;
 	}
 
 	/**
@@ -810,8 +846,7 @@ class RuntimeTemplate {
 	 */
 	_canDeferOrBail(chunks, module) {
 		if (this._canDeferAnalyzableName(chunks)) return true;
-		this._analyzableBailout(module, DEFER_BAILOUT);
-		return false;
+		return this._analyzableBailout(module, DEFER_BAILOUT, false);
 	}
 
 	/**
@@ -861,9 +896,7 @@ class RuntimeTemplate {
 	 */
 	_partsBakeFullHash(parts) {
 		for (const [kind, value] of parts) {
-			if (kind === "publicPath" || kind === "template" || kind === "unserved") {
-				return true;
-			}
+			if (FULL_HASH_PART_KINDS.has(kind)) return true;
 			if (kind === "literal" && this._hasReservedFullHash(String(value))) {
 				return true;
 			}
@@ -962,95 +995,83 @@ class RuntimeTemplate {
 		const base = this.analyzableUrlReadsBaseUri()
 			? this.entryBaseUri(runtime)
 			: undefined;
-		if (base !== undefined) {
-			if (base === null) {
-				this._analyzableBailout(
-					module,
-					"the entries this module is generated for set different baseUri values, so no one url resolves for all of them"
-				);
-				return null;
-			}
-			// A relative one is no base of its own: the runtime reads it against the
-			// chunk, so the literal spells it there rather than resolving against it.
-			if (isChunkRelativeBaseUri(base)) {
-				return this._getAnalyzableFileSpecifier(
-					module,
-					chunkGraph,
-					[["literal", filename]],
-					true,
-					base
-				);
-			}
-			const chunks = this._moduleChunks(module, chunkGraph);
-			// A protocol-relative base names a host but no scheme, and the runtime reads it
-			// against the chunk's own url to get one — the very url this literal is
-			// resolved against — so it may stay protocol-relative instead of being settled
-			// here. Nothing walks back to the output root first: the base replaces it.
-			if (base.startsWith("//")) {
-				const relative = this._resolvePublicPathPrefix(
-					publicPath,
-					module,
-					chunks
-				);
-				return relative === null
-					? null
-					: this._specifierOf(
-							[
-								["literal", base],
-								...rootedParts(relative),
-								["literal", filename]
-							],
-							chunks,
-							module
-						);
-			}
-			if (!isAbsoluteBaseUri(base)) {
-				this._analyzableBailout(
-					module,
-					`an entry sets a baseUri of ${JSON.stringify(base)}, whose scheme names no base anything can be resolved against`
-				);
-				return null;
-			}
-			const parts = this._resolvePublicPathPrefix(publicPath, module, chunks);
-			if (parts === null) return null;
-			// Resolved here rather than against the output root, and only an absolute base
-			// settles it — a relative one has no base of its own to be read against.
-			const spelled = literalText(parts);
-			// A hash the deferred pass still has to fill in cannot be resolved against the
-			// base here: the fill would land inside an already-resolved url, where a hash
-			// opening with a letter reads as a scheme and drops the base entirely.
-			const text =
-				spelled !== null && !this._hasReservedFullHash(spelled)
-					? spelled
-					: null;
-			/** @type {URL} */
-			let resolved;
-			try {
-				// Empty where only the deferred pass can spell the rest, which still settles
-				// whether the base itself is one anything may be resolved against.
-				resolved = new URL(text === null ? "" : text + filename, base);
-			} catch (_error) {
-				this._analyzableBailout(
-					module,
-					`an entry sets a baseUri of ${JSON.stringify(base)}, which is not absolute, so no url can be resolved against it here`
-				);
-				return null;
-			}
-			if (text !== null) return toJsStringLiteral(resolved.href);
-			if (!this._canDeferOrBail(chunks, module)) return null;
-			return toJsStringLiteral(
-				this._reserveAnalyzableSpecifier([
-					["base", base],
-					...parts,
-					["literal", filename]
-				])
+		// 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
 			);
 		}
-		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]
+			])
 		);
 	}
 
@@ -1121,55 +1142,119 @@ class RuntimeTemplate {
 		return publicPath.includes("[") ? undefined : publicPath;
 	}
 
+	/**
+	 * Runtime keys grouped by the binaries they share, with what the entries of each
+	 * group asked for. Code generation runs once for runtimes a module hashes alike in,
+	 * and nothing in a binary's hash knows which loader will read it — so a binary two
+	 * runtimes reach carries one shape into both, and a third runtime sharing another
+	 * binary with either is pulled in after them. Only an entry names a loader; every
+	 * other chunk of the runtime is served by the one its entry asked for. Asked of the
+	 * same modules the loaders are created for, and only once per compilation.
+	 * @returns {WasmGroups} the grouping, and which groups fetch
+	 */
+	_wasmGroups() {
+		if (this._wasmGroupsValue === undefined) {
+			const { chunkGraph, chunks, modules } = this.compilation;
+			/** @type {Map<string, string>} */
+			const parent = new Map();
+			/**
+			 * @param {string} key runtime key
+			 * @returns {string} the key naming its group
+			 */
+			const find = (key) => {
+				let root = key;
+				let seen = parent.get(root);
+				while (seen !== undefined && seen !== root) {
+					root = seen;
+					seen = parent.get(root);
+				}
+				// Path compression keeps a long share chain from costing more than once.
+				let walk = key;
+				let next = parent.get(walk);
+				while (next !== undefined && next !== root) {
+					parent.set(walk, root);
+					walk = next;
+					next = parent.get(walk);
+				}
+				return root;
+			};
+			/** @type {string[]} */
+			const keys = [];
+			for (const module of modules) {
+				if (module.type !== WEBASSEMBLY_MODULE_TYPE_ASYNC) continue;
+				keys.length = 0;
+				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+					forEachRuntime(runtime, (key) => {
+						keys.push(/** @type {string} */ (key));
+					});
+				}
+				for (const key of keys) if (!parent.has(key)) parent.set(key, key);
+				// Every runtime this binary reaches answers with the first one.
+				for (let i = 1; i < keys.length; i++) {
+					parent.set(find(keys[i]), find(keys[0]));
+				}
+			}
+			// Flattened once, so a lookup is a single `get` rather than a chain walk.
+			for (const key of parent.keys()) parent.set(key, find(key));
+			/**
+			 * @param {string} key a runtime key
+			 * @returns {string} the group it answers with, or itself when it shares nothing
+			 */
+			const groupOf = (key) => {
+				const group = parent.get(key);
+				// An entry named "" makes "" a runtime key, so test absence, not a falsy value.
+				return group === undefined ? key : group;
+			};
+			/** @type {Set<string>} */
+			const fetching = new Set();
+			/** @type {Map<string, boolean>} */
+			const onlyFetching = new Map();
+			for (const chunk of chunks) {
+				if (!chunk.getEntryOptions()) continue;
+				const fetches = this._chunkWasmLoading(chunk) === "fetch";
+				forEachRuntime(chunk.runtime, (key) => {
+					const group = groupOf(/** @type {string} */ (key));
+					if (fetches) fetching.add(group);
+					onlyFetching.set(group, onlyFetching.get(group) !== false && fetches);
+				});
+			}
+			this._wasmGroupsValue = { groupOf, fetching, onlyFetching };
+		}
+		return this._wasmGroupsValue;
+	}
+
+	/**
+	 * @param {RuntimeSpec} runtime the runtime being asked about
+	 * @returns {string[]} the wasm runtime groups it reaches
+	 */
+	_wasmGroupsOf(runtime) {
+		const { groupOf } = this._wasmGroups();
+		/** @type {string[]} */
+		const reached = [];
+		forEachRuntime(runtime, (key) => {
+			reached.push(groupOf(/** @type {string} */ (key)));
+		});
+		return reached;
+	}
+
 	/**
 	 * Whether a chunk loads WebAssembly through `fetch`, which is the only loader the
 	 * public path reaches: `readFile` resolves the binary's name against the chunk it is
 	 * read from, exactly as a baked literal does, so a public path is irrelevant to it.
-	 * Answered per runtime rather than per chunk on purpose — a module's generated source
+	 * Answered per group rather than per chunk on purpose — a module's generated source
 	 * and the runtime module of every chunk holding it have to agree on the shape, and
-	 * they ask from opposite ends; one loader serves a whole runtime, so that is the
-	 * finest scope on which they can. Without a runtime, or where the runtimes cannot be
-	 * told apart, the answer covers the compilation.
+	 * they ask from opposite ends; one loader serves a whole group, so that is the finest
+	 * scope on which they can. Without a runtime the answer covers the compilation.
 	 * @param {RuntimeSpec=} runtime the runtime being asked about
 	 * @returns {boolean} true when a chunk of that runtime fetches its binaries
 	 */
 	_anyWasmChunkFetches(runtime) {
-		const fetching = this._wasmFetchingGroups();
-		if (fetching === undefined) return false;
+		const { fetching } = this._wasmGroups();
+		if (fetching.size === 0) return false;
 		// Without a runtime to place it in there is nothing to narrow by, so any chunk
 		// answers for all of them.
 		if (runtime === undefined) return true;
-		const groups = this._wasmRuntimeGroups();
-		if (typeof runtime === "string") {
-			return fetching.has(this._wasmGroupOf(groups, runtime));
-		}
-		for (const key of runtime) {
-			if (fetching.has(this._wasmGroupOf(groups, key))) return true;
-		}
-		return false;
-	}
-
-	/**
-	 * Whether every entry of a wasm runtime group reads its binaries with `fetch`. Only
-	 * an entry names a loader, so the scan is of entries, as `_wasmFetchingGroups` is.
-	 * @returns {Map<string, boolean>} whether each group fetches and nothing else
-	 */
-	_wasmGroupOnlyFetches() {
-		if (this._wasmGroupOnlyFetchesMap === undefined) {
-			const groups = this._wasmRuntimeGroups();
-			/** @type {Map<string, boolean>} */
-			const only = new Map();
-			for (const chunk of this.compilation.chunks) {
-				if (!chunk.getEntryOptions()) continue;
-				const fetches = this._chunkWasmLoading(chunk) === "fetch";
-				forEachRuntime(chunk.runtime, (key) => {
-					const group = this._wasmGroupOf(groups, /** @type {string} */ (key));
-					only.set(group, only.get(group) !== false && fetches);
-				});
-			}
-			this._wasmGroupOnlyFetchesMap = only;
-		}
-		return this._wasmGroupOnlyFetchesMap;
+		return this._wasmGroupsOf(runtime).some((group) => fetching.has(group));
 	}
 
 	/**
@@ -1182,30 +1267,31 @@ class RuntimeTemplate {
 	_wasmFetchAnchorIsKnown(runtime) {
 		if (this._wasmAnchorKnownByGroup === undefined) {
 			const { chunkGraph, modules } = this.compilation;
-			const publicPath = /** @type {PublicPath} */ (
-				this.outputOptions.publicPath
-			);
-			const groups = this._wasmRuntimeGroups();
+			const { groupOf, onlyFetching } = this._wasmGroups();
 			/** @type {Map<string, boolean>} */
 			const known = new Map();
 			for (const module of modules) {
 				if (module.type !== WEBASSEMBLY_MODULE_TYPE_ASYNC) continue;
+				// Probed through the very builder the generator runs, so the gate is
+				// exact: a prefix it can spell — the per-asset deferrals included — is
+				// one the group may bake. The probe name stands in for the binary's.
 				const spellable =
-					this._modulePlacement(module, chunkGraph).loaded !== null &&
-					this._resolvePublicPathPrefix(publicPath, module) !== null;
+					this._getAnalyzableFileSpecifier(
+						module,
+						/** @type {ChunkGraph} */ (chunkGraph),
+						[["literal", "x"]],
+						true
+					) !== null;
 				for (const moduleRuntime of chunkGraph.getModuleRuntimes(module)) {
 					forEachRuntime(moduleRuntime, (key) => {
-						const group = this._wasmGroupOf(
-							groups,
-							/** @type {string} */ (key)
-						);
+						const group = groupOf(/** @type {string} */ (key));
 						known.set(group, known.get(group) !== false && spellable);
 					});
 				}
 			}
 			// A group one entry reads with `readFile` cannot take a prefix meant for the
 			// document, and only an entry names its loader.
-			for (const [group, only] of this._wasmGroupOnlyFetches()) {
+			for (const [group, only] of onlyFetching) {
 				if (!only) known.set(group, false);
 			}
 			this._wasmAnchorKnownByGroup = known;
@@ -1217,124 +1303,9 @@ class RuntimeTemplate {
 			for (const value of known.values()) if (!value) return false;
 			return known.size > 0;
 		}
-		const groups = this._wasmRuntimeGroups();
-		if (typeof runtime === "string") {
-			return known.get(this._wasmGroupOf(groups, runtime)) === true;
-		}
-		for (const key of runtime) {
-			if (known.get(this._wasmGroupOf(groups, key)) !== true) return false;
-		}
-		return true;
-	}
-
-	/**
-	 * The runtime groups an entry of which asked for the `fetch` loader, or `undefined`
-	 * where none did — the cheap answer for a compilation with no fetching entry at all,
-	 * which is every non-web target. Only an entry names a loader; every other chunk of
-	 * the runtime is served by the one its entry asked for.
-	 * @returns {Set<string> | undefined} the groups that fetch
-	 */
-	_wasmFetchingGroups() {
-		if (this._wasmFetchingGroupSet === undefined) {
-			/** @type {Set<string>} */
-			const fetching = new Set();
-			/** @type {Map<string, string> | undefined} */
-			let groups;
-			for (const chunk of this.compilation.chunks) {
-				// Only an entry names a loader; every other chunk of the runtime is served
-				// by the one its entry asked for, so it says nothing on its own.
-				if (!chunk.getEntryOptions()) continue;
-				if (this._chunkWasmLoading(chunk) !== "fetch") continue;
-				// Built only once something fetches, so nothing pays for the grouping.
-				if (groups === undefined) groups = this._wasmRuntimeGroups();
-				const named = /** @type {Map<string, string>} */ (groups);
-				forEachRuntime(chunk.runtime, (key) => {
-					fetching.add(this._wasmGroupOf(named, /** @type {string} */ (key)));
-				});
-			}
-			this._wasmFetchingGroupSet = fetching.size === 0 ? false : fetching;
-		}
-		return this._wasmFetchingGroupSet === false
-			? undefined
-			: this._wasmFetchingGroupSet;
-	}
-
-	/**
-	 * Runtime keys mapped to the group they answer with, named by one key of it. Code
-	 * generation runs once for runtimes a module hashes alike in, and nothing in a
-	 * binary's hash knows which loader will read it — so a binary two runtimes reach
-	 * carries one shape into both, and a third runtime sharing another binary with
-	 * either is pulled in after them. A key in no group answers as itself. Asked of the
-	 * same modules the loaders are created for, and only once per compilation.
-	 * @returns {Map<string, string>} runtime key to the group it answers with
-	 */
-	_wasmRuntimeGroups() {
-		if (this._wasmRuntimeGroupsByKey === undefined) {
-			const { chunkGraph } = this.compilation;
-			/** @type {Map<string, string>} */
-			const parent = new Map();
-			/**
-			 * @param {string} key runtime key
-			 * @returns {string} the key naming its group
-			 */
-			const find = (key) => {
-				let root = key;
-				let seen = parent.get(root);
-				while (seen !== undefined && seen !== root) {
-					root = seen;
-					seen = parent.get(root);
-				}
-				// Path compression keeps a long share chain from costing more than once.
-				let walk = key;
-				let next = parent.get(walk);
-				while (next !== undefined && next !== root) {
-					parent.set(walk, root);
-					walk = next;
-					next = parent.get(walk);
-				}
-				return root;
-			};
-			/** @type {string[]} */
-			const keys = [];
-			/**
-			 * @param {RuntimeSpec} runtime a runtime the module is generated for
-			 * @returns {void}
-			 */
-			const collectKeys = (runtime) => {
-				forEachRuntime(runtime, (key) => {
-					keys.push(/** @type {string} */ (key));
-				});
-			};
-			for (const module of this.compilation.modules) {
-				if (module.type !== WEBASSEMBLY_MODULE_TYPE_ASYNC) continue;
-				keys.length = 0;
-				for (const runtime of chunkGraph.getModuleRuntimes(module)) {
-					collectKeys(runtime);
-				}
-				for (const key of keys) {
-					if (!parent.has(key)) parent.set(key, key);
-				}
-				// Every runtime this binary reaches answers with the first one.
-				for (let i = 1; i < keys.length; i++) {
-					parent.set(find(keys[i]), find(keys[0]));
-				}
-			}
-			// Flattened once, so a lookup is a single `get` rather than a chain walk.
-			for (const key of parent.keys()) parent.set(key, find(key));
-			this._wasmRuntimeGroupsByKey = parent;
-		}
-		return this._wasmRuntimeGroupsByKey;
-	}
-
-	/**
-	 * @param {Map<string, string>} groups runtime key to the group it answers with
-	 * @param {string} key a runtime key
-	 * @returns {string} the group it answers with, or itself when it shares nothing
-	 */
-	_wasmGroupOf(groups, key) {
-		const group = groups.get(key);
-		// An entry named "" makes "" a runtime key, so test absence, not a falsy value.
-		return group === undefined ? key : group;
+		return this._wasmGroupsOf(runtime).every(
+			(group) => known.get(group) === true
+		);
 	}
 
 	supportTemplateLiteral() {
@@ -2019,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(
 						"",
@@ -2255,11 +2229,14 @@ class RuntimeTemplate {
 			(dependency instanceof HarmonyImportDependency ||
 				dependency instanceof ImportDependency) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
-			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+			!isAsyncExternal(module);
 
 		if (isModuleDeferred) {
 			/** @type {Set<Module>} */
 			const outgoingAsyncModules = getOutgoingAsyncModules(moduleGraph, module);
+			// A module deferring itself is already evaluating, so awaiting it here
+			// would deadlock; forcing the namespace throws instead.
+			outgoingAsyncModules.delete(originModule);
 
 			importContent = `/* deferred harmony import */ ${optDeclaration}${importVar} = ${getOptimizedDeferredModule(
 				moduleId,
@@ -2344,7 +2321,7 @@ class RuntimeTemplate {
 			(dependency instanceof HarmonyImportDependency ||
 				dependency instanceof ImportDependency) &&
 			ImportPhaseUtils.isDefer(dependency.phase) &&
-			!(/** @type {BuildMeta} */ (module.buildMeta).async);
+			!isAsyncExternal(module);
 
 		if (defaultInterop) {
 			// when the defaultInterop is used (when a ESM imports a CJS module),
@@ -2684,6 +2661,22 @@ class RuntimeTemplate {
 		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
@@ -2711,30 +2704,15 @@ class RuntimeTemplate {
 		) {
 			return null;
 		}
-		// Prefetch/preload children are injected by the runtime `.f` handlers, which `.ei`
-		// runs too — but they attach to `.f`, so it has to exist.
-		const needsHintHandlers =
-			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
-			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
-			chunk.hasChildByOrder(chunkGraph, "cssPreload", true);
 		// `.ei` always performs the import, where `.e` only reaches the javascript
 		// loader when there is javascript to load. A module federation remote is the
 		// case that matters: its chunk is emitted by the container's build, not this one.
 		if (!JavascriptModulesPlugin.chunkHasJs(chunk, chunkGraph)) {
-			this._analyzableBailout(
+			return this._analyzableBailout(
 				originModule,
-				"this compilation emits no javascript for the chunk, so there is nothing to import"
+				"this compilation emits no javascript for the chunk, so there is nothing to import",
+				null
 			);
-			return null;
-		}
-		let hasNonJsTypes = false;
-		for (const module of chunkGraph.getChunkModulesIterable(chunk)) {
-			for (const type of chunkGraph.getModuleSourceTypes(module)) {
-				if (!TYPES_WITHOUT_CHUNK_HANDLER.has(type)) {
-					// Loaded by that type's own `.f` handler, which `.ei` still dispatches.
-					hasNonJsTypes = true;
-				}
-			}
 		}
 		// Relative to the consuming chunk (`import.meta.url`) for `auto`, else an
 		// absolute publicPath prefix.
@@ -2756,9 +2734,15 @@ class RuntimeTemplate {
 			? specifier
 			: `"./${specifier.slice(1)}`;
 		runtimeRequirements.add(RuntimeGlobals.analyzableChunkImport);
-		if (needsHintHandlers || hasNonJsTypes) {
-			// Those handlers attach to the `.f` map, which has to exist — but the runtime
-			// `ensureChunk` around it does not, since `.ei` dispatches them itself.
+		// Prefetch/preload children and every non-javascript source type are loaded by a
+		// `.f` handler, which `.ei` dispatches — but they attach to `.f`, so it has to
+		// exist. The runtime `ensureChunk` around it does not.
+		if (
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true) ||
+			chunk.hasChildByOrder(chunkGraph, "preload", true) ||
+			chunk.hasChildByOrder(chunkGraph, "cssPreload", true) ||
+			this._chunkLoadsBeyondJs(chunk, chunkGraph)
+		) {
 			runtimeRequirements.add(RuntimeGlobals.ensureChunkHandlers);
 		}
 		// Drop-in for `ensureChunk(id)`: the literal `import()` can be statically
@@ -2928,6 +2912,11 @@ class RuntimeTemplate {
 		/** @type {Set<string>} */
 		const names = new Set();
 		let found = false;
+		// Its own copy, since `lastIndex` is walked below; reset by the loop that ends it.
+		const regexp = new RegExp(
+			ANALYZABLE_TOKEN_REGEXP.source,
+			ANALYZABLE_TOKEN_REGEXP.flags
+		);
 		for (const module of modules) {
 			if (!results.has(module, chunk.runtime)) continue;
 			const source = results.getSource(module, chunk.runtime, JAVASCRIPT_TYPE);
@@ -2937,10 +2926,6 @@ class RuntimeTemplate {
 				carriesFullHash = true;
 				found = true;
 			}
-			const regexp = new RegExp(
-				ANALYZABLE_TOKEN_REGEXP.source,
-				ANALYZABLE_TOKEN_REGEXP.flags
-			);
 			/** @type {RegExpExecArray | null} */
 			let match;
 			while ((match = regexp.exec(content)) !== null) {
@@ -2948,11 +2933,7 @@ class RuntimeTemplate {
 				if (parts === null) continue;
 				found = true;
 				for (const [kind, value] of parts) {
-					if (
-						kind === "publicPath" ||
-						kind === "template" ||
-						kind === "unserved"
-					) {
+					if (FULL_HASH_PART_KINDS.has(kind)) {
 						carriesFullHash = true;
 					} else if (CHUNK_SPECIFIER_PART_KINDS.has(kind)) {
 						names.add(String(value));
@@ -3213,13 +3194,13 @@ class RuntimeTemplate {
 			return template.replace(HASH_IN_FILENAME_GLOBAL, "x");
 		}
 		try {
-			return template({
-				chunk: createHashProbeChunk(chunk, HASH_PROBE, true),
-				runtime: chunk.runtime,
-				contentHashType: JAVASCRIPT_TYPE,
-				hash: HASH_PROBE,
-				contentHash: HASH_PROBE
-			}).replace(HASH_IN_FILENAME_GLOBAL, "x");
+			return probeTemplateName(
+				template,
+				chunk,
+				JAVASCRIPT_TYPE,
+				HASH_PROBE,
+				true
+			).replace(HASH_IN_FILENAME_GLOBAL, "x");
 		} catch (_error) {
 			// Nothing to report: the naming call is given strictly less than this probe, so
 			// one that throws here fails the build where the name is actually needed.
@@ -3311,6 +3292,41 @@ class RuntimeTemplate {
 			: { undo, loaded };
 	}
 
+	/**
+	 * Static literal specifier (already quoted) for the `new URL(<here>, import.meta.url)`
+	 * a worker or worklet entry chunk bakes to, or `null` to keep the runtime form. The
+	 * gate and the build are asked together so every call site agrees on both — the
+	 * `new Worker(...)` emit, and the resource hint `ResourceHintPlugin` spells for it.
+	 * @param {string | undefined} overridePublicPath a `publicPath` set on the worker itself
+	 * @param {Chunk} chunk the worker's entry chunk
+	 * @param {Module} module the module the reference is emitted into
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @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
+		);
+	}
+
 	/**
 	 * Static literal specifier (already quoted) for a `new URL(<here>, import.meta.url)`
 	 * or `import(<here>)` pointing at `chunk`'s JS file, or `null` when it can't be known
@@ -3358,33 +3374,30 @@ class RuntimeTemplate {
 		const chunks =
 			consumingChunks ||
 			this._moduleChunks(/** @type {Module} */ (consumingModule), chunkGraph);
-		// Baking makes the consuming chunk's content depend on this one's hash. A pair that
-		// reaches back has no fixed point if both bake, so only the lower id's name does.
-		const cycles =
-			deferred &&
-			this._reachesAny(chunk, chunks) &&
-			!this._namesBeforeAll(chunk, chunks);
+		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.
+		// 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 && !cycles && this._canDeferAnalyzableName(chunks);
+			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.
-		const canFold = !canReserve && this._namesBeforeAll(chunk, chunks);
+		// 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 = () => {
+		const cannotReserve = () =>
 			this._analyzableBailout(
 				consumingModule,
-				cycles
-					? "this chunk and the one it references name each other, so neither hash could settle"
-					: DEFER_BAILOUT
+				!namesFirst && this._reachesAny(chunk, chunks)
+					? "this chunk and the one it references name each other, which only optimization.realContentHash could settle"
+					: DEFER_BAILOUT,
+				null
 			);
-			return null;
-		};
 		if (deferred && !canReserve && !canFold) return cannotReserve();
 		const filename = deferred
 			? ""
@@ -3483,24 +3496,17 @@ class RuntimeTemplate {
 			// Each knows its own answer, so the fill asks per asset — where each has one,
 			// and where nothing else goes between the two shapes.
 			if (relativeBase !== undefined || !this._eachChunkServedOneWay(chunks)) {
-				this._analyzableBailout(module, SERVED_BAILOUT);
-				return null;
+				return this._analyzableBailout(module, SERVED_BAILOUT, null);
 			}
 			return [...head, ["unserved", ""]];
 		}
 		if (climb !== "" && relativeBase === undefined) return head;
 		const resolved = resolve();
 		if (resolved === null) return null;
-		return [
-			...head,
-			.../** @type {SpecifierPart[]} */ (
-				climb === "" ? [] : [["literal", climb]]
-			),
-			.../** @type {SpecifierPart[]} */ (
-				relativeBase === undefined ? [] : [["literal", relativeBase]]
-			),
-			...rootedParts(resolved)
-		];
+		if (climb !== "") head.push(["literal", climb]);
+		if (relativeBase !== undefined) head.push(["literal", relativeBase]);
+		head.push(...rootedParts(resolved));
+		return head;
 	}
 
 	/**
@@ -3626,11 +3632,6 @@ class RuntimeTemplate {
 	) {
 		const { publicPath } = this.outputOptions;
 		const chunks = this._moduleChunks(module, chunkGraph);
-		/**
-		 * @param {SpecifierPart[]} parts the whole specifier
-		 * @returns {string | null} it already quoted, or `null` when no stand-in may be reserved
-		 */
-		const specifier = (parts) => this._specifierOf(parts, chunks, module);
 		if (bakePublicPath && publicPath !== "auto") {
 			const prefix = this._analyzablePathPrefix(
 				module,
@@ -3638,25 +3639,24 @@ class RuntimeTemplate {
 				chunks,
 				relativeBase
 			);
-			return prefix === null ? null : specifier([...prefix, ...file]);
+			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);
-		return specifier([
-			undo === null ? ["undo", ""] : ["literal", undo],
-			...(relativeBase === undefined
-				? []
-				: /** @type {SpecifierPart[]} */ ([["literal", relativeBase]])),
-			...file
-		]);
+		/** @type {SpecifierPart[]} */
+		const parts = [undo === null ? ["undo", ""] : ["literal", undo]];
+		if (relativeBase !== undefined) parts.push(["literal", relativeBase]);
+		parts.push(...file);
+		return this._specifierOf(parts, chunks, module);
 	}
 
 	/**
 	 * Static `new URL(<file>, import.meta.url)` for every stylesheet a runtime can load,
-	 * keyed by chunk id, or `null` when any of them has to keep the runtime
-	 * `publicPath + getChunkCssFilename(id)` form. Both the runtime module reading them
+	 * 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
@@ -3666,7 +3666,7 @@ class RuntimeTemplate {
 	 * @param {ChunkGraph} chunkGraph the chunk graph
 	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements what that chunk needs
 	 * @param {Module=} consumingModule the runtime module, where one exists to report against
-	 * @returns {Map<ChunkId, string> | null} the urls, or `null` to keep the runtime form
+	 * @returns {AnalyzableChunkUrls | null} the urls, or `null` to keep the runtime form
 	 */
 	analyzableCssChunkUrls(
 		runtimeChunk,
@@ -3698,14 +3698,14 @@ class RuntimeTemplate {
 	/**
 	 * Static `new URL(<file>, import.meta.url).href` for every javascript chunk a
 	 * runtime can hint at with `<link rel="prefetch"/"modulepreload">`, keyed by chunk
-	 * id, or `null` when any of them has to keep the runtime
-	 * `publicPath + getChunkScriptFilename(id)` form. Both the runtime module reading
+	 * 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 {Map<ChunkId, string> | null} the urls, or `null` to keep the runtime form
+	 * @returns {AnalyzableChunkUrls | null} the urls, or `null` to keep the runtime form
 	 */
 	analyzableChunkScriptUrls(
 		runtimeChunk,
@@ -3722,11 +3722,9 @@ class RuntimeTemplate {
 		);
 		/** @type {Set<ChunkId>} */
 		const hinted = new Set();
-		for (const order of Object.keys(orders)) {
-			for (const from of Object.keys(orders[order])) {
-				for (const id of orders[order][/** @type {ChunkId} */ (from)]) {
-					hinted.add(id);
-				}
+		for (const byParent of Object.values(orders)) {
+			for (const ids of Object.values(byParent)) {
+				for (const id of ids) hinted.add(id);
 			}
 		}
 		/** @type {Chunk[]} */
@@ -3746,14 +3744,15 @@ class RuntimeTemplate {
 
 	/**
 	 * The urls of one asset of each of `chunks`, written out so they can be read by
-	 * chunk id, or `null` as soon as one of them cannot be named here.
+	 * 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 {Map<ChunkId, string> | null} the urls, or `null` to keep the runtime form
+	 * @returns {AnalyzableChunkUrls | null} the urls, or `null` to keep the runtime form
 	 */
 	_analyzableChunkUrls(
 		chunks,
@@ -3773,6 +3772,7 @@ class RuntimeTemplate {
 		}
 		/** @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(
@@ -3784,10 +3784,14 @@ class RuntimeTemplate {
 				consumingChunks,
 				sourceType
 			);
-			if (specifier === null) return null;
+			// `_getAnalyzableChunkSpecifier` has already recorded why.
+			if (specifier === null) {
+				complete = false;
+				continue;
+			}
 			urls.set(chunk.id, `${this.importMetaUrl(specifier)}.href`);
 		}
-		return urls.size > 0 ? urls : null;
+		return urls.size > 0 ? { urls, complete } : null;
 	}
 
 	/**
@@ -3852,20 +3856,20 @@ class RuntimeTemplate {
 		try {
 			// Everything the naming call is given except the hashes, so only a hash can
 			// make the two answers differ.
-			const template = filenameTemplate({
-				chunk: createHashProbeChunk(chunk, HASH_PROBE, true),
-				runtime: chunk.runtime,
+			const template = probeTemplateName(
+				filenameTemplate,
+				chunk,
 				contentHashType,
-				hash: HASH_PROBE,
-				contentHash: HASH_PROBE
-			});
-			const probe = filenameTemplate({
-				chunk: createHashProbeChunk(chunk, HASH_PROBE_ALTERNATE, false),
-				runtime: chunk.runtime,
+				HASH_PROBE,
+				true
+			);
+			const probe = probeTemplateName(
+				filenameTemplate,
+				chunk,
 				contentHashType,
-				hash: HASH_PROBE_ALTERNATE,
-				contentHash: HASH_PROBE_ALTERNATE
-			});
+				HASH_PROBE_ALTERNATE,
+				false
+			);
 			return template === probe ? template : undefined;
 		} catch (_error) {
 			// Nothing to report: the probe is given strictly more than the naming call,
@@ -3882,21 +3886,16 @@ class RuntimeTemplate {
 	 * @returns {boolean} true when every runtime reaching it fetches
 	 */
 	_wasmModuleFetches(module, chunkGraph) {
-		/** @type {string[]} */
-		const keys = [];
+		const { onlyFetching } = this._wasmGroups();
+		let placed = false;
 		for (const moduleRuntime of chunkGraph.getModuleRuntimes(module)) {
-			forEachRuntime(moduleRuntime, (key) => {
-				keys.push(/** @type {string} */ (key));
-			});
+			for (const group of this._wasmGroupsOf(moduleRuntime)) {
+				placed = true;
+				if (!onlyFetching.get(group)) return false;
+			}
 		}
 		// In no runtime at all nothing named a loader, so `output` answers.
-		if (keys.length === 0) return this.outputOptions.wasmLoading === "fetch";
-		const only = this._wasmGroupOnlyFetches();
-		const groups = this._wasmRuntimeGroups();
-		for (const key of keys) {
-			if (!only.get(this._wasmGroupOf(groups, key))) return false;
-		}
-		return true;
+		return placed || this.outputOptions.wasmLoading === "fetch";
 	}
 
 	/**
@@ -4073,6 +4072,18 @@ class RuntimeTemplate {
 					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
@@ -4127,10 +4138,7 @@ class RuntimeTemplate {
 									{}
 								);
 							} else if (kind === "publicPath") {
-								specifier += compilation.getPath(
-									outputOptions.publicPath || "",
-									{}
-								);
+								specifier += resolvedPublicPath();
 							} else if (kind === "unserved") {
 								const holder = chunkOf(assetName);
 								if (holder === undefined) return null;
@@ -4141,10 +4149,7 @@ class RuntimeTemplate {
 									compilation.runtimeTemplate._chunkPlacement(holder).loaded ===
 									false
 								) {
-									const path = compilation.getPath(
-										outputOptions.publicPath || "",
-										{}
-									);
+									const path = resolvedPublicPath();
 									// The `../` already reached the root this is read from.
 									specifier += path.startsWith("./") ? path.slice(2) : path;
 								}