@chromatic-com/playwright 0.14.10 → 0.14.11

package/embedded/node_modules/webpack/lib/NormalModule.js

@@ -6,7 +6,6 @@
 "use strict";
 
 const querystring = require("querystring");
-const parseJson = require("json-parse-even-better-errors");
 const { getContext, runLoaders } = require("loader-runner");
 const {
 	AsyncSeriesBailHook,
@@ -21,18 +20,17 @@ const {
 	SourceMapSource
 } = require("webpack-sources");
 const Compilation = require("./Compilation");
-const HookWebpackError = require("./HookWebpackError");
 const Module = require("./Module");
-const ModuleBuildError = require("./ModuleBuildError");
-const ModuleError = require("./ModuleError");
 const ModuleGraphConnection = require("./ModuleGraphConnection");
-const ModuleParseError = require("./ModuleParseError");
 const { JAVASCRIPT_MODULE_TYPE_AUTO } = require("./ModuleTypeConstants");
-const ModuleWarning = require("./ModuleWarning");
 const RuntimeGlobals = require("./RuntimeGlobals");
-const UnhandledSchemeError = require("./UnhandledSchemeError");
-const WebpackError = require("./WebpackError");
-const formatLocation = require("./formatLocation");
+const HookWebpackError = require("./errors/HookWebpackError");
+const ModuleBuildError = require("./errors/ModuleBuildError");
+const ModuleError = require("./errors/ModuleError");
+const ModuleParseError = require("./errors/ModuleParseError");
+const ModuleWarning = require("./errors/ModuleWarning");
+const NonErrorEmittedError = require("./errors/NonErrorEmittedError");
+const UnhandledSchemeError = require("./errors/UnhandledSchemeError");
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
@@ -45,6 +43,7 @@ const {
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
 const { createFakeHook } = require("./util/deprecation");
+const formatLocation = require("./util/formatLocation");
 const { join } = require("./util/fs");
 const {
 	absolutify,
@@ -53,6 +52,7 @@ const {
 } = require("./util/identifier");
 const makeSerializable = require("./util/makeSerializable");
 const memoize = require("./util/memoize");
+const parseJson = require("./util/parseJson");
 
 /** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
 /** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
@@ -61,6 +61,7 @@ const memoize = require("./util/memoize");
 /** @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 */
@@ -87,6 +88,10 @@ const memoize = require("./util/memoize");
 /** @typedef {import("./ModuleGraphConnection").ConnectionState} ConnectionState */
 /** @typedef {import("./NormalModuleFactory")} NormalModuleFactory */
 /** @typedef {import("./NormalModuleFactory").NormalModuleTypes} NormalModuleTypes */
+/** @typedef {import("./NormalModuleFactory").ParserByType} ParserByType */
+/** @typedef {import("./NormalModuleFactory").ParserOptionsByType} ParserOptionsByType */
+/** @typedef {import("./NormalModuleFactory").GeneratorByType} GeneratorByType */
+/** @typedef {import("./NormalModuleFactory").GeneratorOptionsByType} GeneratorOptionsByType */
 /** @typedef {import("./NormalModuleFactory").ResourceSchemeData} ResourceSchemeData */
 /** @typedef {import("./Parser")} Parser */
 /** @typedef {import("./Parser").PreparsedAst} PreparsedAst */
@@ -119,13 +124,495 @@ const memoize = require("./util/memoize");
 /** @typedef {(content: string) => boolean} NoParseFn */
 
 const getInvalidDependenciesModuleWarning = memoize(() =>
-	require("./InvalidDependenciesModuleWarning")
+	require("./errors/InvalidDependenciesModuleWarning")
 );
 
 const getExtractSourceMap = memoize(() => require("./util/extractSourceMap"));
 
 const getValidate = memoize(() => require("schema-utils").validate);
 
+const getHarmonyImportSideEffectDependency = memoize(() =>
+	require("./dependencies/HarmonyImportSideEffectDependency")
+);
+
+/**
+ * @param {NormalModule} mod the module
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {Dependency} dep the dep that triggered the bailout
+ */
+const recordSideEffectsBailout = (mod, moduleGraph, dep) => {
+	if (mod._addedSideEffectsBailout === undefined) {
+		mod._addedSideEffectsBailout = new WeakSet();
+	} else if (mod._addedSideEffectsBailout.has(moduleGraph)) {
+		return;
+	}
+	mod._addedSideEffectsBailout.add(moduleGraph);
+	moduleGraph
+		.getOptimizationBailout(mod)
+		.push(
+			() =>
+				`Dependency (${dep.type}) with side effects at ${formatLocation(dep.loc)}`
+		);
+};
+
+// 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 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) {
+							_sideEffectsCircularSeen = 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) {
+						_sideEffectsCircularSeen = 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 {
+					_sideEffectsCircularSeen = 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 (!_sideEffectsCircularSeen) {
+			topMod._sideEffectsStateGraph = moduleGraph;
+			topMod._sideEffectsStateValue = current;
+		}
+		pending = current;
+		modStack.pop();
+		depsStack.pop();
+		indexStack.pop();
+		currentStack.pop();
+	}
+
+	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;
+
+/**
+ * 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
+ * @returns {ConnectionState} the root ancestor's result
+ */
+const propagateLinearResult = (ancestors, state, moduleGraph) => {
+	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
+			// `_sideEffectsCircularSeen`).
+			state = false;
+		} else if (!_sideEffectsCircularSeen) {
+			ancestor._sideEffectsStateGraph = moduleGraph;
+			ancestor._sideEffectsStateValue = state;
+		}
+	}
+	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
+ * @returns {ConnectionState} the side-effects connection state
+ */
+const walkSideEffectsRecursive = (mod, moduleGraph, depth, SideEffectDep) => {
+	// 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
+			);
+		}
+
+		if (mod.factoryMeta !== undefined) {
+			if (mod.factoryMeta.sideEffectFree) {
+				return propagateLinearResult(linearAncestors, false, moduleGraph);
+			}
+			if (mod.factoryMeta.sideEffectFree === false) {
+				return propagateLinearResult(linearAncestors, true, moduleGraph);
+			}
+		}
+		if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+			return propagateLinearResult(linearAncestors, true, moduleGraph);
+		}
+		if (mod._isEvaluatingSideEffects) {
+			_sideEffectsCircularSeen = true;
+			return propagateLinearResult(
+				linearAncestors,
+				ModuleGraphConnection.CIRCULAR_CONNECTION,
+				moduleGraph
+			);
+		}
+
+		// 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);
+				}
+				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 (!_sideEffectsCircularSeen) {
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = false;
+			}
+			return propagateLinearResult(linearAncestors, false, moduleGraph);
+		}
+
+		const refModule = moduleGraph.getModule(linearDep);
+		if (!refModule) {
+			recordSideEffectsBailout(mod, moduleGraph, linearDep);
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = true;
+			return propagateLinearResult(linearAncestors, true, moduleGraph);
+		}
+		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),
+			moduleGraph
+		);
+	}
+
+	mod._isEvaluatingSideEffects = true;
+	/** @type {ConnectionState} */
+	let current = false;
+
+	for (const dep of mod.dependencies) {
+		/** @type {ConnectionState} */
+		let state;
+		if (dep instanceof SideEffectDep) {
+			const refModule = moduleGraph.getModule(dep);
+			if (!refModule) {
+				state = true;
+			} else if (refModule instanceof NormalModule) {
+				state = walkSideEffectsRecursive(
+					refModule,
+					moduleGraph,
+					depth + 1,
+					SideEffectDep
+				);
+			} 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.
+				_sideEffectsCircularSeen = true;
+				state = refModule.getSideEffectsConnectionState(moduleGraph);
+			}
+		} else {
+			state = dep.getModuleEvaluationSideEffectsState(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;
+			return propagateLinearResult(linearAncestors, true, moduleGraph);
+		}
+		if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+			current = ModuleGraphConnection.addConnectionStates(current, state);
+		}
+	}
+
+	mod._isEvaluatingSideEffects = false;
+
+	// 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 (!_sideEffectsCircularSeen) {
+		mod._sideEffectsStateGraph = moduleGraph;
+		mod._sideEffectsStateValue = current;
+	}
+	return propagateLinearResult(linearAncestors, current, moduleGraph);
+};
+
 const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
 
 /**
@@ -207,44 +694,32 @@ const asBuffer = (input) => {
 	return input;
 };
 
-class NonErrorEmittedError extends WebpackError {
-	/**
-	 * @param {EXPECTED_ANY} error value which is not an instance of Error
-	 */
-	constructor(error) {
-		super();
-
-		this.name = "NonErrorEmittedError";
-		this.message = `(Emitted value instead of an instance of Error) ${error}`;
-	}
-}
-
-makeSerializable(
-	NonErrorEmittedError,
-	"webpack/lib/NormalModule",
-	"NonErrorEmittedError"
-);
-
 /** @typedef {[string | Buffer, string | RawSourceMap | undefined, PreparsedAst | undefined]}  Result */
 
 /** @typedef {LoaderContext<EXPECTED_ANY>} AnyLoaderContext */
 
+/**
+ * @deprecated Use the `readResource` hook instead.
+ * @typedef {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} DeprecatedReadResourceForScheme
+ */
+
 /**
  * @typedef {object} NormalModuleCompilationHooks
  * @property {SyncHook<[AnyLoaderContext, NormalModule]>} loader
  * @property {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} beforeLoaders
  * @property {SyncHook<[NormalModule]>} beforeParse
  * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} readResourceForScheme
+ * @property {DeprecatedReadResourceForScheme} readResourceForScheme
  * @property {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} readResource
  * @property {SyncWaterfallHook<[Result, NormalModule]>} processResult
  * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
  */
 
 /**
+ * @template {NormalModuleTypes | ""} [T=NormalModuleTypes | ""]
  * @typedef {object} NormalModuleCreateData
  * @property {string=} layer an optional layer in which the module is
- * @property {NormalModuleTypes | ""} type module type. When deserializing, this is set to an empty string "".
+ * @property {T} type module type. When deserializing, this is set to an empty string "".
  * @property {string} request request string
  * @property {string} userRequest request intended by user (without loaders from config)
  * @property {string} rawRequest request without resolving
@@ -253,10 +728,10 @@ makeSerializable(
  * @property {(ResourceSchemeData & Partial<ResolveRequest>)=} resourceResolveData resource resolve data
  * @property {string} context context directory for resolving
  * @property {string=} matchResource path + query of the matched resource (virtual)
- * @property {Parser} parser the parser used
- * @property {ParserOptions=} parserOptions the options of the parser used
- * @property {Generator} generator the generator used
- * @property {GeneratorOptions=} generatorOptions the options of the generator used
+ * @property {ParserByType[T]} parser the parser used
+ * @property {ParserOptionsByType[T]=} parserOptions the options of the parser used
+ * @property {GeneratorByType[T]} generator the generator used
+ * @property {GeneratorOptionsByType[T]=} generatorOptions the options of the generator used
  * @property {ResolveOptions=} resolveOptions options used for resolving requests from this module
  * @property {boolean} extractSourceMap enable/disable extracting source map
  */
@@ -389,7 +864,7 @@ class NormalModule extends Module {
 		this.extractSourceMap = extractSourceMap;
 
 		// Info from Build
-		/** @type {WebpackError | null} */
+		/** @type {Error | null} */
 		this.error = null;
 		/**
 		 * @private
@@ -418,15 +893,25 @@ class NormalModule extends Module {
 		 */
 		this._forceBuild = true;
 		/**
-		 * @private
 		 * @type {boolean}
 		 */
 		this._isEvaluatingSideEffects = false;
 		/**
-		 * @private
 		 * @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}
@@ -435,6 +920,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -448,6 +934,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Returns a human-readable identifier for this module.
 	 * @param {RequestShortener} requestShortener the request shortener
 	 * @returns {string} a user readable identifier of the module
 	 */
@@ -463,6 +950,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Gets the library identifier.
 	 * @param {LibIdentOptions} options options
 	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
@@ -477,6 +965,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Returns the path used when matching this module against rule conditions.
 	 * @returns {NameForCondition | null} absolute path which should be used for condition matching (usually the resource path)
 	 */
 	nameForCondition() {
@@ -530,6 +1019,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;
 	}
 
 	/**
@@ -702,11 +1196,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)
@@ -717,7 +1208,9 @@ class NormalModule extends Module {
 				if (typeof options === "string") {
 					if (options.startsWith("{") && options.endsWith("}")) {
 						try {
-							options = parseJson(options);
+							options =
+								/** @type {LoaderItem["options"]} */
+								(parseJson(options));
 						} catch (err) {
 							throw new Error(
 								`Cannot parse string options: ${/** @type {Error} */ (err).message}`,
@@ -735,7 +1228,7 @@ class NormalModule extends Module {
 					options = {};
 				}
 
-				if (schema) {
+				if (schema && compilation.options.validate) {
 					let name = "Loader";
 					let baseDataPath = "options";
 					/** @type {RegExpExecArray | null} */
@@ -751,6 +1244,7 @@ class NormalModule extends Module {
 
 				return /** @type {T} */ (options);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
@@ -761,6 +1255,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
 				if (!(error instanceof Error)) {
 					error = new NonErrorEmittedError(error);
@@ -771,6 +1266,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["getLogger"]} */
 			getLogger: (name) => {
 				const currentLoader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
@@ -782,9 +1278,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"]>} */ (
@@ -814,6 +1312,7 @@ class NormalModule extends Module {
 					}
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitFile"]} */
 			emitFile: (name, content, sourceMap, assetInfo) => {
 				const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
 
@@ -872,7 +1371,6 @@ class NormalModule extends Module {
 		return /** @type {AnyLoaderContext} */ (loaderContext);
 	}
 
-	// TODO remove `loaderContext` in webpack@6
 	/**
 	 * @param {AnyLoaderContext} loaderContext loader context
 	 * @param {number} index index
@@ -1166,7 +1664,7 @@ class NormalModule extends Module {
 	}
 
 	/**
-	 * @param {WebpackError} error the error
+	 * @param {Error} error the error
 	 * @returns {void}
 	 */
 	markModuleAsErrored(error) {
@@ -1241,6 +1739,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -1317,7 +1816,7 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(/** @type {WebpackError} */ (err));
+					this.markModuleAsErrored(/** @type {Error} */ (err));
 					return callback();
 				}
 
@@ -1409,7 +1908,7 @@ class NormalModule extends Module {
 			try {
 				hooks.beforeParse.call(this);
 			} catch (err) {
-				this.markModuleAsErrored(/** @type {WebpackError} */ (err));
+				this.markModuleAsErrored(/** @type {Error} */ (err));
 				this._initBuildHash(compilation);
 				return callback();
 			}
@@ -1444,6 +1943,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Returns the reason this module cannot be concatenated, when one exists.
 	 * @param {ConcatenationBailoutReasonContext} context context
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
@@ -1454,54 +1954,28 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Gets side effects connection state.
 	 * @param {ModuleGraph} moduleGraph the module graph
 	 * @returns {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only
 	 */
 	getSideEffectsConnectionState(moduleGraph) {
-		if (this.factoryMeta !== undefined) {
-			if (this.factoryMeta.sideEffectFree) return false;
-			if (this.factoryMeta.sideEffectFree === false) return true;
-		}
-		if (this.buildMeta !== undefined && this.buildMeta.sideEffectFree) {
-			if (this._isEvaluatingSideEffects) {
-				return ModuleGraphConnection.CIRCULAR_CONNECTION;
-			}
-			this._isEvaluatingSideEffects = true;
-			/** @type {ConnectionState} */
-			let current = false;
-			for (const dep of this.dependencies) {
-				const state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
-				if (state === true) {
-					if (
-						this._addedSideEffectsBailout === undefined
-							? ((this._addedSideEffectsBailout = new WeakSet()), true)
-							: !this._addedSideEffectsBailout.has(moduleGraph)
-					) {
-						this._addedSideEffectsBailout.add(moduleGraph);
-						moduleGraph
-							.getOptimizationBailout(this)
-							.push(
-								() =>
-									`Dependency (${
-										dep.type
-									}) with side effects at ${formatLocation(dep.loc)}`
-							);
-					}
-					this._isEvaluatingSideEffects = false;
-					return true;
-				} else if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
-					current = ModuleGraphConnection.addConnectionStates(current, state);
-				}
-			}
-			this._isEvaluatingSideEffects = false;
-			// When caching is implemented here, make sure to not cache when
-			// at least one circular connection was in the loop above
-			return current;
-		}
-		return true;
+		// 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,
+			getHarmonyImportSideEffectDependency()
+		);
+		_sideEffectsCircularSeen = savedCircular;
+		return result;
 	}
 
 	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
@@ -1514,6 +1988,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
 	 * @returns {CodeGenerationResult} result
 	 */
@@ -1592,6 +2067,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Gets the original source.
 	 * @returns {Source | null} the original source for the module before webpack transformation
 	 */
 	originalSource() {
@@ -1599,6 +2075,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Invalidates the cached state associated with this value.
 	 * @returns {void}
 	 */
 	invalidateBuild() {
@@ -1606,6 +2083,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Checks whether the module needs to be rebuilt for the current build state.
 	 * @param {NeedBuildContext} context context info
 	 * @param {NeedBuildCallback} callback callback function, returns true, if the module needs a rebuild
 	 * @returns {void}
@@ -1665,6 +2143,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Returns the estimated size for the requested source type.
 	 * @param {string=} type the source type for which the size should be estimated
 	 * @returns {number} the estimated size of the module (must be non-zero)
 	 */
@@ -1686,6 +2165,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Adds the provided file dependencies to the module.
 	 * @param {FileSystemDependencies} fileDependencies set where file dependencies are added to
 	 * @param {FileSystemDependencies} contextDependencies set where context dependencies are added to
 	 * @param {FileSystemDependencies} missingDependencies set where missing dependencies are added to
@@ -1719,6 +2199,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Updates the hash with the data contributed by this instance.
 	 * @param {Hash} hash the hash used to track dependencies
 	 * @param {UpdateHashContext} context context
 	 * @returns {void}
@@ -1729,6 +2210,15 @@ class NormalModule extends Module {
 			/** @type {string} */
 			(buildInfo.hash)
 		);
+		// Clear cached source types and re-compute so that changes in incoming
+		// connections (e.g. asset module newly referenced from JS via lazy
+		// compilation) are reflected in the hash and trigger code generation
+		// cache invalidation.
+		// https://github.com/webpack/webpack/issues/20800
+		this._sourceTypes = undefined;
+		for (const type of this.getSourceTypes()) {
+			hash.update(type);
+		}
 		/** @type {Generator} */
 		(this.generator).updateHash(hash, {
 			module: this,
@@ -1738,6 +2228,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -1780,6 +2271,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {