webpack 5.111.0 → 5.112.0

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

@@ -6,29 +6,29 @@
 "use strict";
 
 const util = require("util");
+const { ImportPhaseUtils } = require("../dependencies/core/ImportPhase");
+const SortableSet = require("../util/SortableSet");
+const WeakTupleMap = require("../util/WeakTupleMap");
+const { sortWithSourceOrder } = require("../util/comparators");
 const ExportsInfo = require("./ExportsInfo");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
-const HarmonyImportDependency = require("./dependencies/HarmonyImportDependency");
-const { ImportPhaseUtils } = require("./dependencies/ImportPhase");
-const SortableSet = require("./util/SortableSet");
-const WeakTupleMap = require("./util/WeakTupleMap");
-const { sortWithSourceOrder } = require("./util/comparators");
+const isDependencyKind = require("./isDependencyKind");
 
-/** @import { ModuleMemCaches } from "./Compilation" */
+/** @import { ModuleMemCaches } from "../Compilation" */
 /** @import DependenciesBlock from "./DependenciesBlock" */
 /** @import Dependency, { ExportInfoName } from "./Dependency" */
 /** @import { ExportInfo } from "./ExportsInfo" */
-/** @import Module from "./Module" */
-/** @import ModuleProfile from "./ModuleProfile" */
-/** @import RequestShortener from "./RequestShortener" */
-/** @import { RuntimeSpec } from "./util/runtime" */
-/** @import HarmonyImportSideEffectDependency from "./dependencies/HarmonyImportSideEffectDependency" */
+/** @import Module from "../module/Module" */
+/** @import ModuleProfile from "../module/ModuleProfile" */
+/** @import RequestShortener from "../util/RequestShortener" */
+/** @import { RuntimeSpec } from "../util/runtime" */
+/** @import ESMImportSideEffectDependency from "../dependencies/esm/ESMImportSideEffectDependency" */
 /**
- * @import HarmonyImportSpecifierDependency, {
- * 	idsSymbol as HarmonyImportSpecifierDependencyIDsSymbol
- * } from "./dependencies/HarmonyImportSpecifierDependency"
+ * @import ESMImportSpecifierDependency, {
+ * 	idsSymbol as ESMImportSpecifierDependencyIDsSymbol
+ * } from "../dependencies/esm/ESMImportSpecifierDependency"
  */
-/** @import { DependencySourceOrder } from "./util/comparators" */
+/** @import { DependencySourceOrder } from "../util/comparators" */
 
 /**
  * Defines the optimization bailout function callback.
@@ -130,12 +130,12 @@ class ModuleGraphModule {
 /**
  * @import {
  * 	idsSymbol as CommonJsExportRequireDependencyIDsSymbol
- * } from "./dependencies/CommonJsExportRequireDependency"
+ * } from "../dependencies/commonjs/CommonJsExportRequireDependency"
  */
 /**
  * @import {
- * 	idsSymbol as HarmonyExportImportedSpecifierDependencyIDsSymbol
- * } from "./dependencies/HarmonyExportImportedSpecifierDependency"
+ * 	idsSymbol as ESMExportImportedSpecifierDependencyIDsSymbol
+ * } from "../dependencies/esm/ESMExportImportedSpecifierDependency"
  */
 
 /**
@@ -143,9 +143,10 @@ class ModuleGraphModule {
  * @typedef {object} KnownMeta
  * @property {Map<Module, string>=} importVarMap
  * @property {Map<Module, string>=} deferredImportVarMap
+ * @property {boolean=} onDemandExports generate export definitions on demand
  */
 
-/** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | HarmonyImportSpecifierDependencyIDsSymbol | HarmonyExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
+/** @typedef {KnownMeta & Record<CommonJsExportRequireDependencyIDsSymbol | ESMImportSpecifierDependencyIDsSymbol | ESMExportImportedSpecifierDependencyIDsSymbol, string[]> & Record<string, EXPECTED_ANY>} Meta */
 
 class ModuleGraph {
 	constructor() {
@@ -342,29 +343,25 @@ class ModuleGraph {
 		}
 		const originDependency = connection.dependency;
 
-		// src/index.js
-		// import { c } from "lib/c" -> c = 0
-		// import { a, b } from "lib" -> a and b have the same source order -> a = b = 1
-		// import { d } from "lib/d" -> d = 2
+		// Specifiers of one import statement share its source order, so `a` and `b`
+		// of `import { a, b } from "lib"` both take the statement's index.
 		const currentSourceOrder =
-			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			/** @type {ESMImportSideEffectDependency | ESMImportSpecifierDependency} */
 			(dependency).sourceOrder;
 
 		// lib/index.js (reexport)
 		// import { a } from "lib/a" -> a = 0
 		// import { b } from "lib/b" -> b = 1
 		const originSourceOrder =
-			/** @type {HarmonyImportSideEffectDependency | HarmonyImportSpecifierDependency} */
+			/** @type {ESMImportSideEffectDependency | ESMImportSpecifierDependency} */
 			(originDependency).sourceOrder;
 		if (
 			typeof currentSourceOrder === "number" &&
 			typeof originSourceOrder === "number"
 		) {
-			// src/index.js
-			// import { c } from "lib/c" -> c = 0
-			// import { a } from "lib/a" -> a = 1.0 = 1(main) + 0.0(sub)
-			// import { b } from "lib/b" -> b = 1.1 = 1(main) + 0.1(sub)
-			// import { d } from "lib/d" -> d = 2
+			// A re-exported specifier keeps the importing statement's order as `main`
+			// and its own position as `sub`, so the pair orders it within that
+			// statement without disturbing the statements around it.
 			this._dependencySourceOrderMap.set(dependency, {
 				main: currentSourceOrder,
 				sub: originSourceOrder
@@ -384,7 +381,7 @@ class ModuleGraph {
 			return;
 		}
 		for (const mod of this._modulesNeedingSort) {
-			// If dependencies like HarmonyImportSideEffectDependency and HarmonyImportSpecifierDependency have a SourceOrder,
+			// If dependencies like ESMImportSideEffectDependency and ESMImportSpecifierDependency have a SourceOrder,
 			// we sort based on it; otherwise, we preserve the original order.
 			sortWithSourceOrder(
 				mod.dependencies,
@@ -464,7 +461,7 @@ class ModuleGraph {
 				connection
 			);
 		}
-		pending.length = 0;
+		mgm._unassignedConnections = undefined;
 	}
 
 	/**
@@ -742,7 +739,7 @@ class ModuleGraph {
 							foundConnection = connection;
 						}
 					}
-					mgm._unassignedConnections.length = 0;
+					mgm._unassignedConnections = undefined;
 					if (foundConnection !== undefined) {
 						return foundConnection;
 					}
@@ -1090,7 +1087,7 @@ class ModuleGraph {
 		for (const connection of connections) {
 			if (
 				!connection.dependency ||
-				!(connection.dependency instanceof HarmonyImportDependency)
+				!isDependencyKind(connection.dependency, "esm-import")
 			) {
 				continue;
 			}
@@ -1197,7 +1194,7 @@ class ModuleGraph {
 		);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Gets module graph for module.
 	 * @deprecated
@@ -1231,7 +1228,7 @@ class ModuleGraph {
 		return newFn(module);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Sets module graph for module.
 	 * @deprecated
@@ -1243,7 +1240,7 @@ class ModuleGraph {
 		moduleGraphForModuleMap.set(module, moduleGraph);
 	}
 
-	// TODO remove in webpack 6
+	// TODO in the next major release: remove
 	/**
 	 * Clear module graph for module.
 	 * @deprecated
@@ -1255,11 +1252,11 @@ class ModuleGraph {
 	}
 }
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {WeakMap<Module, ModuleGraph>} */
 const moduleGraphForModuleMap = new WeakMap();
 
-// TODO remove in webpack 6
+// TODO in the next major release: remove
 /** @type {Map<string, (module: Module) => ModuleGraph>} */
 const deprecateMap = new Map();
 

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

@@ -6,8 +6,8 @@
 "use strict";
 
 /** @import Dependency, { GetConditionFn } from "./Dependency" */
-/** @import Module from "./Module" */
-/** @import { RuntimeSpec } from "./util/runtime" */
+/** @import Module from "../module/Module" */
+/** @import { RuntimeSpec } from "../util/runtime" */
 
 /**
  * Module itself is not connected, but transitive modules are connected transitively.

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
@@ -358,10 +359,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 +433,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 +464,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 +479,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 +612,6 @@ const visitModules = (
 						depModule,
 						circular: b.circular,
 						chunkGroup: entrypoint,
-						initialized: false,
 						runtime:
 							entrypoint.options.runtime ||
 							/** @type {string | undefined} */ (entrypoint.name),
@@ -605,7 +619,9 @@ const visitModules = (
 						availableModulesToBeMerged: [],
 						skippedItems: undefined,
 						resultingAvailableModules: undefined,
+						connectedAvailableModules: undefined,
 						children: undefined,
+						parents: undefined,
 						availableSources: undefined,
 						availableChildren: undefined,
 						preOrderIndex: 0,
@@ -641,16 +657,13 @@ const visitModules = (
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// Fill in options the existing entrypoint hasn't set yet. We never
-					// overwrite: blocks that dedupe to one entrypoint (e.g. several
-					// workers pointing at the same module) legitimately carry distinct
-					// values such as `runtime`, so the first block to create the
-					// entrypoint wins and later ones only contribute missing keys.
-					// `name` is excluded: it is the entrypoint's identity, fixed at
-					// creation (and used to key namedChunkGroups), so back-filling it
-					// from a block that deduped in via its module would leave
-					// `entrypoint.name` out of sync and make module codegen
-					// order-dependent, which breaks persistent caching.
+					// Fill in only the options still unset: blocks deduping to one
+					// entrypoint may carry different values, so the first to create it
+					// wins.
+
+					// `name` is excluded, being the entrypoint's identity and fixed at
+					// creation. Back-filling it would make codegen order-dependent, which
+					// breaks persistent caching.
 					const existingOptions = entrypoint.options;
 					for (const key_ of Object.keys(entryOptions)) {
 						const key =
@@ -703,14 +716,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,
@@ -956,6 +970,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: {
@@ -1012,6 +1032,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
@@ -1022,18 +1055,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 = () => {
@@ -1051,13 +1075,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) {
@@ -1075,7 +1116,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;
@@ -1102,25 +1143,17 @@ const visitModules = (
 				outdatedChunkGroupInfo.add(info);
 			}
 
-			if (processBlock) {
-				let blocks = blocksByChunkGroups.get(info);
-				if (!blocks) {
-					blocksByChunkGroups.set(info, (blocks = new Set()));
-				}
-
-				// 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 (queueItem !== null) {
+				let blocks = blocksByChunkGroupInfo.get(info);
+				if (blocks === undefined) {
+					blocks = new Set();
+					blocksByChunkGroupInfo.set(info, blocks);
 				}
 
-				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();
@@ -1155,6 +1188,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
@@ -1212,21 +1286,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);
@@ -1239,7 +1313,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");
@@ -1277,12 +1356,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;
@@ -1370,11 +1462,10 @@ const connectChunkGroups = (
 
 	// For each edge in the basic chunk graph
 	for (const [block, connections] of blockConnections) {
-		// 1. Check if connection is needed
-		// When none of the dependencies need to be connected
-		// we can skip all of them
-		// It's not possible to filter each item so it doesn't create inconsistent
-		// connections and modules can only create one version
+		// Skip the whole set when no dependency needs connecting. They cannot be
+		// filtered one by one without inconsistent connections, since a module can
+		// only carry one version.
+
 		// TODO maybe decide this per runtime
 		if (
 			// Blocks with nested blocks must stay connected — skipping orphans the