@depup/webpack 5.110.1-depup.0 → 5.111.1-depup.0

package/lib/optimize/ConcatenatedModule.js

@@ -34,11 +34,13 @@ const analyzeScope = require("../javascript/ScopeAnalyzer");
 const {
 	getDeferredCycleModuleIds,
 	getDeferredCycleModules,
+	getKnownExportNames,
 	getMakeDeferredNamespaceModeFromExportsType,
 	getOptimizedDeferredModule
 } = require("../runtime/MakeDeferredNamespaceObjectRuntime");
 const { equals } = require("../util/ArrayHelpers");
 const LazySet = require("../util/LazySet");
+const { getBuildDiagnostics } = require("../util/buildDiagnostics");
 const {
 	compareModulesByFullName,
 	concatComparators
@@ -116,8 +118,7 @@ const { InlinedUsedName } = require("./InlineExports");
  * @import {
  * 	ChunkRenderContext,
  * 	Scope,
- * 	Reference,
- * 	Variable
+ * 	Reference
  * } from "../javascript/JavascriptModulesPlugin"
  */
 /** @import { Range } from "../javascript/JavascriptParser" */
@@ -181,6 +182,7 @@ const findIdentifiers = (source) => {
  * @property {string=} comment
  * @property {ExportName} ids
  * @property {ExportName} exportName
+ * @property {boolean=} accessorCall the raw name is the wrapper accessor call itself, so it binds looser than the identifier it replaces
  */
 
 /**
@@ -246,6 +248,7 @@ const findIdentifiers = (source) => {
  * @property {boolean} deferred the module is deferred at least once
  * @property {boolean} deferredNamespaceObjectUsed deferred namespace object that being used in a not-analyzable way so it must be materialized
  * @property {string | undefined} deferredNamespaceObjectName deferred namespace object that being used in a not-analyzable way so it must be materialized
+ * @property {boolean} specNamespaceObjectUsed an import reads the spec namespace object the module hands out
  * @property {boolean} interopNamespaceObjectUsed "default-with-named" namespace
  * @property {string | undefined} interopNamespaceObjectName "default-with-named" namespace
  * @property {boolean} interopNamespaceObject2Used "default-only" namespace
@@ -422,13 +425,26 @@ const getInteropExpr = (info, interopName) =>
  * slot, but a wrapped one only runs when its accessor is called, so dropping
  * the reference would drop the module's side effects with it.
  * @param {ConcatenatedModuleInfo} info module info
+ * @param {boolean | undefined} asiSafe asiSafe
  * @returns {string} expression evaluating to undefined
  */
-const getUnusedExportExpr = (info) =>
+const getUnusedExportExpr = (info, asiSafe) =>
 	info.wrapped
-		? `/* unused export */ (${info.namespaceObjectName}, undefined)`
+		? `${asiSafe === false ? ";" : ""}/* unused export */ (${info.namespaceObjectName}, undefined)`
 		: "/* unused export */ undefined";
 
+/**
+ * Parenthesizes a reference that may already carry an ASI guard of its own,
+ * keeping that guard outside the new parentheses — nested it would not parse.
+ * @param {string} reference the reference
+ * @param {boolean | undefined} asiSafe asiSafe
+ * @returns {string} the parenthesized reference
+ */
+const parenthesizeReference = (reference, asiSafe) =>
+	asiSafe === false
+		? `;(${reference.startsWith(";") ? reference.slice(1) : reference})`
+		: `(${reference})`;
+
 /**
  * @param {ModuleGraph} moduleGraph the module graph
  * @param {ModuleInfo} info module info
@@ -483,7 +499,7 @@ const getFinalBinding = (
 		if (!usedName) {
 			return {
 				info,
-				rawName: getUnusedExportExpr(info),
+				rawName: getUnusedExportExpr(info, asiSafe),
 				ids: [],
 				exportName
 			};
@@ -494,11 +510,14 @@ const getFinalBinding = (
 				/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
 				(info.namespaceObjectName),
 			ids: /** @type {ExportName} */ (usedName),
-			exportName
+			exportName,
+			accessorCall: info.wrapped
 		};
 	}
 
-	if (exportName.length === 0) {
+	if (moduleExportsAccess) {
+		// Skip ESM interop when require() targets a module outside the concatenation
+	} else if (exportName.length === 0) {
 		switch (exportsType) {
 			case "default-only":
 				if (deferred) info.deferredNamespaceObjectUsed = true;
@@ -509,7 +528,8 @@ const getFinalBinding = (
 						? /** @type {string} */ (info.deferredNamespaceObjectName)
 						: getInteropExpr(info, info.interopNamespaceObject2Name),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: !deferred && info.wrapped
 				};
 			case "default-with-named":
 				if (deferred) info.deferredNamespaceObjectUsed = true;
@@ -520,7 +540,8 @@ const getFinalBinding = (
 						? /** @type {string} */ (info.deferredNamespaceObjectName)
 						: getInteropExpr(info, info.interopNamespaceObjectName),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: !deferred && info.wrapped
 				};
 			case "namespace":
 			case "dynamic":
@@ -537,12 +558,13 @@ const getFinalBinding = (
 					case "default":
 						exportName = exportName.slice(1);
 						if (deferred) {
-							// `ns.default` for a deferred default-with-named external
-							// module must read through the optimized `.a` getter
-							// (which lazily evaluates the module and returns its
-							// exports), not the proxy namespace itself — otherwise
-							// `typeof ns.default` / `ns.default instanceof X`
-							// observe the proxy instead of the actual default.
+							// WHY: `ns.default` for a deferred default-with-named external
+							// module must read through the optimized `.a` getter, which
+							// evaluates the
+							// module lazily and returns its exports, rather than through the
+							// proxy namespace — otherwise `typeof ns.default` and
+							// `ns.default instanceof X` observe the proxy, not the actual
+							// default.
 							return {
 								info,
 								rawName: `${info.deferredName}.a`,
@@ -581,10 +603,9 @@ const getFinalBinding = (
 					};
 				}
 				if (deferred) {
-					// As with default-with-named above, `ns.default` for a
-					// deferred default-only external must read through the
-					// optimized `.a` getter so that `typeof` / `instanceof`
-					// observe the actual default value rather than the proxy.
+					// As with default-with-named above, a deferred default-only
+					// external reads through the `.a` getter, so `typeof` and
+					// `instanceof` see the value rather than the proxy.
 					return {
 						info,
 						rawName: `${info.deferredName}.a`,
@@ -611,7 +632,8 @@ const getFinalBinding = (
 								info,
 								rawName: getExternalModuleExpr(info),
 								ids: exportName,
-								exportName
+								exportName,
+								accessorCall: info.wrapped
 							};
 						}
 						info.interopDefaultAccessUsed = true;
@@ -657,9 +679,10 @@ const getFinalBinding = (
 						/** @type {NonNullable<ConcatenatedModuleInfo["namespaceObjectName"]>} */
 						(info.namespaceObjectName),
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: info.wrapped
 				};
-			case "external":
+			case "external": {
 				if (deferred) {
 					info.deferredNamespaceObjectUsed = true;
 					return {
@@ -669,12 +692,30 @@ const getFinalBinding = (
 						exportName
 					};
 				}
+
+				// `require()` reads the exports object rather than a namespace, so
+				// only an import gets the spec object and interop keeps working.
+				const spec =
+					!moduleExportsAccess &&
+					exportsType === "namespace" &&
+					Boolean(
+						/** @type {BuildInfo} */
+						(info.module.buildInfo).specNamespaceObject
+					);
+				const rawName = getExternalModuleExpr(info);
+
+				if (spec) info.specNamespaceObjectUsed = true;
+
 				return {
 					info,
-					rawName: getExternalModuleExpr(info),
+					rawName: spec
+						? `${RuntimeGlobals.specNamespaceObject}(${rawName})`
+						: rawName,
 					ids: exportName,
-					exportName
+					exportName,
+					accessorCall: spec || info.wrapped
 				};
+			}
 		}
 	}
 	const exportsInfo = moduleGraph.getExportsInfo(info.module);
@@ -718,10 +759,9 @@ const getFinalBinding = (
 				if (usedName instanceof InlinedUsedName) {
 					return {
 						info,
-						// Render the inlined literal only (e.g. `"str"`), not its property
-						// suffix: that suffix is returned in `ids` and appended once by
-						// getFinalName. Using `usedName.render()` would emit it here too,
-						// duplicating the access (e.g. `"str".a.a`).
+						// Render the inlined literal only, not its property suffix: that
+						// comes back in `ids` and getFinalName appends it once, so emitting
+						// it here too would duplicate the access.
 						rawName: usedName.render(
 							Template.toNormalComment(
 								`inlined export ${propertyAccess(exportName)}`
@@ -938,9 +978,13 @@ const getFinalName = (
 		let reference;
 		/** @type {boolean} */
 		let isPropertyAccess;
+		// the raw name is the wrapper accessor call itself, so the reference binds
+		// looser than the identifier it stands in for
+		let accessorCall = false;
 		if ("rawName" in binding) {
 			reference = `${binding.rawName}${comment || ""}${propertyAccess(ids)}`;
 			isPropertyAccess = ids.length > 0;
+			accessorCall = binding.accessorCall === true;
 		} else {
 			const { info, name: exportId } = binding;
 			const name = info.internalNames.get(exportId);
@@ -968,8 +1012,12 @@ const getFinalName = (
 						? `;(0,${reference})`
 						: `/*#__PURE__*/Object(${reference})`;
 			} else if (binding.info.wrapped) {
-				return asiSafe === false ? `;(${reference})` : `(${reference})`;
+				return parenthesizeReference(reference, asiSafe);
 			}
+		} else if (accessorCall && !asCall) {
+			// without parentheses `new X()` would construct the accessor rather
+			// than what it returns
+			return parenthesizeReference(reference, asiSafe);
 		}
 
 		return reference;
@@ -978,7 +1026,6 @@ const getFinalName = (
 
 /**
  * @typedef {object} ConcatenateModuleHooks
- * @property {SyncBailHook<[ConcatenatedModule, RuntimeSpec[], string, Record<string, string>], boolean>} onDemandExportsGeneration
  * @property {SyncBailHook<[Partial<ConcatenatedModuleInfo>, ConcatenatedModuleInfo], boolean | void>} concatenatedModuleInfo
  */
 
@@ -1166,15 +1213,17 @@ class ConcatenatedModule extends Module {
 
 		for (const m of this._modules) {
 			// populate cacheable
-			const { cacheable, notCacheableReasons } = /** @type {BuildInfo} */ (
-				m.buildInfo
-			);
+			const { cacheable, diagnostics } = /** @type {BuildInfo} */ (m.buildInfo);
 			if (!cacheable) {
 				this.buildInfo.cacheable = false;
+				const notCacheableReasons =
+					diagnostics === undefined
+						? undefined
+						: diagnostics.notCacheableReasons;
 				if (notCacheableReasons) {
+					const own = getBuildDiagnostics(this.buildInfo);
 					const reasons =
-						this.buildInfo.notCacheableReasons ||
-						(this.buildInfo.notCacheableReasons = []);
+						own.notCacheableReasons || (own.notCacheableReasons = []);
 					for (const reason of notCacheableReasons) {
 						if (!reasons.includes(reason)) reasons.push(reason);
 					}
@@ -1193,10 +1242,9 @@ class ConcatenatedModule extends Module {
 					this.dependencies.push(d);
 				}
 			}
-			// populate codeGenerationDependencies — the inner modules'
-			// templates are applied during ConcatenatedModule.codeGeneration,
-			// so the referenced modules must have been code-generated by then.
-			// Skip references that point back into the concat set itself.
+			// populate codeGenerationDependencies: the inner templates are applied
+			// during this module's own codeGeneration, so what they reference must be
+			// generated by then. References back into the concat set are skipped.
 			if (m.codeGenerationDependencies !== undefined) {
 				for (const d of m.codeGenerationDependencies) {
 					const referenced =
@@ -1352,10 +1400,9 @@ class ConcatenatedModule extends Module {
 						(connection.dependency);
 					return {
 						connection,
-						// A require() edge carries no sourceOrder; Infinity sorts it last,
-						// matching the low-priority sentinel. NaN must not be used here:
-						// compareNumbers returns 0 against every number, which makes the
-						// comparator non-transitive and the order depend on insertion order.
+						// A require() edge carries no sourceOrder, and Infinity sorts it
+						// last. Not NaN: `compareNumbers` returns 0 against every number,
+						// which makes the comparator non-transitive.
 						sourceOrder:
 							typeof dep.sourceOrder === "number" ? dep.sourceOrder : Infinity,
 						rangeStart: dep.range && dep.range[0],
@@ -1415,10 +1462,18 @@ class ConcatenatedModule extends Module {
 					runtimeCondition,
 					runtime
 				);
+				const wasDeferredOnly = !entry.nonDeferAccess;
 				entry.nonDeferAccess = mergeNonDeferAccess(
 					entry.nonDeferAccess,
 					nonDeferAccess
 				);
+				// A deferred import does not evaluate, so the first eager reference
+				// fixes the position; insertion order is emit order.
+				if (wasDeferredOnly && nonDeferAccess) {
+					entry.connection = connection;
+					referencesMap.delete(module);
+					referencesMap.set(module, entry);
+				}
 			}
 			if (targets !== undefined) importConnections.set(module, targets);
 			return referencesMap.values();
@@ -1645,40 +1700,38 @@ class ConcatenatedModule extends Module {
 		}
 	}
 
-	/*
-	 * How the inner modules become one flat source. Stages [1]-[5] only mutate the
-	 * per-module info records (names, ReplaceSource patches); stages [6]-[9] append
-	 * to the single output ConcatSource, in exactly the order shown.
-	 *
-	 *  _getModulesWithInfo() — ordered concatenation list + one info per module
-	 *  |     (concatenated [+wrapped] | external | reference)
-	 *  v
-	 *  [1] ANALYSE — inner codeGeneration() per module, into a ConcatenationScope
-	 *  |     plain    -> ReplaceSource + ast + scope analysis
-	 *  |     wrapped  -> ReplaceSource only, body kept verbatim
-	 *  |     external -> nothing yet, rendered as a require() below
-	 *  [2] RESERVE — free globals of the analysed bodies enter allUsedNames, so
-	 *  |     renaming in [3] can't shadow them (a wrapped body is not analysed;
-	 *  |     the reserved `__webpack_` prefix protects it)
-	 *  [3] RENAME — module-scope variables renamed inside the ReplaceSource, then
-	 *  |     the generated names allocated: wrapper accessor, namespace object,
-	 *  |     interop helpers, external import variable
-	 *  [4] LINK — __WEBPACK_MODULE_REFERENCE__ tokens replaced by their final
-	 *  |     binding; through the ast for analysed bodies, textually for wrapped
-	 *  [5] COLLECT EXPORTS — root exports split into used / unused / inlined
-	 *  v
-	 *  ---- from here on everything is appended to the result ConcatSource ----
-	 *  |
-	 *  [6] EMIT EXPORTS — __esModule flag + exports getters, UNUSED/INLINED lists
-	 *  [7] BUILD NS — namespace object sources built as strings (not emitted yet)
-	 *  [8] DEFINE — everything that must exist before any body runs: namespace
-	 *  |     objects, wrapper accessors (wrapped modules and wrapped externals),
-	 *  |     deferred external loaders
-	 *  [9] EVALUATE — bodies in concatenation order: plain bodies inline, externals
-	 *  |     as require(); a wrapped body stays behind its accessor
-	 *  v
-	 *  [10] RESULT — CodeGenerationResult { sources, data, runtimeRequirements }
-	 */
+	// WHY: how the inner modules become one flat source. Stages [1]-[5] only mutate
+	// the per-module info records (names, ReplaceSource patches); stages [6]-[9]
+	// append to the single output ConcatSource, in exactly the order shown.
+	//
+	//  _getModulesWithInfo() — ordered concatenation list + one info per module
+	//  |     (concatenated [+wrapped] | external | reference)
+	//  v
+	//  [1] ANALYSE — inner codeGeneration() per module, into a ConcatenationScope
+	//  |     plain    -> ReplaceSource + ast + scope analysis
+	//  |     wrapped  -> ReplaceSource only, body kept verbatim
+	//  |     external -> nothing yet, rendered as a require() below
+	//  [2] RESERVE — free globals of the analysed bodies enter allUsedNames, so
+	//  |     renaming in [3] can't shadow them (a wrapped body is not analysed;
+	//  |     the reserved `__webpack_` prefix protects it)
+	//  [3] RENAME — module-scope variables renamed inside the ReplaceSource, then
+	//  |     the generated names allocated: wrapper accessor, namespace object,
+	//  |     interop helpers, external import variable
+	//  [4] LINK — __WEBPACK_MODULE_REFERENCE__ tokens replaced by their final
+	//  |     binding; through the ast for analysed bodies, textually for wrapped
+	//  [5] COLLECT EXPORTS — root exports split into used / unused / inlined
+	//  v
+	//  ---- from here on everything is appended to the result ConcatSource ----
+	//  |
+	//  [6] EMIT EXPORTS — __esModule flag + exports getters, UNUSED/INLINED lists
+	//  [7] BUILD NS — namespace object sources built as strings (not emitted yet)
+	//  [8] DEFINE — everything that must exist before any body runs: namespace
+	//  |     objects, wrapper accessors (wrapped modules and wrapped externals),
+	//  |     deferred external loaders
+	//  [9] EVALUATE — bodies in concatenation order: plain bodies inline, externals
+	//  |     as require(); a wrapped body stays behind its accessor
+	//  v
+	//  [10] RESULT — CodeGenerationResult { sources, data, runtimeRequirements }
 	/**
 	 * Generates code and runtime requirements for this module.
 	 * @param {CodeGenerationContext} context context for code generation
@@ -1796,6 +1849,15 @@ class ConcatenatedModule extends Module {
 				return info.escapeNamespaceObjectName;
 			}
 			const exportsInfo = moduleGraph.getExportsInfo(info.module);
+			// Its names are not mangled, and the wrapped binding is already the
+			// namespace, so a decoupled object would only shadow it.
+			if (
+				/** @type {BuildInfo} */
+				(info.module.buildInfo).specNamespaceObject
+			) {
+				return undefined;
+			}
+
 			let mangled = false;
 			for (const exportInfo of exportsInfo.orderedExports) {
 				if (exportInfo.provided === false) continue;
@@ -1841,6 +1903,13 @@ class ConcatenatedModule extends Module {
 					for (const reference of ConcatenationScope.findModuleReferences(
 						/** @type {Source} */ (info.internalSource)
 					)) {
+						if (reference.leaked) {
+							throw new Error(
+								`Unsubstituted module reference "${reference.name}" in ${info.module.readableIdentifier(
+									requestShortener
+								)}`
+							);
+						}
 						if (visitedReferences.has(reference.name)) continue;
 						visitedReferences.add(reference.name);
 						const match = ConcatenationScope.matchModuleReference(
@@ -1934,6 +2003,13 @@ class ConcatenatedModule extends Module {
 									ignoredScopes
 								);
 							} else {
+								if (ConcatenationScope.isLeakedModuleReference(name)) {
+									throw new Error(
+										`Unsubstituted module reference "${name}" in ${info.module.readableIdentifier(
+											requestShortener
+										)}`
+									);
+								}
 								allUsedNames.add(name);
 								freeNames.add(name);
 							}
@@ -2026,10 +2102,9 @@ class ConcatenatedModule extends Module {
 			switch (info.type) {
 				case "concatenated": {
 					if (info.wrapped) {
-						// A wrapped module declares exactly one shared-scope name: the
-						// lazy wrapper accessor holding its body. [2] claimed every
-						// identifier of that body, so findNewName avoids the ones that
-						// would shadow the accessor from inside it.
+						// A wrapped module declares one shared-scope name, the lazy accessor
+						// holding its body. Stage 2 claimed that body's identifiers, so
+						// findNewName avoids the ones that would shadow it from inside.
 						const namespaceFnName = findNewName(
 							"namespaceFn",
 							allUsedNames,
@@ -2337,10 +2412,9 @@ class ConcatenatedModule extends Module {
 		}
 		// #endregion
 
-		// #region [5] COLLECT EXPORTS: split the root module's exports into used /
-		// unused / inlined. Used ones stay thunks — resolving one can still
-		// register a namespace object, which [7] must see
-		// Map with all root exposed used exports
+		// #region [5] COLLECT EXPORTS: split the root module's exports into used,
+		// unused and inlined. Used ones stay thunks, since resolving one can still
+		// register a namespace object that stage 7 must see.
 		/** @type {Map<string, (requestShortener: RequestShortener) => string>} */
 		const exportsMap = new Map();
 
@@ -2418,6 +2492,8 @@ class ConcatenatedModule extends Module {
 			shouldAddHarmonyFlag = true;
 		}
 
+		/** @type {string | undefined} */
+		let onDemandExportsSource;
 		// define exports
 		if (exportsMap.size > 0) {
 			/** @type {string[]} */
@@ -2448,17 +2524,10 @@ class ConcatenatedModule extends Module {
 					this.exportsArgument
 				}, {${definitions.join(",")}\n});\n`;
 
-			const { onDemandExportsGeneration } =
-				ConcatenatedModule.getCompilationHooks(this.compilation);
-
-			if (
-				!onDemandExportsGeneration.call(
-					this,
-					runtimes,
-					`${harmonyFlagSource}${exportsSource}`,
-					exportsFinalName
-				)
-			) {
+			const meta = moduleGraph.getMetaIfExisting(this);
+			if (meta !== undefined && meta.onDemandExports === true) {
+				onDemandExportsSource = `${harmonyFlagSource}${exportsSource}`;
+			} else {
 				result.add(harmonyFlagSource);
 				result.add(exportsSource);
 			}
@@ -2480,13 +2549,12 @@ class ConcatenatedModule extends Module {
 		// #endregion
 
 		// #region [7] BUILD NS: namespace object sources are built as strings here
-		// and emitted by [8]; an external's is emitted next to its import variable
-		// or accessor instead, which is defined later.
-		//
-		// generate decoupled namespace objects for escaping mangled namespaces:
-		// same getters as the regular namespace object, but keyed by the original
-		// export names so untracked access by name keeps working. Done before the
-		// regular namespace objects so any nested namespace they pull in is built.
+		// and emitted by stage 8; an external's goes next to its import variable or
+		// accessor instead, defined later.
+
+		// Decoupled namespace objects for escaping mangled namespaces carry the same
+		// getters keyed by the original export names, so untracked access by name
+		// keeps working. Built first, so any nested namespace they pull in exists.
 		/** @type {Map<ConcatenatedModuleInfo | ExternalModuleInfo, string>} */
 		const escapeNamespaceObjectSources = new Map();
 		for (const info of neededEscapeNamespaceObjects) {
@@ -2658,10 +2726,9 @@ ${defineGetters}`
 					}) {\n`
 				);
 				result.add(/** @type {ReplaceSource} */ (info.source));
-				// A generated body (json, asset, html) binds its value to a local
-				// instead of writing exports; hand that local to the accessor. The
-				// name is verbatim: a wrapped body is not scope-analysed, so it keeps
-				// the reserved symbol the generator registered.
+				// A generated body binds its value to a local rather than writing
+				// exports, so hand that local to the accessor. The name is verbatim: a
+				// wrapped body is not scope-analysed and keeps the reserved symbol.
 				result.add(
 					info.namespaceExportSymbol
 						? `\n${info.module.moduleArgument}.exports = ${info.namespaceExportSymbol};\n});\n`
@@ -2680,10 +2747,18 @@ ${defineGetters}`
 					runtimeRequirements
 				});
 				const moduleId = JSON.stringify(chunkGraph.getModuleId(info.module));
+				const required = `${RuntimeGlobals.require}(${moduleId})`;
+
+				// The wrapping happens per reference, so only the helper has to be
+				// declared here.
+				if (info.specNamespaceObjectUsed) {
+					runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+				}
+
 				const body =
 					condition === "true"
-						? `return ${RuntimeGlobals.require}(${moduleId});`
-						: `if (${condition}) return ${RuntimeGlobals.require}(${moduleId});`;
+						? `return ${required};`
+						: `if (${condition}) return ${required};`;
 				result.add(
 					`\n// EXTERNAL MODULE: ${info.module.readableIdentifier(
 						requestShortener
@@ -2739,14 +2814,31 @@ ${defineGetters}`
 				);
 				if (info.deferredNamespaceObjectUsed) {
 					runtimeRequirements.add(RuntimeGlobals.makeDeferredNamespaceObject);
+					// Every call site for a module must agree on the shape, since the
+					// runtime caches one namespace object per module and mode.
+					const deferredExportsType = getExportsType(
+						moduleGraph,
+						info,
+						strictHarmonyModule
+					);
+					const names = getKnownExportNames(
+						moduleGraph,
+						info.module,
+						deferredExportsType
+					);
+					runtimeRequirements.add(
+						names
+							? RuntimeGlobals.hasSealedDeferredNamespace
+							: RuntimeGlobals.hasSynthesizedDeferredNamespace
+					);
 					result.add(
 						`\nvar ${info.deferredNamespaceObjectName} = /*#__PURE__*/${
 							RuntimeGlobals.makeDeferredNamespaceObject
 						}(${JSON.stringify(
 							chunkGraph.getModuleId(info.module)
 						)}, ${getMakeDeferredNamespaceModeFromExportsType(
-							getExportsType(moduleGraph, info, strictHarmonyModule)
-						)});`
+							deferredExportsType
+						)}${names ? `, ${JSON.stringify(names)}` : ""});`
 					);
 				}
 			}
@@ -2832,7 +2924,15 @@ ${defineGetters}`
 						// External module bindings may be wrapped in
 						// runtime-condition `if` blocks but referenced outside,
 						// so they must remain function-scoped (`var`).
-						result.add(`var ${info.name} = __webpack_require__(${moduleId});`);
+						const required = `__webpack_require__(${moduleId})`;
+
+						// The wrapping happens per reference, so only the helper has
+						// to be declared here.
+						if (info.specNamespaceObjectUsed) {
+							runtimeRequirements.add(RuntimeGlobals.specNamespaceObject);
+						}
+
+						result.add(`var ${info.name} = ${required};`);
 
 						// Decoupled namespace object for an escaping mangled external
 						// module must come after its import variable is defined.
@@ -2865,9 +2965,8 @@ ${defineGetters}`
 					throw new Error(`Unsupported concatenation entry type ${info.type}`);
 			}
 			// Building a wrapped module's interop object here would evaluate its body
-			// at the top level and break require() cycles, so defer it behind a
-			// hoisted function. The memo lives on the function object: it keeps the
-			// identity stable without claiming a second top-level name.
+			// at the top level and break require() cycles, so it is deferred behind a
+			// hoisted function, memoized on the function object itself.
 			/**
 			 * @param {string} interopName interop variable name
 			 * @param {string} expr interop object expression
@@ -2919,6 +3018,10 @@ ${defineGetters}`
 		}
 		data.set("topLevelDeclarations", topLevelDeclarations);
 		data.set("freeNames", freeNames);
+		if (onDemandExportsSource !== undefined) {
+			data.set("exportsSource", onDemandExportsSource);
+			data.set("exportsFinalName", exportsFinalName);
+		}
 
 		/** @type {CodeGenerationResult} */
 		const resultEntry = {
@@ -2958,10 +3061,9 @@ ${defineGetters}`
 		if (info.type === "concatenated") {
 			const m = info.module;
 			if (info.wrapped) {
-				// the wrapper isolates the body's top-level declarations, so no
-				// renaming is needed -- only a concatenation scope, to rewrite in-scope
-				// `require()` targets to accessor references. [2] claims its identifiers
-				// textually in place of the scope analysis skipped here.
+				// the wrapper isolates the body's top-level declarations, so only a
+				// concatenation scope is needed, rewriting in-scope `require()` targets.
+				// Stage 2 claims its identifiers textually, in place of that analysis.
 				const concatenationScope = new ConcatenationScope(
 					modulesMap,
 					info,
@@ -3140,6 +3242,7 @@ ${defineGetters}`
 							namespaceFnName: undefined,
 							escapeNamespaceObjectName: undefined,
 							deferredName: undefined,
+							specNamespaceObjectUsed: false,
 							interopNamespaceObjectUsed: false,
 							interopNamespaceObjectName: undefined,
 							interopNamespaceObject2Used: false,
@@ -3233,12 +3336,6 @@ ${defineGetters}`
 ConcatenatedModule.getCompilationHooks = createHooksRegistry(
 	() =>
 		/** @type {ConcatenateModuleHooks} */ ({
-			onDemandExportsGeneration: new SyncBailHook([
-				"module",
-				"runtimes",
-				"exportsFinalName",
-				"exportsSource"
-			]),
 			concatenatedModuleInfo: new SyncBailHook([
 				"updatedInfo",
 				"concatenatedModuleInfo"