webpack 5.106.2 → 5.107.0

package/lib/optimize/RealContentHashPlugin.js

@@ -8,7 +8,7 @@
 const { SyncBailHook } = require("tapable");
 const { CachedSource, CompatSource, RawSource } = require("webpack-sources");
 const Compilation = require("../Compilation");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { compareSelect, compareStrings } = require("../util/comparators");
 const createHash = require("../util/createHash");
 
@@ -46,24 +46,77 @@ const addToList = (itemOrItems, list) => {
 };
 
 /**
- * Map and deduplicate buffers.
+ * Compares two non-empty buffer chunk arrays for byte-equality without
+ * allocating a concatenated buffer.
+ * @param {Buffer[]} a first chunk array
+ * @param {Buffer[]} b second chunk array
+ * @returns {boolean} true if the concatenations are byte-equal
+ */
+const bufferArraysEqual = (a, b) => {
+	let aIdx = 0;
+	let aOff = 0;
+	let bIdx = 0;
+	let bOff = 0;
+	while (aIdx < a.length && bIdx < b.length) {
+		const aBuf = a[aIdx];
+		const bBuf = b[bIdx];
+		const len = Math.min(aBuf.length - aOff, bBuf.length - bOff);
+		if (aBuf.compare(bBuf, bOff, bOff + len, aOff, aOff + len) !== 0) {
+			return false;
+		}
+		aOff += len;
+		bOff += len;
+		if (aOff === aBuf.length) {
+			aIdx++;
+			aOff = 0;
+		}
+		if (bOff === bBuf.length) {
+			bIdx++;
+			bOff = 0;
+		}
+	}
+	return aIdx === a.length && bIdx === b.length;
+};
+
+/**
+ * Map sources to their buffer chunks and deduplicate by total byte content,
+ * grouping by total length first to avoid full comparisons.
  * @template T
  * @param {T[]} input list
- * @param {(item: T) => Buffer} fn map function
- * @returns {Buffer[]} buffers without duplicates
+ * @param {(item: T) => Source} fn map function returning a Source
+ * @returns {Buffer[][]} unique chunk arrays
  */
-const mapAndDeduplicateBuffers = (input, fn) => {
-	// Buffer.equals compares size first so this should be efficient enough
-	// If it becomes a performance problem we can use a map and group by size
-	// instead of looping over all assets.
-	/** @type {Buffer[]} */
+const mapAndDeduplicateSourceBuffers = (input, fn) => {
+	/** @type {Map<number, Buffer[][]>} */
+	const bySize = new Map();
+	/** @type {Buffer[][]} */
 	const result = [];
-	outer: for (const value of input) {
-		const buf = fn(value);
-		for (const other of result) {
-			if (buf.equals(other)) continue outer;
+	for (const value of input) {
+		const source = fn(value);
+		// TODO webpack 6: drop the `buffers` check, require webpack-sources >= 3.4
+		// and call `source.buffers()` unconditionally.
+		const chunks =
+			// TODO remove in webpack 6, this is protection against authors who directly use `webpack-sources` outdated version
+			typeof source.buffers === "function"
+				? source.buffers()
+				: [source.buffer()];
+		let total = 0;
+		for (const c of chunks) total += c.length;
+		const sameSize = bySize.get(total);
+		if (sameSize) {
+			let duplicate = false;
+			for (const other of sameSize) {
+				if (bufferArraysEqual(chunks, other)) {
+					duplicate = true;
+					break;
+				}
+			}
+			if (duplicate) continue;
+			sameSize.push(chunks);
+		} else {
+			bySize.set(total, [chunks]);
 		}
-		result.push(buf);
+		result.push(chunks);
 	}
 	return result;
 };
@@ -437,24 +490,34 @@ ${referencingAssets
 									: computeNewContent(asset)
 							)
 						);
-						const assetsContent = mapAndDeduplicateBuffers(assets, (asset) => {
-							if (/** @type {Hashes} */ (asset.ownHashes).has(oldHash)) {
-								return asset.newSourceWithoutOwn
-									? asset.newSourceWithoutOwn.buffer()
-									: asset.source.buffer();
+						const uniqueChunkArrays = mapAndDeduplicateSourceBuffers(
+							assets,
+							(asset) => {
+								if (/** @type {Hashes} */ (asset.ownHashes).has(oldHash)) {
+									return asset.newSourceWithoutOwn || asset.source;
+								}
+								return asset.newSource || asset.source;
 							}
-							return asset.newSource
-								? asset.newSource.buffer()
-								: asset.source.buffer();
-						});
-						let newHash = hooks.updateHash.call(assetsContent, oldHash);
+						);
+						/** @type {string | undefined} */
+						let newHash;
+						// Only materialize the public `Buffer[]` (one entry per unique
+						// asset) when something is tapped; otherwise the hot path feeds
+						// chunks into the hash directly, avoiding per-asset Buffer.concat.
+						if (hooks.updateHash.isUsed()) {
+							const assetsContent = uniqueChunkArrays.map((chunks) =>
+								chunks.length === 1 ? chunks[0] : Buffer.concat(chunks)
+							);
+							newHash =
+								hooks.updateHash.call(assetsContent, oldHash) || undefined;
+						}
 						if (!newHash) {
 							const hash = createHash(this._hashFunction);
 							if (compilation.outputOptions.hashSalt) {
 								hash.update(compilation.outputOptions.hashSalt);
 							}
-							for (const content of assetsContent) {
-								hash.update(content);
+							for (const chunks of uniqueChunkArrays) {
+								for (const c of chunks) hash.update(c);
 							}
 							const digest = hash.digest(this._hashDigest);
 							newHash = digest.slice(0, oldHash.length);

package/lib/optimize/SideEffectsFlagPlugin.js

@@ -14,12 +14,14 @@ const {
 const { STAGE_DEFAULT } = require("../OptimizationStages");
 const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
 const HarmonyImportSpecifierDependency = require("../dependencies/HarmonyImportSpecifierDependency");
-const formatLocation = require("../formatLocation");
+const formatLocation = require("../util/formatLocation");
+const { CompilerHintNotationRegExp } = require("../util/magicComment");
 
 /** @typedef {import("estree").MaybeNamedClassDeclaration} MaybeNamedClassDeclaration */
 /** @typedef {import("estree").MaybeNamedFunctionDeclaration} MaybeNamedFunctionDeclaration */
 /** @typedef {import("estree").ModuleDeclaration} ModuleDeclaration */
 /** @typedef {import("estree").Statement} Statement */
+/** @typedef {import("estree").CallExpression} CallExpression */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency").DependencyLocation} DependencyLocation */
 /** @typedef {import("../Module")} Module */
@@ -63,6 +65,24 @@ const globToRegexp = (glob, cache) => {
 	return regexp;
 };
 
+/**
+ * @param {JavascriptParser} parser parser
+ * @param {number} start start position
+ * @param {number} end end position
+ * @returns {boolean} if annotation is found in the range
+ */
+const hasNoSideEffectsNotation = (parser, start, end) => {
+	// Fast path
+	if (end - start < 18) return false;
+
+	const comments = parser.getComments([start, end]);
+	return comments.some(
+		(c) =>
+			c.type === "Block" &&
+			CompilerHintNotationRegExp.NoSideEffects.test(c.value)
+	);
+};
+
 const PLUGIN_NAME = "SideEffectsFlagPlugin";
 
 class SideEffectsFlagPlugin {
@@ -129,7 +149,7 @@ class SideEffectsFlagPlugin {
 					 * @param {JavascriptParser} parser the parser
 					 * @returns {void}
 					 */
-					const parserHandler = (parser) => {
+					const applySideEffectsStmtHandler = (parser) => {
 						/** @type {undefined | Statement | ModuleDeclaration | MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration} */
 						let sideEffectsStatement;
 						parser.hooks.program.tap(PLUGIN_NAME, () => {
@@ -260,6 +280,91 @@ class SideEffectsFlagPlugin {
 							}
 						});
 					};
+
+					/**
+					 * @param {JavascriptParser} parser the parser
+					 * @returns {void}
+					 */
+					const applyNoSideEffectsNotationHandler = (parser) => {
+						/** @type {Set<string>} */
+						let noSideEffectsFnNames;
+
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
+							noSideEffectsFnNames = new Set();
+						});
+
+						// Detect on function declarations
+						// Covers:
+						// 	1. function foo
+						//  2. export function foo
+						//  3. export default function foo
+						parser.hooks.preStatement.tap(PLUGIN_NAME, (statement) => {
+							if (parser.scope.topLevelScope !== true) return;
+							if (statement.type !== "FunctionDeclaration" || !statement.id) {
+								return;
+							}
+							const commentsStart = parser.prevStatement
+								? /** @type {Range} */ (parser.prevStatement.range)[1]
+								: 0;
+							if (
+								hasNoSideEffectsNotation(
+									parser,
+									commentsStart,
+									/** @type {Range} */ (statement.range)[0]
+								)
+							) {
+								noSideEffectsFnNames.add(statement.id.name);
+							}
+						});
+
+						// Detect on variable declarations with function init
+						parser.hooks.preDeclarator.tap(PLUGIN_NAME, (decl, statement) => {
+							if (parser.scope.topLevelScope !== true) return;
+							if (!decl.init || decl.id.type !== "Identifier") return;
+							if (!decl.init.type.endsWith("FunctionExpression")) return;
+
+							let hasAnnotation = false;
+							// Before the VariableDeclaration (only for const)
+							if (statement.kind === "const") {
+								const commentsStart = parser.prevStatement
+									? /** @type {Range} */ (parser.prevStatement.range)[1]
+									: 0;
+								hasAnnotation = hasNoSideEffectsNotation(
+									parser,
+									commentsStart,
+									/** @type {Range} */ (statement.range)[0]
+								);
+							}
+
+							if (!hasAnnotation) {
+								hasAnnotation = hasNoSideEffectsNotation(
+									parser,
+									/** @type {Range} */ (decl.id.range)[1],
+									/** @type {Range} */ (decl.init.range)[0]
+								);
+							}
+							if (hasAnnotation) {
+								noSideEffectsFnNames.add(decl.id.name);
+							}
+						});
+
+						// Mark calls to annotated functions as pure
+						parser.hooks.isPure
+							.for("CallExpression")
+							.tap(PLUGIN_NAME, (expression, commentsStartPos) => {
+								const expr = /** @type {CallExpression} */ (expression);
+								if (expr.callee.type !== "Identifier") return;
+								if (!noSideEffectsFnNames.has(expr.callee.name)) return;
+								commentsStartPos = /** @type {Range} */ (expr.callee.range)[1];
+								for (const arg of expr.arguments) {
+									if (arg.type === "SpreadElement") return;
+									if (!parser.isPure(arg, commentsStartPos)) return;
+									commentsStartPos = /** @type {Range} */ (arg.range)[1];
+								}
+								return true;
+							});
+					};
+
 					for (const key of [
 						JAVASCRIPT_MODULE_TYPE_AUTO,
 						JAVASCRIPT_MODULE_TYPE_ESM,
@@ -267,7 +372,10 @@ class SideEffectsFlagPlugin {
 					]) {
 						normalModuleFactory.hooks.parser
 							.for(key)
-							.tap(PLUGIN_NAME, parserHandler);
+							.tap(PLUGIN_NAME, (parser) => {
+								applyNoSideEffectsNotationHandler(parser);
+								applySideEffectsStmtHandler(parser);
+							});
 					}
 				}
 				compilation.hooks.optimizeDependencies.tap(

package/lib/optimize/SplitChunksPlugin.js

@@ -7,7 +7,7 @@
 
 const Chunk = require("../Chunk");
 const { STAGE_ADVANCED } = require("../OptimizationStages");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 const { requestToId } = require("../ids/IdHelpers");
 const { isSubset } = require("../util/SetHelpers");
 const SortableSet = require("../util/SortableSet");

package/lib/performance/AssetsOverSizeLimitWarning.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const { formatSize } = require("../SizeFormatHelpers");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
+const formatSize = require("../util/formatSize");
 
 /** @typedef {import("./SizeLimitsPlugin").AssetDetails} AssetDetails */
 

package/lib/performance/EntrypointsOverSizeLimitWarning.js

@@ -5,8 +5,8 @@
 
 "use strict";
 
-const { formatSize } = require("../SizeFormatHelpers");
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
+const formatSize = require("../util/formatSize");
 
 /** @typedef {import("./SizeLimitsPlugin").EntrypointDetails} EntrypointDetails */
 

package/lib/performance/NoAsyncChunksWarning.js

@@ -5,9 +5,9 @@
 
 "use strict";
 
-const WebpackError = require("../WebpackError");
+const WebpackError = require("../errors/WebpackError");
 
-module.exports = class NoAsyncChunksWarning extends WebpackError {
+class NoAsyncChunksWarning extends WebpackError {
 	constructor() {
 		super(
 			"webpack performance recommendations: \n" +
@@ -18,4 +18,6 @@ module.exports = class NoAsyncChunksWarning extends WebpackError {
 		/** @type {string} */
 		this.name = "NoAsyncChunksWarning";
 	}
-};
+}
+
+module.exports = NoAsyncChunksWarning;

package/lib/performance/SizeLimitsPlugin.js

@@ -16,7 +16,7 @@ const NoAsyncChunksWarning = require("./NoAsyncChunksWarning");
 /** @typedef {import("../Compilation").Asset} Asset */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
-/** @typedef {import("../WebpackError")} WebpackError */
+/** @typedef {import("../errors/WebpackError")} WebpackError */
 
 /**
  * Defines the asset details type used by this module.

package/lib/prefetch/ChunkPrefetchTriggerRuntimeModule.js

@@ -39,10 +39,13 @@ class ChunkPrefetchTriggerRuntimeModule extends RuntimeModule {
 				`${
 					RuntimeGlobals.ensureChunkHandlers
 				}.prefetch = ${runtimeTemplate.expressionFunction(
+					// Prefetch is best-effort; silence rejections so a failed chunk
+					// load (e.g. chunkLoadTimeout) doesn't surface as an unhandled
+					// rejection through this dangling Promise.all chain.
 					`Promise.all(promises).then(${runtimeTemplate.basicFunction(
 						"",
 						body
-					)})`,
+					)}, ${runtimeTemplate.basicFunction("", "")})`,
 					"chunkId, promises"
 				)};`
 			])

package/lib/rules/UseEffectRulePlugin.js

@@ -13,6 +13,7 @@ const util = require("util");
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUse} RuleSetUse */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetUseItem} RuleSetUseItem */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetUseFunction} RuleSetUseFunction */
 /** @typedef {import("./RuleSetCompiler")} RuleSetCompiler */
 /** @typedef {import("./RuleSetCompiler").Effect} Effect */
 /** @typedef {import("./RuleSetCompiler").EffectData} EffectData */
@@ -82,7 +83,7 @@ class UseEffectRulePlugin {
 					 * Returns effect.
 					 * @param {string} path options path
 					 * @param {string} defaultIdent default ident when none is provided
-					 * @param {Exclude<NonNullable<RuleSetUseItem>, EXPECTED_FUNCTION>} item user provided use value
+					 * @param {Exclude<NonNullable<RuleSetUseItem>, RuleSetUseFunction>} item user provided use value
 					 * @returns {Effect} effect
 					 */
 					const useToEffectRaw = (path, defaultIdent, item) => {
@@ -132,7 +133,7 @@ class UseEffectRulePlugin {
 								useToEffectRaw(
 									`${path}[${idx}]`,
 									"[[missing ident]]",
-									/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+									/** @type {Exclude<RuleSetUseItem, RuleSetUseFunction>} */
 									(item)
 								)
 							);
@@ -141,7 +142,7 @@ class UseEffectRulePlugin {
 							useToEffectRaw(
 								path,
 								"[[missing ident]]",
-								/** @type {Exclude<RuleSetUseItem, EXPECTED_FUNCTION>} */
+								/** @type {Exclude<RuleSetUseItem, RuleSetUseFunction>} */
 								(items)
 							)
 						];

package/lib/runtime/MakeDeferredNamespaceObjectRuntime.js

@@ -121,15 +121,40 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 			? "init?.();"
 			: "if (init) init();";
 		return `${fn} = ${runtimeTemplate.basicFunction("moduleId, mode", [
+			// 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.
+			//
+			// 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.
+			"mode &= ~16;",
+			"var byMode = __webpack_module_deferred_namespace_cache__[moduleId];",
+			"if (byMode && byMode[mode] !== undefined) return byMode[mode];",
+			"if (!byMode) byMode = __webpack_module_deferred_namespace_cache__[moduleId] = {};",
 			"var cachedModule = __webpack_module_cache__[moduleId];",
-			"if (cachedModule && cachedModule.error === undefined) {",
+			"if (cachedModule && cachedModule.error === undefined && !(mode & 8)) {",
 			Template.indent([
 				"var exports = cachedModule.exports;",
 				hasAsync
 					? `if (${RuntimeGlobals.asyncModuleExportSymbol} in exports) exports = exports[${RuntimeGlobals.asyncModuleExportSymbol}];`
 					: "",
-				"if (mode & 8) return exports;",
-				`return ${RuntimeGlobals.createFakeNamespaceObject}(exports, mode);`
+				`return byMode[mode] = ${RuntimeGlobals.createFakeNamespaceObject}(exports, mode);`
 			]),
 			"}",
 			"",
@@ -141,9 +166,23 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				"init = null;",
 				"if (mode & 8 || mode & 4 && ns.__esModule && typeof ns === 'object') {",
 				Template.indent([
-					"delete handler.defineProperty;",
-					"delete handler.deleteProperty;",
-					"delete handler.set;",
+					// 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.
 					"delete handler.get;",
 					"delete handler.has;",
 					"delete handler.ownKeys;",
@@ -153,13 +192,58 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				Template.indent([
 					`ns = ${RuntimeGlobals.createFakeNamespaceObject}(ns, mode);`
 				]),
+				"}",
+				// 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
+				// pre-populated with those values below.
+				"var keys = Reflect.ownKeys(ns);",
+				"for (var i = 0; i < keys.length; i++) {",
+				Template.indent([
+					"var k = keys[i];",
+					'if (k === "__esModule" || k === Symbol.toStringTag) continue;',
+					"if (!Object.prototype.hasOwnProperty.call(ns_target, k)) {",
+					Template.indent([
+						"try { Object.defineProperty(ns_target, k, Reflect.getOwnPropertyDescriptor(ns, k)); } catch (_) {}"
+					]),
+					"}"
+				]),
 				"}"
 			])};`,
 			"",
-			"var ns = __webpack_module_deferred_exports__[moduleId] || (__webpack_module_deferred_exports__[moduleId] = { __proto__: null });",
+			// 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.
+			"var ns_target = { __proto__: null };",
+			// 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.
+			'Object.defineProperty(ns_target, "__esModule", { value: true });',
+			'Object.defineProperty(ns_target, Symbol.toStringTag, { value: "Deferred Module" });',
+			"var ns = ns_target;",
 			"var 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()`.
 				`get: ${runtimeTemplate.basicFunction("_, name", [
 					"switch (name) {",
 					Template.indent([
@@ -168,6 +252,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 						'case "then": return undefined;'
 					]),
 					"}",
+					'if (typeof name === "symbol") return ns_target[name];',
 					init,
 					"return ns[name];"
 				])},`,
@@ -186,6 +271,7 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 						].filter(Boolean)
 					),
 					"}",
+					'if (typeof name === "symbol") return name in ns_target;',
 					init,
 					"return name in ns;"
 				])},`,
@@ -197,11 +283,16 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 				`getOwnPropertyDescriptor: ${runtimeTemplate.basicFunction("_, name", [
 					"switch (name) {",
 					Template.indent([
-						'case "__esModule": return { value: true, configurable: !(mode & 8) };',
-						'case Symbol.toStringTag: return { value: "Deferred Module", configurable: !(mode & 8) };',
+						// 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.
+						'case "__esModule": return { value: true, writable: false, enumerable: false, configurable: false };',
+						'case Symbol.toStringTag: return { value: "Deferred Module", writable: false, enumerable: false, configurable: false };',
 						'case "then": return undefined;'
 					]),
 					"}",
+					'if (typeof name === "symbol") return Reflect.getOwnPropertyDescriptor(ns_target, name);',
 					init,
 					"var desc = Reflect.getOwnPropertyDescriptor(ns, name);",
 					'if (mode & 2 && name == "default" && !desc) {',
@@ -209,18 +300,33 @@ class MakeDeferredNamespaceObjectRuntimeModule extends HelperRuntimeModule {
 					"}",
 					"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: ${runtimeTemplate.basicFunction("_, 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: ${runtimeTemplate.basicFunction("_, name", [
+					'if (typeof name === "symbol" || name === "then") return false;',
 					init,
-					// Note: This behavior does not match the spec one, but since webpack does not do it either
-					// for a normal Module Namespace object (in MakeNamespaceObjectRuntimeModule), let's keep it simple.
 					"return false;"
 				])},`,
-				`deleteProperty: ${runtimeTemplate.returningFunction("false")},`,
+				// `set` always returns false without triggering evaluation —
+				// the spec [[Set]] algorithm for Module Namespaces is just
+				// "return false" (no [[GetOwnProperty]], no eval).
 				`set: ${runtimeTemplate.returningFunction("false")},`
 			]),
 			"}",
 			// we don't fully emulate ES Module semantics in this Proxy to align with normal webpack esm namespace object.
-			"return new Proxy(ns, handler);"
+			"return byMode[mode] = new Proxy(ns_target, handler);"
 		])};`;
 	}
 }

package/lib/runtime/SetAnonymousDefaultNameRuntimeModule.js

@@ -0,0 +1,35 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @typedef {import("../Compilation")} Compilation */
+
+class SetAnonymousDefaultNameRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("set anonymous default export name");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const fn = RuntimeGlobals.setAnonymousDefaultName;
+		return Template.asString([
+			"// set .name for anonymous default exports per ES spec",
+			`${fn} = ${runtimeTemplate.basicFunction("x", [
+				'(Object.getOwnPropertyDescriptor(x, "name") || {}).writable || Object.defineProperty(x, "name", { value: "default", configurable: true });'
+			])};`
+		]);
+	}
+}
+
+module.exports = SetAnonymousDefaultNameRuntimeModule;