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

package/lib/optimize/ConstExportsPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const CircularModulesPlugin = require("../CircularModulesPlugin");
 const { UsageState } = require("../ExportsInfo");
 const {
 	JAVASCRIPT_MODULE_TYPE_AUTO,
@@ -18,6 +19,8 @@ const {
 	toInlinedValue
 } = require("./InlineExports");
 
+const { CircularKind } = CircularModulesPlugin;
+
 /** @import { InlinedValue } from "./InlineExports" */
 /** @import Compiler from "../Compiler" */
 /** @import ExportsInfo from "../ExportsInfo" */
@@ -161,50 +164,63 @@ class ConstExportsPlugin {
 				enableInlineExports(compilation.moduleGraph);
 
 				const moduleGraph = compilation.moduleGraph;
-				compilation.hooks.optimizeDependencies.tap(PLUGIN_NAME, (modules) => {
-					/** @type {Set<ExportsInfo>} */
-					const visited = new Set();
-					/** @type {ExportsInfo[]} */
-					let queue = [];
-					for (const module of modules) {
-						queue.push(moduleGraph.getExportsInfo(module));
-					}
-					while (queue.length > 0) {
-						const items = queue;
-						queue = [];
-						for (const exportsInfo of items) {
-							if (visited.has(exportsInfo)) continue;
-							visited.add(exportsInfo);
-							// Other-export usage means we can't safely inline (some non-statically-known consumer)
+				// After CircularModulesPlugin (STAGE_DETECT): needs Binding kind flags.
+				compilation.hooks.optimizeDependencies.tap(
+					{
+						name: PLUGIN_NAME,
+						stage: CircularModulesPlugin.STAGE_DETECT + 1
+					},
+					(modules) => {
+						/** @type {Set<ExportsInfo>} */
+						const visited = new Set();
+						/** @type {ExportsInfo[]} */
+						let queue = [];
+						for (const module of modules) {
+							// Binding-observable cycle peers must keep TDZ live bindings.
 							if (
-								exportsInfo.otherExportsInfo.getUsed(undefined) !==
-								UsageState.Unused
+								CircularModulesPlugin.isCircular(module, CircularKind.Binding)
 							) {
 								continue;
 							}
-							for (const exportInfo of exportsInfo.ownedExports) {
-								const inlined = exportInfo.canInline();
-								const doInline =
-									!exportInfo.hasUsedName() &&
-									inlined !== undefined &&
-									exportInfo.provided === true;
-								if (doInline) {
-									exportInfo.setUsedName(new InlinedUsedName(inlined));
-									exportsInfo.markInlinedExports();
+							queue.push(moduleGraph.getExportsInfo(module));
+						}
+						while (queue.length > 0) {
+							const items = queue;
+							queue = [];
+							for (const exportsInfo of items) {
+								if (visited.has(exportsInfo)) continue;
+								visited.add(exportsInfo);
+								// Other-export usage means we can't safely inline (some non-statically-known consumer)
+								if (
+									exportsInfo.otherExportsInfo.getUsed(undefined) !==
+									UsageState.Unused
+								) {
+									continue;
 								}
-								if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
-									const used = exportInfo.getUsed(undefined);
-									if (
-										used === UsageState.OnlyPropertiesUsed ||
-										used === UsageState.Unused
-									) {
-										queue.push(exportInfo.exportsInfo);
+								for (const exportInfo of exportsInfo.ownedExports) {
+									const inlined = exportInfo.canInline();
+									const doInline =
+										!exportInfo.hasUsedName() &&
+										inlined !== undefined &&
+										exportInfo.provided === true;
+									if (doInline) {
+										exportInfo.setUsedName(new InlinedUsedName(inlined));
+										exportsInfo.markInlinedExports();
+									}
+									if (exportInfo.exportsInfoOwned && exportInfo.exportsInfo) {
+										const used = exportInfo.getUsed(undefined);
+										if (
+											used === UsageState.OnlyPropertiesUsed ||
+											used === UsageState.Unused
+										) {
+											queue.push(exportInfo.exportsInfo);
+										}
 									}
 								}
 							}
 						}
 					}
-				});
+				);
 			}
 		);
 	}

package/lib/optimize/FlagIncludedChunksPlugin.js

@@ -24,17 +24,9 @@ class FlagIncludedChunksPlugin {
 			compilation.hooks.optimizeChunkIds.tap(PLUGIN_NAME, (chunks) => {
 				const chunkGraph = compilation.chunkGraph;
 
-				// prepare two bit integers for each module
-				// 2^31 is the max number represented as SMI in v8
-				// we want the bits distributed this way:
-				// the bit 2^31 is pretty rar and only one module should get it
-				// so it has a probability of 1 / modulesCount
-				// the first bit (2^0) is the easiest and every module could get it
-				// if it doesn't get a better bit
-				// from bit 2^n to 2^(n+1) there is a probability of p
-				// so 1 / modulesCount == p^31
-				// <=> p = sqrt31(1 / modulesCount)
-				// so we use a modulo of 1 / sqrt31(1 / modulesCount)
+				// Two bit integers per module, within v8's 2^31 SMI range. The bits are
+				// spread so 2^31 falls to about one module in `modulesCount` and 2^0 to
+				// any module missing a better one, which gives the modulo below.
 				/** @type {WeakMap<Module, number>} */
 				const moduleBits = new WeakMap();
 				const modulesCount = compilation.modules.size;

package/lib/optimize/InlineExports.js

@@ -17,6 +17,7 @@ const { propertyAccess } = require("../util/property");
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import Module from "../Module" */
 /** @import { RuntimeSpec } from "../util/runtime" */
+/** @import Hash from "../util/Hash" */
 
 const MAX_INLINE_BYTES = 6;
 
@@ -60,6 +61,14 @@ class InlinedValue {
 		return `(${comment}${this.renderLiteral()})`;
 	}
 
+	/**
+	 * @param {InlinedValue} other other inlined value
+	 * @returns {boolean} true when kind and value match
+	 */
+	equals(other) {
+		return this.kind === other.kind && this.value === other.value;
+	}
+
 	/**
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -96,12 +105,21 @@ class InlinedUsedName {
 	}
 
 	/**
-	 * @param {string} comment leading comment text
+	 * @param {string=} comment leading comment text
 	 * @returns {string} rendered literal with property access suffix
 	 */
-	render(comment) {
+	render(comment = "") {
 		return this.value.render(comment) + propertyAccess(this.suffix);
 	}
+
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash the hash used to track dependencies
+	 * @returns {void}
+	 */
+	updateHash(hash) {
+		hash.update(this.render());
+	}
 }
 
 /**

package/lib/optimize/InnerGraphPlugin.js

@@ -122,10 +122,8 @@ class InnerGraphPlugin {
 					// nodes that have a TopLevelSymbol assigned and
 					// variables are tagged with the assigned TopLevelSymbol
 
-					// We differ 3 types of nodes:
-					// 1. full statements (export default, function declaration)
-					// 2. classes (class declaration, class expression)
-					// 3. variable declarators (const x = ...)
+					// Three kinds of node carry a symbol: a full statement, a class, and a
+					// variable declarator.
 
 					/** @type {WeakMap<Node | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration, TopLevelSymbol>} */
 					let statementWithTopLevelSymbol = new WeakMap();
@@ -360,16 +358,12 @@ class InnerGraphPlugin {
 					// During real walking we set the TopLevelSymbol state to the assigned
 					// TopLevelSymbol by using the fill datastructures.
 
-					// In addition to tracking TopLevelSymbols, we sometimes need to
-					// add a PureExpressionDependency. This is needed to skip execution
-					// of pure expressions, even when they are not dropped due to
-					// minimizing. Otherwise symbols used there might not exist anymore
-					// as they are removed as unused by this optimization
+					// A `PureExpressionDependency` is sometimes added too, so a pure
+					// expression is skipped even where minimizing leaves it: the symbols it
+					// uses may have been removed as unused by this optimization.
 
-					// When we find a reference to a TopLevelSymbol, we register a
-					// TopLevelSymbol dependency from TopLevelSymbol in state to the
-					// referenced TopLevelSymbol. This way we get a graph of all
-					// TopLevelSymbols.
+					// A reference registers a dependency from the symbol in state to the one
+					// referenced, which is how the graph of all of them is built.
 
 					// The following hooks are called during walking:
 

package/lib/optimize/LimitChunkCountPlugin.js

@@ -101,10 +101,8 @@ class LimitChunkCountPlugin {
 					/** @type {Chunk[]} */
 					const orderedChunks = [...chunks].sort(compareChunksWithGraph);
 
-					// create a lazy sorted data structure to keep all combinations
-					// this is large. Size = chunks * (chunks - 1) / 2
-					// It uses a multi layer bucket sort plus normal sort in the last layer
-					// It's also lazy so only accessed buckets are sorted
+					// All `chunks * (chunks - 1) / 2` combinations, held in a multi-layer
+					// bucket sort that sorts only the buckets actually reached.
 					/** @type {LazyBucketSortedSet<ChunkCombination, number>} */
 					const combinations = new LazyBucketSortedSet(
 						// Layer 1: ordered by largest size benefit
@@ -214,10 +212,9 @@ class LimitChunkCountPlugin {
 							for (const group of queue) {
 								for (const mChunk of modifiedChunks) {
 									if (mChunk !== a && mChunk !== b && mChunk.isInGroup(group)) {
-										// This is a potential pair which needs recalculation
-										// We can't do that now, but it merge before following pairs
-										// so we leave space for it, and consider chunks as modified
-										// just for the worse case
+										// A pair needing recalculation, which cannot happen now yet may
+										// merge before the ones that follow, so room is left for it and
+										// the chunks count as modified for the worst case.
 										remainingChunksToMerge--;
 										if (remainingChunksToMerge <= 0) break loop;
 										modifiedChunks.add(a);

package/lib/optimize/MangleExportsPlugin.js

@@ -15,6 +15,7 @@ const { assignDeterministicIds } = require("../ids/IdHelpers");
 const { compareSelect, compareStringsNumeric } = require("../util/comparators");
 
 /** @import Compiler from "../Compiler" */
+/** @import { BuildInfo } from "../Module" */
 /** @import ExportsInfo, { ExportInfo } from "../ExportsInfo" */
 /** @import { UsedNames } from "../util/concatenate" */
 
@@ -59,10 +60,9 @@ const mangleExportsInfo = (deterministic, exportsInfo, isNamespace) => {
 	/** @type {InstanceType<ExportInfo>[]} */
 	const mangleableExports = [];
 
-	// Avoid to renamed exports that are not provided when
-	// 1. it's not a namespace export: non-provided exports can be found in prototype chain
-	// 2. there are other provided exports and deterministic mode is chosen:
-	//    non-provided exports would break the determinism
+	// A non-provided export is left unmangled outside a namespace export, where the
+	// prototype chain may still carry it, and under deterministic mode beside other
+	// provided exports, where it would break the determinism.
 	let avoidMangleNonProvided = !isNamespace;
 	if (!avoidMangleNonProvided && deterministic) {
 		for (const exportInfo of exportsInfo.ownedExports) {
@@ -184,6 +184,15 @@ class MangleExportsPlugin {
 					);
 				}
 				for (const module of modules) {
+					// A spec namespace reports the names the module exports, so a
+					// module handing one out cannot have them renamed.
+					if (
+						/** @type {BuildInfo} */
+						(module.buildInfo).specNamespaceObject
+					) {
+						continue;
+					}
+
 					const isNamespace =
 						module.buildMeta && module.buildMeta.exportsType === "namespace";
 					const exportsInfo = moduleGraph.getExportsInfo(module);

package/lib/optimize/ModuleConcatenationPlugin.js

@@ -5,7 +5,6 @@
 
 "use strict";
 
-const asyncLib = require("neo-async");
 const ChunkGraph = require("../ChunkGraph");
 const Dependency = require("../Dependency");
 const Module = require("../Module");
@@ -14,6 +13,7 @@ const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
 const { ImportPhaseUtils } = require("../dependencies/ImportPhase");
+const asyncLib = require("../util/async");
 const { compareModulesByIdentifier } = require("../util/comparators");
 const { isCommonJsConcatenationEnabled } = require("../util/concatenate");
 const {
@@ -28,6 +28,7 @@ const ConcatenatedModule = require("./ConcatenatedModule");
 /** @import Chunk from "../Chunk" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /** @import { BuildInfo, BuildMeta } from "../Module" */
 /** @import RequestShortener from "../RequestShortener" */
 /** @import { RuntimeSpec } from "../util/runtime" */
@@ -235,6 +236,19 @@ class ModuleConcatenationPlugin {
 							continue;
 						}
 
+						// Concatenation materializes the namespace inline, which would
+						// silently drop the spec exotic object the module asked for.
+						if (
+							/** @type {BuildInfo} */
+							(module.buildInfo).specNamespaceObject
+						) {
+							setBailoutReason(
+								module,
+								"Module hands out a spec namespace object"
+							);
+							continue;
+						}
+
 						// Module must be in any chunk (we don't want to do useless work)
 						if (chunkGraph.getNumberOfModuleChunks(module) === 0) {
 							setBailoutReason(module, "Module is not in any chunk");
@@ -302,6 +316,15 @@ class ModuleConcatenationPlugin {
 							canBeInner = false;
 						}
 
+						// The root stands in for the whole concatenation, so an
+						// expression only an inner module can answer statically rules it out
+						if (
+							/** @type {JavascriptModuleBuildInfo} */
+							(module.buildInfo).moduleConcatenationRootBailout
+						) {
+							canBeRoot = false;
+						}
+
 						if (deferEnabled && moduleGraph.isDeferred(module)) {
 							setInnerBailoutReason(module, "Module is deferred");
 							canBeInner = false;
@@ -455,10 +478,9 @@ class ModuleConcatenationPlugin {
 					logger.debug(
 						`${statsCandidates} candidates were considered for adding (${stats.cached} cached failure, ${stats.alreadyInConfig} already in config, ${stats.invalidModule} invalid module, ${stats.incorrectChunks} incorrect chunks, ${stats.incorrectDependency} incorrect dependency, ${stats.incorrectChunksOfImporter} incorrect chunks of importer, ${stats.incorrectModuleDependency} incorrect module dependency, ${stats.incorrectRuntimeCondition} incorrect runtime condition, ${stats.importerFailed} importer failed, ${stats.added} added)`
 					);
-					// Create the largest configurations first: if a root also ended up inside
-					// a bigger configuration, the bigger one wins (smaller skipped below).
-					// Configurations can't be reused across roots: a module shared by several
-					// chunks is concatenated into each consumer (module duplication).
+					// Largest configurations first, so a root that also landed inside a
+					// bigger one loses to it. None is reused across roots: a module shared by
+					// several chunks is concatenated into each consumer.
 					logger.time("sort concat configurations");
 					concatConfigurations.sort((a, b) => b.modules.size - a.modules.size);
 					logger.timeEnd("sort concat configurations");

package/lib/optimize/RealContentHashPlugin.js

@@ -187,6 +187,7 @@ const createCompilationHooks = () => ({
  * @typedef {object} RealContentHashPluginOptions
  * @property {HashFunction} hashFunction the hash function to use
  * @property {HashDigest} hashDigest the hash digest to use
+ * @property {boolean=} onDemand run only where analyzable output marked a name for repair
  */
 
 const PLUGIN_NAME = "RealContentHashPlugin";
@@ -196,11 +197,13 @@ class RealContentHashPlugin {
 	 * Creates an instance of RealContentHashPlugin.
 	 * @param {RealContentHashPluginOptions} options options
 	 */
-	constructor({ hashFunction, hashDigest }) {
+	constructor({ hashFunction, hashDigest, onDemand }) {
 		/** @type {HashFunction} */
 		this._hashFunction = hashFunction;
 		/** @type {HashDigest} */
 		this._hashDigest = hashDigest;
+		/** @type {boolean} */
+		this._onDemand = Boolean(onDemand);
 	}
 
 	/**
@@ -223,6 +226,14 @@ class RealContentHashPlugin {
 					stage: Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_HASH
 				},
 				async () => {
+					// Set by the deferred fill where a baked name would leave a hashed name
+					// stale; only then is `[chunkhash]` repaired rather than left as named.
+					const repairing = compilation.runtimeTemplate.needsAnalyzableRepair();
+					if (this._onDemand && !repairing) return;
+					// On demand, only a name the fill left stale moves, and whatever names it.
+					const repairedAssets = this._onDemand
+						? compilation.runtimeTemplate.analyzableRepairedAssets()
+						: undefined;
 					const assets = compilation.getAssets();
 					/** @type {AssetInfoForRealContentHash[]} */
 					const assetsWithInfo = [];
@@ -238,6 +249,7 @@ class RealContentHashPlugin {
 						/** @type {Hashes} */
 						const hashes = new Set();
 						addToList(info.contenthash, hashes);
+						if (repairing) addToList(info.chunkhash, hashes);
 						if (info.contenthashDigest) {
 							for (const hash of Object.keys(info.contenthashDigest)) {
 								hashToDigest.set(hash, info.contenthashDigest[hash]);
@@ -345,47 +357,68 @@ ${referencingAssets
 						}
 						return hashes;
 					};
+					// Tarjan: hashes naming each other come out as one group where a chain
+					// walk would never end, and groups arrive dependencies-first as needed.
+					/** @type {string[][]} */
+					const groupsInOrder = [];
+					/** @type {Map<string, number>} */
+					const indexOf = new Map();
+					/** @type {Map<string, number>} */
+					const lowOf = new Map();
+					/** @type {Set<string>} */
+					const onStack = new Set();
+					/** @type {string[]} */
+					const stack = [];
 					/**
-					 * Returns the hash info.
+					 * Visits one hash and everything its assets reference.
 					 * @param {string} hash the hash
-					 * @returns {string} the hash info
+					 * @returns {void}
 					 */
-					const hashInfo = (hash) => {
-						const assets = hashToAssets.get(hash);
-						return `${hash} (${Array.from(
-							/** @type {AssetInfoForRealContentHash[]} */ (assets),
-							(a) => a.name
-						)})`;
-					};
-					/** @type {Hashes} */
-					const hashesInOrder = new Set();
-					for (const hash of hashToAssets.keys()) {
-						/**
-						 * Processes the provided hash.
-						 * @param {string} hash the hash
-						 * @param {Set<string>} stack stack of hashes
-						 */
-						const add = (hash, stack) => {
-							const deps = getDependencies(hash);
-							if (!deps) return;
-							stack.add(hash);
+					const strongConnect = (hash) => {
+						const index = indexOf.size;
+						indexOf.set(hash, index);
+						lowOf.set(hash, index);
+						stack.push(hash);
+						onStack.add(hash);
+						// An unowned reference reports the caching problem and stays a leaf.
+						const deps = getDependencies(hash);
+						if (deps) {
 							for (const dep of deps) {
-								if (hashesInOrder.has(dep)) continue;
-								if (stack.has(dep)) {
-									throw new Error(
-										`Circular hash dependency ${Array.from(
-											stack,
-											hashInfo
-										).join(" -> ")} -> ${hashInfo(dep)}`
+								if (!indexOf.has(dep)) {
+									strongConnect(dep);
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (lowOf.get(dep))
+										)
+									);
+								} else if (onStack.has(dep)) {
+									lowOf.set(
+										hash,
+										Math.min(
+											/** @type {number} */ (lowOf.get(hash)),
+											/** @type {number} */ (indexOf.get(dep))
+										)
 									);
 								}
-								add(dep, stack);
 							}
-							hashesInOrder.add(hash);
-							stack.delete(hash);
-						};
-						if (hashesInOrder.has(hash)) continue;
-						add(hash, new Set());
+						}
+						if (lowOf.get(hash) === indexOf.get(hash)) {
+							/** @type {string[]} */
+							const group = [];
+							/** @type {string} */
+							let member;
+							do {
+								member = /** @type {string} */ (stack.pop());
+								onStack.delete(member);
+								if (hashToAssets.has(member)) group.push(member);
+							} while (member !== hash);
+							if (group.length > 0) groupsInOrder.push(group);
+						}
+					};
+					for (const hash of hashToAssets.keys()) {
+						if (!indexOf.has(hash)) strongConnect(hash);
 					}
 					/** @type {Map<string, string>} */
 					const hashToNewHash = new Map();
@@ -474,7 +507,99 @@ ${referencingAssets
 					};
 					/** @type {Comparator<AssetInfoForRealContentHash>} */
 					const comparator = compareSelect((a) => a.name, compareStrings);
-					for (const oldHash of hashesInOrder) {
+					/**
+					 * Whether a group's names went stale: the fill rewrote an asset of theirs, or
+					 * one names a hash that already moved (groups arrive dependencies first).
+					 * @param {string[]} group the hashes assigned together
+					 * @returns {boolean} true when they have to be recomputed
+					 */
+					const staleOnDemand = (group) => {
+						const own = new Set(group);
+						for (const hash of group) {
+							for (const asset of /** @type {AssetInfoForRealContentHash[]} */ (
+								hashToAssets.get(hash)
+							)) {
+								if (
+									/** @type {ReadonlySet<string>} */ (repairedAssets).has(
+										asset.name
+									)
+								) {
+									return true;
+								}
+								for (const referenced of /** @type {Hashes} */ (
+									asset.referencedHashes
+								)) {
+									if (
+										!own.has(referenced) &&
+										hashToNewHash.get(referenced) !== referenced
+									) {
+										return true;
+									}
+								}
+							}
+						}
+						return false;
+					};
+					for (const group of groupsInOrder) {
+						if (repairedAssets !== undefined && !staleOnDemand(group)) {
+							for (const hash of group) hashToNewHash.set(hash, hash);
+							continue;
+						}
+						// A cycle is assigned as one group: members are told apart by stable
+						// markers, so the group hashes to a fixed point instead of chasing one.
+						if (group.length > 1) {
+							const members = group.sort();
+							/** @type {Map<string, string>} */
+							const markerOf = new Map(
+								members.map((hash, i) => [hash, `|webpack/scc/${i}|`])
+							);
+							for (let i = 0; i < members.length; i++) {
+								const oldHash = members[i];
+								const memberAssets =
+									/** @type {AssetInfoForRealContentHash[]} */
+									(hashToAssets.get(oldHash));
+								memberAssets.sort(comparator);
+								const hash = createHash(this._hashFunction);
+								if (compilation.outputOptions.hashSalt) {
+									hash.update(compilation.outputOptions.hashSalt);
+								}
+								// Two members can normalize to the same text; the position keeps
+								// their hashes apart, and sorting keeps the position stable.
+								hash.update(`${i}`);
+								for (const asset of memberAssets) {
+									if (Buffer.isBuffer(asset.content)) {
+										hash.update(asset.content);
+										continue;
+									}
+									const withoutOwn =
+										/** @type {Hashes} */
+										(asset.ownHashes).has(oldHash);
+									hash.update(
+										asset.content.replace(hashRegExp, (matched) => {
+											// Its own occurrences vanish, exactly as a lone hash's do.
+											if (
+												withoutOwn &&
+												/** @type {Hashes} */ (asset.ownHashes).has(matched)
+											) {
+												return "";
+											}
+											const marker = markerOf.get(matched);
+											if (marker !== undefined) return marker;
+											const mapped = hashToNewHash.get(matched);
+											return mapped === undefined ? matched : mapped;
+										})
+									);
+								}
+								const digest = hash.digest(
+									/** @type {HashDigest} */ (
+										hashToDigest.get(oldHash) || this._hashDigest
+									)
+								);
+								hashToNewHash.set(oldHash, digest.slice(0, oldHash.length));
+							}
+							continue;
+						}
+						const oldHash = group[0];
 						const assets =
 							/** @type {AssetInfoForRealContentHash[]} */
 							(hashToAssets.get(oldHash));
@@ -532,15 +657,25 @@ ${referencingAssets
 								(hash) => /** @type {string} */ (hashToNewHash.get(hash))
 							);
 
+							/**
+							 * @param {string | string[]} hash what the asset was named with
+							 * @returns {string | string[]} the same, repaired
+							 */
+							const repaired = (hash) =>
+								Array.isArray(hash)
+									? hash.map(
+											(hash) => /** @type {string} */ (hashToNewHash.get(hash))
+										)
+									: /** @type {string} */ (hashToNewHash.get(hash));
+							/** @type {AssetInfo} */
 							const infoUpdate = {};
-							const hash =
-								/** @type {Exclude<AssetInfo["contenthash"], undefined>} */
-								(asset.info.contenthash);
-							infoUpdate.contenthash = Array.isArray(hash)
-								? hash.map(
-										(hash) => /** @type {string} */ (hashToNewHash.get(hash))
-									)
-								: /** @type {string} */ (hashToNewHash.get(hash));
+							if (asset.info.contenthash) {
+								infoUpdate.contenthash = repaired(asset.info.contenthash);
+							}
+							// Tracked only while repairing, so only then does it move with the name.
+							if (repairing && asset.info.chunkhash) {
+								infoUpdate.chunkhash = repaired(asset.info.chunkhash);
+							}
 
 							if (asset.newSource !== undefined) {
 								compilation.updateAsset(