webpack 5.107.1 → 5.108.0

package/lib/NormalModule.js

@@ -20,6 +20,7 @@ const {
 	SourceMapSource
 } = require("webpack-sources");
 const Compilation = require("./Compilation");
+const Dependency = require("./Dependency");
 const Module = require("./Module");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
@@ -35,8 +36,6 @@ const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const {
-	compareLocations,
-	compareSelect,
 	concatComparators,
 	keepOriginalOrder,
 	sortWithSourceOrder
@@ -46,6 +45,7 @@ const { createFakeHook } = require("./util/deprecation");
 const formatLocation = require("./util/formatLocation");
 const { join } = require("./util/fs");
 const {
+	ABSOLUTE_PATH_REGEXP,
 	absolutify,
 	contextify,
 	makePathsRelative
@@ -61,12 +61,13 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("./Dependency")} Dependency */
 /** @typedef {import("./Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("./Generator")} Generator */
 /** @typedef {import("./Generator").GenerateErrorFn} GenerateErrorFn */
+/** @typedef {import("./FileSystemInfo").Snapshot} Snapshot */
 /** @typedef {import("./Module").BuildInfo} BuildInfo */
 /** @typedef {import("./Module").FileSystemDependencies} FileSystemDependencies */
+/** @typedef {import("./Module").ValueCacheVersions} ValueCacheVersions */
 /** @typedef {import("./Module").BuildMeta} BuildMeta */
 /** @typedef {import("./Module").CodeGenerationContext} CodeGenerationContext */
 /** @typedef {import("./Module").CodeGenerationResult} CodeGenerationResult */
@@ -86,7 +87,6 @@ const parseJson = require("./util/parseJson");
 /** @typedef {import("./Module").UnsafeCacheData} UnsafeCacheData */
 /** @typedef {import("./ModuleGraph")} ModuleGraph */
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
-/** @typedef {Iterator<SideEffectsWalk, ConnectionState, ConnectionState>} SideEffectsWalk */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */
 /** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */
@@ -156,27 +156,407 @@ const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
 		);
 };
 
+// Maximum recursive descent depth before switching to the iterative walker.
+// #20986 reported overflow around 1300 modules in webpack 5.107.0 where each
+// step consumed two stack frames (`NormalModule.getSideEffectsConnectionState`
+// plus `HarmonyImportSideEffectDependency.getModuleEvaluationSideEffectsState`).
+// `walkSideEffectsRecursive` folds the second call into the first and uses
+// one frame per module, so this limit caps the native stack at half the depth
+// where the original code overflowed — well within the safe range across
+// platforms while keeping the common (shallow) case purely recursive.
+const SIDE_EFFECTS_RECURSION_LIMIT = 2000;
+
 /**
- * Generator form of `getSideEffectsConnectionState` — descends through
- * `HarmonyImportSideEffectDependency` via `yield` so the trampoline in
- * `getSideEffectsConnectionState` can drive the walk iteratively (#20986).
- * @param {NormalModule} mod the module being evaluated
+ * Iterative form of the side-effects walker. Used as a fallback once the
+ * recursive form reaches `SIDE_EFFECTS_RECURSION_LIMIT` so deep chains
+ * (#20986) don't overflow V8's stack. Safe to enter while ancestors set
+ * `_isEvaluatingSideEffects` on their own modules — those are treated as
+ * `CIRCULAR_CONNECTION` if revisited, matching the original recursive
+ * behavior.
+ * @param {NormalModule} rootMod the module to walk
  * @param {ModuleGraph} moduleGraph the module graph
- * @returns {SideEffectsWalk} the generator
+ * @param {SideEffectsWalkContext} ctx per-walk cycle-tracking context
+ * @returns {ConnectionState} the side-effects connection state
  */
-function* walkSideEffects(mod, moduleGraph) {
-	if (mod.factoryMeta !== undefined) {
-		if (mod.factoryMeta.sideEffectFree) return false;
-		if (mod.factoryMeta.sideEffectFree === false) return true;
+const walkSideEffectsIterative = (rootMod, moduleGraph, ctx) => {
+	const SideEffectDep = getHarmonyImportSideEffectDependency();
+
+	/** @type {NormalModule[]} */
+	const modStack = [rootMod];
+	/** @type {Dependency[][]} */
+	const depsStack = [rootMod.dependencies];
+	const indexStack = [0];
+	/** @type {ConnectionState[]} */
+	const currentStack = [false];
+	rootMod._isEvaluatingSideEffects = true;
+
+	/**
+	 * Result from a just-popped child frame, to be applied to the new
+	 * top's current dep. `undefined` means "no pending; advance".
+	 * @type {ConnectionState | undefined}
+	 */
+	let pending;
+
+	while (modStack.length > 0) {
+		const top = modStack.length - 1;
+		const topMod = modStack[top];
+		const deps = depsStack[top];
+		let index = indexStack[top];
+		let current = currentStack[top];
+
+		if (pending !== undefined) {
+			const state = pending;
+			pending = undefined;
+			const dep = deps[index];
+
+			if (state === true) {
+				recordSideEffectsBailout(topMod, moduleGraph, dep);
+				topMod._isEvaluatingSideEffects = false;
+				// `true` is monotonic — safe to memoize regardless of cycle
+				// status, matching the direct-bailout branch below.
+				topMod._sideEffectsStateGraph = moduleGraph;
+				topMod._sideEffectsStateValue = true;
+				modStack.pop();
+				depsStack.pop();
+				indexStack.pop();
+				currentStack.pop();
+				pending = true;
+				continue;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				current = ModuleGraphConnection.addConnectionStates(current, state);
+			}
+			index++;
+		}
+
+		let descended = false;
+		const depCount = deps.length;
+		while (index < depCount) {
+			const dep = deps[index];
+			/** @type {ConnectionState} */
+			let state;
+
+			if (dep instanceof SideEffectDep) {
+				const refModule = moduleGraph.getModule(dep);
+				if (!refModule) {
+					state = true;
+				} else if (refModule instanceof NormalModule) {
+					// Cache hit
+					if (refModule._sideEffectsStateGraph === moduleGraph) {
+						state = /** @type {ConnectionState} */ (
+							refModule._sideEffectsStateValue
+						);
+					}
+					// Fast-path checks inlined to avoid the helper call.
+					else if (refModule.factoryMeta !== undefined) {
+						if (refModule.factoryMeta.sideEffectFree) {
+							state = false;
+						} else if (refModule.factoryMeta.sideEffectFree === false) {
+							state = true;
+						} else if (
+							!(
+								refModule.buildMeta !== undefined &&
+								refModule.buildMeta.sideEffectFree
+							)
+						) {
+							state = true;
+						} else if (refModule._isEvaluatingSideEffects) {
+							ctx.circular = true;
+							state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+						} else {
+							// Descend
+							indexStack[top] = index;
+							currentStack[top] = current;
+							refModule._isEvaluatingSideEffects = true;
+							modStack.push(refModule);
+							depsStack.push(refModule.dependencies);
+							indexStack.push(0);
+							currentStack.push(false);
+							descended = true;
+							break;
+						}
+					} else if (
+						!(
+							refModule.buildMeta !== undefined &&
+							refModule.buildMeta.sideEffectFree
+						)
+					) {
+						state = true;
+					} else if (refModule._isEvaluatingSideEffects) {
+						ctx.circular = true;
+						state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+					} else {
+						// Descend
+						indexStack[top] = index;
+						currentStack[top] = current;
+						refModule._isEvaluatingSideEffects = true;
+						modStack.push(refModule);
+						depsStack.push(refModule.dependencies);
+						indexStack.push(0);
+						currentStack.push(false);
+						descended = true;
+						break;
+					}
+				} else {
+					ctx.circular = true;
+					state = refModule.getSideEffectsConnectionState(moduleGraph);
+				}
+			} else {
+				state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+			}
+
+			if (state === true) {
+				recordSideEffectsBailout(topMod, moduleGraph, dep);
+				topMod._isEvaluatingSideEffects = false;
+				topMod._sideEffectsStateGraph = moduleGraph;
+				topMod._sideEffectsStateValue = true;
+				modStack.pop();
+				depsStack.pop();
+				indexStack.pop();
+				currentStack.pop();
+				pending = true;
+				descended = true;
+				break;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				current = ModuleGraphConnection.addConnectionStates(current, state);
+			}
+			index++;
+		}
+
+		if (descended) continue;
+
+		topMod._isEvaluatingSideEffects = false;
+		if (!ctx.circular) {
+			topMod._sideEffectsStateGraph = moduleGraph;
+			topMod._sideEffectsStateValue = current;
+		}
+		pending = current;
+		modStack.pop();
+		depsStack.pop();
+		indexStack.pop();
+		currentStack.pop();
 	}
-	if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
-		return true;
+
+	return /** @type {ConnectionState} */ (pending);
+};
+
+/**
+ * @typedef {object} SideEffectsWalkContext
+ * @property {boolean} circular whether a cycle was seen anywhere in this walk
+ */
+
+/**
+ * Walks back up a stack of linear-chain ancestors, applying the result
+ * `state` of the chain's tail to each ancestor. Each ancestor in the
+ * stack had exactly one `HarmonyImportSideEffectDependency` returning
+ * `state`, so its result is just `state` (with the usual aggregation
+ * rules) and we can avoid building per-frame `current` accumulators.
+ * @param {(NormalModule | Dependency)[] | null} ancestors interleaved stack of `[mod, sideEffectDep, mod, sideEffectDep, …]` in descent order; `null` if there were none
+ * @param {ConnectionState} state result from the chain's tail
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {SideEffectsWalkContext} ctx per-walk cycle-tracking context
+ * @returns {ConnectionState} the root ancestor's result
+ */
+const propagateLinearResult = (ancestors, state, moduleGraph, ctx) => {
+	if (ancestors === null) return state;
+	while (ancestors.length > 0) {
+		const dep = /** @type {Dependency} */ (ancestors.pop());
+		const ancestor = /** @type {NormalModule} */ (ancestors.pop());
+		ancestor._isEvaluatingSideEffects = false;
+
+		if (state === true) {
+			recordSideEffectsBailout(ancestor, moduleGraph, dep);
+			// `true` is monotonic — safe to cache regardless of cycle status.
+			ancestor._sideEffectsStateGraph = moduleGraph;
+			ancestor._sideEffectsStateValue = true;
+		} else if (state === ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			// CIRCULAR_CONNECTION is filtered before folding into `current`,
+			// so the ancestor's `current` stays at its initial `false`. From
+			// this point upward the propagated state is `false`, and the
+			// cycle taint prevents memoization further up (handled by
+			// `ctx.circular`).
+			state = false;
+		} else if (!ctx.circular) {
+			ancestor._sideEffectsStateGraph = moduleGraph;
+			ancestor._sideEffectsStateValue = state;
+		}
 	}
-	if (mod._isEvaluatingSideEffects) {
-		return ModuleGraphConnection.CIRCULAR_CONNECTION;
+	return state;
+};
+
+/**
+ * Recursive form of the side-effects walker. Folds the descent through
+ * `HarmonyImportSideEffectDependency.getModuleEvaluationSideEffectsState`
+ * directly into the loop so each module costs only one V8 stack frame
+ * (vs. two in the original recursive code).
+ *
+ * Linear-chain heads (modules with exactly one
+ * `HarmonyImportSideEffectDependency` to another `NormalModule`) are
+ * walked iteratively inside the function via an explicit
+ * `linearAncestors` stack — no additional V8 frame per descent — and
+ * their results are propagated back up by `propagateLinearResult`. This
+ * keeps stack consumption at O(1) for the common deep-import-chain
+ * pattern that motivated #20986 and also avoids the heavier iterative
+ * fallback.
+ *
+ * Falls back to `walkSideEffectsIterative` only when a *non-linear*
+ * walk reaches `SIDE_EFFECTS_RECURSION_LIMIT` — i.e. a deep tree, where
+ * each level genuinely needs its own recursion frame.
+ *
+ * Caches the result on the module when the walk did not encounter a
+ * cycle, so subsequent queries (e.g. repeated lookups during
+ * `SideEffectsFlagPlugin`'s incoming-connection optimization and its
+ * `exportInfo.getTarget` callbacks) return in O(1).
+ * @param {NormalModule} mod the module being walked
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {number} depth current recursion depth (only counts true V8 frames)
+ * @param {EXPECTED_ANY} SideEffectDep `HarmonyImportSideEffectDependency` constructor, resolved once at the public entry to avoid repeated `require` lookups in the recursive call
+ * @param {SideEffectsWalkContext} ctx per-walk cycle-tracking context
+ * @returns {ConnectionState} the side-effects connection state
+ */
+const walkSideEffectsRecursive = (
+	mod,
+	moduleGraph,
+	depth,
+	SideEffectDep,
+	ctx
+) => {
+	// Interleaved `[mod, linearDep, mod, linearDep, …]` for the linear
+	// chain head; `null` until the first descent.
+	/** @type {(NormalModule | Dependency)[] | null} */
+	let linearAncestors = null;
+
+	// Walk the linear-chain head iteratively. Every loop iteration peels
+	// off one module without consuming a V8 stack frame.
+	while (true) {
+		if (mod._sideEffectsStateGraph === moduleGraph) {
+			return propagateLinearResult(
+				linearAncestors,
+				/** @type {ConnectionState} */ (mod._sideEffectsStateValue),
+				moduleGraph,
+				ctx
+			);
+		}
+
+		if (mod.factoryMeta !== undefined) {
+			if (mod.factoryMeta.sideEffectFree) {
+				return propagateLinearResult(linearAncestors, false, moduleGraph, ctx);
+			}
+			if (mod.factoryMeta.sideEffectFree === false) {
+				return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
+			}
+		}
+		if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+			return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
+		}
+		if (mod._isEvaluatingSideEffects) {
+			ctx.circular = true;
+			return propagateLinearResult(
+				linearAncestors,
+				ModuleGraphConnection.CIRCULAR_CONNECTION,
+				moduleGraph,
+				ctx
+			);
+		}
+
+		// A real ESM module's `dependencies` typically include one
+		// `HarmonyImportSideEffectDependency` plus several non-recursive deps
+		// (export specifiers, const dependencies, …) that report
+		// `false`/`CIRCULAR_CONNECTION` from
+		// `getModuleEvaluationSideEffectsState`. Walk the deps in order
+		// here: as long as at most one is a `SideEffectDep` and no
+		// non-recursive dep triggers a bailout or contributes a non-`false`
+		// state, we can still tail-call iteratively through that one
+		// `SideEffectDep` — no V8 frame needed. This is what keeps the
+		// 1300-module cyclic chain from #20986 from overflowing V8's stack
+		// even though each generated module has multiple `dependencies`.
+		const deps = mod.dependencies;
+		/** @type {Dependency | null} */
+		let linearDep = null;
+		/** @type {ConnectionState} */
+		let nonRecursiveCurrent = false;
+		let linearOk = true;
+		for (let i = 0; i < deps.length; i++) {
+			const dep = deps[i];
+			if (dep instanceof SideEffectDep) {
+				if (linearDep !== null) {
+					// Two `SideEffectDep`s in the same module — fall back to
+					// the general walk so each can recurse normally.
+					linearOk = false;
+					break;
+				}
+				linearDep = dep;
+			} else {
+				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+				if (state === true) {
+					recordSideEffectsBailout(mod, moduleGraph, dep);
+					mod._sideEffectsStateGraph = moduleGraph;
+					mod._sideEffectsStateValue = true;
+					return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
+				}
+				if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+					nonRecursiveCurrent = ModuleGraphConnection.addConnectionStates(
+						nonRecursiveCurrent,
+						state
+					);
+				}
+			}
+		}
+
+		if (!linearOk || nonRecursiveCurrent !== false) {
+			// Multiple `SideEffectDep`s, or a non-recursive dep contributed
+			// a non-`false` state (e.g. `TRANSITIVE_ONLY`). The linear
+			// propagation rule "ancestor's current = chain state" no longer
+			// holds, so fall back to the general walk.
+			break;
+		}
+
+		if (linearDep === null) {
+			// No `SideEffectDep` — the module is a leaf as far as the
+			// side-effects graph is concerned. Cache and propagate `false`.
+			if (!ctx.circular) {
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = false;
+			}
+			return propagateLinearResult(linearAncestors, false, moduleGraph, ctx);
+		}
+
+		const refModule = moduleGraph.getModule(linearDep);
+		if (!refModule) {
+			recordSideEffectsBailout(mod, moduleGraph, linearDep);
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = true;
+			return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
+		}
+		if (!(refModule instanceof NormalModule)) {
+			// Non-NormalModule's `getSideEffectsConnectionState` re-enters
+			// the public method; defer to the general walk for safety.
+			break;
+		}
+
+		mod._isEvaluatingSideEffects = true;
+		if (linearAncestors === null) linearAncestors = [];
+		// Push (mod, linearDep) so `propagateLinearResult` records bailouts
+		// against the actual `SideEffectDep` that triggered the descent —
+		// which may not be `dependencies[0]` when the module also has
+		// export / const dependencies.
+		linearAncestors.push(mod, linearDep);
+		mod = refModule;
+		continue;
+	}
+
+	// Non-linear walk. Each genuine recursive call costs one V8 frame, so
+	// honour the depth limit here.
+	if (depth >= SIDE_EFFECTS_RECURSION_LIMIT) {
+		return propagateLinearResult(
+			linearAncestors,
+			walkSideEffectsIterative(mod, moduleGraph, ctx),
+			moduleGraph,
+			ctx
+		);
 	}
 
-	const SideEffectDep = getHarmonyImportSideEffectDependency();
 	mod._isEvaluatingSideEffects = true;
 	/** @type {ConnectionState} */
 	let current = false;
@@ -189,8 +569,22 @@ function* walkSideEffects(mod, moduleGraph) {
 			if (!refModule) {
 				state = true;
 			} else if (refModule instanceof NormalModule) {
-				state = yield walkSideEffects(refModule, moduleGraph);
+				state = walkSideEffectsRecursive(
+					refModule,
+					moduleGraph,
+					depth + 1,
+					SideEffectDep,
+					ctx
+				);
 			} else {
+				// Non-NormalModule's `getSideEffectsConnectionState` (notably
+				// `ConcatenatedModule` delegating to its root) re-enters the
+				// public method and may walk through modules that the outer
+				// walk has marked as evaluating. We can't observe whether
+				// the inner walk hit a cycle that reflected the outer's
+				// state, so treat the walk as cycle-tainted and skip the
+				// cache for safety.
+				ctx.circular = true;
 				state = refModule.getSideEffectsConnectionState(moduleGraph);
 			}
 		} else {
@@ -200,7 +594,12 @@ function* walkSideEffects(mod, moduleGraph) {
 		if (state === true) {
 			recordSideEffectsBailout(mod, moduleGraph, dep);
 			mod._isEvaluatingSideEffects = false;
-			return true;
+			// `true` is monotonic — once any dep declares side effects, the
+			// answer is `true` regardless of how cycles resolve, so it's
+			// always safe to memoize.
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = true;
+			return propagateLinearResult(linearAncestors, true, moduleGraph, ctx);
 		}
 		if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
 			current = ModuleGraphConnection.addConnectionStates(current, state);
@@ -208,12 +607,19 @@ function* walkSideEffects(mod, moduleGraph) {
 	}
 
 	mod._isEvaluatingSideEffects = false;
-	// When caching is implemented here, make sure to not cache when
-	// at least one circular connection was folded into `current`.
-	return current;
-}
 
-const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
+	// Only memoize when no cycle has been observed anywhere in the walk
+	// since the public entry. A cycle anywhere can affect any ancestor's
+	// result (the back-edge target's contribution is hidden by
+	// CIRCULAR_CONNECTION short-circuiting), so this single flag is the
+	// conservative-but-cheap approximation of "this subtree's result is
+	// independent of cycle context". The public entry resets the flag.
+	if (!ctx.circular) {
+		mod._sideEffectsStateGraph = moduleGraph;
+		mod._sideEffectsStateValue = current;
+	}
+	return propagateLinearResult(linearAncestors, current, moduleGraph, ctx);
+};
 
 /**
  * @typedef {object} LoaderItem
@@ -340,6 +746,22 @@ const asBuffer = (input) => {
  * @typedef {(resourcePath: string, getLoaderContext: (resourcePath: string) => AnyLoaderContext) => Promise<string | Buffer<ArrayBufferLike>>} ReadResource
  */
 
+/**
+ * Defines the build info properties of normal modules (filesystem-backed, loader-processed).
+ * @typedef {object} KnownNormalModuleBuildInfo
+ * @property {boolean=} parsed
+ * @property {string=} hash
+ * @property {FileSystemDependencies=} fileDependencies
+ * @property {FileSystemDependencies=} contextDependencies
+ * @property {FileSystemDependencies=} missingDependencies
+ * @property {FileSystemDependencies=} buildDependencies
+ * @property {ValueCacheVersions=} valueDependencies
+ * @property {(Snapshot | null)=} snapshot
+ * @property {string=} resourceIntegrity using in HttpUriPlugin
+ */
+
+/** @typedef {BuildInfo & KnownNormalModuleBuildInfo} NormalModuleBuildInfo */
+
 /** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
 const compilationHooksMap = new WeakMap();
 
@@ -463,7 +885,14 @@ class NormalModule extends Module {
 		/** @type {NormalModuleCreateData['extractSourceMap']} */
 		this.extractSourceMap = extractSourceMap;
 
+		// Set by HotModuleReplacementPlugin via NormalModuleFactory's `module` hook
+		/** @type {boolean} */
+		this.hot = false;
+
 		// Info from Build
+		// Redeclared with the normal module specific shape (see KnownNormalModuleBuildInfo)
+		/** @type {NormalModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
 		/** @type {Error | null} */
 		this.error = null;
 		/**
@@ -500,6 +929,18 @@ class NormalModule extends Module {
 		 * @type {WeakSet<ModuleGraph> | undefined}
 		 */
 		this._addedSideEffectsBailout = undefined;
+		/**
+		 * Memoizes the result of `getSideEffectsConnectionState`. The
+		 * graph slot keys the cached value to the `ModuleGraph` it was
+		 * computed against so stale values never leak across compilations
+		 * — a walk that targets a different graph just overwrites both
+		 * slots. Populated only for results computed without encountering
+		 * a circular connection (see `walkSideEffectsRecursive`).
+		 * @type {ModuleGraph | undefined}
+		 */
+		this._sideEffectsStateGraph = undefined;
+		/** @type {ConnectionState | undefined} */
+		this._sideEffectsStateValue = undefined;
 		/**
 		 * @private
 		 * @type {CodeGenerationResultData}
@@ -607,6 +1048,11 @@ class NormalModule extends Module {
 		this.parserOptions = undefined;
 		this.generator = undefined;
 		this.generatorOptions = undefined;
+		// Drop the side-effects memoization so a long-lived module doesn't
+		// strong-reference a stale `ModuleGraph`/`Compilation` for graphs
+		// that never get re-queried with a fresh one.
+		this._sideEffectsStateGraph = undefined;
+		this._sideEffectsStateValue = undefined;
 	}
 
 	/**
@@ -779,11 +1225,8 @@ class NormalModule extends Module {
 		/** @type {NormalModuleLoaderContext<T>} */
 		const loaderContext = {
 			version: 2,
-			/**
-			 * @param {import("../declarations/LoaderContext").Schema=} schema schema
-			 * @returns {T} options
-			 */
-			getOptions: (schema) => {
+			/** @type {LoaderContext<EXPECTED_ANY>["getOptions"]} */
+			getOptions: (/** @type {EXPECTED_ANY} */ schema = undefined) => {
 				const loader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
 					(loaderContext)
@@ -830,6 +1273,7 @@ class NormalModule extends Module {
 
 				return /** @type {T} */ (options);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
@@ -840,6 +1284,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
 				if (!(error instanceof Error)) {
 					error = new NonErrorEmittedError(error);
@@ -850,6 +1295,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["getLogger"]} */
 			getLogger: (name) => {
 				const currentLoader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
@@ -861,9 +1307,11 @@ class NormalModule extends Module {
 						.join("|")
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["resolve"]} */
 			resolve(context, request, callback) {
 				resolver.resolve({}, context, request, getResolveContext(), callback);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["getResolve"]} */
 			getResolve(options) {
 				const child = options ? resolver.withOptions(options) : resolver;
 				return /** @type {ReturnType<import("../declarations/LoaderContext").NormalModuleLoaderContext<T>["getResolve"]>} */ (
@@ -893,8 +1341,9 @@ class NormalModule extends Module {
 					}
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitFile"]} */
 			emitFile: (name, content, sourceMap, assetInfo) => {
-				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+				const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 
 				if (!buildInfo.assets) {
 					buildInfo.assets = Object.create(null);
@@ -918,7 +1367,7 @@ class NormalModule extends Module {
 				assetsInfo.set(name, assetInfo);
 			},
 			addBuildDependency: (dep) => {
-				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+				const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 
 				if (buildInfo.buildDependencies === undefined) {
 					buildInfo.buildDependencies = new LazySet();
@@ -1091,7 +1540,7 @@ class NormalModule extends Module {
 			return callback();
 		};
 
-		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+		const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 
 		buildInfo.fileDependencies = new LazySet();
 		buildInfo.contextDependencies = new LazySet();
@@ -1111,7 +1560,7 @@ class NormalModule extends Module {
 		}
 
 		if (this.loaders.length > 0) {
-			/** @type {BuildInfo} */
+			/** @type {NormalModuleBuildInfo} */
 			(this.buildInfo).buildDependencies = new LazySet();
 		}
 
@@ -1207,7 +1656,7 @@ class NormalModule extends Module {
 						(undefined);
 
 				if (!result) {
-					/** @type {BuildInfo} */
+					/** @type {NormalModuleBuildInfo} */
 					(this.buildInfo).cacheable = false;
 					return processResult(
 						err || new Error("No result from loader-runner processing"),
@@ -1215,16 +1664,16 @@ class NormalModule extends Module {
 					);
 				}
 
-				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+				const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 
 				const fileDependencies =
-					/** @type {NonNullable<KnownBuildInfo["fileDependencies"]>} */
+					/** @type {NonNullable<KnownNormalModuleBuildInfo["fileDependencies"]>} */
 					(buildInfo.fileDependencies);
 				const contextDependencies =
-					/** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+					/** @type {NonNullable<KnownNormalModuleBuildInfo["contextDependencies"]>} */
 					(buildInfo.contextDependencies);
 				const missingDependencies =
-					/** @type {NonNullable<KnownBuildInfo["missingDependencies"]>} */
+					/** @type {NonNullable<KnownNormalModuleBuildInfo["missingDependencies"]>} */
 					(buildInfo.missingDependencies);
 
 				fileDependencies.addAll(result.fileDependencies);
@@ -1232,7 +1681,7 @@ class NormalModule extends Module {
 				missingDependencies.addAll(result.missingDependencies);
 				for (const loader of this.loaders) {
 					const buildDependencies =
-						/** @type {NonNullable<KnownBuildInfo["buildDependencies"]>} */
+						/** @type {NonNullable<KnownNormalModuleBuildInfo["buildDependencies"]>} */
 						(buildInfo.buildDependencies);
 
 					buildDependencies.add(loader.loader);
@@ -1314,7 +1763,7 @@ class NormalModule extends Module {
 		}
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
-		/** @type {BuildInfo} */
+		/** @type {NormalModuleBuildInfo} */
 		(this.buildInfo).hash = hash.digest("hex");
 	}
 
@@ -1336,7 +1785,12 @@ class NormalModule extends Module {
 		this.error = null;
 		this.clearWarningsAndErrors();
 		this.clearDependenciesAndBlocks();
-		this.buildMeta = {};
+		this.buildMeta = {
+			exportsType: undefined,
+			defaultObject: undefined,
+			strictHarmonyModule: undefined,
+			async: undefined
+		};
 		this.buildInfo = {
 			cacheable: false,
 			parsed: true,
@@ -1347,7 +1801,16 @@ class NormalModule extends Module {
 			valueDependencies: undefined,
 			hash: undefined,
 			assets: undefined,
-			assetsInfo: undefined
+			assetsInfo: undefined,
+			snapshot: undefined,
+			strict: undefined,
+			exportsArgument: undefined,
+			moduleArgument: undefined,
+			topLevelDeclarations: undefined,
+			pureFunctions: undefined,
+			inlineExports: undefined,
+			moduleConcatenationBailout: undefined,
+			needCreateRequire: undefined
 		};
 
 		const startTime = compilation.compiler.fsStartTime || Date.now();
@@ -1380,7 +1843,7 @@ class NormalModule extends Module {
 			const handleParseResult = () => {
 				this.dependencies.sort(
 					concatComparators(
-						compareSelect((a) => a.loc, compareLocations),
+						Dependency.compareLocations,
 						keepOriginalOrder(this.dependencies)
 					)
 				);
@@ -1401,7 +1864,9 @@ class NormalModule extends Module {
 				}
 
 				const snapshotOptions = compilation.options.snapshot.module;
-				const { cacheable } = /** @type {BuildInfo} */ (this.buildInfo);
+				const { cacheable } = /** @type {NormalModuleBuildInfo} */ (
+					this.buildInfo
+				);
 				if (!cacheable || !snapshotOptions) {
 					return callback();
 				}
@@ -1414,7 +1879,7 @@ class NormalModule extends Module {
 				 */
 				const checkDependencies = (deps) => {
 					for (const dep of deps) {
-						if (!ABSOLUTE_PATH_REGEX.test(dep)) {
+						if (!ABSOLUTE_PATH_REGEXP.test(dep)) {
 							if (nonAbsoluteDependencies === undefined) {
 								nonAbsoluteDependencies = new Set();
 							}
@@ -1428,11 +1893,11 @@ class NormalModule extends Module {
 									(this.context),
 									depWithoutGlob
 								);
-								if (absolute !== dep && ABSOLUTE_PATH_REGEX.test(absolute)) {
+								if (absolute !== dep && ABSOLUTE_PATH_REGEXP.test(absolute)) {
 									(depWithoutGlob !== dep
-										? /** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+										? /** @type {NonNullable<KnownNormalModuleBuildInfo["contextDependencies"]>} */
 											(
-												/** @type {BuildInfo} */
+												/** @type {NormalModuleBuildInfo} */
 												(this.buildInfo).contextDependencies
 											)
 										: deps
@@ -1444,15 +1909,15 @@ class NormalModule extends Module {
 						}
 					}
 				};
-				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+				const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 				const fileDependencies =
-					/** @type {NonNullable<KnownBuildInfo["fileDependencies"]>} */
+					/** @type {NonNullable<KnownNormalModuleBuildInfo["fileDependencies"]>} */
 					(buildInfo.fileDependencies);
 				const contextDependencies =
-					/** @type {NonNullable<KnownBuildInfo["contextDependencies"]>} */
+					/** @type {NonNullable<KnownNormalModuleBuildInfo["contextDependencies"]>} */
 					(buildInfo.contextDependencies);
 				const missingDependencies =
-					/** @type {NonNullable<KnownBuildInfo["missingDependencies"]>} */
+					/** @type {NonNullable<KnownNormalModuleBuildInfo["missingDependencies"]>} */
 					(buildInfo.missingDependencies);
 				checkDependencies(fileDependencies);
 				checkDependencies(missingDependencies);
@@ -1498,7 +1963,7 @@ class NormalModule extends Module {
 			const noParseRule = options.module && options.module.noParse;
 			if (this.shouldPreventParsing(noParseRule, this.request)) {
 				// We assume that we need module and exports
-				/** @type {BuildInfo} */
+				/** @type {NormalModuleBuildInfo} */
 				(this.buildInfo).parsed = false;
 				this._initBuildHash(compilation);
 				return handleBuildDone();
@@ -1512,7 +1977,11 @@ class NormalModule extends Module {
 					current: this,
 					module: this,
 					compilation,
-					options
+					options,
+					harmonyNamedExports: undefined,
+					harmonyStarExports: undefined,
+					lastHarmonyImportOrder: undefined,
+					localModules: undefined
 				});
 			} catch (parseErr) {
 				handleParseError(/** @type {Error} */ (parseErr));
@@ -1539,21 +2008,16 @@ class NormalModule extends Module {
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
 	getSideEffectsConnectionState(moduleGraph) {
-		// Trampoline `walkSideEffects` so the descent doesn't consume the
-		// call stack (#20986).
-		const stack = [walkSideEffects(this, moduleGraph)];
-		/** @type {ConnectionState} */
-		let r = false;
-		while (stack.length > 0) {
-			const step = stack[stack.length - 1].next(r);
-			if (step.done) {
-				stack.pop();
-				r = step.value;
-			} else {
-				stack.push(step.value);
-			}
-		}
-		return r;
+		// Fresh per-walk context; re-entrant calls (e.g.
+		// `ConcatenatedModule.getSideEffectsConnectionState` delegating back
+		// through here) get their own and can't clobber the outer walk.
+		return walkSideEffectsRecursive(
+			this,
+			moduleGraph,
+			0,
+			getHarmonyImportSideEffectDependency(),
+			{ circular: false }
+		);
 	}
 
 	/**
@@ -1569,6 +2033,18 @@ class NormalModule extends Module {
 		return this._sourceTypes;
 	}
 
+	/**
+	 * Freshly recomputed source types when they depend on incoming connections, for chunk-graph cache invalidation; undefined otherwise. #20800
+	 * @returns {SourceTypes | undefined} source types or undefined
+	 */
+	getReferencedSourceTypes() {
+		const generator = /** @type {Generator} */ (this.generator);
+		// Bypass the _sourceTypes cache: it may be stale when the module is not rebuilt.
+		return generator.getTypesDependOnIncomingConnections()
+			? generator.getTypes(this)
+			: undefined;
+	}
+
 	/**
 	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
@@ -1587,7 +2063,7 @@ class NormalModule extends Module {
 		/** @type {RuntimeRequirements} */
 		const runtimeRequirements = new Set();
 
-		const { parsed } = /** @type {BuildInfo} */ (this.buildInfo);
+		const { parsed } = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 
 		if (!parsed) {
 			runtimeRequirements.add(RuntimeGlobals.module);
@@ -1643,7 +2119,8 @@ class NormalModule extends Module {
 		const resultEntry = {
 			sources,
 			runtimeRequirements,
-			data: this._codeGeneratorData
+			data: this._codeGeneratorData,
+			hash: undefined
 		};
 		return resultEntry;
 	}
@@ -1679,7 +2156,7 @@ class NormalModule extends Module {
 		if (this.error) return callback(null, true);
 
 		const { cacheable, snapshot, valueDependencies } =
-			/** @type {BuildInfo} */ (this.buildInfo);
+			/** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 
 		// always build when module is not cacheable
 		if (!cacheable) return callback(null, true);
@@ -1760,7 +2237,7 @@ class NormalModule extends Module {
 		buildDependencies
 	) {
 		const { snapshot, buildDependencies: buildDeps } =
-			/** @type {BuildInfo} */ (this.buildInfo);
+			/** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 		if (snapshot) {
 			fileDependencies.addAll(snapshot.getFileIterable());
 			contextDependencies.addAll(snapshot.getContextIterable());
@@ -1770,7 +2247,7 @@ class NormalModule extends Module {
 				fileDependencies: fileDeps,
 				contextDependencies: contextDeps,
 				missingDependencies: missingDeps
-			} = /** @type {BuildInfo} */ (this.buildInfo);
+			} = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 			if (fileDeps !== undefined) fileDependencies.addAll(fileDeps);
 			if (contextDeps !== undefined) contextDependencies.addAll(contextDeps);
 			if (missingDeps !== undefined) missingDependencies.addAll(missingDeps);
@@ -1787,7 +2264,7 @@ class NormalModule extends Module {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+		const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 		hash.update(
 			/** @type {string} */
 			(buildInfo.hash)
@@ -1821,6 +2298,7 @@ class NormalModule extends Module {
 		write(this._lastSuccessfulBuildMeta);
 		write(this._forceBuild);
 		write(this._codeGeneratorData);
+		write(this.hot);
 		super.serialize(context);
 	}
 
@@ -1829,7 +2307,8 @@ class NormalModule extends Module {
 	 * @returns {NormalModule} module
 	 */
 	static deserialize(context) {
-		const obj = new NormalModule({
+		// `new this` so subclasses without extra constructor options inherit this method
+		const obj = new this({
 			// will be deserialized by Module
 			layer: /** @type {EXPECTED_ANY} */ (null),
 			type: "",
@@ -1863,6 +2342,7 @@ class NormalModule extends Module {
 		this._lastSuccessfulBuildMeta = read();
 		this._forceBuild = read();
 		this._codeGeneratorData = read();
+		this.hot = read();
 		super.deserialize(context);
 	}
 }