webpack 5.111.1 → 5.112.1

package/lib/{buildChunkGraph.js → graph/buildChunkGraph.js}

@@ -5,27 +5,27 @@
 
 "use strict";
 
-const ModuleGraphConnection = require("./ModuleGraphConnection");
-const memoize = require("./util/memoize");
+const memoize = require("../util/memoize");
 
-const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
+const { getEntryRuntime, mergeRuntime } = require("../util/runtime");
+const ModuleGraphConnection = require("./ModuleGraphConnection");
 
 const getAsyncDependencyToInitialChunkError = memoize(() =>
-	require("./errors/AsyncDependencyToInitialChunkError")
+	require("../errors/AsyncDependencyToInitialChunkError")
 );
 
 /** @import AsyncDependenciesBlock from "./AsyncDependenciesBlock" */
 /** @import Chunk from "./Chunk" */
 /** @import ChunkGroup from "./ChunkGroup" */
-/** @import Compilation from "./Compilation" */
+/** @import Compilation from "../Compilation" */
 /** @import DependenciesBlock from "./DependenciesBlock" */
 /** @import { DependencyLocation } from "./Dependency" */
 /** @import Entrypoint, { EntryOptions } from "./Entrypoint" */
-/** @import Module from "./Module" */
+/** @import Module from "../module/Module" */
 /** @import ModuleGraph from "./ModuleGraph" */
 /** @import { ConnectionState } from "./ModuleGraphConnection" */
-/** @import { Logger } from "./logging/Logger" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import { Logger } from "../logging/Logger" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * Defines the queue item type used by this module.
@@ -43,13 +43,14 @@ const getAsyncDependencyToInitialChunkError = memoize(() =>
  * @typedef {object} ChunkGroupInfo
  * @property {ChunkGroup} chunkGroup the chunk group
  * @property {RuntimeSpec} runtime the runtimes
- * @property {boolean} initialized is this chunk group initialized
  * @property {bigint | undefined} minAvailableModules current minimal set of modules available at this point
  * @property {bigint[]} availableModulesToBeMerged enqueued updates to the minimal set of available modules
- * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules is shrinking)
+ * @property {Set<Module>=} skippedItems modules that were skipped because module is already available in parent chunks (need to reconsider when minAvailableModules changes)
  * @property {Set<[Module, ModuleGraphConnection[]]>=} skippedModuleConnections referenced modules that where skipped because they were not active in this runtime
  * @property {bigint | undefined} resultingAvailableModules set of modules available including modules from this chunk group
- * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when availableModules shrink
+ * @property {bigint | undefined} connectedAvailableModules resultingAvailableModules last passed to children, to detect when it grows
+ * @property {Set<ChunkGroupInfo> | undefined} children set of children chunk groups, that will be revisited when resultingAvailableModules changes
+ * @property {Set<ChunkGroupInfo> | undefined} parents set of parent chunk groups, whose resultingAvailableModules intersect to minAvailableModules
  * @property {Set<ChunkGroupInfo> | undefined} availableSources set of chunk groups that are the source for minAvailableModules
  * @property {Set<ChunkGroupInfo> | undefined} availableChildren set of chunk groups which depend on the this chunk group as availableSource
  * @property {number} preOrderIndex next pre order index
@@ -191,7 +192,11 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					if (modules[i] === m) {
 						const merged = /** @type {ConnectionState} */ (modules[i + 1]);
 						/** @type {ModuleGraphConnection[]} */
-						(/** @type {unknown} */ (modules[i + 2])).push(connection);
+						(
+							/** @type {BlockModulesInFlattenTuples[number]} */ (
+								modules[i + 2]
+							)
+						).push(connection);
 						if (merged === true) continue outer;
 						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
 							merged,
@@ -205,7 +210,8 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 				modules[length] = state;
 				length++;
 				/** @type {ModuleGraphConnection[]} */
-				(/** @type {unknown} */ (modules[length])) = [connection];
+				(/** @type {BlockModulesInFlattenTuples[number]} */ (modules[length])) =
+					[connection];
 				length++;
 				if (length > 30) {
 					// To avoid worse case performance, we will use an index map for
@@ -221,7 +227,11 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 				if (idx !== undefined) {
 					const merged = /** @type {ConnectionState} */ (modules[idx]);
 					/** @type {ModuleGraphConnection[]} */
-					(/** @type {unknown} */ (modules[idx + 1])).push(connection);
+					(
+						/** @type {BlockModulesInFlattenTuples[number]} */ (
+							modules[idx + 1]
+						)
+					).push(connection);
 					if (merged === true) continue;
 					modules[idx] = ModuleGraphConnection.addConnectionStates(
 						merged,
@@ -235,7 +245,7 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					length++;
 					/** @type {ModuleGraphConnection[]} */
 					(
-						/** @type {unknown} */
+						/** @type {BlockModulesInFlattenTuples[number]} */
 						(modules[length])
 					) = [connection];
 					length++;
@@ -358,10 +368,21 @@ const visitModules = (
 		const module = /** @type {Module} */ (block.getRootBlock());
 		const memCache = moduleMemCaches && moduleMemCaches.get(module);
 		if (memCache !== undefined) {
+			// an optimization (e.g. side effects) can flip a connection's active
+			// state without the module changing — key the cache by the states too
+			let stateEtag = "";
+			for (const connection of moduleGraph.getOutgoingConnections(module)) {
+				if (!connection.dependency || !connection.module || connection.weak) {
+					continue;
+				}
+				const state = connection.getActiveState(runtime);
+				stateEtag += state === true ? "T" : state === false ? "F" : "O";
+			}
 			/** @type {BlockModulesMap} */
 			const map = memCache.provide(
 				"bundleChunkGraph.blockModules",
 				runtime,
+				stateEtag,
 				() => {
 					logger.time("visitModules: prepare");
 					const map = new Map();
@@ -421,7 +442,7 @@ const visitModules = (
 	const blockChunkGroups = new Map();
 
 	/** @type {Map<ChunkGroupInfo, Set<DependenciesBlock>>} */
-	const blocksByChunkGroups = new Map();
+	const blocksByChunkGroupInfo = new Map();
 
 	/** @typedef {Map<string, ChunkGroupInfo>} NamedChunkGroup */
 
@@ -452,6 +473,8 @@ const visitModules = (
 	const queueConnect = new Map();
 	/** @type {Set<ChunkGroupInfo>} */
 	const chunkGroupsForCombining = new Set();
+	/** @type {Set<ChunkGroupInfo>} */
+	const chunkGroupsForGrowing = new Set();
 
 	// Fill queue with entrypoint modules
 	// Create ChunkGroupInfo for entrypoints
@@ -465,14 +488,15 @@ const visitModules = (
 		const chunkGroupInfo = {
 			depModule: null,
 			circular: false,
-			initialized: false,
 			chunkGroup,
 			runtime,
 			minAvailableModules: undefined,
 			availableModulesToBeMerged: [],
 			skippedItems: undefined,
 			resultingAvailableModules: undefined,
+			connectedAvailableModules: undefined,
 			children: undefined,
+			parents: undefined,
 			availableSources: undefined,
 			availableChildren: undefined,
 			preOrderIndex: 0,
@@ -597,7 +621,6 @@ const visitModules = (
 						depModule,
 						circular: b.circular,
 						chunkGroup: entrypoint,
-						initialized: false,
 						runtime:
 							entrypoint.options.runtime ||
 							/** @type {string | undefined} */ (entrypoint.name),
@@ -605,7 +628,9 @@ const visitModules = (
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
+						connectedAvailableModules: undefined,
 						children: undefined,
+						parents: undefined,
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
@@ -619,25 +644,14 @@ const visitModules = (
 								? entryOptions.asyncChunks
 								: chunkGroupInfo.asyncChunks
 					};
-					chunkGroupInfoMap.set(
-						entrypoint,
-						/** @type {ChunkGroupInfo} */
-						(cgi)
-					);
+					chunkGroupInfoMap.set(entrypoint, cgi);
 
 					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
 					if (chunkName) {
-						namedAsyncEntrypoints.set(
-							chunkName,
-							/** @type {ChunkGroupInfo} */
-							(cgi)
-						);
+						namedAsyncEntrypoints.set(chunkName, cgi);
 					}
 					if (!b.circular && depModule) {
-						depModuleAsyncEntrypoints.set(
-							depModule,
-							/** @type {ChunkGroupInfo} */ (cgi)
-						);
+						depModuleAsyncEntrypoints.set(depModule, cgi);
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
@@ -674,7 +688,7 @@ const visitModules = (
 					module,
 					chunk: entrypoint.chunks[0],
 					chunkGroup: entrypoint,
-					chunkGroupInfo: /** @type {ChunkGroupInfo} */ (cgi)
+					chunkGroupInfo: cgi
 				});
 			} else if (!chunkGroupInfo.asyncChunks || !chunkGroupInfo.chunkLoading) {
 				// Just queue the block into the current chunk group
@@ -700,14 +714,15 @@ const visitModules = (
 					cgi = {
 						depModule,
 						circular: b.circular,
-						initialized: false,
 						chunkGroup: c,
 						runtime: chunkGroupInfo.runtime,
 						minAvailableModules: undefined,
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
+						connectedAvailableModules: undefined,
 						children: undefined,
+						parents: undefined,
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
@@ -953,6 +968,12 @@ const visitModules = (
 					let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
 					chunkMask |= ONE_BIGINT << BigInt(moduleOrdinal);
 					maskByChunk.set(chunk, chunkMask);
+					if (chunkGroupInfo.resultingAvailableModules !== undefined) {
+						// A later block reached this chunk group after its children read this value,
+						// we clear it and mark outdated so the children reconnect and drop it
+						chunkGroupInfo.resultingAvailableModules = undefined;
+						outdatedChunkGroupInfo.add(chunkGroupInfo);
+					}
 				}
 				// fallthrough
 				case ENTER_MODULE: {
@@ -1009,6 +1030,19 @@ const visitModules = (
 		}
 	};
 
+	/**
+	 * Get the modules in the chunks of a chunk group.
+	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
+	 * @returns {bigint} The mask of modules in the chunks of the chunk group
+	 */
+	const getChunkGroupMask = (chunkGroupInfo) => {
+		let mask = ZERO_BIGINT;
+		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
+			mask |= /** @type {bigint} */ (maskByChunk.get(chunk));
+		}
+		return mask;
+	};
+
 	/**
 	 * Calculate resulting available modules.
 	 * @param {ChunkGroupInfo} chunkGroupInfo The info object for the chunk group
@@ -1019,18 +1053,9 @@ const visitModules = (
 			return chunkGroupInfo.resultingAvailableModules;
 		}
 
-		let resultingAvailableModules = /** @type {bigint} */ (
-			chunkGroupInfo.minAvailableModules
-		);
-
-		// add the modules from the chunk group to the set
-		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
-			const mask = /** @type {bigint} */ (maskByChunk.get(chunk));
-			resultingAvailableModules |= mask;
-		}
-
 		return (chunkGroupInfo.resultingAvailableModules =
-			resultingAvailableModules);
+			/** @type {bigint} */ (chunkGroupInfo.minAvailableModules) |
+			getChunkGroupMask(chunkGroupInfo));
 	};
 
 	const processConnectQueue = () => {
@@ -1048,13 +1073,30 @@ const visitModules = (
 			// 2. Calculate resulting available modules
 			const resultingAvailableModules =
 				calculateResultingAvailableModules(chunkGroupInfo);
+			const connectedAvailableModules =
+				chunkGroupInfo.connectedAvailableModules;
+			// Merging only intersects, so when this grew all children need the growing phase
+			if (
+				connectedAvailableModules !== undefined &&
+				resultingAvailableModules !== connectedAvailableModules &&
+				(resultingAvailableModules & ~connectedAvailableModules) !== ZERO_BIGINT
+			) {
+				for (const child of chunkGroupInfo.children) {
+					if (!child.chunkGroup.isInitial()) chunkGroupsForGrowing.add(child);
+				}
+			}
+			chunkGroupInfo.connectedAvailableModules = resultingAvailableModules;
 
 			const runtime = chunkGroupInfo.runtime;
 
 			// 3. Update chunk group info
-			for (const [target, processBlock] of targets) {
+			for (const [target, queueItem] of targets) {
+				if (target.parents === undefined) {
+					target.parents = new Set();
+				}
+				target.parents.add(chunkGroupInfo);
 				target.availableModulesToBeMerged.push(resultingAvailableModules);
-				chunkGroupsForMerging.add([target, processBlock]);
+				chunkGroupsForMerging.add([target, queueItem]);
 				const oldRuntime = target.runtime;
 				const newRuntime = mergeRuntime(oldRuntime, runtime);
 				if (oldRuntime !== newRuntime) {
@@ -1072,7 +1114,7 @@ const visitModules = (
 		statProcessedChunkGroupsForMerging += chunkGroupsForMerging.size;
 
 		// Execute the merge
-		for (const [info, processBlock] of chunkGroupsForMerging) {
+		for (const [info, queueItem] of chunkGroupsForMerging) {
 			const availableModulesToBeMerged = info.availableModulesToBeMerged;
 			const cachedMinAvailableModules = info.minAvailableModules;
 			let minAvailableModules = cachedMinAvailableModules;
@@ -1099,25 +1141,17 @@ const visitModules = (
 				outdatedChunkGroupInfo.add(info);
 			}
 
-			if (processBlock) {
-				let blocks = blocksByChunkGroups.get(info);
-				if (!blocks) {
-					blocksByChunkGroups.set(info, (blocks = new Set()));
+			if (queueItem !== null) {
+				let blocks = blocksByChunkGroupInfo.get(info);
+				if (blocks === undefined) {
+					blocks = new Set();
+					blocksByChunkGroupInfo.set(info, blocks);
 				}
 
-				// Whether to walk block depends on minAvailableModules and input block.
-				// We can treat creating chunk group as a function with 2 input, entry block and minAvailableModules
-				// If input is the same, we can skip re-walk
-				let needWalkBlock = !info.initialized || changed;
-				if (!blocks.has(processBlock.block)) {
-					needWalkBlock = true;
-					blocks.add(processBlock.block);
-				}
-
-				if (needWalkBlock) {
-					info.initialized = true;
-					queueDelayed.push(processBlock);
-				}
+				// A walk depends only on the block and minAvailableModules: skip it when both are seen
+				const newBlock = !blocks.has(queueItem.block);
+				if (newBlock) blocks.add(queueItem.block);
+				if (newBlock || changed) queueDelayed.push(queueItem);
 			}
 		}
 		chunkGroupsForMerging.clear();
@@ -1152,6 +1186,47 @@ const visitModules = (
 		chunkGroupsForCombining.clear();
 	};
 
+	const processChunkGroupsForGrowing = () => {
+		for (const info of chunkGroupsForGrowing) {
+			/** @type {bigint | undefined} */
+			let availableModules;
+			for (const parent of /** @type {Set<ChunkGroupInfo>} */ (info.parents)) {
+				const resultingAvailableModules =
+					calculateResultingAvailableModules(parent);
+				availableModules =
+					availableModules === undefined
+						? resultingAvailableModules
+						: availableModules & resultingAvailableModules;
+				// Each parent covers minAvailableModules, so the intersection cannot drop below it
+				if (availableModules === info.minAvailableModules) break;
+			}
+			if (availableModules === info.minAvailableModules) continue;
+			info.minAvailableModules = availableModules;
+			info.resultingAvailableModules = undefined;
+			outdatedChunkGroupInfo.add(info);
+			// Reverse of revisiting skipped items: move the own modules now available
+			// to skippedItems, where they are added back if it shrinks again
+			for (const chunk of info.chunkGroup.chunks) {
+				let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
+				const coveredModules =
+					chunkMask & /** @type {bigint} */ (availableModules);
+				if (coveredModules === ZERO_BIGINT) continue;
+				if (info.skippedItems === undefined) {
+					info.skippedItems = new Set();
+				}
+				for (const module of chunkGraph.getChunkModules(chunk)) {
+					const ordinal = getModuleOrdinal(module);
+					if (!isOrdinalSetInMask(coveredModules, ordinal)) continue;
+					chunkGraph.disconnectChunkAndModule(chunk, module);
+					chunkMask &= ~(ONE_BIGINT << BigInt(ordinal));
+					info.skippedItems.add(module);
+				}
+				maskByChunk.set(chunk, chunkMask);
+			}
+		}
+		chunkGroupsForGrowing.clear();
+	};
+
 	const processOutdatedChunkGroupInfo = () => {
 		statChunkGroupInfoUpdated += outdatedChunkGroupInfo.size;
 		// Revisit skipped elements
@@ -1209,21 +1284,21 @@ const visitModules = (
 				}
 			}
 
-			// 2. Reconsider children chunk groups
-			if (info.children !== undefined) {
+			// 3. Reconsider children chunk groups
+			if (info.children !== undefined && info.children.size > 0) {
 				statChildChunkGroupsReconnected += info.children.size;
+				let connectList = queueConnect.get(info);
+				if (connectList === undefined) {
+					/** @type {ConnectList} */
+					connectList = new Set();
+					queueConnect.set(info, connectList);
+				}
 				for (const cgi of info.children) {
-					let connectList = queueConnect.get(info);
-					if (connectList === undefined) {
-						/** @type {ConnectList} */
-						connectList = new Set();
-						queueConnect.set(info, connectList);
-					}
 					connectList.add([cgi, null]);
 				}
 			}
 
-			// 3. Reconsider chunk groups for combining
+			// 4. Reconsider chunk groups for combining
 			if (info.availableChildren !== undefined) {
 				for (const cgi of info.availableChildren) {
 					chunkGroupsForCombining.add(cgi);
@@ -1236,7 +1311,12 @@ const visitModules = (
 
 	// Iterative traversal of the Module graph
 	// Recursive would be simpler to write but could result in Stack Overflows
-	while (queue.length || queueConnect.size) {
+	while (
+		queue.length ||
+		queueConnect.size ||
+		outdatedChunkGroupInfo.size ||
+		chunkGroupsForCombining.size
+	) {
 		logger.time("visitModules: visiting");
 		processQueue();
 		logger.timeAggregateEnd("visitModules: prepare");
@@ -1274,12 +1354,25 @@ const visitModules = (
 			queue = queueDelayed.reverse();
 			queueDelayed = tempQueue;
 		}
+
+		// Grow only after the shrinking phase finishes, so growth
+		// reads each parent's final `resultingAvailableModules`
+		if (
+			queue.length === 0 &&
+			queueConnect.size === 0 &&
+			chunkGroupsForCombining.size === 0 &&
+			chunkGroupsForGrowing.size > 0
+		) {
+			logger.time("visitModules: growing available modules");
+			processChunkGroupsForGrowing();
+			logger.timeEnd("visitModules: growing available modules");
+		}
 	}
 
 	for (const info of outdatedOrderIndexChunkGroups) {
 		const { chunkGroup, runtime } = info;
 
-		const blocks = blocksByChunkGroups.get(info);
+		const blocks = blocksByChunkGroupInfo.get(info);
 
 		if (!blocks) {
 			continue;

package/lib/{util → graph}/findGraphRoots.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { first } = require("../util/SetHelpers");
+
 const NO_MARKER = 0;
 const IN_PROGRESS_MARKER = 1;
 const DONE_MARKER = 2;
@@ -13,16 +15,16 @@ const CANDIDATE_MARKER = 3;
 /**
  * Defines the nodes type used by this module.
  * @template T
- * @typedef {Set<Node<T>>} Nodes
+ * @typedef {Set<GraphNode<T>>} Nodes
  */
 
 /**
  * Represents the node runtime component.
  * @template T
  */
-class Node {
+class GraphNode {
 	/**
-	 * Creates an instance of Node.
+	 * Creates an instance of GraphNode.
 	 * @param {T} item the value of the node
 	 */
 	constructor(item) {
@@ -56,8 +58,8 @@ class SCC {
  * Defines the stack entry type used by this module.
  * @template T
  * @typedef {object} StackEntry
- * @property {Node<T>} node
- * @property {Node<T>[]} openEdges
+ * @property {GraphNode<T>} node
+ * @property {GraphNode<T>[]} openEdges
  */
 
 /**
@@ -68,10 +70,10 @@ class SCC {
  * @returns {Iterable<T>} graph roots of the items
  */
 module.exports = (items, getDependencies) => {
-	/** @type {Map<T, Node<T>>} */
+	/** @type {Map<T, GraphNode<T>>} */
 	const itemToNode = new Map();
 	for (const item of items) {
-		const node = new Node(item);
+		const node = new GraphNode(item);
 		itemToNode.set(item, node);
 	}
 
@@ -112,7 +114,7 @@ module.exports = (items, getDependencies) => {
 				// Process one unvisited outgoing edge if available
 				if (topOfStack.openEdges.length > 0) {
 					const dependency =
-						/** @type {Node<T>} */
+						/** @type {GraphNode<T>} */
 						(topOfStack.openEdges.pop());
 					const depSCC = dependency.scc;
 					switch (depSCC.marker) {
@@ -148,7 +150,7 @@ module.exports = (items, getDependencies) => {
 						case CANDIDATE_MARKER:
 							// This finished SCC was previously considered as root SCC
 							// We just found a new incoming edge, so it is no longer a candidate
-							rootSCCs.delete(/** @type {SCC<T>} */ (depSCC));
+							rootSCCs.delete(depSCC);
 							depSCC.marker = DONE_MARKER;
 							break;
 						case DONE_MARKER:
@@ -183,6 +185,10 @@ module.exports = (items, getDependencies) => {
 	// For each root SCC, we select node with the most incoming edges
 	// from within the same SCC
 	for (const scc of rootSCCs) {
+		if (scc.nodes.size === 1) {
+			rootNodes.add(/** @type {GraphNode<T>} */ (first(scc.nodes)).item);
+			continue;
+		}
 		let max = 0;
 		/** @type {Nodes<T>} */
 		const nodes = new Set(scc.nodes);

package/lib/graph/isDependencyKind.js

@@ -0,0 +1,23 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+/** @import Dependency, { DependencyKinds } from "./Dependency" */
+
+/**
+ * Returns whether a dependency is of the given kind; use it wherever a plugin's dependency can reach.
+ * A dependency extending another webpack copy's `Dependency` has no `is()` and is of no kind.
+ * @template {keyof DependencyKinds} K
+ * @param {Dependency} dependency a dependency
+ * @param {K} kind a dependency kind
+ * @returns {dependency is DependencyKinds[K]} true when the dependency is of that kind
+ */
+const isDependencyKind = (dependency, kind) =>
+	// TODO in the next major release: remove, require plugin dependencies to extend the current
+	// `Dependency` and call `dependency.is(kind)` directly
+	typeof dependency.is === "function" && dependency.is(kind);
+
+module.exports = isDependencyKind;

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -6,15 +6,15 @@
 "use strict";
 
 /** @typedef {string | number} ModuleId */
-/** @typedef {Record<string, unknown>} HotData */
+/** @typedef {object} HotData */
 /** @typedef {(data: HotData) => void} DisposeHandler */
 /** @typedef {(outdatedDependencies: ModuleId[]) => void} AcceptCallback */
 /** @typedef {(err: Error, context: { moduleId: ModuleId, dependencyId?: ModuleId, module?: HotModule }) => void} AcceptErrorHandler */
 /** @typedef {(status: string) => (Promise<void> | void)} StatusHandler */
-/** @typedef {Record<string, unknown>} ApplyOptions */
+/** @typedef {import("./JavascriptHotModuleReplacement.runtime").ApplyOptions} ApplyOptions */
 /** @typedef {(reportError: (err: Error) => void) => Promise<ModuleId[]>} ApplyFn */
-/** @typedef {(chunkId: ModuleId, fetchPriority?: string) => Promise<unknown>} EnsureChunk */
-/** @typedef {(chunkId: ModuleId, importFn: () => Promise<unknown>) => Promise<unknown>} AnalyzableChunkImport */
+/** @typedef {(chunkId: ModuleId, fetchPriority?: string) => Promise<void[] | void>} EnsureChunk */
+/** @typedef {<T>(chunkId: ModuleId, importFn: () => Promise<T>) => Promise<T>} AnalyzableChunkImport */
 /** @typedef {{ (id: ModuleId): unknown, e?: EnsureChunk, ei?: AnalyzableChunkImport, [name: string]: unknown }} WebpackRequire */
 
 /**
@@ -32,7 +32,7 @@
  * @property {Record<string, string>=} n the stylesheet name of each updated chunk whose name moved with its content
  */
 
-/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: Promise<unknown>[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: CssUpdateManifest | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
+/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: (Promise<void> | undefined)[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: CssUpdateManifest | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
 
 /**
  * @typedef {object} HMRManifest
@@ -56,14 +56,14 @@
  * @property {Record<ModuleId, AcceptCallback>} _acceptedDependencies accept callbacks by dependency id
  * @property {Record<ModuleId, AcceptErrorHandler | undefined>} _acceptedErrorHandlers error handlers by dependency id
  * @property {Record<ModuleId, boolean>} _declinedDependencies declined dependency ids
- * @property {boolean | EXPECTED_FUNCTION} _selfAccepted true or the self-accept error handler
+ * @property {boolean | AcceptErrorHandler} _selfAccepted true or the self-accept error handler
  * @property {boolean} _selfDeclined module declined itself
  * @property {boolean} _selfInvalidated module invalidated itself
  * @property {DisposeHandler[]} _disposeHandlers registered dispose handlers
  * @property {boolean} _main module is the entry of the update
  * @property {() => void} _requireSelf re-require the module on apply
  * @property {boolean} active module is not disposed
- * @property {(dep?: ModuleId | ModuleId[] | AcceptCallback, callback?: AcceptCallback, errorHandler?: AcceptErrorHandler) => void} accept accept updates
+ * @property {(dep?: ModuleId | ModuleId[] | AcceptErrorHandler, callback?: AcceptCallback, errorHandler?: AcceptErrorHandler) => void} accept accept updates
  * @property {(dep?: ModuleId | ModuleId[]) => void} decline decline updates
  * @property {(callback: DisposeHandler) => void} dispose add a dispose handler
  * @property {(callback: DisposeHandler) => void} addDisposeHandler add a dispose handler
@@ -363,8 +363,9 @@ module.exports = function () {
 	}
 
 	/**
-	 * @param {Promise<unknown>} promise blocking promise
-	 * @returns {Promise<unknown>} the same promise
+	 * @template T
+	 * @param {Promise<T>} promise blocking promise
+	 * @returns {Promise<T>} the same promise
 	 */
 	function trackBlockingPromise(promise) {
 		switch (currentStatus) {
@@ -435,7 +436,7 @@ module.exports = function () {
 								update.f
 							);
 							return promises;
-						}, /** @type {Promise<unknown>[]} */ ([]))
+						}, /** @type {(Promise<void> | undefined)[]} */ ([]))
 					).then(function () {
 						return waitForBlockingPromises(function () {
 							if (applyOnUpdate) {
@@ -479,7 +480,7 @@ module.exports = function () {
 		var results = /** @type {ApplyHandler[]} */ (
 			currentUpdateApplyHandlers
 		).map(function (handler) {
-			return handler(/** @type {ApplyOptions} */ (options));
+			return handler(options);
 		});
 		currentUpdateApplyHandlers = undefined;