@@ -0,0 +1,5 @@
+---
+"webpack": patch
+---
+
+Rewrite `NormalModule#getSideEffectsConnectionState` walk as an allocation-light iterative loop instead of a generator trampoline, restoring rebuild performance lost in #20993 while keeping deep import chains stack-safe.
@@ -86,7 +86,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 */
@@ -157,14 +156,13 @@ const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
 };
 
 /**
- * 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
- * @param {ModuleGraph} moduleGraph the module graph
- * @returns {SideEffectsWalk} the generator
+ * Resolves a module's side-effects state without descending into its
+ * dependencies. Returns the state when known, or `undefined` when the caller
+ * must walk the module's dependencies to compute it.
+ * @param {NormalModule} mod the module
+ * @returns {ConnectionState | undefined} the state, or `undefined` to descend
  */
-function* walkSideEffects(mod, moduleGraph) {
+const sideEffectsFastPath = (mod) => {
 	if (mod.factoryMeta !== undefined) {
 		if (mod.factoryMeta.sideEffectFree) return false;
 		if (mod.factoryMeta.sideEffectFree === false) return true;
@@ -175,12 +173,197 @@ function* walkSideEffects(mod, moduleGraph) {
 	if (mod._isEvaluatingSideEffects) {
 		return ModuleGraphConnection.CIRCULAR_CONNECTION;
 	}
+	return undefined;
+};
+
+// 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;
+
+/**
+ * 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 {ConnectionState} the side-effects connection state
+ */
+const walkSideEffectsIterative = (rootMod, moduleGraph) => {
+	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 deps = depsStack[top];
+
+		if (pending !== undefined) {
+			const state = pending;
+			pending = undefined;
+			const dep = deps[indexStack[top]];
+
+			if (state === true) {
+				recordSideEffectsBailout(modStack[top], moduleGraph, dep);
+				modStack[top]._isEvaluatingSideEffects = false;
+				modStack.pop();
+				depsStack.pop();
+				indexStack.pop();
+				currentStack.pop();
+				pending = true;
+				continue;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				currentStack[top] = ModuleGraphConnection.addConnectionStates(
+					currentStack[top],
+					state
+				);
+			}
+			indexStack[top]++;
+		}
+
+		let descended = false;
+		while (indexStack[top] < deps.length) {
+			const dep = deps[indexStack[top]];
+			/** @type {ConnectionState} */
+			let state;
+
+			if (dep instanceof SideEffectDep) {
+				const refModule = moduleGraph.getModule(dep);
+				if (!refModule) {
+					state = true;
+				} else if (refModule instanceof NormalModule) {
+					const refFast = sideEffectsFastPath(refModule);
+					if (refFast !== undefined) {
+						state = refFast;
+					} else {
+						refModule._isEvaluatingSideEffects = true;
+						modStack.push(refModule);
+						depsStack.push(refModule.dependencies);
+						indexStack.push(0);
+						currentStack.push(false);
+						descended = true;
+						break;
+					}
+				} else {
+					state = refModule.getSideEffectsConnectionState(moduleGraph);
+				}
+			} else {
+				state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+			}
+
+			if (state === true) {
+				recordSideEffectsBailout(modStack[top], moduleGraph, dep);
+				modStack[top]._isEvaluatingSideEffects = false;
+				modStack.pop();
+				depsStack.pop();
+				indexStack.pop();
+				currentStack.pop();
+				pending = true;
+				descended = true;
+				break;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				currentStack[top] = ModuleGraphConnection.addConnectionStates(
+					currentStack[top],
+					state
+				);
+			}
+			indexStack[top]++;
+		}
+
+		if (descended) continue;
+
+		modStack[top]._isEvaluatingSideEffects = false;
+		pending = currentStack[top];
+		modStack.pop();
+		depsStack.pop();
+		indexStack.pop();
+		currentStack.pop();
+	}
+
+	// When caching is implemented here, make sure to not cache when
+	// at least one circular connection was folded into the result.
+	return /** @type {ConnectionState} */ (pending);
+};
+
+/**
+ * Tracks whether a cycle (CIRCULAR_CONNECTION) was encountered anywhere
+ * in the currently-executing walk. The walker uses this to decide whether
+ * an intermediate result is safe to memoize on the module: a result
+ * computed in the presence of a cycle can differ from the result computed
+ * fresh, because cycle short-circuiting hides the contribution of the
+ * back-edge target. Reset to `false` at the top-level entry; read and
+ * propagated by each recursive frame.
+ */
+let _sideEffectsCircularSeen = false;
+
+/**
+ * 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). Falls back to
+ * `walkSideEffectsIterative` once depth reaches
+ * `SIDE_EFFECTS_RECURSION_LIMIT` to keep deep chains stack-safe (#20986).
+ *
+ * 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
+ * @returns {ConnectionState} the side-effects connection state
+ */
+const walkSideEffectsRecursive = (mod, moduleGraph, depth) => {
+	if (mod._sideEffectsStateGraph === moduleGraph) {
+		return /** @type {ConnectionState} */ (mod._sideEffectsStateValue);
+	}
+
+	const fast = sideEffectsFastPath(mod);
+	if (fast !== undefined) {
+		if (fast === ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			_sideEffectsCircularSeen = true;
+		}
+		return fast;
+	}
+
+	if (depth >= SIDE_EFFECTS_RECURSION_LIMIT) {
+		return walkSideEffectsIterative(mod, moduleGraph);
+	}
 
 	const SideEffectDep = getHarmonyImportSideEffectDependency();
 	mod._isEvaluatingSideEffects = true;
 	/** @type {ConnectionState} */
 	let current = false;
 
+	// Snapshot whatever the parent has seen so we can isolate this
+	// module's own subtree and re-merge on the way out.
+	const outerCircularSeen = _sideEffectsCircularSeen;
+	_sideEffectsCircularSeen = false;
+
 	for (const dep of mod.dependencies) {
 		/** @type {ConnectionState} */
 		let state;
@@ -189,8 +372,16 @@ function* walkSideEffects(mod, moduleGraph) {
 			if (!refModule) {
 				state = true;
 			} else if (refModule instanceof NormalModule) {
-				state = yield walkSideEffects(refModule, moduleGraph);
+				state = walkSideEffectsRecursive(refModule, moduleGraph, depth + 1);
 			} 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 this frame as cycle-tainted and skip the
+				// cache for safety.
+				_sideEffectsCircularSeen = true;
 				state = refModule.getSideEffectsConnectionState(moduleGraph);
 			}
 		} else {
@@ -200,6 +391,12 @@ function* walkSideEffects(mod, moduleGraph) {
 		if (state === true) {
 			recordSideEffectsBailout(mod, moduleGraph, dep);
 			mod._isEvaluatingSideEffects = false;
+			// `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;
+			_sideEffectsCircularSeen = outerCircularSeen || _sideEffectsCircularSeen;
 			return true;
 		}
 		if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
@@ -208,10 +405,17 @@ 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`.
+	const sawCircularInSubtree = _sideEffectsCircularSeen;
+	_sideEffectsCircularSeen = outerCircularSeen || sawCircularInSubtree;
+
+	// Only memoize when the subtree's result is independent of the
+	// current cycle context — i.e. no CIRCULAR_CONNECTION was observed.
+	if (!sawCircularInSubtree) {
+		mod._sideEffectsStateGraph = moduleGraph;
+		mod._sideEffectsStateValue = current;
+	}
 	return current;
-}
+};
 
 const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
 
@@ -500,6 +704,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}
@@ -1539,21 +1755,14 @@ 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;
+		// Save and restore the cycle-tracking flag so that re-entrant calls
+		// (e.g. `ConcatenatedModule.getSideEffectsConnectionState` delegating
+		// back through here) don't clobber the outer walk's state.
+		const savedCircular = _sideEffectsCircularSeen;
+		_sideEffectsCircularSeen = false;
+		const result = walkSideEffectsRecursive(this, moduleGraph, 0);
+		_sideEffectsCircularSeen = savedCircular;
+		return result;
 	}
 
 	/**
 
@@ -429,6 +429,18 @@ describe("NormalModule", () => {
 			expect(modules[0].getSideEffectsConnectionState(moduleGraph)).toBe(false);
 		});
 
+		it("propagates bailout across the recursive→iterative crossover", () => {
+			// Chain length is chosen to exceed `SIDE_EFFECTS_RECURSION_LIMIT`,
+			// so the walker recurses for the head of the chain and switches
+			// to iteration deeper in. A bailout deep in the iterative tail
+			// must still propagate all the way back to module 0.
+			const { modules, moduleGraph } = buildChain(5000);
+			modules[4500].buildMeta = { sideEffectFree: false };
+			expect(modules[0].getSideEffectsConnectionState(moduleGraph)).toBe(true);
+			expect(modules[0]._isEvaluatingSideEffects).toBe(false);
+			expect(modules[4499]._isEvaluatingSideEffects).toBe(false);
+		});
+
 		it("detects cycles in the side-effect graph", () => {
 			const { modules, moduleGraph } = buildChain(50);
 			// close the loop: last module's dep points to modules[0]
@@ -468,5 +480,39 @@ describe("NormalModule", () => {
 				);
 			}
 		});
+
+		it("aggregates state across branching deps", () => {
+			// Diamond: root depends on two side-effect-free leaves.
+			const make = (id) => {
+				const mod = new NormalModule({
+					type: "javascript/auto",
+					request: `/${id}`,
+					userRequest: `/${id}`,
+					rawRequest: id,
+					loaders: [],
+					resource: `/${id}`,
+					parser: { parse() {} },
+					generator: null,
+					resolveOptions: {}
+				});
+				mod.buildMeta = { sideEffectFree: true };
+				mod.dependencies = [];
+				return mod;
+			};
+			const root = make("root");
+			const a = make("a");
+			const b = make("b");
+			const depA = new HarmonyImportSideEffectDependency("a", 0, "evaluation");
+			const depB = new HarmonyImportSideEffectDependency("b", 1, "evaluation");
+			root.dependencies = [depA, depB];
+			const moduleGraph = {
+				getModule: (dep) => (dep === depA ? a : dep === depB ? b : undefined),
+				getOptimizationBailout: () => []
+			};
+			expect(root.getSideEffectsConnectionState(moduleGraph)).toBe(false);
+			expect(root._isEvaluatingSideEffects).toBe(false);
+			expect(a._isEvaluatingSideEffects).toBe(false);
+			expect(b._isEvaluatingSideEffects).toBe(false);
+		});
 	});
 });
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": patch
 +---
++
 +Rewrite `NormalModule#getSideEffectsConnectionState` walk as an allocation-light iterative loop instead of a generator trampoline, restoring rebuild performance lost in #20993 while keeping deep import chains stack-safe.