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

package/lib/dependencies/HarmonyImportDependencyParserPlugin.js

@@ -5,6 +5,7 @@
 
 "use strict";
 
+const ImportedBindingAssignmentError = require("../errors/ImportedBindingAssignmentError");
 const WebpackError = require("../errors/WebpackError");
 const getParserHooks = require("../hmr/parserHooks");
 const {
@@ -17,6 +18,7 @@ const HarmonyAcceptDependency = require("./HarmonyAcceptDependency");
 const HarmonyAcceptImportDependency = require("./HarmonyAcceptImportDependency");
 const HarmonyEvaluatedImportSpecifierDependency = require("./HarmonyEvaluatedImportSpecifierDependency");
 const HarmonyExports = require("./HarmonyExports");
+const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
 const {
 	ExportPresenceModes,
 	getNonOptionalPart
@@ -34,7 +36,9 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
  * 	Expression,
  * 	PrivateIdentifier,
  * 	Identifier,
- * 	MemberExpression
+ * 	MemberExpression,
+ * 	Pattern,
+ * 	UpdateExpression
  * } from "estree"
  */
 /**
@@ -43,11 +47,13 @@ const { ImportPhaseUtils, createGetImportPhase } = require("./ImportPhase");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import Module from "../Module" */
+/** @import { JavascriptModuleBuildInfo } from "../javascript/JavascriptModule" */
 /**
  * @import JavascriptParser, {
  * 	ImportAttributes,
  * 	Range,
- * 	Members
+ * 	Members,
+ * 	WriteStatement
  * } from "../javascript/JavascriptParser"
  */
 /** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
@@ -71,10 +77,24 @@ const EMPTY_ID_RANGES = [];
  * @property {boolean} await
  * @property {ImportAttributes=} attributes
  * @property {ImportPhaseType} phase
+ * @property {boolean} used whether the binding is referenced anywhere
+ * @property {HarmonyImportSideEffectDependency | undefined} dependency the statement's own dependency
  */
 
 const PLUGIN_NAME = "HarmonyImportDependencyParserPlugin";
 
+/**
+ * Records that an import binding is referenced, so it is not reported as an
+ * unused specifier naming a missing export.
+ * @param {HarmonySettings | undefined} settings settings of the referenced tag
+ * @returns {boolean} true when the reference was a harmony import specifier
+ */
+const markUsed = (settings) => {
+	if (!settings) return false;
+	settings.used = true;
+	return true;
+};
+
 /**
  * Gets in operator harmony import info.
  * @param {JavascriptParser} parser the parser
@@ -107,6 +127,7 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 	if (!settings) {
 		return;
 	}
+	settings.used = true;
 
 	return {
 		leftPart,
@@ -125,7 +146,10 @@ const getInOperatorHarmonyImportInfo = (parser, left, right) => {
 const findImportSpecifier = (parser, node) => {
 	switch (node.type) {
 		case "Identifier":
-			return Boolean(parser.getTagData(node.name, harmonySpecifierTag));
+			return markUsed(
+				/** @type {HarmonySettings | undefined} */
+				(parser.getTagData(node.name, harmonySpecifierTag))
+			);
 		case "UnaryExpression":
 			return findImportSpecifier(
 				parser,
@@ -213,6 +237,39 @@ class HarmonyImportDependencyParserPlugin {
 			this.options.sourceImport
 		);
 
+		// Parsers are reused across modules, so all three are reset per program.
+		/** @type {HarmonySettings[]} */
+		const declaredSpecifiers = [];
+		/** @type {HarmonyImportSideEffectDependency | undefined} */
+		let lastSideEffectDependency;
+		/** @type {Identifier | MemberExpression | undefined} */
+		let assignmentTarget;
+
+		parser.hooks.program.tap(PLUGIN_NAME, () => {
+			declaredSpecifiers.length = 0;
+			lastSideEffectDependency = undefined;
+			assignmentTarget = undefined;
+		});
+		parser.hooks.finish.tap(PLUGIN_NAME, () => {
+			for (const settings of declaredSpecifiers) {
+				const dependency = settings.dependency;
+				if (dependency === undefined || settings.used) continue;
+				if (dependency.unusedSpecifiers === undefined) {
+					dependency.unusedSpecifiers = {
+						exportPresenceMode: this.exportPresenceMode,
+						specifiers: []
+					};
+				}
+				dependency.unusedSpecifiers.specifiers.push([
+					settings.ids,
+					settings.name
+				]);
+			}
+			declaredSpecifiers.length = 0;
+			lastSideEffectDependency = undefined;
+			assignmentTarget = undefined;
+		});
+
 		/**
 		 * Gets non optional member chain.
 		 * @param {MemberExpression} node member expression
@@ -228,7 +285,10 @@ class HarmonyImportDependencyParserPlugin {
 			const expr = /** @type {Identifier} */ (expression);
 			if (
 				parser.isVariableDefined(expr.name) ||
-				parser.getTagData(expr.name, harmonySpecifierTag)
+				markUsed(
+					/** @type {HarmonySettings | undefined} */
+					(parser.getTagData(expr.name, harmonySpecifierTag))
+				)
 			) {
 				return true;
 			}
@@ -259,7 +319,13 @@ class HarmonyImportDependencyParserPlugin {
 				parser.state.current.addError(error);
 			}
 
-			const sideEffectDep = new HarmonyImportSideEffectDependency(
+			// A declaration binding nothing was written for what importing produces,
+			// which for a module emitting its own file is that file.
+			const SideEffectDependency =
+				statement.specifiers.length === 0
+					? HarmonyImportBareSideEffectDependency
+					: HarmonyImportSideEffectDependency;
+			const sideEffectDep = new SideEffectDependency(
 				/** @type {string} */ (source),
 				parser.state.lastHarmonyImportOrder,
 				phase,
@@ -267,6 +333,7 @@ class HarmonyImportDependencyParserPlugin {
 			);
 			sideEffectDep.loc = parser.getLocation(statement);
 			parser.state.module.addDependency(sideEffectDep);
+			lastSideEffectDependency = sideEffectDep;
 			return true;
 		});
 		parser.hooks.importSpecifier.tap(
@@ -274,18 +341,20 @@ class HarmonyImportDependencyParserPlugin {
 			(statement, source, id, name) => {
 				const ids = id === null ? [] : [id];
 				const phase = getImportPhase(parser, statement);
-				parser.tagVariable(
+				const settings = /** @type {HarmonySettings} */ ({
 					name,
-					harmonySpecifierTag,
-					/** @type {HarmonySettings} */ ({
-						name,
-						source,
-						ids,
-						sourceOrder: parser.state.lastHarmonyImportOrder,
-						attributes: getImportAttributes(statement),
-						phase
-					})
-				);
+					source,
+					ids,
+					sourceOrder: parser.state.lastHarmonyImportOrder,
+					attributes: getImportAttributes(statement),
+					phase,
+					used: false,
+					dependency: lastSideEffectDependency
+				});
+				parser.tagVariable(name, harmonySpecifierTag, settings);
+				// The statement's dependency carries them, so a never-referenced
+				// one still resolves; a namespace import names no export.
+				if (ids.length !== 0) declaredSpecifiers.push(settings);
 				return true;
 			}
 		);
@@ -328,16 +397,111 @@ class HarmonyImportDependencyParserPlugin {
 					nameInfo &&
 					nameInfo.rootInfo instanceof VariableInfo &&
 					nameInfo.rootInfo.name &&
-					parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag)
+					markUsed(
+						/** @type {HarmonySettings | undefined} */
+						(parser.getTagData(nameInfo.rootInfo.name, harmonySpecifierTag))
+					)
 				) {
 					return true;
 				}
 			}
 		);
+		/**
+		 * The reference a write lands on, which is a pattern for a
+		 * destructuring write.
+		 * @param {WriteStatement} node the construct performing the write
+		 * @returns {Pattern | MemberExpression} the written reference
+		 */
+		const writeTargetOf = (node) =>
+			/** @type {Pattern | MemberExpression} */ (
+				node.type === "UpdateExpression" ? node.argument : node.left
+			);
+
+		/**
+		 * Whether a member write lands on the namespace object itself, which is
+		 * read-only. A property of an imported object is an ordinary write.
+		 * @param {HarmonySettings} settings the specifier's settings
+		 * @param {Members} members the member chain
+		 * @returns {boolean} true when the write targets a namespace member
+		 */
+		const isNamespaceMemberWrite = (settings, members) =>
+			settings.ids.length === 0 && members.length === 1;
+
+		/**
+		 * Keeps the module whole, for a write whose reference the output has no
+		 * way to flag.
+		 * @returns {void}
+		 */
+		const bailOutOfConcatenation = () => {
+			/** @type {JavascriptModuleBuildInfo} */
+			(parser.state.module.buildInfo).moduleConcatenationBailout =
+				"assignment to an imported binding";
+		};
+
+		/**
+		 * Records the write target of an assignment or update to an imported
+		 * binding, so the reference walked next renders as a throwing write.
+		 * @param {WriteStatement} expr the write
+		 * @param {Identifier | MemberExpression | undefined} target the written reference, if any
+		 * @returns {void}
+		 */
+		const markImportedBindingWrite = (expr, target) => {
+			const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+			markUsed(settings);
+			// A named import is written through the namespace's getter-only
+			// property, which throws on its own. A namespace one is the binding
+			// itself, and nothing webpack can emit for it throws, so report it.
+			if (settings.ids.length === 0) {
+				const error = new ImportedBindingAssignmentError(settings.name);
+				error.loc = parser.getLocation(expr);
+				parser.state.module.addError(error);
+			} else if (target) {
+				assignmentTarget = target;
+			} else {
+				// A destructuring target emits no reference to flag, so the whole
+				// module stays out of concatenation.
+				bailOutOfConcatenation();
+			}
+		};
+
+		parser.hooks.assign.for(harmonySpecifierTag).tap(PLUGIN_NAME, (expr) => {
+			markImportedBindingWrite(
+				expr,
+				expr.left.type === "Identifier" ? expr.left : undefined
+			);
+		});
+		parser.hooks.write.for(harmonySpecifierTag).tap(PLUGIN_NAME, (node) => {
+			const written = writeTargetOf(node);
+			const target =
+				written.type === "Identifier"
+					? /** @type {Identifier} */ (written)
+					: undefined;
+			markImportedBindingWrite(node, target);
+			// A loop's binding walks nothing on its own, so the reference the
+			// write renders as has to be walked here to exist at all.
+			if (!target || node.type === "UpdateExpression") return;
+			parser.walkExpression(target);
+			return true;
+		});
+		// A namespace member is written through the reference its member chain
+		// emits, so both write forms flag that reference rather than the binding.
+		parser.hooks.writeMemberChain
+			.for(harmonySpecifierTag)
+			.tap(PLUGIN_NAME, (node, members) => {
+				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				if (!isNamespaceMemberWrite(settings, members)) return;
+				const written = writeTargetOf(node);
+				if (written.type === "MemberExpression") {
+					assignmentTarget = written;
+				} else {
+					bailOutOfConcatenation();
+				}
+			});
 		parser.hooks.expression
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expr) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				settings.used = true;
 
 				const dep = new HarmonyImportSpecifierDependency(
 					settings.source,
@@ -360,6 +524,10 @@ class HarmonyImportDependencyParserPlugin {
 				);
 				dep.loc = parser.getLocation(expr);
 				dep.call = parser.scope.inTaggedTemplateTag;
+				if (assignmentTarget === expr) {
+					dep.assignment = true;
+					assignmentTarget = undefined;
+				}
 				parser.state.module.addDependency(dep);
 				attachDependencyGuards(parser, dep);
 				getInnerGraphUtils(parser.state.compilation).onUsage(
@@ -376,6 +544,7 @@ class HarmonyImportDependencyParserPlugin {
 					const settings =
 						/** @type {HarmonySettings} */
 						(parser.currentTagData);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -412,6 +581,10 @@ class HarmonyImportDependencyParserPlugin {
 						(expr.range)[0]
 					);
 					dep.loc = parser.getLocation(expr);
+					if (assignmentTarget === expression) {
+						dep.assignment = true;
+						assignmentTarget = undefined;
+					}
 					parser.state.module.addDependency(dep);
 					attachDependencyGuards(parser, dep);
 					getInnerGraphUtils(parser.state.compilation).onUsage(
@@ -431,6 +604,7 @@ class HarmonyImportDependencyParserPlugin {
 					const settings = /** @type {HarmonySettings} */ (
 						parser.currentTagData
 					);
+					settings.used = true;
 					const nonOptionalMembers = getNonOptionalPart(
 						members,
 						membersOptionals
@@ -479,18 +653,17 @@ class HarmonyImportDependencyParserPlugin {
 					return true;
 				}
 			);
-		// Per the TC39 import-defer spec, [[Set]] on a Module Namespace
-		// Exotic Object returns false without triggering evaluation. The
-		// default expressionMemberChain path produces `<importVar>.a.foo`
-		// whose `.a` getter eagerly requires (and thus evaluates) the
-		// deferred module. For top-level `ns.foo = value`, walk only the
-		// bare `ns` identifier so it gets replaced with the deferred
-		// namespace proxy (whose set trap returns false), and leave the
-		// `.foo = value` part as plain code.
+		// `[[Set]]` on a Module Namespace returns false without evaluating, yet the
+		// member-chain path emits `<importVar>.a.foo`, whose getter evaluates. So
+		// only the bare `ns` is walked, leaving `.foo = value` as plain code.
 		parser.hooks.assignMemberChain
 			.for(harmonySpecifierTag)
 			.tap(PLUGIN_NAME, (expression, members) => {
 				const settings = /** @type {HarmonySettings} */ (parser.currentTagData);
+				settings.used = true;
+				if (isNamespaceMemberWrite(settings, members)) {
+					assignmentTarget = /** @type {MemberExpression} */ (expression.left);
+				}
 				if (!ImportPhaseUtils.isDefer(settings.phase)) return;
 				if (expression.operator !== "=") return;
 				if (members.length !== 1) return;

package/lib/dependencies/HarmonyImportSideEffectDependency.js

@@ -13,6 +13,8 @@ const makeSerializable = require("../util/makeSerializable");
 const HarmonyImportDependency = require("./HarmonyImportDependency");
 const { ImportPhaseUtils } = require("./ImportPhase");
 
+const { ExportPresenceModes } = HarmonyImportDependency;
+
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import { GetConditionFn, LazyUntil } from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
@@ -20,6 +22,19 @@ const { ImportPhaseUtils } = require("./ImportPhase");
 /** @import { ConnectionState } from "../ModuleGraphConnection" */
 /** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { ImportPhaseType } from "./ImportPhase" */
+/** @import { Ids, ExportPresenceMode } from "./HarmonyImportDependency" */
+/** @import { JavascriptModuleBuildMeta } from "../javascript/JavascriptModule" */
+/** @import WebpackError from "../errors/WebpackError" */
+/** @import { ObjectSerializerContext, ObjectDeserializerContext } from "../serialization/ObjectMiddleware" */
+
+/**
+ * Specifiers the module declares but never reads, with the presence level to
+ * report them at. Allocated only for a module that has one, so the common
+ * import pays a single empty slot.
+ * @typedef {object} UnusedSpecifiers
+ * @property {ExportPresenceMode} exportPresenceMode
+ * @property {[Ids, string][]} specifiers
+ */
 
 class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	/**
@@ -31,12 +46,111 @@ class HarmonyImportSideEffectDependency extends HarmonyImportDependency {
 	 */
 	constructor(request, sourceOrder, phase, attributes) {
 		super(request, sourceOrder, phase, attributes);
+		/** @type {UnusedSpecifiers | undefined} */
+		this.unusedSpecifiers = undefined;
 	}
 
 	get type() {
 		return "harmony side effect evaluation";
 	}
 
+	/**
+	 * Returns warnings.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} warnings
+	 */
+	getWarnings(moduleGraph) {
+		if (
+			this._getEffectiveExportPresenceLevel(moduleGraph) !==
+			ExportPresenceModes.WARN
+		) {
+			return null;
+		}
+		return this._getUnusedSpecifierErrors(moduleGraph);
+	}
+
+	/**
+	 * Get effective export presence level.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {ExportPresenceMode} effective mode
+	 */
+	_getEffectiveExportPresenceLevel(moduleGraph) {
+		if (this.unusedSpecifiers === undefined) return ExportPresenceModes.NONE;
+		const mode = this.unusedSpecifiers.exportPresenceMode;
+		if (mode !== ExportPresenceModes.AUTO) return mode;
+		const buildMeta =
+			/** @type {JavascriptModuleBuildMeta} */
+			(
+				/** @type {Module} */
+				(moduleGraph.getParentModule(this)).buildMeta
+			);
+		return buildMeta.strictHarmonyModule
+			? ExportPresenceModes.ERROR
+			: ExportPresenceModes.WARN;
+	}
+
+	/**
+	 * Returns errors.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | null | undefined} errors
+	 */
+	getErrors(moduleGraph) {
+		if (
+			this._getEffectiveExportPresenceLevel(moduleGraph) !==
+			ExportPresenceModes.ERROR
+		) {
+			return null;
+		}
+		return this._getUnusedSpecifierErrors(moduleGraph);
+	}
+
+	/**
+	 * Linking errors for specifiers the module declares but never references.
+	 * The spec resolves every import entry, so a name that does not exist is a
+	 * link error whether or not the binding is read.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {WebpackError[] | undefined} errors
+	 */
+	_getUnusedSpecifierErrors(moduleGraph) {
+		// Both callers resolve the presence level first, which is NONE without
+		// specifiers, so this only runs when there are some.
+		const { specifiers } = /** @type {UnusedSpecifiers} */ (
+			this.unusedSpecifiers
+		);
+		/** @type {WebpackError[] | undefined} */
+		let errors;
+		for (const [ids, name] of specifiers) {
+			const linkingErrors = this.getLinkingErrors(
+				moduleGraph,
+				ids,
+				`(imported as '${name}')`
+			);
+			if (linkingErrors) {
+				if (errors === undefined) errors = linkingErrors;
+				else errors.push(...linkingErrors);
+			}
+		}
+		return errors;
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.unusedSpecifiers);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.unusedSpecifiers = context.read();
+		super.deserialize(context);
+	}
+
 	/**
 	 * Returns the export name this dependency requests from its target module (lazy barrel optimization).
 	 * @returns {string | true | null} export name, true for all exports, null for none
@@ -112,10 +226,9 @@ HarmonyImportSideEffectDependency.Template = class HarmonyImportSideEffectDepend
 				if (ImportPhaseUtils.isDefer(dep.phase)) return;
 				const connection = moduleGraph.getConnection(dep);
 				if (!connection || !connection.isTargetActive(runtime)) return;
-				// A hoisted body cannot be deferred, so its imports evaluate at their
-				// own slots; calling from here would run them after everything hoisted
-				// in between. Eagerness stops at one level: a module is generated
-				// before its importers, so it never learns whether it is itself eager.
+				// A hoisted body cannot be deferred, so its imports evaluate in their own
+				// slots; calling from here would run them after everything hoisted in
+				// between. Eagerness stops at one level, generation order allowing no more.
 				if (concatenationScope.isWrapped()) {
 					initFragments.push(
 						new InitFragment(

package/lib/dependencies/HarmonyImportSpecifierDependency.js

@@ -26,10 +26,11 @@ const HarmonyImportGuard = require("./HarmonyImportGuard");
 const { ImportPhaseUtils } = require("./ImportPhase");
 
 /** @import { ReplaceSource } from "webpack-sources" */
-/** @import { GetConditionFn, ReferencedExports } from "../Dependency" */
+/** @import { GetConditionFn, ReferencedExports, UpdateHashContext } from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
 /** @import Module, { BuildMeta } from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */
+/** @import Hash from "../util/Hash" */
 /**
  * @import ModuleGraphConnection, {
  * 	ConnectionState
@@ -133,6 +134,8 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.referencedPropertiesInDestructuring = undefined;
 		/** @type {DependencyGuard[] | undefined} */
 		this.branchGuards = undefined;
+		/** @type {undefined | boolean} this reference is an assignment target */
+		this.assignment = undefined;
 	}
 
 	// TODO webpack 6 remove
@@ -262,6 +265,28 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		return condition;
 	}
 
+	/**
+	 * Updates the hash with the data contributed by this instance.
+	 * @param {Hash} hash hash to be updated
+	 * @param {UpdateHashContext} context context
+	 * @returns {void}
+	 */
+	updateHash(hash, context) {
+		const { chunkGraph, runtime } = context;
+		const moduleGraph = chunkGraph.moduleGraph;
+		if (!isInlineExportsEnabled(moduleGraph)) return;
+		const module = moduleGraph.getModule(this);
+		if (!module || !isInlineEnabled(module)) return;
+		const ids = this.getIds(moduleGraph);
+		if (ids.length === 0) return;
+		const exportsInfo = moduleGraph.getExportsInfo(module);
+		if (!exportsInfo.hasInlinedUsedName(ids, runtime)) return;
+		const usedName = exportsInfo.getUsedName(ids, runtime);
+		if (usedName instanceof InlinedUsedName) {
+			usedName.updateHash(hash);
+		}
+	}
+
 	/**
 	 * Gets module evaluation side effects state.
 	 * @param {ModuleGraph} moduleGraph the module graph
@@ -356,8 +381,9 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 					{
 						name: ids,
 						canMangle: true,
-						// Need access the export value to trigger side effects for deferred module
-						canInline: !ImportPhaseUtils.isDefer(this.phase)
+						// Need access the export value to trigger side effects for deferred module.
+						// An inlined literal cannot be an assignment target at all.
+						canInline: !this.assignment && !ImportPhaseUtils.isDefer(this.phase)
 					}
 				]
 			: Dependency.EXPORTS_OBJECT_REFERENCED;
@@ -450,6 +476,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		write(this.usedByExports);
 		write(this.referencedPropertiesInDestructuring);
 		write(this.branchGuards);
+		write(this.assignment);
 		super.serialize(context);
 	}
 
@@ -472,6 +499,7 @@ class HarmonyImportSpecifierDependency extends HarmonyImportDependency {
 		this.usedByExports = read();
 		this.referencedPropertiesInDestructuring = read();
 		this.branchGuards = read();
+		this.assignment = read();
 		super.deserialize(context);
 	}
 }
@@ -654,6 +682,15 @@ HarmonyImportSpecifierDependency.Template = class HarmonyImportSpecifierDependen
 						deferredImport: ImportPhaseUtils.isDefer(dep.phase)
 					}
 				);
+				// Concatenation merges the binding into a plain local a write would
+				// succeed against. Routing the write at a getter-only property of a
+				// throwaway object restores the TypeError the namespace gave it.
+				if (dep.assignment) {
+					// the local binding, the one name here an export is free not to
+					// spell as an identifier: `import { "a-b" as ab }`
+					const holder = `{ get ${dep.name}() { return ${exportExpr}; } }`;
+					exportExpr = `${dep.asiSafe ? "" : ";"}(${holder}).${dep.name}`;
+				}
 			}
 		} else {
 			super.apply(dep, source, templateContext);

package/lib/dependencies/HarmonyModulesPlugin.js

@@ -20,6 +20,7 @@ const HarmonyExportExpressionDependency = require("./HarmonyExportExpressionDepe
 const HarmonyExportHeaderDependency = require("./HarmonyExportHeaderDependency");
 const HarmonyExportImportedSpecifierDependency = require("./HarmonyExportImportedSpecifierDependency");
 const HarmonyExportSpecifierDependency = require("./HarmonyExportSpecifierDependency");
+const HarmonyImportBareSideEffectDependency = require("./HarmonyImportBareSideEffectDependency");
 const HarmonyImportDependencyParserPlugin = require("./HarmonyImportDependencyParserPlugin");
 const HarmonyImportSideEffectDependency = require("./HarmonyImportSideEffectDependency");
 const HarmonyImportSpecifierDependency = require("./HarmonyImportSpecifierDependency");
@@ -34,6 +35,7 @@ const TopLevelAwaitDependency = require("./TopLevelAwaitDependency");
  */
 /** @import Compiler from "../Compiler" */
 /** @import Parser from "../javascript/JavascriptParser" */
+/** @import { BuildInfo } from "../Module" */
 
 /**
  * Defines the harmony modules plugin options type used by this module.
@@ -81,6 +83,15 @@ class HarmonyModulesPlugin {
 					new HarmonyImportSideEffectDependency.Template()
 				);
 
+				compilation.dependencyFactories.set(
+					HarmonyImportBareSideEffectDependency,
+					normalModuleFactory
+				);
+				compilation.dependencyTemplates.set(
+					HarmonyImportBareSideEffectDependency,
+					new HarmonyImportBareSideEffectDependency.Template()
+				);
+
 				compilation.dependencyFactories.set(
 					HarmonyImportSpecifierDependency,
 					normalModuleFactory
@@ -149,6 +160,15 @@ class HarmonyModulesPlugin {
 						return;
 					}
 
+					if (parserOptions.specNamespaceObject) {
+						// Recorded on the module, because an importer asks the module it
+						// imports whether its namespace is a spec exotic object.
+						parser.hooks.program.tap(PLUGIN_NAME, () => {
+							/** @type {BuildInfo} */
+							(parser.state.module.buildInfo).specNamespaceObject = true;
+						});
+					}
+
 					new HarmonyDetectionParserPlugin().apply(parser);
 					new HarmonyImportDependencyParserPlugin(parserOptions).apply(parser);
 					new HarmonyExportDependencyParserPlugin(parserOptions).apply(parser);