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

package/lib/util/nonNumericOnlyHash.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("./Hash")} Hash */
+/** @import Hash from "./Hash" */
 
 const A_CODE = "a".charCodeAt(0);
 
@@ -47,6 +47,7 @@ const digestNonNumericOnlyWithFull = (hash, hashDigest, hashDigestLength) => {
 	return [nonNumericOnlyHash(full, hashDigestLength), full];
 };
 
+nonNumericOnlyHash.digestNonNumericOnly = digestNonNumericOnly;
+nonNumericOnlyHash.digestNonNumericOnlyWithFull = digestNonNumericOnlyWithFull;
+
 module.exports = nonNumericOnlyHash;
-module.exports.digestNonNumericOnly = digestNonNumericOnly;
-module.exports.digestNonNumericOnlyWithFull = digestNonNumericOnlyWithFull;

package/lib/util/parseJson.js

@@ -4,9 +4,11 @@
 
 "use strict";
 
-const JSONParseError = require("../errors/JSONParseError");
+const memoize = require("./memoize");
 
-/** @typedef {import("../util/fs").JsonValue} JsonValue */
+const getJSONParseError = memoize(() => require("../errors/JSONParseError"));
+
+/** @import { JsonValue } from "../util/fs" */
 
 // Inspired by https://github.com/npm/json-parse-even-better-errors
 
@@ -34,7 +36,7 @@ const parseJson = (raw, reviver) => {
 	try {
 		return JSON.parse(txt, reviver);
 	} catch (err) {
-		throw new JSONParseError(/** @type {Error} */ (err), raw, txt);
+		throw new (getJSONParseError())(/** @type {Error} */ (err), raw, txt);
 	}
 };
 

package/lib/util/preloadModuleType.js

@@ -0,0 +1,32 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import NormalModuleFactory from "../NormalModuleFactory" */
+/** @typedef {import("./lazyModule").LazyModuleAccessor<EXPECTED_ANY>} AnyLazyModuleAccessor */
+
+/**
+ * Warms the modules a type's `createParser`/`createGenerator`/`createModuleClass`
+ * taps read, at the factory's async boundary — those hooks are synchronous, so
+ * they cannot await the load themselves.
+ * @param {NormalModuleFactory} normalModuleFactory the normal module factory
+ * @param {string} pluginName name of the tapping plugin
+ * @param {Iterable<[string, AnyLazyModuleAccessor[]]>} table module type to the accessors its taps read
+ * @returns {void}
+ */
+const preloadModuleType = (normalModuleFactory, pluginName, table) => {
+	for (const [type, accessors] of table) {
+		normalModuleFactory.hooks.prepareModuleType
+			.for(type)
+			.tapPromise(pluginName, () =>
+				Promise.all(accessors.map((accessor) => accessor())).then(
+					() => undefined
+				)
+			);
+	}
+};
+
+module.exports = preloadModuleType;

package/lib/util/registerExternalSerializer.js

@@ -19,11 +19,13 @@ const {
 } = require("webpack-sources");
 const { register } = require("./serialization");
 
-/** @typedef {import("acorn").Position} Position */
-/** @typedef {import("../Dependency").RealDependencyLocation} RealDependencyLocation */
-/** @typedef {import("../Dependency").SourcePosition} SourcePosition */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @import { RealDependencyLocation, SourcePosition } from "../Dependency" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
 
 const CURRENT_MODULE = "webpack/lib/util/registerExternalSerializer";
 

package/lib/util/removeBOM.js

@@ -5,12 +5,17 @@
 
 "use strict";
 
+const { decodeVLQ, encodeVLQ } = require("./createMappings");
+
+/** @import { RawSourceMap } from "webpack-sources" */
+/** @import { Result } from "../NormalModule" */
+
 /**
  * Returns result without BOM.
  * @param {string | Buffer} strOrBuffer string or buffer
  * @returns {string | Buffer} result without BOM
  */
-module.exports = (strOrBuffer) => {
+const removeBOM = (strOrBuffer) => {
 	if (typeof strOrBuffer === "string" && strOrBuffer.charCodeAt(0) === 0xfeff) {
 		return strOrBuffer.slice(1);
 	} else if (
@@ -24,3 +29,79 @@ module.exports = (strOrBuffer) => {
 
 	return strOrBuffer;
 };
+
+/**
+ * A BOM occupies generated column 0 of the first line, so a map describing
+ * BOM-prefixed content starts that line at column 1 or later. Removing the BOM
+ * moves the line one column left; the segments after the first are encoded
+ * relative to it, so only the first is rewritten. A map already starting at
+ * column 0 describes the content without its BOM and is left alone.
+ * @param {string} mappings VLQ encoded `mappings` of a map for BOM-prefixed content
+ * @returns {string} `mappings` for the same content without its BOM
+ */
+const shiftMappings = (mappings) => {
+	const { value, end } = decodeVLQ(mappings, 0);
+	if (end === 0 || value <= 0) return mappings;
+	return encodeVLQ(value - 1) + mappings.slice(end);
+};
+
+/**
+ * Adjust a source map that accompanied BOM-prefixed content for the removal of
+ * that BOM. Anything without VLQ `mappings` is passed through untouched, as is
+ * a map declaring a version other than 3 — earlier versions spell `mappings`
+ * differently. A map that declares no version at all is taken as version 3.
+ * @param {(string | RawSourceMap)=} sourceMap the map, as an object or as JSON
+ * @returns {(string | RawSourceMap)=} the adjusted map
+ */
+const adjustSourceMapForRemovedBOM = (sourceMap) => {
+	if (!sourceMap) return sourceMap;
+
+	if (typeof sourceMap === "string") {
+		/** @type {RawSourceMap} */
+		let parsed;
+		try {
+			parsed = JSON.parse(sourceMap);
+		} catch (_err) {
+			return sourceMap;
+		}
+		const adjusted = adjustSourceMapForRemovedBOM(parsed);
+		return adjusted === parsed ? sourceMap : JSON.stringify(adjusted);
+	}
+
+	if (sourceMap.version !== undefined && sourceMap.version !== 3) {
+		return sourceMap;
+	}
+
+	if (typeof sourceMap.mappings !== "string") return sourceMap;
+
+	const mappings = shiftMappings(sourceMap.mappings);
+
+	return mappings === sourceMap.mappings
+		? sourceMap
+		: { ...sourceMap, mappings };
+};
+
+/**
+ * @param {Result} result a loader result: content, an optional source map, extra info
+ * @returns {Result} the result with a leading BOM removed from its content and its source map kept in sync
+ */
+const removeBOMFromResult = (result) => {
+	const content = result[0];
+	const withoutBOM = removeBOM(content);
+
+	if (withoutBOM === content) return result;
+
+	// Copied rather than rebuilt, so a result carrying no source map keeps its
+	// arity.
+	const adjusted = /** @type {Result} */ ([...result]);
+
+	adjusted[0] = withoutBOM;
+
+	if (adjusted[1]) adjusted[1] = adjustSourceMapForRemovedBOM(adjusted[1]);
+
+	return adjusted;
+};
+
+module.exports.adjustSourceMapForRemovedBOM = adjustSourceMapForRemovedBOM;
+module.exports.removeBOM = removeBOM;
+module.exports.removeBOMFromResult = removeBOMFromResult;

package/lib/util/runtime.js

@@ -7,8 +7,8 @@
 
 const SortableSet = require("./SortableSet");
 
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Entrypoint").EntryOptions} EntryOptions */
+/** @import Compilation from "../Compilation" */
+/** @import { EntryOptions } from "../Entrypoint" */
 
 /** @typedef {SortableSet<string>} RuntimeSpecSortableSet */
 /** @typedef {string | RuntimeSpecSortableSet | undefined} RuntimeSpec */

package/lib/util/semver.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+/** @import RuntimeTemplate from "../RuntimeTemplate" */
 /** @typedef {string | number} VersionValue */
 /** @typedef {VersionValue | undefined} SemVerRangeItem */
 /** @typedef {(SemVerRangeItem | SemVerRangeItem[])[]} SemVerRange */

package/lib/util/serialization.js

@@ -5,31 +5,18 @@
 "use strict";
 
 const { DEFAULTS } = require("../config/defaults");
+const ObjectMiddleware = require("../serialization/ObjectMiddleware");
+const SerializerMiddleware = require("../serialization/SerializerMiddleware");
 const memoize = require("./memoize");
 
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_END_OPERATION_TYPE} MEASURE_END_OPERATION */
-/** @typedef {import("../serialization/BinaryMiddleware").MEASURE_START_OPERATION_TYPE} MEASURE_START_OPERATION */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
-
-/**
- * Defines the serializer type used by this module.
- * @template D, S, C
- * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
- */
+const getSerializer = memoize(() => require("../serialization/Serializer"));
 
-const getBinaryMiddleware = memoize(() =>
-	require("../serialization/BinaryMiddleware")
-);
-const getObjectMiddleware = memoize(() =>
-	require("../serialization/ObjectMiddleware")
-);
 const getSingleItemMiddleware = memoize(() =>
 	require("../serialization/SingleItemMiddleware")
 );
-const getSerializer = memoize(() => require("../serialization/Serializer"));
-const getSerializerMiddleware = memoize(() =>
-	require("../serialization/SerializerMiddleware")
+
+const getBinaryMiddleware = memoize(() =>
+	require("../serialization/BinaryMiddleware")
 );
 
 const getBinaryMiddlewareInstance = memoize(
@@ -43,7 +30,7 @@ const registerSerializers = memoize(() => {
 	// This allows bundling all internal serializers
 	const internalSerializables = require("./internalSerializables");
 
-	getObjectMiddleware().registerLoader(/^webpack\/lib\//, (req) => {
+	ObjectMiddleware.registerLoader(/^webpack\/lib\//, (req) => {
 		const loader =
 			internalSerializables[
 				/** @type {keyof import("./internalSerializables")} */
@@ -59,6 +46,21 @@ const registerSerializers = memoize(() => {
 	});
 });
 
+/**
+ * @import {
+ * 	MEASURE_END_OPERATION_TYPE as MEASURE_END_OPERATION,
+ * 	MEASURE_START_OPERATION_TYPE as MEASURE_START_OPERATION
+ * } from "../serialization/BinaryMiddleware"
+ */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { IntermediateFileSystem } from "../util/fs" */
+
+/**
+ * Defines the serializer type used by this module.
+ * @template D, S, C
+ * @typedef {import("../serialization/Serializer")<D, S, C>} Serializer
+ */
+
 /**
  * @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>}
  */
@@ -67,16 +69,16 @@ let buffersSerializer;
 // Expose serialization API
 module.exports = {
 	get register() {
-		return getObjectMiddleware().register;
+		return ObjectMiddleware.register;
 	},
 	get registerLoader() {
-		return getObjectMiddleware().registerLoader;
+		return ObjectMiddleware.registerLoader;
 	},
 	get registerNotSerializable() {
-		return getObjectMiddleware().registerNotSerializable;
+		return ObjectMiddleware.registerNotSerializable;
 	},
 	get NOT_SERIALIZABLE() {
-		return getObjectMiddleware().NOT_SERIALIZABLE;
+		return ObjectMiddleware.NOT_SERIALIZABLE;
 	},
 	/** @type {MEASURE_START_OPERATION} */
 	get MEASURE_START_OPERATION() {
@@ -91,12 +93,11 @@ module.exports = {
 		registerSerializers();
 		const Serializer = getSerializer();
 		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
 		return /** @type {Serializer<EXPECTED_ANY, EXPECTED_ANY, EXPECTED_ANY>} */ (
 			buffersSerializer = new Serializer([
 				new SingleItemMiddleware(),
-				new (getObjectMiddleware())((context) => {
+				new ObjectMiddleware((context) => {
 					if ("write" in context) {
 						context.writeLazy = (value) => {
 							context.write(
@@ -124,12 +125,11 @@ module.exports = {
 
 		const fileMiddleware = new FileMiddleware(fs, hashFunction);
 		const binaryMiddleware = getBinaryMiddlewareInstance();
-		const SerializerMiddleware = getSerializerMiddleware();
 		const SingleItemMiddleware = getSingleItemMiddleware();
 		return /** @type {Serializer<D, S, C>} */ (
 			new Serializer([
 				new SingleItemMiddleware(),
-				new (getObjectMiddleware())((context) => {
+				new ObjectMiddleware((context) => {
 					if ("write" in context) {
 						context.writeLazy = (value) => {
 							context.write(

package/lib/util/source.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("webpack-sources").Source} Source */
-/** @typedef {import("./Hash")} Hash */
+/** @import { Source } from "webpack-sources" */
+/** @import Hash from "./Hash" */
 
 /** @type {WeakMap<Source, WeakMap<Source, boolean>>} */
 const equalityCache = new WeakMap();

package/lib/util/traverseDestructuringAssignmentProperties.js

@@ -5,8 +5,12 @@
 
 "use strict";
 
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperties} DestructuringAssignmentProperties */
-/** @typedef {import("../javascript/JavascriptParser").DestructuringAssignmentProperty} DestructuringAssignmentProperty */
+/**
+ * @import {
+ * 	DestructuringAssignmentProperties,
+ * 	DestructuringAssignmentProperty
+ * } from "../javascript/JavascriptParser"
+ */
 
 /**
  * Deep first traverse the properties of a destructuring assignment.

package/lib/wasm/EnableWasmLoadingPlugin.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-/** @typedef {import("../../declarations/WebpackOptions").WasmLoadingType} WasmLoadingType */
-/** @typedef {import("../Compiler")} Compiler */
+/** @import { WasmLoadingType } from "../../declarations/WebpackOptions" */
+/** @import Compiler from "../Compiler" */
 
 /** @typedef {Set<WasmLoadingType>} WasmLoadingTypes */
 
@@ -114,9 +114,10 @@ class EnableWasmLoadingPlugin {
 
 						new ReadFileCompileWasmPlugin({
 							mangleImports: compiler.options.optimization.mangleWasmImports,
-							import:
-								compiler.options.output.module &&
-								compiler.options.output.environment.dynamicImport
+							// ESM output has no `require`, and any runtime that loads ESM has
+							// `import()` — pairing them by `dynamicImport` emitted CJS into an
+							// ES module, which the runtime refuses to load at all.
+							import: compiler.options.output.module
 						}).apply(compiler);
 					}
 
@@ -124,9 +125,10 @@ class EnableWasmLoadingPlugin {
 						const ReadFileCompileAsyncWasmPlugin = require("../node/ReadFileCompileAsyncWasmPlugin");
 
 						new ReadFileCompileAsyncWasmPlugin({
-							import:
-								compiler.options.output.module &&
-								compiler.options.output.environment.dynamicImport
+							// ESM output has no `require`, and any runtime that loads ESM has
+							// `import()` — pairing them by `dynamicImport` emitted CJS into an
+							// ES module, which the runtime refuses to load at all.
+							import: compiler.options.output.module
 						}).apply(compiler);
 					}
 

package/lib/wasm/wasmModuleFilename.js

@@ -0,0 +1,54 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q @sheo13666q
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const {
+	getPresentKinds,
+	reEncodeDigest,
+	usesFullHashDigest
+} = require("../TemplatedPathPlugin");
+
+/** @import Compilation from "../Compilation" */
+
+/**
+ * Whether the runtime needs `getFullHash` to build a binary's name. A `[hash]` next to
+ * a module resolves to that module's hash, not the compilation's, so only the explicit
+ * `[fullhash]` spelling asks for it — and a digest is inlined rather than read.
+ * @param {string} filename `output.webassemblyModuleFilename`
+ * @returns {boolean} true when the runtime reads the compilation hash
+ */
+const needsRuntimeFullHash = (filename) =>
+	getPresentKinds(filename).has("fullhash") && !usesFullHashDigest(filename);
+
+/**
+ * The compilation-hash half of the `getPath` data for interpolating
+ * `output.webassemblyModuleFilename` into runtime code.
+ * @param {Compilation} compilation the compilation
+ * @returns {{ hash: string, hashWithLength: (length: number) => string, hashWithDigest: (digest: string, length?: number) => string }} the fields
+ */
+const fullHashPathData = (compilation) => ({
+	hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
+	hashWithLength: (length) =>
+		`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
+	// A digest re-encodes the hash, which the runtime expression above cannot carry, so
+	// the settled value is inlined instead — byte-identical to the emitted filename.
+	hashWithDigest: (digest, length) => {
+		const { fullHash, outputOptions } = compilation;
+		// Pre-hash pass: a stand-in, replaced on the post-hash re-render that
+		// `needsInlinedFullHash` asks for. Matches `GetFullHashRuntimeModule`.
+		if (!fullHash) return length ? "x".repeat(length) : "x";
+		const hash = reEncodeDigest(
+			fullHash,
+			outputOptions.hashDigest || "hex",
+			digest
+		);
+		return length ? hash.slice(0, length) : hash;
+	}
+});
+
+module.exports.fullHashPathData = fullHashPathData;
+module.exports.needsRuntimeFullHash = needsRuntimeFullHash;

package/lib/wasm-async/AsyncWasmCompileRuntimeModule.js

@@ -8,12 +8,15 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeCompileStreaming */
 
 /**
@@ -22,6 +25,7 @@ const Template = require("../Template");
  * @property {GenerateBeforeLoadBinaryCode=} generateBeforeLoadBinaryCode
  * @property {GenerateBeforeCompileStreaming=} generateBeforeCompileStreaming
  * @property {boolean} supportsStreaming
+ * @property {boolean=} fullHashDigest the binary's name inlines a re-encoded compilation hash
  */
 
 class AsyncWasmCompileRuntimeModule extends RuntimeModule {
@@ -32,9 +36,16 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		generateLoadBinaryCode,
 		generateBeforeLoadBinaryCode,
 		generateBeforeCompileStreaming,
-		supportsStreaming
+		supportsStreaming,
+		fullHashDigest
 	}) {
 		super("wasm compile", RuntimeModule.STAGE_NORMAL);
+		// A re-encoded digest is inlined from the settled hash, so this has to render
+		// again once there is one.
+		if (fullHashDigest) {
+			/** @type {boolean} */
+			this.fullHash = true;
+		}
 		/** @type {GenerateLoadBinaryCode} */
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
 		/** @type {GenerateBeforeLoadBinaryCode | undefined} */
@@ -56,24 +67,35 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		// Opt-out fallback to non-streaming when the server serves wasm with a wrong MIME type.
 		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.compileWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: '" + wasmModuleHash + "',
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
+		// Analyzable output bakes the binary's URL into the call site instead.
+		const analyzable = runtimeTemplate.supportsAnalyzable(
+			"wasm",
+			/** @type {ChunkGraph} */ (this.chunkGraph),
+			undefined,
+			chunk.runtime
 		);
+		const wasmModuleSrcPath = analyzable
+			? "wasmModuleUrl"
+			: compilation.getPath(
+					JSON.stringify(outputOptions.webassemblyModuleFilename),
+					{
+						...fullHashPathData(compilation),
+						module: {
+							id: '" + wasmModuleId + "',
+							hash: '" + wasmModuleHash + "',
+							hashWithLength(length) {
+								return `" + wasmModuleHash.slice(0, ${length}) + "`;
+							}
+						},
+						runtime: chunk.runtime
+					}
+				);
 
-		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+		const loader = this.generateLoadBinaryCode(
+			wasmModuleSrcPath,
+			chunk.runtime,
+			analyzable
+		);
 
 		// Fallback path: fetch -> arrayBuffer -> WebAssembly.compile
 		const fallback = [
@@ -138,7 +160,7 @@ class AsyncWasmCompileRuntimeModule extends RuntimeModule {
 		};
 
 		return `${fn} = ${runtimeTemplate.basicFunction(
-			"wasmModuleId, wasmModuleHash",
+			analyzable ? "wasmModuleUrl" : "wasmModuleId, wasmModuleHash",
 			this.supportsStreaming
 				? getStreaming()
 				: [

package/lib/wasm-async/AsyncWasmLoadingRuntimeModule.js

@@ -8,12 +8,15 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { fullHashPathData } = require("../wasm/wasmModuleFilename");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Compilation from "../Compilation" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /** @typedef {(wasmModuleSrcPath: string) => string} GenerateBeforeLoadBinaryCode */
-/** @typedef {(wasmModuleSrcPath: string) => string} GenerateLoadBinaryCode */
+/** @typedef {(wasmModuleSrcPath: string, runtime: RuntimeSpec, analyzable: boolean) => string} GenerateLoadBinaryCode */
 /** @typedef {() => string} GenerateBeforeInstantiateStreaming */
 
 /**
@@ -22,6 +25,7 @@ const Template = require("../Template");
  * @property {GenerateBeforeLoadBinaryCode=} generateBeforeLoadBinaryCode
  * @property {GenerateBeforeInstantiateStreaming=} generateBeforeInstantiateStreaming
  * @property {boolean} supportsStreaming
+ * @property {boolean=} fullHashDigest the binary's name inlines a re-encoded compilation hash
  */
 
 class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
@@ -32,9 +36,16 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		generateLoadBinaryCode,
 		generateBeforeLoadBinaryCode,
 		generateBeforeInstantiateStreaming,
-		supportsStreaming
+		supportsStreaming,
+		fullHashDigest
 	}) {
 		super("wasm loading", RuntimeModule.STAGE_NORMAL);
+		// A re-encoded digest is inlined from the settled hash, so this has to render
+		// again once there is one.
+		if (fullHashDigest) {
+			/** @type {boolean} */
+			this.fullHash = true;
+		}
 		/** @type {GenerateLoadBinaryCode} */
 		this.generateLoadBinaryCode = generateLoadBinaryCode;
 		/** @type {generateBeforeLoadBinaryCode | undefined} */
@@ -57,24 +68,35 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		// Opt-in fallback to non-streaming when the server serves wasm with a wrong MIME type.
 		const streamingFallback = outputOptions.wasmStreamingFallback;
 		const fn = RuntimeGlobals.instantiateWasm;
-		const wasmModuleSrcPath = compilation.getPath(
-			JSON.stringify(outputOptions.webassemblyModuleFilename),
-			{
-				hash: `" + ${RuntimeGlobals.getFullHash}() + "`,
-				hashWithLength: (length) =>
-					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
-				module: {
-					id: '" + wasmModuleId + "',
-					hash: '" + wasmModuleHash + "',
-					hashWithLength(length) {
-						return `" + wasmModuleHash.slice(0, ${length}) + "`;
-					}
-				},
-				runtime: chunk.runtime
-			}
+		// Analyzable output bakes the binary's URL into the call site instead.
+		const analyzable = runtimeTemplate.supportsAnalyzable(
+			"wasm",
+			/** @type {ChunkGraph} */ (this.chunkGraph),
+			undefined,
+			chunk.runtime
 		);
+		const wasmModuleSrcPath = analyzable
+			? "wasmModuleUrl"
+			: compilation.getPath(
+					JSON.stringify(outputOptions.webassemblyModuleFilename),
+					{
+						...fullHashPathData(compilation),
+						module: {
+							id: '" + wasmModuleId + "',
+							hash: '" + wasmModuleHash + "',
+							hashWithLength(length) {
+								return `" + wasmModuleHash.slice(0, ${length}) + "`;
+							}
+						},
+						runtime: chunk.runtime
+					}
+				);
 
-		const loader = this.generateLoadBinaryCode(wasmModuleSrcPath);
+		const loader = this.generateLoadBinaryCode(
+			wasmModuleSrcPath,
+			chunk.runtime,
+			analyzable
+		);
 		const fallback = [
 			`.then(${runtimeTemplate.returningFunction("x.arrayBuffer()", "x")})`,
 			`.then(${runtimeTemplate.returningFunction(
@@ -149,7 +171,9 @@ class AsyncWasmLoadingRuntimeModule extends RuntimeModule {
 		};
 
 		return `${fn} = ${runtimeTemplate.basicFunction(
-			"exports, wasmModuleId, wasmModuleHash, importsObj",
+			analyzable
+				? "exports, wasmModuleUrl, importsObj"
+				: "exports, wasmModuleId, wasmModuleHash, importsObj",
 			this.supportsStreaming
 				? getStreaming()
 				: [