webpack 5.111.0 → 5.112.0

package/lib/runtime/HasOwnPropertyRuntimeModule.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const Template = require("../template/Template");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
 /** @import Compilation from "../Compilation" */
 

package/lib/runtime/HelperRuntimeModule.js

@@ -4,7 +4,11 @@
 
 "use strict";
 
-const RuntimeModule = require("../RuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
+
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
 
 /**
  * Base class for runtime modules that only emit helper functions and do not
@@ -28,6 +32,17 @@ class HelperRuntimeModule extends RuntimeModule {
 		// A helper defines a function on the require global and nothing else.
 		return RuntimeModule.NO_CHUNK_HANDLERS;
 	}
+
+	/**
+	 * Whether a hot update can deliver this helper, which then runs outside the
+	 * bootstrap scope and reaches its state only through `__webpack_require__`.
+	 * @returns {boolean} true, when the runtime accepts hot updates
+	 */
+	receivesHotUpdates() {
+		return /** @type {ChunkGraph} */ (this.chunkGraph)
+			.getTreeRuntimeRequirements(/** @type {Chunk} */ (this.chunk))
+			.has(RuntimeGlobals.hmrDownloadManifest);
+	}
 }
 
 module.exports = HelperRuntimeModule;

package/lib/runtime/LoadScriptRuntimeModule.js

@@ -6,12 +6,12 @@
 
 const { SyncWaterfallHook } = require("tapable");
 /** @import Compilation from "../Compilation" */
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const createHooksRegistry = require("../util/createHooksRegistry");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
-/** @import Chunk from "../Chunk" */
+/** @import Chunk from "../graph/Chunk" */
 
 /**
  * @typedef {object} LoadScriptCompilationHooks

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -4,14 +4,15 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const HarmonyImportDependency = require("../dependencies/HarmonyImportDependency");
+const isDependencyKind = require("../graph/isDependencyKind");
+const Template = require("../template/Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
-/** @import { ModuleId } from "../ChunkGraph" */
-/** @import Module, { RuntimeRequirements, ExportsType } from "../Module" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { ModuleId } from "../graph/ChunkGraph" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
+/** @import Module, { RuntimeRequirements, ExportsType } from "../module/Module" */
+/** @import ModuleGraph from "../graph/ModuleGraph" */
 
 /**
  * @typedef {object} DeferredCycleState
@@ -39,7 +40,8 @@ function harmonyImportTargets(moduleGraph, module) {
 			dep &&
 			moduleConnections.some(
 				(c) =>
-					c.dependency instanceof HarmonyImportDependency &&
+					c.dependency !== null &&
+					isDependencyKind(c.dependency, "esm-import") &&
 					c.isTargetActive(undefined)
 			)
 		) {
@@ -220,6 +222,41 @@ function getOptimizedDeferredModule(
 	)})`;
 }
 
+/**
+ * Renders the setup a deferred namespace helper needs when a hot update delivers
+ * it, since the running bootstrap may not mark modules as evaluating.
+ * @param {RuntimeTemplate} runtimeTemplate the runtime template
+ * @param {boolean} recordErrors the bootstrap may not keep evaluation errors
+ * @returns {string} setup code, run once per runtime
+ */
+function renderHotDeferredSetup(runtimeTemplate, recordErrors) {
+	const cache = RuntimeGlobals.deferredModuleNamespaceCache;
+	return Template.asString([
+		// The namespace cache doubles as the flag that the interceptor is installed.
+		`if (!${cache}) {`,
+		Template.indent([
+			`${cache} = {};`,
+			`${RuntimeGlobals.interceptModuleExecution}.push(${runtimeTemplate.basicFunction(
+				"options",
+				[
+					`${runtimeTemplate.renderConst()} factory = options.factory;`,
+					"if (factory) options.factory = function(module) {",
+					Template.indent([
+						"module.evaluating = true;",
+						"try { return factory.apply(this, arguments); }",
+						...(recordErrors
+							? ["catch (e) { module.error = e; throw e; }"]
+							: []),
+						"finally { module.evaluating = false; }"
+					]),
+					"};"
+				]
+			)});`
+		]),
+		"}"
+	]);
+}
+
 class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 	/**
 	 * Returns true, if the runtime module should get it's own scope.
@@ -251,7 +288,15 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 		const lt = runtimeTemplate.renderLet();
 		const fn = RuntimeGlobals.makeOptimizedDeferredNamespaceObject;
 		const hasAsync = this.hasAsyncRuntime;
+		const hot = this.receivesHotUpdates();
+		const moduleCache = hot
+			? RuntimeGlobals.moduleCache
+			: "__webpack_module_cache__";
+		// Without strict error handling the running bootstrap keeps no error to rethrow.
+		const recordErrors =
+			hot && !runtimeTemplate.outputOptions.strictModuleErrorHandling;
 		return Template.asString([
+			...(hot ? [renderHotDeferredSetup(runtimeTemplate, recordErrors)] : []),
 			// Note: must be a function (not arrow), because this is used in body!
 			// `asyncDeps` keeps a fixed positional slot even without async runtime
 			// so the trailing `syncDeps` (defer-cycle closure) always lines up.
@@ -263,16 +308,19 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 				Template.indent([
 					"get a() {",
 					Template.indent([
-						// Forcing evaluation of a module that is currently evaluating
-						// (a cycle reached through a deferred import) must throw rather
-						// than expose its partial exports. `syncDeps` (present only for
-						// cyclic deferred modules) carries the transitive static closure,
-						// so an evaluating dependency is caught before any evaluation.
-						`${cst} cachedModule = __webpack_module_cache__[moduleId];`,
+						// Forcing a module that is already evaluating, a cycle reached
+						// through a deferred import, must throw rather than expose partial
+						// exports. `syncDeps` carries the closure that catches it first.
+						`${cst} cachedModule = ${moduleCache}[moduleId];`,
 						'if (cachedModule !== undefined && (cachedModule.evaluating || cachedModule.evaluatingAsync)) throw new TypeError("Cannot access a deferred module namespace while the module is being evaluated");',
+						...(recordErrors
+							? [
+									"if (cachedModule !== undefined && cachedModule.error !== undefined) throw cachedModule.error;"
+								]
+							: []),
 						"if (syncDeps) for (var i = 0; i < syncDeps.length; i++) {",
 						Template.indent([
-							`${cst} depModule = __webpack_module_cache__[syncDeps[i]];`,
+							`${cst} depModule = ${moduleCache}[syncDeps[i]];`,
 							'if (depModule !== undefined && (depModule.evaluating || depModule.evaluatingAsync)) throw new TypeError("Cannot access a deferred module namespace while a dependency is being evaluated");'
 						]),
 						"}",
@@ -295,7 +343,7 @@ class MakeOptimizedDeferredNamespaceObjectRuntimeModule extends HelperRuntimeMod
 						`if(isAsync) obj[${RuntimeGlobals.deferredModuleAsyncTransitiveDependenciesSymbol}] = asyncDeps.filter(${runtimeTemplate.basicFunction(
 							"id",
 							[
-								`${cst} dep = __webpack_module_cache__[id];`,
+								`${cst} dep = ${moduleCache}[id];`,
 								"if (dep && dep.evaluating) return false;",
 								"r(id);",
 								"return true;"
@@ -351,43 +399,43 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 		const sealed = this.sealed;
 		const synthesized = this.synthesized;
 		const init = `${runtimeTemplate.optionalChaining("init", "()")};`;
-		return `${fn} = ${runtimeTemplate.basicFunction(
+		const hot = this.receivesHotUpdates();
+		const moduleCache = hot
+			? RuntimeGlobals.moduleCache
+			: "__webpack_module_cache__";
+		const namespaceCache = hot
+			? RuntimeGlobals.deferredModuleNamespaceCache
+			: "__webpack_module_deferred_namespace_cache__";
+		// Without strict error handling the running bootstrap keeps no error to rethrow.
+		const recordErrors =
+			hot && !runtimeTemplate.outputOptions.strictModuleErrorHandling;
+		return `${hot ? `${renderHotDeferredSetup(runtimeTemplate, recordErrors)}\n` : ""}${fn} = ${runtimeTemplate.basicFunction(
 			"moduleId, mode, exportNames",
 			[
-				// Per the TC39 import-defer spec, deferred namespaces are
-				// distinct from their eager counterparts and the same module
-				// referenced from multiple defer-import sites must yield the
-				// same object. Cache the Proxy / fake namespace per-moduleId so
-				// repeated calls (including across files) share identity.
+				// WHY: the TC39 import-defer spec makes a deferred namespace distinct
+				// from its eager counterpart, and one module reached from several defer
+				// sites must yield the same object, so the Proxy is cached per moduleId.
 				//
-				// Bit 16 (`createFakeNamespaceObject`'s "return value when
-				// it's Promise-like" flag added by
-				// `RuntimeTemplate.moduleNamespacePromise` for dynamic
-				// imports) is irrelevant for deferred namespaces — the value
-				// passed into `createFakeNamespaceObject` here is always the
-				// resolved module exports (after unwrapping the async-module
-				// export symbol when present), never a Promise. Strip it
-				// once so all downstream behavior, the cache key, and the
-				// `createFakeNamespaceObject` call below see the same shape
-				// mode. This keeps static defer (mode 8) and dynamic
-				// `await import.defer` (mode 8 | 16) sharing the same
-				// Deferred Module Namespace object, while still keying by
-				// `(moduleId, mode)` so distinct exports-type shapes
-				// (e.g. one importer treats a CJS module as
-				// "default-with-named", another as "namespace") get
-				// distinct cache entries.
+				// Bit 16 is `createFakeNamespaceObject`'s "return value when it's
+				// Promise-like" flag, which `RuntimeTemplate.moduleNamespacePromise` adds
+				// for a dynamic import. It is irrelevant here: what is passed in is
+				// always the resolved module exports, after unwrapping the async-module
+				// export symbol where there is one, and never a Promise. Stripping it
+				// once leaves the cache key, the call below and everything downstream on
+				// one shape mode, so static defer (mode 8) and `await import.defer`
+				// (mode 8 | 16) share the same object. The key stays `(moduleId, mode)`
+				// so two importers reading one CJS module differently — as
+				// "default-with-named" against "namespace" — still get distinct entries.
 				"mode &= ~16;",
 				// Only a real ES module namespace has the spec's exotic shape; a
 				// synthesized one (JSON, asset, CommonJS interop) keeps the old form.
 				sealed && synthesized
 					? "if (!(mode & 8)) exportNames = undefined;"
 					: "",
-				`${lt} byMode = __webpack_module_deferred_namespace_cache__[moduleId];`,
+				`${lt} byMode = ${namespaceCache}[moduleId];`,
 				"if (byMode && byMode[mode] !== undefined) return byMode[mode];",
-				"if (!byMode) byMode = __webpack_module_deferred_namespace_cache__[moduleId] = {};",
-				synthesized
-					? `${cst} cachedModule = __webpack_module_cache__[moduleId];`
-					: "",
+				`if (!byMode) byMode = ${namespaceCache}[moduleId] = {};`,
+				synthesized ? `${cst} cachedModule = ${moduleCache}[moduleId];` : "",
 				synthesized
 					? "if (cachedModule && cachedModule.error === undefined && !(mode & 8)) {"
 					: "",
@@ -406,8 +454,13 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					// A deferred namespace that forces evaluation of a module that is
 					// already evaluating (a cycle) must throw rather than expose its
 					// partial exports.
-					`${cst} evaluatingModule = __webpack_module_cache__[moduleId];`,
+					`${cst} evaluatingModule = ${moduleCache}[moduleId];`,
 					'if (evaluatingModule !== undefined && (evaluatingModule.evaluating || evaluatingModule.evaluatingAsync)) throw new TypeError("Cannot access a deferred module namespace while the module is being evaluated");',
+					...(recordErrors
+						? [
+								"if (evaluatingModule !== undefined && evaluatingModule.error !== undefined) throw evaluatingModule.error;"
+							]
+						: []),
 					`ns = ${RuntimeGlobals.require}(moduleId);`,
 					hasAsync
 						? `if (${RuntimeGlobals.asyncModuleExportSymbol} in ns) ns = ns[${RuntimeGlobals.asyncModuleExportSymbol}];`
@@ -417,23 +470,16 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 						? "if (mode & 8 || mode & 4 && ns.__esModule && typeof ns === 'object') {"
 						: "",
 					Template.indent([
-						// Drop only the read-side traps after init: with the
-						// resolved namespace's own keys mirrored onto
-						// `ns_target` below, the default `Reflect` behavior
-						// returns the right values via the live-binding
-						// getters, so we no longer need to intercept `get` /
-						// `has` / `ownKeys` / `getOwnPropertyDescriptor`.
-						//
-						// The mutation traps (`set`, `deleteProperty`,
-						// `defineProperty`) are kept because per the TC39
-						// import-defer spec, `[[Set]]` / `[[Delete]]` /
-						// `[[DefineOwnProperty]]` on a Deferred Module
-						// Namespace Exotic Object never succeed — and the
-						// proxy target itself remains extensible
-						// (architecturally we cannot freeze it up-front),
-						// so without these traps `ns.notExported = "x"`
-						// after evaluation would silently create a property
-						// on the target instead of returning false.
+						// Drop only the read traps after init: with the namespace's own keys
+						// mirrored onto `ns_target`, default `Reflect` behavior already
+						// returns the right values through the live-binding getters.
+
+						// WHY: the spec makes `[[Set]]`, `[[Delete]]` and
+						// `[[DefineOwnProperty]]` on a Deferred Module Namespace always
+						// fail, yet the target stays extensible because it cannot be frozen
+						// up front — so without the mutation traps `ns.notExported = "x"`
+						// would silently create a property instead of returning false.
+
 						// A sealed target holds placeholder values, so the read traps stay to
 						// keep the live bindings visible.
 						sealed && synthesized ? "if (!exportNames) {" : "",
@@ -454,18 +500,12 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 							])
 						: "",
 					synthesized ? "}" : "",
-					// Mirror own properties from the resolved namespace onto the proxy
-					// target so that proxy invariants hold for callers that structurally
-					// introspect via `Object.keys` / `Object.getOwnPropertyNames` /
-					// `Object.getOwnPropertyDescriptor`: when our trap reports a
-					// non-configurable descriptor for a key, the target must also have
-					// that key with a matching descriptor.
-					//
-					// `__esModule` and `Symbol.toStringTag` are intentionally skipped:
-					// the proxy synthesizes "Deferred Module" / true regardless of what
-					// the underlying namespace exposes (per the TC39 import-defer
-					// proposal, the [[StringTag]] of a Deferred Module Namespace
-					// Exotic Object is "Deferred Module"), and the target was already
+					// Mirror the resolved namespace's own properties onto the target, or
+					// the proxy invariants break: where a trap reports a non-configurable
+					// descriptor, the target must carry a matching one.
+
+					// `__esModule` and `Symbol.toStringTag` are skipped: the proxy
+					// synthesizes them whatever the namespace exposes, and the target is
 					// pre-populated with those values below.
 					synthesized
 						? `${cst} keys = ${sealed ? "exportNames ? [] : " : ""}Reflect.ownKeys(ns);`
@@ -485,23 +525,23 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					synthesized ? "}" : ""
 				])};`,
 				"",
-				// The proxy target is a fresh placeholder, separate from
-				// `__webpack_module_deferred_exports__[moduleId]` (which is reused
-				// by `__webpack_require__` as `module.exports` for deferred-loaded
-				// modules and would conflict with our pre-populated synthetic
-				// `__esModule` / `Symbol.toStringTag` non-configurable properties).
-				// Using a dedicated target keeps the proxy invariant-compliant
-				// without interfering with the module's own exports object.
+				// WHY: the proxy target is a fresh placeholder, separate from
+				// `__webpack_module_deferred_exports__[moduleId]`, which
+				// `__webpack_require__` reuses as `module.exports` for a deferred-loaded
+				// module and would conflict with the pre-populated synthetic `__esModule`
+				// and `Symbol.toStringTag` non-configurable properties. A dedicated
+				// target keeps the proxy invariant-compliant without interfering with the
+				// module's own exports object.
 				`${cst} ns_target = { __proto__: null };`,
 				// With the export list known at build time the target carries the spec's
 				// keys and is sealed, so `[[IsExtensible]]` is false up front.
 				sealed
 					? `${synthesized ? "if (exportNames) " : ""}for (var e = 0; e < exportNames.length; e++) ns_target[exportNames[e]] = undefined;`
 					: "",
-				// Pre-populate the synthetic deferred-namespace properties with
-				// fully non-configurable, non-writable, non-enumerable descriptors
-				// (matching the TC39 import-defer spec for Module Namespace
-				// Exotic Objects). The trap returns the same descriptors below.
+				// Pre-populate the synthetic properties with the non-configurable,
+				// non-writable, non-enumerable descriptors the spec gives a Module
+				// Namespace, which the trap below returns unchanged.
+
 				// `__esModule` is not one of the spec's keys, so a sealed namespace omits
 				// it; the synthesized form keeps it for interop.
 				synthesized
@@ -515,12 +555,9 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`${cst} handler = {`,
 				Template.indent([
 					"__proto__: null,",
-					// Per the TC39 import-defer proposal, `IsSymbolLikeNamespaceKey`
-					// returns true for any Symbol-keyed access (and for "then"); such
-					// accesses go through `OrdinaryGetOwnProperty` and must not
-					// trigger evaluation of the deferred module. The Symbol checks
-					// below short-circuit to the pre-populated target without
-					// running `init()`.
+					// `IsSymbolLikeNamespaceKey` holds for any Symbol key and for `then`,
+					// and such a read must not evaluate the deferred module, so the checks
+					// below reach the pre-populated target without running `init()`.
 					`${runtimeTemplate.method("get", "_, name", [
 						"switch (name) {",
 						Template.indent([
@@ -589,10 +626,9 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					`${runtimeTemplate.method("getOwnPropertyDescriptor", "_, name", [
 						"switch (name) {",
 						Template.indent([
-							// Match the descriptors actually defined on `ns_target`
-							// (non-configurable, non-writable, non-enumerable) so the
-							// proxy invariant holds for both the trap result and any
-							// post-init forwarding via the deleted-handler path.
+							// Match the descriptors actually defined on `ns_target`, so the
+							// proxy invariant holds both for this result and for the
+							// post-init forwarding through the deleted-handler path.
 							synthesized
 								? `case "__esModule": ${sealed ? "if (!exportNames) " : ""}return { value: true, writable: false, enumerable: false, configurable: false };${sealed ? " break;" : ""}`
 								: "",
@@ -617,20 +653,17 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 						synthesized ? "}" : "",
 						synthesized ? "return desc;" : ""
 					])},`,
-					// `defineProperty` always rejects, but per the TC39 spec it
-					// must still trigger evaluation for string keys (the spec
-					// algorithm calls `[[GetOwnProperty]]` first, which forces
-					// evaluation on a deferred namespace). Symbol keys go through
-					// OrdinaryDefineOwnProperty and do not trigger eval.
+					// `defineProperty` always rejects, yet must still evaluate on a string
+					// key, since the spec calls `[[GetOwnProperty]]` first. A Symbol key
+					// takes OrdinaryDefineOwnProperty and evaluates nothing.
 					`${runtimeTemplate.method("defineProperty", "_, name", [
 						'if (typeof name === "symbol" || name === "then") return false;',
 						init,
 						"return false;"
 					])},`,
-					// `deleteProperty` rejects, but per the TC39 spec it must
-					// still trigger evaluation for string keys (the spec
-					// algorithm calls `GetModuleExportsList` for non-symbol-like
-					// keys, forcing evaluation on a deferred namespace).
+					// `deleteProperty` rejects too, and likewise still evaluates on a
+					// string key: the spec calls `GetModuleExportsList` for every
+					// non-symbol-like key.
 					`${runtimeTemplate.method("deleteProperty", "_, name", [
 						'if (typeof name === "symbol" || name === "then") return false;',
 						init,

package/lib/runtime/MakeNamespaceObjectRuntimeModule.js

@@ -4,9 +4,9 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
 /** @import Compilation from "../Compilation" */
 

package/lib/runtime/NonceRuntimeModule.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
 class NonceRuntimeModule extends RuntimeModule {
 	constructor() {

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -4,14 +4,14 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const { getOnlyHandlerKey } = require("../util/handlerKeys");
 const { propertyAccess } = require("../util/property");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
 /** @import Compilation from "../Compilation" */
-/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
+/** @import { ReadOnlyRuntimeRequirements } from "../module/Module" */
 
 class OnChunksLoadedRuntimeModule extends RuntimeModule {
 	/**

package/lib/runtime/PublicPathRuntimeModule.js

@@ -4,8 +4,8 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
 /** @import { PublicPath } from "../../declarations/WebpackOptions" */
 /** @import Compilation from "../Compilation" */

package/lib/runtime/RelativeUrlRuntimeModule.js

@@ -4,9 +4,9 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
+const Template = require("../template/Template");
 const HelperRuntimeModule = require("./HelperRuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
 
 /** @import Compilation from "../Compilation" */
 

package/lib/{RuntimeGlobals.js → runtime/RuntimeGlobals.js}

@@ -121,6 +121,11 @@ module.exports.deferredModuleAsyncTransitiveDependencies =
 module.exports.deferredModuleAsyncTransitiveDependenciesSymbol =
 	"__webpack_require__.zS";
 
+/**
+ * cached deferred namespaces, kept on `__webpack_require__` when hot updates can replace their helper
+ */
+module.exports.deferredModuleNamespaceCache = "__webpack_require__.zC";
+
 /**
  * the exported property define getters function
  */
@@ -157,6 +162,11 @@ module.exports.entryModuleId = "__webpack_require__.s";
  */
 module.exports.esmIds = "__webpack_esm_ids__";
 
+/**
+ * esm module decorator
+ */
+module.exports.esmModuleDecorator = "__webpack_require__.hmd";
+
 /**
  * esm modules
  */
@@ -233,7 +243,8 @@ module.exports.getWorkletBootstrap = "__webpack_require__.wb";
 module.exports.global = "__webpack_require__.g";
 
 /**
- * harmony module decorator
+ * esm module decorator
+ * @deprecated use `esmModuleDecorator` — TODO in the next major release: remove
  */
 module.exports.harmonyModuleDecorator = "__webpack_require__.hmd";
 
@@ -242,6 +253,12 @@ module.exports.harmonyModuleDecorator = "__webpack_require__.hmd";
  */
 module.exports.hasCssModules = "has css modules";
 
+/**
+ * a flag when a server render may already have put the stylesheets in the
+ * document, so the css runtime has to wait for one that has not applied yet
+ */
+module.exports.hasServerRenderedStylesheets = "has server rendered stylesheets";
+
 /**
  * a flag when a chunk has a fetch priority
  */

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -4,11 +4,11 @@
 
 "use strict";
 
-const RuntimeGlobals = require("../RuntimeGlobals");
-const RuntimeModule = require("../RuntimeModule");
+const RuntimeGlobals = require("./RuntimeGlobals");
+const RuntimeModule = require("./RuntimeModule");
 
-/** @import Chunk from "../Chunk" */
-/** @import ChunkGraph from "../ChunkGraph" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
 
 class RuntimeIdRuntimeModule extends RuntimeModule {
 	constructor() {