webpack 5.111.1 → 5.112.1

package/lib/library/ModuleLibraryPlugin.js

@@ -6,27 +6,40 @@
 "use strict";
 
 const { ConcatSource } = require("webpack-sources");
-const { UsageState } = require("../ExportsInfo");
-const ExternalModule = require("../ExternalModule");
-const { JAVASCRIPT_TYPE } = require("../ModuleSourceTypeConstants");
-const RuntimeGlobals = require("../RuntimeGlobals");
-const Template = require("../Template");
-const HarmonyExportExpressionDependency = require("../dependencies/HarmonyExportExpressionDependency");
-const HarmonyExportImportedSpecifierDependency = require("../dependencies/HarmonyExportImportedSpecifierDependency");
-const HarmonyExportSpecifierDependency = require("../dependencies/HarmonyExportSpecifierDependency");
+const ESMLiveExportDependency = require("../dependencies/esm/ESMLiveExportDependency");
+const ESMLiveExportParserPlugin = require("../dependencies/esm/ESMLiveExportParserPlugin");
 const ExternalStarReexportError = require("../errors/ExternalStarReexportError");
+const { UsageState } = require("../graph/ExportsInfo");
+const isDependencyKind = require("../graph/isDependencyKind");
 const JavascriptModulesPlugin = require("../javascript/JavascriptModulesPlugin");
-const ConcatenatedModule = require("../optimize/ConcatenatedModule");
-const { InlinedUsedName } = require("../optimize/InlineExports");
-const { toJsStringLiteral } = require("../util/identifier");
 const {
-	RESERVED_IDENTIFIER,
-	SAFE_IDENTIFIER,
-	propertyAccess
-} = require("../util/property");
-const { getEntryRuntime } = require("../util/runtime");
+	getMergedExports,
+	mergedEntryModules
+} = require("../javascript/MergedEntryExports");
+const { JAVASCRIPT_TYPE } = require("../module/ModuleSourceTypeConstants");
+const {
+	JAVASCRIPT_MODULE_TYPE_AUTO,
+	JAVASCRIPT_MODULE_TYPE_ESM
+} = require("../module/ModuleTypeConstants");
+const { isInlinedUsedName } = require("../optimize/InlineExports");
+const RuntimeGlobals = require("../runtime/RuntimeGlobals");
+const Template = require("../template/Template");
+const { someInIterable } = require("../util/IterableHelpers");
+const { renameIdentifiers } = require("../util/concatenate");
+const { SAFE_IDENTIFIER, propertyAccess } = require("../util/property");
+const {
+	getEntryRuntime,
+	getRuntimeKey,
+	intersectRuntime
+} = require("../util/runtime");
 const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
 
+/** @import ExternalModule from "../externals/ExternalModule" */
+/** @import { ExportInfo } from "../graph/ExportsInfo" */
+/** @import Chunk from "../graph/Chunk" */
+/** @import ESMExportSpecifierDependency from "../dependencies/esm/ESMExportSpecifierDependency" */
+/** @import NormalModuleFactory from "../module/NormalModuleFactory" */
+/** @import { InlinedUsedName } from "../optimize/InlineExports" */
 /** @import { Source } from "webpack-sources" */
 /**
  * @import {
@@ -35,18 +48,19 @@ const AbstractLibraryPlugin = require("./AbstractLibraryPlugin");
  * 	LibraryExport
  * } from "../../declarations/WebpackOptions"
  */
-/** @import Chunk from "../Chunk" */
+/** @import CodeGenerationResults from "../module/CodeGenerationResults" */
 /** @import Compilation from "../Compilation" */
 /** @import Compiler from "../Compiler" */
-/** @import ModuleGraph from "../ModuleGraph" */
-/** @import Module from "../Module" */
+/** @import ModuleGraph, { LiveBinding } from "../graph/ModuleGraph" */
+/** @import Module from "../module/Module" */
+/** @import ChunkGraph from "../graph/ChunkGraph" */
+/** @import RuntimeTemplate from "../template/RuntimeTemplate" */
 /**
  * @import {
  * 	StartupRenderContext,
  * 	ModuleRenderContext
  * } from "../javascript/JavascriptModulesPlugin"
  */
-/** @import { ImportAttributes } from "../javascript/JavascriptParser" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /**
  * @import {
@@ -83,37 +97,115 @@ const PLUGIN_NAME = "ModuleLibraryPlugin";
 const libraryEntryModules = new WeakMap();
 
 /**
- * Whether every export the module defines is a binding the library can export
- * natively, so the definitions written into the exports object are read by nobody.
- * A re-export or a renamed import is not: `renderStartup` reads those back off the
- * object, and `treatAsCommonJs` hands the object out as the default export.
+ * @typedef {object} ChunkLiveExports
+ * @property {string[]} names the names the chunk's scope declares
+ * @property {Map<InstanceType<ExportInfo>, string>} exports the name each live export binds to
+ * @property {[string, string, string, string | false, boolean][]} setters the module id, local name, declared name, used export name and async status of each binding a module writes through a setter
+ * @property {boolean} hasAsync whether any setter belongs to an async module
+ */
+
+/**
+ * @typedef {object} LiveExportCandidate
+ * @property {Module} module the module declaring the binding
+ * @property {ESMLiveExportDependency} declaration its declaration
+ * @property {InstanceType<ExportInfo>} exportInfo the library's export of it
+ * @property {string} localName the local name the export binds to
+ * @property {boolean} mirrored whether the module keeps its declaration and mirrors each write
+ */
+
+/** @type {WeakMap<Chunk, ChunkLiveExports>} */
+const chunkLiveExports = new WeakMap();
+
+/** @type {WeakSet<NormalModuleFactory>} */
+const liveExportFactories = new WeakSet();
+
+/** @type {WeakMap<Compilation, Set<string>>} */
+const hoistedNames = new WeakMap();
+
+/**
+ * @typedef {object} ModuleLocalExports
+ * @property {Map<string, ESMExportSpecifierDependency>} specifiers each local export by its name
+ * @property {Map<string, ESMLiveExportDependency>} declarations each live `let` by a name it declares
+ */
+
+/**
+ * Indexes the local exports and live `let` declarations of a module, once per module.
+ * @param {Module} module the module
+ * @param {Map<Module, ModuleLocalExports>} cache the indexes built so far
+ * @returns {ModuleLocalExports} the module's index
+ */
+const getModuleLocalExports = (module, cache) => {
+	let result = cache.get(module);
+	if (result !== undefined) return result;
+	result = { specifiers: new Map(), declarations: new Map() };
+	for (const dependency of module.dependencies) {
+		if (isDependencyKind(dependency, "esm-export-specifier")) {
+			result.specifiers.set(dependency.name, dependency);
+		} else if (isDependencyKind(dependency, "esm-live-export")) {
+			for (const name of dependency.names) {
+				result.declarations.set(name, dependency);
+			}
+		}
+	}
+	cache.set(module, result);
+	return result;
+};
+
+/**
+ * Why a module's exported module-level bindings cannot move to the chunk's scope.
+ * @param {Module} module the module declaring them
+ * @param {Module} entry the entry module exporting them
+ * @param {ESMLiveExportDependency} declaration one of its declarations
+ * @returns {string | null} the reason they stay and mirror, empty where they are live already, null where they can move
+ */
+const getHoistRefusal = (module, entry, declaration) => {
+	// A concatenation puts its modules' bindings in one scope already.
+	if (
+		module.is("concatenated") ||
+		(entry !== module &&
+			someInIterable(entry.getSourceModules(), (source) => source === module))
+	) {
+		return "";
+	}
+	if (declaration.readByEval) {
+		return "the module calls eval(), and a function it creates may write a binding later";
+	}
+	return null;
+};
+
+/**
+ * Whether a module's code runs where the chunk's scope is not: in a hot update, or in
+ * another chunk of the runtime, so it can reach the declared names only through setters.
+ * @param {Module} module the module declaring them
+ * @param {ESMLiveExportDependency} declaration one of its declarations
+ * @param {Chunk} chunk the library's chunk
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @returns {boolean} true when the module needs the setters
+ */
+const needsSetters = (module, declaration, chunk, chunkGraph) =>
+	declaration.hot ||
+	!chunkGraph.isModuleInChunk(module, chunk) ||
+	someInIterable(
+		chunkGraph.getModuleChunksIterable(module),
+		(other) =>
+			other !== chunk &&
+			intersectRuntime(other.runtime, chunk.runtime) !== undefined
+	);
+
+/**
+ * Whether the library reads every export of the entry off its exports object, never
+ * binding one to a declaration of the inlined body, so no definition can be left out.
  * @param {Module} module the entry module
  * @param {ModuleGraph} moduleGraph the module graph
- * @returns {boolean} true when the definitions may be taken over
+ * @returns {boolean} true when the entry has no export the library exposes natively
  */
-const definesOnlyNativeExports = (module, moduleGraph) => {
+const noNativeExports = (module, moduleGraph) => {
 	const buildMeta = /** @type {JavascriptModuleBuildMeta} */ (module.buildMeta);
-	if (buildMeta && buildMeta.treatAsCommonJs) return false;
+	if (buildMeta && buildMeta.treatAsCommonJs) return true;
 	// A top-level `await` wraps the body in `__webpack_require__.a`, and the
 	// definitions read declarations inside that wrapper — re-emitting them after the
 	// module would put them out of scope.
-	if (moduleGraph.isAsync(module)) return false;
-	const topLevelDeclarations =
-		module.buildInfo && module.buildInfo.topLevelDeclarations;
-	if (!topLevelDeclarations) return false;
-	for (const dep of module.dependencies) {
-		// A re-export or an `export default` has no declaration of its own to bind to,
-		// so `renderStartup` reads its value back off the exports object.
-		if (
-			dep instanceof HarmonyExportImportedSpecifierDependency ||
-			dep instanceof HarmonyExportExpressionDependency
-		) {
-			return false;
-		}
-		if (!(dep instanceof HarmonyExportSpecifierDependency)) continue;
-		if (!topLevelDeclarations.has(dep.id)) return false;
-	}
-	return true;
+	return moduleGraph.isAsync(module);
 };
 
 /**
@@ -125,26 +217,6 @@ const definesOnlyNativeExports = (module, moduleGraph) => {
 const toExportName = (name) =>
 	SAFE_IDENTIFIER.test(name) ? name : JSON.stringify(name);
 
-/**
- * Renders the import attributes of a reexport in the syntax the author wrote,
- * since a legacy `assert` clause and a `with` clause are not interchangeable.
- * @param {ImportAttributes | undefined} attributes the import attributes
- * @returns {string} the attributes clause, empty when there are none
- */
-const toAttributesClause = (attributes) => {
-	if (!attributes) return "";
-	const { _isLegacyAssert: isLegacyAssert, ...values } = attributes;
-	return ` ${isLegacyAssert ? "assert" : "with"} ${JSON.stringify(values)}`;
-};
-
-/**
- * Whether the export name can also be used as the declared binding name.
- * @param {string} name export name
- * @returns {boolean} true, when the name can be declared
- */
-const isDeclarableExportName = (name) =>
-	SAFE_IDENTIFIER.test(name) && !RESERVED_IDENTIFIER.has(name);
-
 /**
  * Represents the module library plugin runtime component.
  * @typedef {ModuleLibraryPluginParsed} T
@@ -170,10 +242,34 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	apply(compiler) {
 		super.apply(compiler);
 
+		// Both library types apply this plugin, and one parser tap records everything.
+		compiler.hooks.normalModuleFactory.tap(
+			PLUGIN_NAME,
+			(normalModuleFactory) => {
+				if (liveExportFactories.has(normalModuleFactory)) return;
+				liveExportFactories.add(normalModuleFactory);
+				for (const type of [
+					JAVASCRIPT_MODULE_TYPE_AUTO,
+					JAVASCRIPT_MODULE_TYPE_ESM
+				]) {
+					normalModuleFactory.hooks.parser
+						.for(type)
+						.tap(PLUGIN_NAME, (parser) => {
+							new ESMLiveExportParserPlugin().apply(parser);
+						});
+				}
+			}
+		);
+
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			const javascriptHooks =
 				JavascriptModulesPlugin.getCompilationHooks(compilation);
 
+			compilation.dependencyTemplates.set(
+				ESMLiveExportDependency,
+				new ESMLiveExportDependency.Template()
+			);
+
 			compilation.hooks.beforeCodeGeneration.tap(PLUGIN_NAME, () => {
 				const entries = libraryEntryModules.get(compilation);
 				if (entries === undefined) return;
@@ -182,13 +278,9 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					for (const dep of dependencies) {
 						const module = dep && moduleGraph.getModule(dep);
 						if (!module) continue;
-						const root =
-							module instanceof ConcatenatedModule ? module.rootModule : module;
+						const root = module.getRootModule();
 						if (!entries.has(root)) continue;
-						if (
-							root === module &&
-							!definesOnlyNativeExports(module, moduleGraph)
-						) {
+						if (root === module && noNativeExports(module, moduleGraph)) {
 							continue;
 						}
 						moduleGraph.getMeta(module).onDemandExports = true;
@@ -196,11 +288,218 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			});
 
+			// An exported module-level `let` or `var` of a module the chunk runs as a function
+			// moves to the chunk's scope under a reserved name, which the library then
+			// exports itself; decided before hashing, as the module's code changes.
+			compilation.hooks.beforeModuleHash.tap(PLUGIN_NAME, () => {
+				const entries = libraryEntryModules.get(compilation);
+				if (entries === undefined) return;
+				const { chunkGraph, moduleGraph } = compilation;
+				/** @type {Map<Module, ModuleLocalExports>} */
+				const localExports = new Map();
+				// Both library types name bindings in one compilation, so they share it.
+				let usedNames = hoistedNames.get(compilation);
+				if (usedNames === undefined) {
+					usedNames = new Set();
+					hoistedNames.set(compilation, usedNames);
+				}
+				/** @type {Map<Module, Set<string>>} */
+				const registeredRuntimes = new Map();
+				/** @type {{ chunk: Chunk, runtimeKey: string, candidates: LiveExportCandidate[] }[]} */
+				const chunkCandidates = [];
+				for (const chunk of compilation.chunks) {
+					if (chunkGraph.getNumberOfEntryModules(chunk) === 0) continue;
+					const entryOptions = chunk.getEntryOptions();
+					const library =
+						entryOptions && entryOptions.library !== undefined
+							? entryOptions.library
+							: compilation.outputOptions.library;
+					if (this._parseOptionsCached(library) === false) continue;
+					const runtimeKey = getRuntimeKey(chunk.runtime);
+					/** @type {LiveExportCandidate[]} */
+					const candidates = [];
+					// why each module keeps its bindings, null where they move
+					/** @type {Map<Module, string | null>} */
+					const refusals = new Map();
+					for (const entry of chunkGraph.getChunkEntryModulesIterable(chunk)) {
+						if (!entries.has(entry.getRootModule())) continue;
+						for (const exportInfo of moduleGraph.getExportsInfo(entry)
+							.orderedExports) {
+							if (!exportInfo.provided) continue;
+							const target = exportInfo.getTarget(moduleGraph);
+							if (target && (!target.export || target.export.length !== 1)) {
+								continue;
+							}
+							const module = target ? target.module : entry;
+							const { specifiers, declarations } = getModuleLocalExports(
+								module,
+								localExports
+							);
+							const local = specifiers.get(
+								target
+									? /** @type {string[]} */ (target.export)[0]
+									: exportInfo.name
+							);
+							const declaration = local && declarations.get(local.id);
+							if (!declaration) continue;
+							let refusal = refusals.get(module);
+							if (refusal === undefined) {
+								refusal = getHoistRefusal(module, entry, declaration);
+								refusals.set(module, refusal);
+								if (refusal) {
+									compilation.runtimeTemplate.analyzableBailout(
+										module,
+										`a module library may export a stale binding, since ${refusal}`
+									);
+								}
+							}
+							if (refusal === "") continue;
+							candidates.push({
+								module,
+								declaration,
+								exportInfo,
+								localName: local.id,
+								mirrored: declaration.earlyUse || refusal !== null
+							});
+							// A module runs once per runtime, so one library of it needing the
+							// setters makes every library of that runtime register them.
+							if (needsSetters(module, declaration, chunk, chunkGraph)) {
+								let runtimes = registeredRuntimes.get(module);
+								if (runtimes === undefined) {
+									runtimes = new Set();
+									registeredRuntimes.set(module, runtimes);
+								}
+								runtimes.add(runtimeKey);
+							}
+						}
+					}
+					if (candidates.length > 0) {
+						chunkCandidates.push({ chunk, runtimeKey, candidates });
+					}
+				}
+				for (const { chunk, runtimeKey, candidates } of chunkCandidates) {
+					/** @type {string[]} */
+					const names = [];
+					/** @type {Set<LiveBinding>} */
+					const declared = new Set();
+					/** @type {ChunkLiveExports["exports"]} */
+					const exports = new Map();
+					/** @type {ChunkLiveExports["setters"]} */
+					const setters = [];
+					/** @type {Map<Module, { runtimeKeys: string[], usedExports: Map<string, string> }>} */
+					const moduleRuntimeInfo = new Map();
+					let hasAsync = false;
+					for (const {
+						module,
+						declaration,
+						exportInfo,
+						localName,
+						mirrored
+					} of candidates) {
+						const runtimes = registeredRuntimes.get(module);
+						const registered =
+							runtimes !== undefined && runtimes.has(runtimeKey);
+						const isAsync = registered && moduleGraph.isAsync(module);
+						const meta = moduleGraph.getMeta(module);
+						// Renaming takes the module's own declaration, which an early use needs in
+						// order to throw and eval() to read, so such a module mirrors each write.
+						const bindings =
+							registered || mirrored
+								? meta.liveSetters || (meta.liveSetters = new Map())
+								: meta.liveBindings || (meta.liveBindings = new Map());
+						for (const name of declaration.names) {
+							let binding = bindings.get(name);
+							if (binding === undefined) {
+								let hoisted = `__webpack_live_${name}__`;
+								for (let i = 1; usedNames.has(hoisted); i++) {
+									hoisted = `__webpack_live_${name}_${i}__`;
+								}
+								usedNames.add(hoisted);
+								binding = {
+									name: hoisted,
+									runtimes: new Set(),
+									registered: new Set()
+								};
+								bindings.set(name, binding);
+							}
+							if (declared.has(binding)) continue;
+							declared.add(binding);
+							binding.runtimes.add(runtimeKey);
+							names.push(binding.name);
+							if (!registered) continue;
+							binding.registered.add(runtimeKey);
+							let runtimeInfo = moduleRuntimeInfo.get(module);
+							if (runtimeInfo === undefined) {
+								runtimeInfo = { runtimeKeys: [], usedExports: new Map() };
+								// Shared chunks generate the module for a union of runtimes;
+								// guarded setters apply when any of them registers this binding.
+								for (const runtime of chunkGraph.getModuleRuntimes(module)) {
+									if (intersectRuntime(runtime, chunk.runtime) === undefined) {
+										continue;
+									}
+									runtimeInfo.runtimeKeys.push(getRuntimeKey(runtime));
+								}
+								const exportsInfo = moduleGraph.getExportsInfo(module);
+								for (const [exportName, specifier] of getModuleLocalExports(
+									module,
+									localExports
+								).specifiers) {
+									// A module that already ran seeds the binding from its first used alias.
+									if (runtimeInfo.usedExports.has(specifier.id)) continue;
+									const usedName = exportsInfo.getUsedName(
+										exportName,
+										chunk.runtime
+									);
+									if (typeof usedName === "string") {
+										runtimeInfo.usedExports.set(specifier.id, usedName);
+									}
+								}
+								moduleRuntimeInfo.set(module, runtimeInfo);
+							}
+							for (const key of runtimeInfo.runtimeKeys) {
+								binding.runtimes.add(key);
+								binding.registered.add(key);
+							}
+							const used = runtimeInfo.usedExports.get(name);
+							hasAsync = hasAsync || isAsync;
+							setters.push([
+								JSON.stringify(chunkGraph.getModuleId(module)),
+								name,
+								binding.name,
+								used === undefined ? false : used,
+								isAsync
+							]);
+						}
+						exports.set(
+							exportInfo,
+							/** @type {LiveBinding} */ (bindings.get(localName)).name
+						);
+					}
+					if (names.length > 0) {
+						chunkLiveExports.set(chunk, { names, exports, setters, hasAsync });
+					}
+				}
+			});
+
 			// The stashed exports source is re-emitted only where the entry is wrapped;
 			// inlined directly, the helpers it pulled in have no reader and can go.
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set) => {
+					const live = chunkLiveExports.get(chunk);
+					if (live && live.setters.length > 0) {
+						set.add(RuntimeGlobals.moduleCache);
+						if (live.hasAsync) {
+							set.add(RuntimeGlobals.asyncModuleExportSymbol);
+						}
+					}
+				}
+			);
+
 			compilation.hooks.additionalChunkRuntimeRequirements.tap(
 				PLUGIN_NAME,
 				(chunk, set, { chunkGraph, codeGenerationResults }) => {
+					const { moduleGraph, runtimeTemplate } = compilation;
 					if (!set.has(RuntimeGlobals.definePropertyGetters)) return;
 					if (chunkGraph.getNumberOfEntryModules(chunk) !== 1) return;
 					if (
@@ -215,6 +514,48 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					if (javascriptHooks.inlineInRuntimeBailout.isUsed()) return;
 
 					const [module] = chunkGraph.getChunkEntryModulesIterable(chunk);
+					if (chunk.hasRuntime()) {
+						// The startup inlines the entry only where nothing else loads with
+						// it: another chunk of the entrypoint delays the execution, and a
+						// module reading the entry needs it in the registry.
+						for (const [
+							,
+							entrypoint
+						] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
+							if (entrypoint && entrypoint.chunks.some((c) => c !== chunk)) {
+								return;
+							}
+						}
+						if (
+							someInIterable(
+								moduleGraph.getIncomingConnectionsByOriginModule(module),
+								([originModule, connections]) =>
+									originModule &&
+									originModule !== module &&
+									connections.some((c) => c.isTargetActive(chunk.runtime)) &&
+									someInIterable(
+										chunkGraph.getModuleRuntimes(originModule),
+										(runtime) =>
+											intersectRuntime(runtime, chunk.runtime) !== undefined
+									)
+							)
+						) {
+							return;
+						}
+					} else if (
+						// A chunk whose runtime is elsewhere lifts its entry to the top
+						// level under the same conditions, and renders it into the module
+						// registry otherwise.
+						JavascriptModulesPlugin._getEsmEntryModuleToInline({
+							chunk,
+							chunkGraph,
+							moduleGraph,
+							runtimeTemplate,
+							codeGenerationResults
+						}) !== module
+					) {
+						return;
+					}
 					const codeGenResult = codeGenerationResults.get(
 						module,
 						chunk.runtime
@@ -243,45 +584,32 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						}
 					}
 
-					// The helpers land in the runtime, not in this chunk, so what still
-					// needs them is asked of every chunk sharing the entrypoint — the
-					// runtime chunk, and whatever `splitChunks` moved out of the entry.
-					/** @type {Set<Chunk>} */
-					const siblings = new Set([chunk]);
-					for (const [
-						,
-						entrypoint
-					] of chunkGraph.getChunkEntryModulesWithChunkGroupIterable(chunk)) {
-						if (!entrypoint) continue;
-						for (const sibling of entrypoint.chunks) siblings.add(sibling);
-					}
-
+					// The entrypoint loads as this chunk alone, so what still needs the
+					// helpers is whatever else it holds beside the entry.
 					let otherNeedsDefine = false;
 					let otherNeedsNamespaceObject = false;
 					let otherNeedsExports = false;
 					let otherNeedsRequireScope = false;
-					outer: for (const sibling of siblings) {
-						for (const m of chunkGraph.getChunkModulesIterable(sibling)) {
-							if (m === module) continue;
-							const requirements = chunkGraph.getModuleRuntimeRequirements(
-								m,
-								sibling.runtime
-							);
-							if (!requirements) continue;
-							if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
-								otherNeedsDefine = true;
-							}
-							if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
-								otherNeedsNamespaceObject = true;
-							}
-							if (requirements.has(RuntimeGlobals.exports)) {
-								otherNeedsExports = true;
-							}
-							if (requirements.has(RuntimeGlobals.requireScope)) {
-								otherNeedsRequireScope = true;
-							}
-							if (otherNeedsDefine) break outer;
+					for (const m of chunkGraph.getChunkModulesIterable(chunk)) {
+						if (m === module) continue;
+						const requirements = chunkGraph.getModuleRuntimeRequirements(
+							m,
+							chunk.runtime
+						);
+						if (!requirements) continue;
+						if (requirements.has(RuntimeGlobals.definePropertyGetters)) {
+							otherNeedsDefine = true;
+						}
+						if (requirements.has(RuntimeGlobals.makeNamespaceObject)) {
+							otherNeedsNamespaceObject = true;
+						}
+						if (requirements.has(RuntimeGlobals.exports)) {
+							otherNeedsExports = true;
 						}
+						if (requirements.has(RuntimeGlobals.requireScope)) {
+							otherNeedsRequireScope = true;
+						}
+						if (otherNeedsDefine) break;
 					}
 
 					if (otherNeedsDefine) return;
@@ -368,7 +696,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 				// Only handle star-reexport statement
 				if (
-					!(dep instanceof HarmonyExportImportedSpecifierDependency) ||
+					dep === null ||
+					!isDependencyKind(dep, "esm-reexport") ||
 					dep.name !== null
 				) {
 					continue;
@@ -382,7 +711,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				) {
 					continue;
 				}
-				if (importedModule instanceof ExternalModule) {
+				if (importedModule.is("external")) {
 					const request = importedModule.getResolvedRequest();
 					if (Array.isArray(request) && request.length > 1) {
 						unsupportedExternals.add(importedModule);
@@ -426,6 +755,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 	 * @param {Module} module module
 	 * @param {ModuleGraph} moduleGraph moduleGraph
 	 * @param {RuntimeSpec} runtime chunk runtime
+	 * @param {CodeGenerationResults} codeGenerationResults the code generation results
 	 * @param {[string, string][]} exports exports
 	 * @param {Set<string>} alreadyRenderedExports already rendered exports
 	 * @returns {ConcatSource} source with null provided exports
@@ -435,6 +765,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		module,
 		moduleGraph,
 		runtime,
+		codeGenerationResults,
 		exports,
 		alreadyRenderedExports
 	) {
@@ -458,7 +789,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 				// Only handle star-reexport statement
 				if (
-					dep instanceof HarmonyExportImportedSpecifierDependency &&
+					dep !== null &&
+					isDependencyKind(dep, "esm-reexport") &&
 					dep.name === null
 				) {
 					const importedModule = connection.resolvedModule;
@@ -472,21 +804,15 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						importedModuleExportsInfo._otherExportsInfo.provided === null
 					) {
 						// Handle export * from 'external'
-						if (importedModule instanceof ExternalModule) {
-							const request = importedModule.getResolvedRequest();
-							// A property path is reported by `_checkStarReexportedExternals`,
-							// and an absent one by the external's own build
-							const specifier =
-								typeof request === "string"
-									? request
-									: Array.isArray(request) && request.length === 1
-										? request[0]
-										: undefined;
-							if (specifier !== undefined) {
-								externalReexports.add(
-									`export * from ${toJsStringLiteral(specifier)}${toAttributesClause(dep.attributes)};\n`
-								);
-							}
+						if (importedModule.is("external")) {
+							const from = codeGenerationResults.has(importedModule, runtime)
+								? codeGenerationResults.getData(
+										importedModule,
+										runtime,
+										"externalReexport"
+									)
+								: undefined;
+							if (from) externalReexports.add(`export * ${from};\n`);
 						} else if (!visitedReexportModules.has(importedModule)) {
 							visitedReexportModules.add(importedModule);
 							resolveDynamicStarReexport(importedModule, true);
@@ -522,7 +848,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		for (const [origin, used] of unknownProvidedExports) {
 			exports.push([
 				origin,
-				used instanceof InlinedUsedName
+				isInlinedUsedName(used)
 					? used.render(
 							Template.toNormalComment(
 								`inlined export ${propertyAccess([origin])}`
@@ -547,12 +873,26 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		const {
 			moduleGraph,
 			chunk,
+			chunkGraph,
 			codeGenerationResults,
 			inlined,
 			inlinedInIIFE,
+			exportsAwaited,
 			runtimeTemplate
 		} = renderContext;
-		let result = new ConcatSource(source);
+		const live = chunkLiveExports.get(chunk);
+		// Declared before the startup runs the module functions assigning them
+		let result = live
+			? new ConcatSource(
+					`${runtimeTemplate.renderLet()} ${live.names.join(", ")};\n`,
+					this._renderLiveExportSetters(live, runtimeTemplate),
+					source
+				)
+			: new ConcatSource(source);
+		// A merged entry exposes what its modules expose together, so the ESM
+		// export list is theirs rather than the last module's alone.
+		const mergedModules = mergedEntryModules(chunk, chunkGraph, compilation);
+		const exportedModules = mergedModules || [module];
 		const exportInfos = options.export
 			? [
 					moduleGraph.getExportInfo(
@@ -560,15 +900,36 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 						Array.isArray(options.export) ? options.export[0] : options.export
 					)
 				]
-			: moduleGraph.getExportsInfo(module).orderedExports;
+			: mergedModules
+				? getMergedExports(
+						mergedModules,
+						moduleGraph,
+						chunk.runtime
+					).exports.map(({ name, module: from }) =>
+						moduleGraph.getExportInfo(from, name)
+					)
+				: moduleGraph.getExportsInfo(module).orderedExports;
 
 		const { data } = codeGenerationResults.get(module, chunk.runtime);
 
 		const isInlinedEntryWithoutIIFE = inlined && !inlinedInIIFE;
-		// Direct export bindings from on-demand concatenation
+		// The binding each export left out on demand reads, exported directly
 		/** @type {Record<string, string>} */
-		const definitions =
+		let definitions =
 			(isInlinedEntryWithoutIIFE && data && data.get("exportsFinalName")) || {};
+		// Inlined beside other modules, the entry's colliding declarations were renamed
+		const { renamedDeclarations } = renderContext;
+		if (renamedDeclarations) {
+			/** @type {Record<string, string>} */
+			const renamed = {};
+			for (const usedName of Object.keys(definitions)) {
+				renamed[usedName] = renameIdentifiers(
+					definitions[usedName],
+					renamedDeclarations
+				);
+			}
+			definitions = renamed;
+		}
 
 		/** @type {string[]} */
 		const shortHandedExports = [];
@@ -594,40 +955,17 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			return name;
 		};
 
-		const isAsync = moduleGraph.isAsync(module);
-
-		const treatAsCommonJs =
-			module.buildMeta &&
-			/** @type {JavascriptModuleBuildMeta} */ (module.buildMeta)
-				.treatAsCommonJs;
-		const skipRenderDefaultExport = Boolean(treatAsCommonJs);
-
-		// A single inlined entry renders at the top level, so its declarations are
-		// bindings that can be exported directly, keeping ESM live bindings rather
-		// than snapshotting them into a `const`.
-		/** @type {Map<string, string> | undefined} */
-		let directBindings;
-		if (isInlinedEntryWithoutIIFE && !treatAsCommonJs) {
-			const topLevelDeclarations =
-				(data && data.get("topLevelDeclarations")) ||
-				(module.buildInfo && module.buildInfo.topLevelDeclarations);
-			if (topLevelDeclarations) {
-				for (const dep of module.dependencies) {
-					if (
-						dep instanceof HarmonyExportSpecifierDependency &&
-						topLevelDeclarations.has(dep.id)
-					) {
-						(directBindings || (directBindings = new Map())).set(
-							dep.name,
-							dep.id
-						);
-					}
-				}
-			}
-		}
+		// A merged entry is awaited in the bootstrap, so the object here is settled.
+		const isAsync = !mergedModules && moduleGraph.isAsync(module);
 
-		const bindingsTakenOver =
-			data !== undefined && data.has("exportsBindingSource");
+		// One ES module among the merged ones still provides a real `default`, and
+		// the synthetic one below would then be a second export of that name.
+		const treatAsCommonJs = exportedModules.every((m) =>
+			Boolean(
+				m.buildMeta &&
+				/** @type {JavascriptModuleBuildMeta} */ (m.buildMeta).treatAsCommonJs
+			)
+		);
 
 		const moduleExportsInfo = moduleGraph.getExportsInfo(module);
 
@@ -642,7 +980,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		let needExportsDeclaration =
 			!isInlinedEntryWithoutIIFE || isAsync || needHarmonyCompatibilityFlag;
 
-		if (isAsync) {
+		// The startup awaits the entry wherever top-level `await` reaches it.
+		if (isAsync && !exportsAwaited) {
 			result.add(
 				`${RuntimeGlobals.exports} = await ${RuntimeGlobals.exports};\n`
 			);
@@ -654,7 +993,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 			const originalName = exportInfo.name;
 			// Skip rendering the default export in some cases
-			if (skipRenderDefaultExport && originalName === "default") continue;
+			if (treatAsCommonJs && originalName === "default") continue;
 
 			// Try to find all exports from the reexported modules
 			const target = exportInfo.getTarget(moduleGraph);
@@ -674,7 +1013,7 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 
 			if (
 				target &&
-				target.module instanceof ExternalModule &&
+				target.module.is("external") &&
 				target.export &&
 				target.export.length === 1 &&
 				codeGenerationResults.has(target.module, chunk.runtime)
@@ -685,7 +1024,8 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 					"externalReexport"
 				);
 				if (reexport) {
-					if (!bindingsTakenOver) needExportsDeclaration = true;
+					// The getter stays in the body, written into the object
+					needExportsDeclaration = true;
 					result.add(
 						`export { ${toExportName(target.export[0])} as ${toExportName(originalName)} } ${reexport};\n`
 					);
@@ -694,28 +1034,25 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 				}
 			}
 
-			// The exports of entry module are never inlined
-			const usedName =
-				/** @type {string} */
-				(exportInfo.getUsedName(originalName, chunk.runtime));
+			// The exports of entry module are never inlined, and a merged exports
+			// object is keyed by the original names rather than the mangled ones.
+			const usedName = mergedModules
+				? originalName
+				: /** @type {string} */
+					(exportInfo.getUsedName(originalName, chunk.runtime));
 			/** @type {string | undefined} */
 			const definition = definitions[usedName];
 			/** @type {string | undefined} */
-			const directLocal =
-				definition === undefined && directBindings
-					? directBindings.get(originalName)
-					: undefined;
-			/** @type {string | undefined} */
 			let finalName;
 
-			if (definition) {
+			const liveName = live && live.exports.get(exportInfo);
+
+			if (liveName) {
+				finalName = liveName;
+				// the body still defines an export it does not leave out on the object
+				if (!definition) needExportsDeclaration = true;
+			} else if (definition) {
 				finalName = definition;
-			} else if (directLocal !== undefined) {
-				// Live binding to the inlined entry's own top-level declaration
-				finalName = directLocal;
-				// The declaration is only there for the definitions written into it; with
-				// those taken over (and not re-emitted here) nothing reads the object.
-				if (!bindingsTakenOver) needExportsDeclaration = true;
 			} else {
 				// Fallback to `__webpack_exports__` property access
 				// when no direct export binding was found
@@ -778,18 +1115,14 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 			module,
 			moduleGraph,
 			chunk.runtime,
+			codeGenerationResults,
 			exports,
 			alreadyRenderedExports
 		);
 
 		for (const [exportName, final] of exports) {
-			if (isDeclarableExportName(exportName)) {
-				result.add(
-					`export ${runtimeTemplate.renderConst()} ${exportName} = ${final};\n`
-				);
-				continue;
-			}
-			// Bind to a generated name, the export name can't be declared
+			// A declaration under the export's own name would shadow a global of that
+			// name every module of the chunk may read, so a generated name binds it.
 			const name = toLocalName(exportName);
 			result.add(
 				`${runtimeTemplate.renderConst()} ${name} = ${final};\nexport { ${name} as ${toExportName(exportName)} };\n`
@@ -803,6 +1136,43 @@ class ModuleLibraryPlugin extends AbstractLibraryPlugin {
 		return result;
 	}
 
+	/**
+	 * Renders the setters through which hot modules, an update included, write the
+	 * bindings the chunk's scope declares; a list per name, as several libraries may.
+	 * A module that ran before the chunk loaded hands over its value through its exports.
+	 * @param {ChunkLiveExports} live the chunk's live bindings
+	 * @param {RuntimeTemplate} runtimeTemplate the runtime template
+	 * @returns {string} the registrations
+	 */
+	_renderLiveExportSetters({ setters, hasAsync }, runtimeTemplate) {
+		if (setters.length === 0) return "";
+		const exports = hasAsync
+			? `(isAsync ? module.exports[${RuntimeGlobals.asyncModuleExportSymbol}] : module.exports)`
+			: "module.exports";
+		const register = "__webpack_live_register__";
+		return Template.asString([
+			`var ${register} = ${runtimeTemplate.basicFunction(
+				hasAsync ? "id, name, set, key, isAsync" : "id, name, set, key",
+				[
+					`var setters = ${RuntimeGlobals.liveExportSetters} = ${RuntimeGlobals.liveExportSetters} || {};`,
+					"setters = setters[id] = setters[id] || {};",
+					"(setters[name] = setters[name] || []).push(set);",
+					`var module = ${RuntimeGlobals.moduleCache}[id];`,
+					// A module still before its declaration throws, and hands the value over later.
+					`if (module && key) try { set(${exports}[key]); } catch (e) {}`
+				]
+			)};`,
+			...setters.map(
+				([id, name, hoisted, used, isAsync]) =>
+					`${register}(${id}, ${JSON.stringify(name)}, ${runtimeTemplate.basicFunction(
+						"value",
+						`${hoisted} = value;`
+					)}${used ? `, ${JSON.stringify(used)}${isAsync ? ", 1" : ""}` : ""});`
+			),
+			""
+		]);
+	}
+
 	/**
 	 * Renders module content.
 	 * @param {Source} source source