@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/NormalModule.js

@@ -6,8 +6,6 @@
 "use strict";
 
 const querystring = require("querystring");
-const parseJson = require("json-parse-even-better-errors");
-const { getContext, runLoaders } = require("loader-runner");
 const {
 	AsyncSeriesBailHook,
 	HookMap,
@@ -20,39 +18,45 @@ const {
 	RawSource,
 	SourceMapSource
 } = require("webpack-sources");
-const Compilation = require("./Compilation");
-const HookWebpackError = require("./HookWebpackError");
+const Dependency = require("./Dependency");
 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 {
+	createLoaderContext,
+	getContext,
+	runLoaders
+} = require("./loaders/LoaderRunner");
 const LazySet = require("./util/LazySet");
 const { isSubset } = require("./util/SetHelpers");
 const { getScheme } = require("./util/URLAbsoluteSpecifier");
 const {
-	compareLocations,
-	compareSelect,
 	concatComparators,
 	keepOriginalOrder,
 	sortWithSourceOrder
 } = require("./util/comparators");
 const createHash = require("./util/createHash");
+const createHooksRegistry = require("./util/createHooksRegistry");
 const { createFakeHook } = require("./util/deprecation");
+const formatLocation = require("./util/formatLocation");
 const { join } = require("./util/fs");
 const {
+	ABSOLUTE_PATH_REGEXP,
 	absolutify,
 	contextify,
-	makePathsRelative
+	contextifySourceUrl
 } = 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 */
@@ -60,12 +64,15 @@ const memoize = require("./util/memoize");
 /** @typedef {import("webpack-sources").RawSourceMap} RawSourceMap */
 /** @typedef {import("../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
 /** @typedef {import("../declarations/WebpackOptions").NoParse} NoParse */
+/** @typedef {import("./Compilation")} Compilation */
 /** @typedef {import("./config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
 /** @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 */
@@ -87,6 +94,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,14 +130,258 @@ 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 ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
+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)}`
+		);
+};
+
+/**
+ * Walks the `HarmonyImportSideEffectDependency` graph to decide how `rootMod`
+ * connects to a referrer when consumed for its side effects only.
+ *
+ * Iterative (explicit work stack) so deep import chains never approach V8's
+ * recursion limit — the overflow behind #20986 — with no separate recursive
+ * form or depth cap. Cycles use Tarjan's `index`/`lowlink`: a module's result
+ * is memoized on `_sideEffectsStateGraph` only when it is context-independent
+ * (cycle-free, or the root of its strongly-connected component), i.e. exactly
+ * when the result cannot depend on which ancestors are mid-walk.
+ *
+ * The previous walker disabled memoization for the whole walk the moment any
+ * cycle appeared (one global `circular` flag). With diamond-shaped graphs that
+ * made the walk exponential, so a single circular import could blow up an
+ * otherwise-linear graph. Per-module lowlink keeps the cycle-free majority
+ * memoized while a cycle exists elsewhere.
+ *
+ * Caching under `lowlink === index` is conservative: an imprecise lowlink can
+ * only skip caching (a later recompute yields the same value), never memoize a
+ * state that depended on stack context. `true` is monotonic and always cached.
+ * A non-`NormalModule` dependency (e.g. `ConcatenatedModule` re-entering this
+ * method) is treated as a taint so its chain is never memoized, and any module
+ * already flagged `_isEvaluatingSideEffects` (this walk or an outer re-entrant
+ * one) counts as circular, matching the previous walker.
+ * @param {NormalModule} rootMod the module being walked
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {EXPECTED_ANY} SideEffectDep `HarmonyImportSideEffectDependency` constructor, resolved once at the entry
+ * @returns {ConnectionState} the side-effects connection state
+ */
+const walkSideEffects = (rootMod, moduleGraph, SideEffectDep) => {
+	// Context-independent state without descending; `undefined` => walk deps.
+	/**
+	 * @param {NormalModule} mod module
+	 * @returns {ConnectionState | undefined} resolved state or undefined
+	 */
+	const quick = (mod) => {
+		if (mod._sideEffectsStateGraph === moduleGraph) {
+			return /** @type {ConnectionState} */ (mod._sideEffectsStateValue);
+		}
+		const fm = mod.factoryMeta;
+		if (fm !== undefined) {
+			if (fm.sideEffectFree) return false;
+			if (fm.sideEffectFree === false) return true;
+		}
+		if (!(mod.buildMeta !== undefined && mod.buildMeta.sideEffectFree)) {
+			return true;
+		}
+		return undefined;
+	};
+
+	const q0 = quick(rootMod);
+	if (q0 !== undefined) return q0;
+
+	/** @type {Map<NormalModule, number>} module -> Tarjan index */
+	const indexOf = new Map();
+	/** @type {Map<NormalModule, number>} module -> Tarjan lowlink */
+	const lowOf = new Map();
+	// Parallel frame arrays, to avoid a per-frame object allocation.
+	/** @type {NormalModule[]} */
+	const fMod = [];
+	/** @type {Dependency[][]} */
+	const fDeps = [];
+	/** @type {number[]} */
+	const fIdx = [];
+	/** @type {ConnectionState[]} */
+	const fCur = [];
+	let counter = 0;
+
+	/**
+	 * @param {NormalModule} mod module to push a frame for
+	 */
+	const enter = (mod) => {
+		indexOf.set(mod, counter);
+		lowOf.set(mod, counter);
+		counter++;
+		mod._isEvaluatingSideEffects = true;
+		fMod.push(mod);
+		fDeps.push(mod.dependencies);
+		fIdx.push(0);
+		fCur.push(false);
+	};
+
+	enter(rootMod);
+	/** @type {ConnectionState} the just-popped frame's result */
+	let result = false;
+	/**
+	 * Result of a just-popped child frame, to apply to the new top's current
+	 * dep. `undefined` means "no pending; advance normally".
+	 * @type {ConnectionState | undefined}
+	 */
+	let pending;
+
+	while (fMod.length > 0) {
+		const top = fMod.length - 1;
+		const mod = fMod[top];
+		const deps = fDeps[top];
+		let i = fIdx[top];
+		let current = fCur[top];
+
+		// Apply a popped child's result to the dep that spawned it.
+		if (pending !== undefined) {
+			const state = pending;
+			pending = undefined;
+			const dep = deps[i];
+			if (state === true) {
+				recordSideEffectsBailout(mod, moduleGraph, dep);
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = true;
+				mod._isEvaluatingSideEffects = false;
+				fMod.pop();
+				fDeps.pop();
+				fIdx.pop();
+				fCur.pop();
+				result = true;
+				pending = true;
+				continue;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				current = ModuleGraphConnection.addConnectionStates(current, state);
+			}
+			i++;
+		}
+
+		let descended = false;
+		while (i < deps.length) {
+			const dep = deps[i];
+			/** @type {ConnectionState} */
+			let state;
+
+			if (dep instanceof SideEffectDep) {
+				const refModule = moduleGraph.getModule(dep);
+				if (!refModule) {
+					state = true;
+				} else if (refModule instanceof NormalModule) {
+					if (refModule._isEvaluatingSideEffects) {
+						// On the current stack (or an outer re-entrant walk) => cycle.
+						state = ModuleGraphConnection.CIRCULAR_CONNECTION;
+						const ri = indexOf.get(refModule);
+						lowOf.set(
+							mod,
+							Math.min(
+								/** @type {number} */ (lowOf.get(mod)),
+								ri === undefined ? -1 : ri
+							)
+						);
+					} else {
+						const q = quick(refModule);
+						if (q !== undefined) {
+							state = q;
+						} else {
+							// Descend: pause this frame, walk the child next.
+							fIdx[top] = i;
+							fCur[top] = current;
+							enter(refModule);
+							descended = true;
+							break;
+						}
+					}
+				} else {
+					// Non-NormalModule (e.g. ConcatenatedModule delegating back
+					// through here) resolves via a re-entrant walk that may see our
+					// in-progress modules as circular, so taint this chain: never
+					// memoize it.
+					state = refModule.getSideEffectsConnectionState(moduleGraph);
+					lowOf.set(mod, -1);
+				}
+			} else {
+				state = dep.getModuleEvaluationSideEffectsState(moduleGraph);
+			}
+
+			if (state === true) {
+				recordSideEffectsBailout(mod, moduleGraph, dep);
+				// `true` is monotonic — always safe to memoize.
+				mod._sideEffectsStateGraph = moduleGraph;
+				mod._sideEffectsStateValue = true;
+				mod._isEvaluatingSideEffects = false;
+				fMod.pop();
+				fDeps.pop();
+				fIdx.pop();
+				fCur.pop();
+				result = true;
+				pending = true;
+				descended = true;
+				break;
+			}
+			if (state !== ModuleGraphConnection.CIRCULAR_CONNECTION) {
+				current = ModuleGraphConnection.addConnectionStates(current, state);
+			}
+			i++;
+		}
+
+		if (descended) continue;
+
+		// `mod` finished without a `true` bailout.
+		mod._isEvaluatingSideEffects = false;
+		// Memoize only when the result is context-independent: no back-edge in
+		// this subtree reached above `mod` (a cycle-free module or an SCC root).
+		if (lowOf.get(mod) === indexOf.get(mod)) {
+			mod._sideEffectsStateGraph = moduleGraph;
+			mod._sideEffectsStateValue = current;
+		}
+		fMod.pop();
+		fDeps.pop();
+		fIdx.pop();
+		fCur.pop();
+		result = current;
+		pending = current;
+		if (fMod.length > 0) {
+			const parent = fMod[fMod.length - 1];
+			lowOf.set(
+				parent,
+				Math.min(
+					/** @type {number} */ (lowOf.get(parent)),
+					/** @type {number} */ (lowOf.get(mod))
+				)
+			);
+		}
+	}
+
+	return result;
+};
 
 /**
  * @typedef {object} LoaderItem
@@ -136,21 +391,6 @@ const ABSOLUTE_PATH_REGEX = /^(?:[a-z]:\\|\\\\|\/)/i;
  * @property {string | null=} type
  */
 
-/**
- * @param {string} context absolute context path
- * @param {string} source a source path
- * @param {AssociatedObjectForCache=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} new source path
- */
-const contextifySourceUrl = (context, source, associatedObjectForCache) => {
-	if (source.startsWith("webpack://")) return source;
-	return `webpack://${makePathsRelative(
-		context,
-		source,
-		associatedObjectForCache
-	)}`;
-};
-
 /**
  * @param {string} context absolute context path
  * @param {string | RawSourceMap} sourceMap a source map
@@ -207,24 +447,6 @@ 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 */
@@ -234,22 +456,86 @@ makeSerializable(
  * @typedef {HookMap<FakeHook<AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>>>} DeprecatedReadResourceForScheme
  */
 
+const createCompilationHooks = () => {
+	/** @type {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} */
+	const readResource = new HookMap(
+		() => new AsyncSeriesBailHook(["loaderContext"])
+	);
+	return {
+		// TODO webpack 6 deprecate
+		/**
+		 * @deprecated Use the `readResource` hook instead.
+		 * @type {DeprecatedReadResourceForScheme}
+		 */
+		readResourceForScheme: new HookMap((scheme) => {
+			const hook = readResource.for(scheme);
+			return createFakeHook(
+				/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
+					tap: (options, fn) =>
+						hook.tap(options, (loaderContext) =>
+							fn(
+								loaderContext.resource,
+								/** @type {NormalModule} */ (loaderContext._module)
+							)
+						),
+					tapAsync: (options, fn) =>
+						hook.tapAsync(options, (loaderContext, callback) =>
+							fn(
+								loaderContext.resource,
+								/** @type {NormalModule} */ (loaderContext._module),
+								callback
+							)
+						),
+					tapPromise: (options, fn) =>
+						hook.tapPromise(options, (loaderContext) =>
+							fn(
+								loaderContext.resource,
+								/** @type {NormalModule} */ (loaderContext._module)
+							)
+						)
+				})
+			);
+		}),
+		/**
+		 * @since 5.58.0
+		 */
+		readResource,
+		/** @type {SyncHook<[AnyLoaderContext, NormalModule]>} */
+		loader: new SyncHook(["loaderContext", "module"]),
+		/** @type {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} */
+		beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
+		/**
+		 * @type {SyncHook<[NormalModule]>}
+		 * @since 5.59.0
+		 */
+		beforeParse: new SyncHook(["module"]),
+		/**
+		 * @type {SyncHook<[NormalModule]>}
+		 * @since 5.59.0
+		 */
+		beforeSnapshot: new SyncHook(["module"]),
+		/**
+		 * @type {SyncWaterfallHook<[Result, NormalModule]>}
+		 * @since 5.99.0
+		 */
+		processResult: new SyncWaterfallHook(["result", "module"]),
+		/**
+		 * @type {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>}
+		 * @since 5.49.0
+		 */
+		needBuild: new AsyncSeriesBailHook(["module", "context"])
+	};
+};
+
 /**
- * @typedef {object} NormalModuleCompilationHooks
- * @property {SyncHook<[AnyLoaderContext, NormalModule]>} loader
- * @property {SyncHook<[LoaderItem[], NormalModule, AnyLoaderContext]>} beforeLoaders
- * @property {SyncHook<[NormalModule]>} beforeParse
- * @property {SyncHook<[NormalModule]>} beforeSnapshot
- * @property {DeprecatedReadResourceForScheme} readResourceForScheme
- * @property {HookMap<AsyncSeriesBailHook<[AnyLoaderContext], string | Buffer | null>>} readResource
- * @property {SyncWaterfallHook<[Result, NormalModule]>} processResult
- * @property {AsyncSeriesBailHook<[NormalModule, NeedBuildContext], boolean>} needBuild
+ * @typedef {ReturnType<typeof createCompilationHooks>} NormalModuleCompilationHooks
  */
 
 /**
+ * @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
@@ -258,10 +544,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
  */
@@ -270,8 +556,23 @@ makeSerializable(
  * @typedef {(resourcePath: string, getLoaderContext: (resourcePath: string) => AnyLoaderContext) => Promise<string | Buffer<ArrayBufferLike>>} ReadResource
  */
 
-/** @type {WeakMap<Compilation, NormalModuleCompilationHooks>} */
-const compilationHooksMap = new WeakMap();
+/**
+ * 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 */
+
+const normalModuleHooksRegistry = createHooksRegistry(createCompilationHooks);
 
 class NormalModule extends Module {
 	/**
@@ -279,62 +580,7 @@ class NormalModule extends Module {
 	 * @returns {NormalModuleCompilationHooks} the attached hooks
 	 */
 	static getCompilationHooks(compilation) {
-		if (!(compilation instanceof Compilation)) {
-			throw new TypeError(
-				"The 'compilation' argument must be an instance of Compilation"
-			);
-		}
-		let hooks = compilationHooksMap.get(compilation);
-		if (hooks === undefined) {
-			hooks = {
-				loader: new SyncHook(["loaderContext", "module"]),
-				beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
-				beforeParse: new SyncHook(["module"]),
-				beforeSnapshot: new SyncHook(["module"]),
-				// TODO webpack 6 deprecate
-				readResourceForScheme: new HookMap((scheme) => {
-					const hook =
-						/** @type {NormalModuleCompilationHooks} */
-						(hooks).readResource.for(scheme);
-					return createFakeHook(
-						/** @type {AsyncSeriesBailHook<[string, NormalModule], string | Buffer | null>} */ ({
-							tap: (options, fn) =>
-								hook.tap(options, (loaderContext) =>
-									fn(
-										loaderContext.resource,
-										/** @type {NormalModule} */ (loaderContext._module)
-									)
-								),
-							tapAsync: (options, fn) =>
-								hook.tapAsync(options, (loaderContext, callback) =>
-									fn(
-										loaderContext.resource,
-										/** @type {NormalModule} */ (loaderContext._module),
-										callback
-									)
-								),
-							tapPromise: (options, fn) =>
-								hook.tapPromise(options, (loaderContext) =>
-									fn(
-										loaderContext.resource,
-										/** @type {NormalModule} */ (loaderContext._module)
-									)
-								)
-						})
-					);
-				}),
-				readResource: new HookMap(
-					() => new AsyncSeriesBailHook(["loaderContext"])
-				),
-				processResult: new SyncWaterfallHook(["result", "module"]),
-				needBuild: new AsyncSeriesBailHook(["module", "context"])
-			};
-			compilationHooksMap.set(
-				compilation,
-				/** @type {NormalModuleCompilationHooks} */ (hooks)
-			);
-		}
-		return /** @type {NormalModuleCompilationHooks} */ (hooks);
+		return normalModuleHooksRegistry(compilation);
 	}
 
 	/**
@@ -393,14 +639,27 @@ 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
-		/** @type {WebpackError | null} */
+		// Redeclared with the normal module specific shape (see KnownNormalModuleBuildInfo)
+		/** @type {NormalModuleBuildInfo | undefined} */
+		this.buildInfo = undefined;
+		/** @type {Error | null} */
 		this.error = null;
 		/**
 		 * @private
 		 * @type {Source | null}
 		 */
 		this._source = null;
+		// Set at build time; declared here so the instance shape is fixed at construction
+		/**
+		 * @private
+		 * @type {PreparsedAst | null}
+		 */
+		this._ast = null;
 		/**
 		 * @private
 		 * @type {Map<undefined | SourceType, number> | undefined}
@@ -423,15 +682,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 context-independent results (cycle-free
+		 * or SCC-root modules; see `walkSideEffects`).
+		 * @type {ModuleGraph | undefined}
+		 */
+		this._sideEffectsStateGraph = undefined;
+		/** @type {ConnectionState | undefined} */
+		this._sideEffectsStateValue = undefined;
 		/**
 		 * @private
 		 * @type {CodeGenerationResultData}
@@ -440,6 +709,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Returns the unique identifier used to reference this module.
 	 * @returns {string} a unique identifier of the module
 	 */
 	identifier() {
@@ -453,6 +723,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
 	 */
@@ -468,6 +739,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Gets the library identifier.
 	 * @param {LibIdentOptions} options options
 	 * @returns {LibIdent | null} an identifier for library inclusion
 	 */
@@ -482,6 +754,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() {
@@ -535,6 +808,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;
 	}
 
 	/**
@@ -707,11 +985,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)
@@ -722,7 +997,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}`,
@@ -756,6 +1033,7 @@ class NormalModule extends Module {
 
 				return /** @type {T} */ (options);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitWarning"]} */
 			emitWarning: (warning) => {
 				if (!(warning instanceof Error)) {
 					warning = new NonErrorEmittedError(warning);
@@ -766,6 +1044,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["emitError"]} */
 			emitError: (error) => {
 				if (!(error instanceof Error)) {
 					error = new NonErrorEmittedError(error);
@@ -776,6 +1055,7 @@ class NormalModule extends Module {
 					})
 				);
 			},
+			/** @type {LoaderContext<EXPECTED_ANY>["getLogger"]} */
 			getLogger: (name) => {
 				const currentLoader = this.getCurrentLoader(
 					/** @type {AnyLoaderContext} */
@@ -787,9 +1067,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"]>} */ (
@@ -819,8 +1101,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);
@@ -844,7 +1127,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();
@@ -867,6 +1150,7 @@ class NormalModule extends Module {
 		};
 
 		Object.assign(loaderContext, options.loader);
+		createLoaderContext(loaderContext);
 
 		hooks.loader.call(
 			/** @type {AnyLoaderContext} */
@@ -1017,7 +1301,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();
@@ -1037,7 +1321,7 @@ class NormalModule extends Module {
 		}
 
 		if (this.loaders.length > 0) {
-			/** @type {BuildInfo} */
+			/** @type {NormalModuleBuildInfo} */
 			(this.buildInfo).buildDependencies = new LazySet();
 		}
 
@@ -1133,7 +1417,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"),
@@ -1141,16 +1425,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);
@@ -1158,19 +1442,22 @@ 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);
 				}
 				buildInfo.cacheable = buildInfo.cacheable && result.cacheable;
+				if (result.notCacheableReasons.length > 0) {
+					buildInfo.notCacheableReasons = result.notCacheableReasons;
+				}
 				processResult(err, result.result);
 			}
 		);
 	}
 
 	/**
-	 * @param {WebpackError} error the error
+	 * @param {Error} error the error
 	 * @returns {void}
 	 */
 	markModuleAsErrored(error) {
@@ -1240,11 +1527,12 @@ class NormalModule extends Module {
 		}
 		hash.update("meta");
 		hash.update(JSON.stringify(this.buildMeta));
-		/** @type {BuildInfo} */
+		/** @type {NormalModuleBuildInfo} */
 		(this.buildInfo).hash = hash.digest("hex");
 	}
 
 	/**
+	 * Builds the module using the provided compilation context.
 	 * @param {WebpackOptions} options webpack options
 	 * @param {Compilation} compilation the compilation
 	 * @param {ResolverWithOptions} resolver the resolver
@@ -1261,9 +1549,15 @@ 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,
+			notCacheableReasons: undefined,
 			parsed: true,
 			fileDependencies: undefined,
 			contextDependencies: undefined,
@@ -1272,7 +1566,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();
@@ -1305,7 +1608,7 @@ class NormalModule extends Module {
 			const handleParseResult = () => {
 				this.dependencies.sort(
 					concatComparators(
-						compareSelect((a) => a.loc, compareLocations),
+						Dependency.compareLocations,
 						keepOriginalOrder(this.dependencies)
 					)
 				);
@@ -1321,12 +1624,14 @@ class NormalModule extends Module {
 				try {
 					hooks.beforeSnapshot.call(this);
 				} catch (err) {
-					this.markModuleAsErrored(/** @type {WebpackError} */ (err));
+					this.markModuleAsErrored(/** @type {Error} */ (err));
 					return callback();
 				}
 
 				const snapshotOptions = compilation.options.snapshot.module;
-				const { cacheable } = /** @type {BuildInfo} */ (this.buildInfo);
+				const { cacheable } = /** @type {NormalModuleBuildInfo} */ (
+					this.buildInfo
+				);
 				if (!cacheable || !snapshotOptions) {
 					return callback();
 				}
@@ -1339,7 +1644,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();
 							}
@@ -1353,11 +1658,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
@@ -1369,15 +1674,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);
@@ -1413,7 +1718,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();
 			}
@@ -1423,7 +1728,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();
@@ -1437,7 +1742,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));
@@ -1448,6 +1757,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
 	 */
@@ -1458,54 +1768,23 @@ 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;
+		// Each call owns its Tarjan bookkeeping; re-entrant calls (e.g.
+		// `ConcatenatedModule.getSideEffectsConnectionState` delegating back
+		// through here) can't clobber the outer walk.
+		return walkSideEffects(
+			this,
+			moduleGraph,
+			getHarmonyImportSideEffectDependency()
+		);
 	}
 
 	/**
+	 * Returns the source types this module can generate.
 	 * @returns {SourceTypes} types available (do not mutate)
 	 */
 	getSourceTypes() {
@@ -1518,6 +1797,19 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * 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
 	 * @returns {CodeGenerationResult} result
 	 */
@@ -1534,7 +1826,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);
@@ -1590,12 +1882,14 @@ class NormalModule extends Module {
 		const resultEntry = {
 			sources,
 			runtimeRequirements,
-			data: this._codeGeneratorData
+			data: this._codeGeneratorData,
+			hash: undefined
 		};
 		return resultEntry;
 	}
 
 	/**
+	 * Gets the original source.
 	 * @returns {Source | null} the original source for the module before webpack transformation
 	 */
 	originalSource() {
@@ -1603,6 +1897,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Invalidates the cached state associated with this value.
 	 * @returns {void}
 	 */
 	invalidateBuild() {
@@ -1610,6 +1905,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}
@@ -1623,7 +1919,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);
@@ -1669,6 +1965,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)
 	 */
@@ -1690,6 +1987,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
@@ -1702,7 +2000,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());
@@ -1712,7 +2010,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);
@@ -1723,16 +2021,26 @@ 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}
 	 */
 	updateHash(hash, context) {
-		const buildInfo = /** @type {BuildInfo} */ (this.buildInfo);
+		const buildInfo = /** @type {NormalModuleBuildInfo} */ (this.buildInfo);
 		hash.update(
 			/** @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,
@@ -1742,6 +2050,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {ObjectSerializerContext} context context
 	 */
 	serialize(context) {
@@ -1752,6 +2061,7 @@ class NormalModule extends Module {
 		write(this._lastSuccessfulBuildMeta);
 		write(this._forceBuild);
 		write(this._codeGeneratorData);
+		write(this.hot);
 		super.serialize(context);
 	}
 
@@ -1760,7 +2070,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: "",
@@ -1784,6 +2095,7 @@ class NormalModule extends Module {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 */
 	deserialize(context) {
@@ -1793,6 +2105,7 @@ class NormalModule extends Module {
 		this._lastSuccessfulBuildMeta = read();
 		this._forceBuild = read();
 		this._codeGeneratorData = read();
+		this.hot = read();
 		super.deserialize(context);
 	}
 }