webpack
diff --git a/‎.changeset/mangle-escaping-namespaces.md‎
Lines changed: 5 additions & 0 deletions b/‎.changeset/mangle-escaping-namespaces.md‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎AGENTS.md‎
Lines changed: 1 addition & 1 deletion b/‎AGENTS.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎lib/ConcatenationScope.js‎
Lines changed: 7 additions & 3 deletions b/‎lib/ConcatenationScope.js‎
Lines changed: 7 additions & 3 deletions
diff --git a/‎lib/Dependency.js‎
Lines changed: 5 additions & 0 deletions b/‎lib/Dependency.js‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎lib/FlagDependencyUsagePlugin.js‎
Lines changed: 77 additions & 4 deletions b/‎lib/FlagDependencyUsagePlugin.js‎
Lines changed: 77 additions & 4 deletions
diff --git a/‎lib/RuntimeTemplate.js‎
Lines changed: 93 additions & 2 deletions b/‎lib/RuntimeTemplate.js‎
Lines changed: 93 additions & 2 deletions
diff --git a/‎lib/WebpackOptionsApply.js‎
Lines changed: 3 additions & 1 deletion b/‎lib/WebpackOptionsApply.js‎
Lines changed: 3 additions & 1 deletion
@@ -0,0 +1,5 @@
+---
+"webpack": minor
+---
+
+Keep export mangling enabled for modules whose namespace object is used as a whole value, by materializing a decoupled namespace object that keeps the original export names.
@@ -267,7 +267,7 @@ Make sure to read our AI policy (https://github.com/webpack/governance/blob/main
 
 Required answer per section — **one sentence each is the target, two or three the absolute maximum**:
 
-- **Summary** — motivation and what problem is solved; link the related issue (`Closes #…` / `Fixes #…`).
+- **Summary** — motivation and what problem is solved; link the related issue. When the PR actually fixes the bug or implements the feature the issue asks for, use the auto-closing form `Closes #…` / `Fixes #…` (not `Refs #…`); reserve `Refs #…` for issues the PR only relates to but does not resolve.
 - **What kind of change does this PR introduce?** — one of: fix, feat, refactor, perf, test, chore, ci, build, style, revert, docs.
 - **Did you add tests for your changes?** — yes/no + which test files.
 - **Does this PR introduce a breaking change?** — yes/no + migration path if yes.
 
@@ -17,7 +17,7 @@ const {
 /** @typedef {import("./optimize/ConcatenatedModule").ExportName} Ids */
 
 const MODULE_REFERENCE_REGEXP =
-	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(?:_asiSafe(\d))?__$/;
+	/^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(_deferredImport)?(_mangleableNs)?(?:_asiSafe(\d))?__$/;
 
 /**
  * Encodes how a concatenated module reference should be interpreted when it is
@@ -27,6 +27,7 @@ const MODULE_REFERENCE_REGEXP =
  * @property {boolean} call true, when this referenced export is called
  * @property {boolean} directImport true, when this referenced export is directly imported (not via property access)
  * @property {boolean} deferredImport true, when this referenced export is deferred
+ * @property {boolean} mangleableNamespace true, when a whole-namespace reference may use a decoupled namespace object that keeps the original export names
  * @property {boolean | undefined} asiSafe if the position is ASI safe or unknown
  */
 
@@ -147,13 +148,15 @@ class ConcatenationScope {
 			call = false,
 			directImport = false,
 			deferredImport = false,
+			mangleableNamespace = false,
 			asiSafe = false
 		}
 	) {
 		const info = /** @type {ModuleInfo} */ (this._modulesMap.get(module));
 		const callFlag = call ? "_call" : "";
 		const directImportFlag = directImport ? "_directImport" : "";
 		const deferredImportFlag = deferredImport ? "_deferredImport" : "";
+		const mangleableNamespaceFlag = mangleableNamespace ? "_mangleableNs" : "";
 		const asiSafeFlag = asiSafe
 			? "_asiSafe1"
 			: asiSafe === false
@@ -163,7 +166,7 @@ class ConcatenationScope {
 			? Buffer.from(JSON.stringify(ids), "utf8").toString("hex")
 			: "ns";
 		// a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
-		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${asiSafeFlag}__._`;
+		return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${deferredImportFlag}${mangleableNamespaceFlag}${asiSafeFlag}__._`;
 	}
 
 	/**
@@ -186,7 +189,7 @@ class ConcatenationScope {
 		const match = MODULE_REFERENCE_REGEXP.exec(name);
 		if (!match) return null;
 		const index = Number(match[1]);
-		const asiSafe = match[6];
+		const asiSafe = match[7];
 		return {
 			index,
 			ids:
@@ -196,6 +199,7 @@ class ConcatenationScope {
 			call: Boolean(match[3]),
 			directImport: Boolean(match[4]),
 			deferredImport: Boolean(match[5]),
+			mangleableNamespace: Boolean(match[6]),
 			asiSafe: asiSafe ? asiSafe === "1" : undefined
 		};
 	}
 
@@ -463,6 +463,11 @@ class Dependency {
 Dependency.NO_EXPORTS_REFERENCED = [];
 /** @type {RawReferencedExports} */
 Dependency.EXPORTS_OBJECT_REFERENCED = [[]];
+// Like EXPORTS_OBJECT_REFERENCED, but the reference can be rendered as a
+// decoupled namespace object, so the module's exports stay mangleable.
+// Same shape as EXPORTS_OBJECT_REFERENCED; only distinguished by identity.
+/** @type {RawReferencedExports} */
+Dependency.EXPORTS_OBJECT_REFERENCED_MANGLEABLE = [[]];
 
 // TODO remove in webpack 6
 Object.defineProperty(Dependency.prototype, "module", {
 
@@ -21,7 +21,11 @@ const { getEntryRuntime, mergeRuntimeOwned } = require("./util/runtime");
 /** @typedef {import("./Module")} Module */
 /** @typedef {import("./util/runtime").RuntimeSpec} RuntimeSpec */
 
-const { NO_EXPORTS_REFERENCED, EXPORTS_OBJECT_REFERENCED } = Dependency;
+const {
+	NO_EXPORTS_REFERENCED,
+	EXPORTS_OBJECT_REFERENCED,
+	EXPORTS_OBJECT_REFERENCED_MANGLEABLE
+} = Dependency;
 
 const PLUGIN_NAME = "FlagDependencyUsagePlugin";
 const PLUGIN_LOGGER_NAME = `webpack.${PLUGIN_NAME}`;
@@ -30,10 +34,13 @@ class FlagDependencyUsagePlugin {
 	/**
 	 * Creates an instance of FlagDependencyUsagePlugin.
 	 * @param {boolean} global do a global analysis instead of per runtime
+	 * @param {boolean=} mangleEscapingNamespaces keep exports mangleable when a module's namespace object escapes
 	 */
-	constructor(global) {
+	constructor(global, mangleEscapingNamespaces = false) {
 		/** @type {boolean} */
 		this.global = global;
+		/** @type {boolean} */
+		this.mangleEscapingNamespaces = mangleEscapingNamespaces;
 	}
 
 	/**
@@ -75,6 +82,42 @@ class FlagDependencyUsagePlugin {
 						forceSideEffects
 					) => {
 						const exportsInfo = moduleGraph.getExportsInfo(module);
+						if (usedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE) {
+							// The whole namespace object escapes via a reference that codegen
+							// can materialize as a decoupled namespace object. When all exports
+							// are statically known we keep them mangleable instead of marking
+							// them used-in-unknown-way.
+							if (
+								this.mangleEscapingNamespaces &&
+								module.buildMeta &&
+								module.buildMeta.exportsType === "namespace" &&
+								exportsInfo.otherExportsInfo.provided === false
+							) {
+								let changed = exportsInfo.setAllKnownExportsUsed(runtime);
+								// The whole namespace object is observed as a value, so the
+								// module must stay a real ES module namespace at runtime
+								// (keep __esModule / the namespace object, i.e. `r()`).
+								if (
+									exportsInfo
+										.getExportInfo("__esModule")
+										.setUsed(UsageState.Used, runtime)
+								) {
+									changed = true;
+								}
+								// Exports must keep a real binding (not be inlined) so member
+								// access on the namespace has ES namespace semantics, e.g.
+								// `delete ns.x` hits a non-configurable property and throws.
+								for (const exportInfo of exportsInfo.ownedExports) {
+									exportInfo.canInlineUse = false;
+								}
+								if (changed) {
+									queue.enqueue(module, runtime);
+								}
+							} else if (exportsInfo.setUsedInUnknownWay(runtime)) {
+								queue.enqueue(module, runtime);
+							}
+							return;
+						}
 						if (usedExports.length > 0) {
 							if (!module.buildMeta || !module.buildMeta.exportsType) {
 								if (exportsInfo.setUsedWithoutInfo(runtime)) {
@@ -183,6 +226,11 @@ class FlagDependencyUsagePlugin {
 						/** @typedef {Map<string, string[] | ReferencedExport>} ExportMaps */
 						/** @type {Map<Module, ReferencedExports | ExportMaps>} */
 						const map = new Map();
+						// Modules whose whole namespace object escapes in a mangleable way.
+						// Tracked separately so specific member references are still merged
+						// (and marked used) instead of being dropped by the escape marker.
+						/** @type {Set<Module>} */
+						const mangleableEscapeModules = new Set();
 
 						/** @type {ArrayQueue<DependenciesBlock>} */
 						const queue = new ArrayQueue();
@@ -221,10 +269,27 @@ class FlagDependencyUsagePlugin {
 								}
 								const referencedExports =
 									compilation.getDependencyReferencedExports(dep, runtime);
+								// The non-mangleable whole-object reference is the most
+								// conservative result and always wins.
+								if (referencedExports === EXPORTS_OBJECT_REFERENCED) {
+									map.set(module, EXPORTS_OBJECT_REFERENCED);
+									mangleableEscapeModules.delete(module);
+									continue;
+								}
+								// A mangleable whole-object escape keeps the module's exports
+								// mangleable (applied after the merge). Unlike the conservative
+								// marker it must not drop specific member references: those still
+								// need their own (possibly non-existent) export marked used so
+								// they render as a qualified access, not a bare `undefined`.
+								if (
+									referencedExports === EXPORTS_OBJECT_REFERENCED_MANGLEABLE
+								) {
+									mangleableEscapeModules.add(module);
+									continue;
+								}
 								if (
 									oldReferencedExports === undefined ||
-									oldReferencedExports === NO_EXPORTS_REFERENCED ||
-									referencedExports === EXPORTS_OBJECT_REFERENCED
+									oldReferencedExports === NO_EXPORTS_REFERENCED
 								) {
 									map.set(module, referencedExports);
 								} else if (
@@ -293,6 +358,14 @@ class FlagDependencyUsagePlugin {
 								);
 							}
 						}
+						for (const module of mangleableEscapeModules) {
+							processReferencedModule(
+								module,
+								EXPORTS_OBJECT_REFERENCED_MANGLEABLE,
+								runtime,
+								forceSideEffects
+							);
+						}
 					};
 
 					logger.time("initialize exports usage");
 
@@ -20,7 +20,7 @@ const {
 const { equals } = require("./util/ArrayHelpers");
 const compileBooleanMatcher = require("./util/compileBooleanMatcher");
 const memoize = require("./util/memoize");
-const { propertyAccess } = require("./util/property");
+const { propertyAccess, propertyName } = require("./util/property");
 const { forEachRuntime, subtractRuntime } = require("./util/runtime");
 
 const getHarmonyImportDependency = memoize(() =>
@@ -1159,6 +1159,7 @@ class RuntimeTemplate {
 	 * @param {RuntimeSpec} options.runtime runtime for which this code will be generated
 	 * @param {RuntimeRequirements} options.runtimeRequirements if set, will be filled with runtime requirements
 	 * @param {ModuleDependency} options.dependency module dependency
+	 * @param {boolean=} options.mangleableNamespace true, when a whole-namespace value may use a decoupled namespace object that keeps the original export names
 	 * @returns {string} expression
 	 */
 	exportFromImport({
@@ -1176,7 +1177,8 @@ class RuntimeTemplate {
 		initFragments,
 		runtime,
 		runtimeRequirements,
-		dependency
+		dependency,
+		mangleableNamespace = false
 	}) {
 		if (!module) {
 			return this.missingModule({
@@ -1342,12 +1344,101 @@ class RuntimeTemplate {
 				asiSafe ? "" : asiSafe === false ? ";" : "Object"
 			}(${importVar}_deferred_namespace_cache || (${importVar}_deferred_namespace_cache = ${init}))`;
 		}
+		// The whole namespace object is used as a value. If the module's exports
+		// were mangled, importVar's keys are the mangled names, so we materialize
+		// a decoupled namespace object that exposes the original names.
+		if (
+			exportsType === "namespace" &&
+			mangleableNamespace &&
+			this.compilation &&
+			this.compilation.options.optimization.mangleExports
+		) {
+			const materialized = this._materializedNamespaceObject({
+				moduleGraph,
+				module,
+				importVar,
+				initFragments,
+				runtime,
+				runtimeRequirements
+			});
+			if (materialized !== undefined) return materialized;
+		}
 		// if we hit here, the importVar is either
 		// - already a ES module namespace object
 		// - or imported by a way that does not need interop.
 		return importVar;
 	}
 
+	/**
+	 * Materializes a namespace object that keeps the original export names while
+	 * the module's own exports are mangled. Returns undefined when no export was
+	 * mangled (then the raw namespace object can be used as-is).
+	 * @template GenerateContext
+	 * @param {object} options options
+	 * @param {ModuleGraph} options.moduleGraph the module graph
+	 * @param {Module} options.module the imported module
+	 * @param {string} options.importVar the import variable referencing the module
+	 * @param {InitFragment<GenerateContext>[]} options.initFragments target array for init fragments
+	 * @param {RuntimeSpec} options.runtime the runtime
+	 * @param {RuntimeRequirements} options.runtimeRequirements runtime requirements
+	 * @returns {string | undefined} expression of the materialized namespace object, or undefined
+	 */
+	_materializedNamespaceObject({
+		moduleGraph,
+		module,
+		importVar,
+		initFragments,
+		runtime,
+		runtimeRequirements
+	}) {
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		/** @type {string[]} */
+		const definitions = [];
+		let mangled = false;
+		for (const exportInfo of exportsInfo.orderedExports) {
+			if (exportInfo.provided === false) continue;
+			const used = exportsInfo.getUsedName([exportInfo.name], runtime);
+			if (!used) continue;
+			if (used instanceof InlinedUsedName) {
+				// An inlined export isn't reachable by name on the raw exports object,
+				// so the decoupled object must expose the inlined value directly.
+				mangled = true;
+				definitions.push(
+					`${propertyName(exportInfo.name)}: ${this.returningFunction(
+						used.render(
+							Template.toNormalComment(
+								`inlined export ${propertyAccess([exportInfo.name])}`
+							)
+						)
+					)}`
+				);
+				continue;
+			}
+			if (used[used.length - 1] !== exportInfo.name) mangled = true;
+			definitions.push(
+				`${propertyName(exportInfo.name)}: ${this.returningFunction(
+					`${importVar}${propertyAccess(used)}`
+				)}`
+			);
+		}
+		if (!mangled) return;
+		const name = `${importVar}_namespace_object`;
+		runtimeRequirements.add(RuntimeGlobals.exports);
+		runtimeRequirements.add(RuntimeGlobals.makeNamespaceObject);
+		runtimeRequirements.add(RuntimeGlobals.definePropertyGetters);
+		initFragments.push(
+			new InitFragment(
+				`var ${name} = {};\n${RuntimeGlobals.makeNamespaceObject}(${name});\n${
+					RuntimeGlobals.definePropertyGetters
+				}(${name}, {\n\t${definitions.join(",\n\t")}\n});\n`,
+				InitFragment.STAGE_PROVIDES,
+				0,
+				name
+			)
+		);
+		return name;
+	}
+
 	/**
 	 * Returns expression.
 	 * @param {object} options options
 
@@ -640,7 +640,9 @@ class WebpackOptionsApply extends OptionsApply {
 			const FlagDependencyUsagePlugin = require("./FlagDependencyUsagePlugin");
 
 			new FlagDependencyUsagePlugin(
-				options.optimization.usedExports === "global"
+				options.optimization.usedExports === "global",
+				// Keep an escaping module's exports mangleable when mangling is on.
+				Boolean(options.optimization.mangleExports)
 			).apply(compiler);
 		}
 		if (options.optimization.innerGraph) {
-Original file line number
+Diff line change
@@ @@ -0,0 +1,5 @@ @@
 +---
 +"webpack": minor
 +---
++
 +Keep export mangling enabled for modules whose namespace object is used as a whole value, by materializing a decoupled namespace object that keeps the original export names.