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

package/lib/debug/ProfilingPlugin.js

@@ -12,6 +12,7 @@ const {
 	WEBASSEMBLY_MODULES
 } = require("../ModuleTypeConstants");
 const { dirname, mkdirpSync } = require("../util/fs");
+const { fileUrlToPath } = require("../util/identifier");
 
 /** @import { Session } from "inspector" */
 /** @import { FullTap } from "tapable" */
@@ -149,10 +150,9 @@ class Profiler {
 			// Avoid coverage problems due indirect changes
 			/* istanbul ignore next */
 			if (profile.startTime < this._startTime || profile.endTime > endTime) {
-				// In some cases timestamps mismatch and we need to adjust them
-				// Both process.hrtime and the inspector timestamps claim to be relative
-				// to a unknown point in time. But they do not guarantee that this is the
-				// same point in time.
+				// `process.hrtime` and the inspector timestamps are each relative to an
+				// unknown point in time, with no guarantee it is the same point, so the
+				// two are rescaled onto one another here.
 				const duration = profile.endTime - profile.startTime;
 				const ownDuration = endTime - this._startTime;
 				const untracked = Math.max(0, ownDuration - duration);
@@ -258,6 +258,9 @@ class ProfilingPlugin {
 	 * @param {ProfilingPluginOptions=} options options object
 	 */
 	constructor(options = {}) {
+		if (typeof options.outputPath === "string") {
+			options.outputPath = fileUrlToPath(options.outputPath);
+		}
 		/** @type {ProfilingPluginOptions} */
 		this.options = options;
 	}

package/lib/dependencies/AMDDefineDependencyParserPlugin.js

@@ -6,6 +6,7 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
+const { recordOptimizationBailout } = require("../util/buildDiagnostics");
 const AMDDefineDependency = require("./AMDDefineDependency");
 const AMDRequireArrayDependency = require("./AMDRequireArrayDependency");
 const AMDRequireContextDependency = require("./AMDRequireContextDependency");
@@ -35,6 +36,7 @@ const { addLocalModule, getLocalModule } = require("./LocalModulesHelpers");
  * } from "../../declarations/WebpackOptions"
  */
 /** @import Dependency from "../Dependency" */
+/** @import { BuildInfo } from "../Module" */
 /** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
 /**
  * @import JavascriptParser, {
@@ -353,9 +355,10 @@ class AMDDefineDependencyParserPlugin {
 				return;
 		}
 		DynamicExports.bailout(parser.state);
-		parser.state.compilation.moduleGraph
-			.getOptimizationBailout(parser.state.module)
-			.push("AMD bailout: define() prevents static exports analysis");
+		recordOptimizationBailout(
+			/** @type {BuildInfo} */ (parser.state.module.buildInfo),
+			"AMD bailout: define() prevents static exports analysis"
+		);
 		/** @type {Identifier[] | null} */
 		let fnParams = null;
 		let fnParamsOffset = 0;

package/lib/dependencies/AMDRuntimeModules.js

@@ -25,6 +25,15 @@ class AMDDefineRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -58,6 +67,15 @@ class AMDOptionsRuntimeModule extends RuntimeModule {
 		this.options = options;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/dependencies/CommonJsExportRequireDependency.js

@@ -273,23 +273,22 @@ class CommonJsExportRequireDependency extends ModuleDependency {
 		const from = moduleGraph.getConnection(this);
 		if (!from) return;
 		if (esmUnwrap) {
-			// Full re-export `module.exports = require("./esm")` of a module
-			// with a `"module.exports"` named export: the wrapping module's
-			// `module.exports` becomes the unwrapped value, whose own
-			// properties webpack cannot enumerate statically.
+			// In `module.exports = require("./esm")` of a module carrying a
+			// `"module.exports"` export, this module's own exports become the
+			// unwrapped value, whose properties cannot be enumerated statically.
 			return {
 				exports: true,
 				canMangle: false,
 				dependencies: [from.module]
 			};
 		}
-		// The imported namespace ESM hasn't been flagged by
-		// FlagDependencyExportsPlugin yet (no exports determined), so its
-		// `"module.exports"` unwrap eligibility is still unknown. Star-reexporting
-		// now would add `__esModule` (and names) the monotonic merge can't retract
-		// once the module turns out to unwrap, making the result order-dependent
-		// across runtimes; defer — the `from.module` dependency re-queues us once
-		// its exports (owned names, or dynamic `other`) become known.
+		// WHY: the imported namespace ESM has not been flagged by
+		// FlagDependencyExportsPlugin yet, so its `"module.exports"` unwrap
+		// eligibility is still unknown. Star-reexporting now would add `__esModule`,
+		// and names, that the monotonic merge cannot retract once the module turns
+		// out to unwrap, making the result order-dependent across runtimes. Deferring
+		// is safe: the `from.module` dependency re-queues this once its exports —
+		// owned names, or a dynamic `other` — become known.
 		if (
 			importedModule &&
 			importedModule.getExportsType(moduleGraph, false) === "namespace"
@@ -528,7 +527,9 @@ CommonJsExportRequireDependency.Template = class CommonJsExportRequireDependency
 				: ids;
 			requireExpr = concatenationScope.createModuleReference(importedModule, {
 				ids: requestedIds.length > 0 ? requestedIds : undefined,
-				asiSafe: true,
+				// a used reexport keeps its assignment, so only an unused one is
+				// left standing where the original statement began
+				asiSafe: used ? true : dep.asiSafe,
 				moduleExportsAccess: true
 			});
 		} else {

package/lib/dependencies/CommonJsExportsParserPlugin.js

@@ -7,6 +7,7 @@
 
 const RuntimeGlobals = require("../RuntimeGlobals");
 const { evaluateToString } = require("../javascript/JavascriptParserHelpers");
+const { recordOptimizationBailout } = require("../util/buildDiagnostics");
 const formatLocation = require("../util/formatLocation");
 const { propertyAccess } = require("../util/property");
 const CommonJsExportRequireDependency = require("./CommonJsExportRequireDependency");
@@ -38,7 +39,7 @@ const FUNCTION_PROPERTY_DROP_HEAD =
  * } from "estree"
  */
 /** @import { ExportInfoName } from "../Dependency" */
-/** @import ModuleGraph from "../ModuleGraph" */
+/** @import { BuildInfo } from "../Module" */
 /** @import BasicEvaluatedExpression from "../javascript/BasicEvaluatedExpression" */
 /**
  * @import JavascriptParser, {
@@ -357,15 +358,6 @@ const getObjectExportKind = (property) => {
 const PLUGIN_NAME = "CommonJsExportsParserPlugin";
 
 class CommonJsExportsParserPlugin {
-	/**
-	 * Creates an instance of CommonJsExportsParserPlugin.
-	 * @param {ModuleGraph} moduleGraph module graph
-	 */
-	constructor(moduleGraph) {
-		/** @type {ModuleGraph} */
-		this.moduleGraph = moduleGraph;
-	}
-
 	/**
 	 * Applies the plugin by registering its hooks on the compiler.
 	 * @param {JavascriptParser} parser the parser
@@ -406,9 +398,10 @@ class CommonJsExportsParserPlugin {
 		 * @param {string} reason reason
 		 */
 		const bailoutHint = (reason) => {
-			this.moduleGraph
-				.getOptimizationBailout(parser.state.module)
-				.push(`CommonJS bailout: ${reason}`);
+			recordOptimizationBailout(
+				/** @type {BuildInfo} */ (parser.state.module.buildInfo),
+				`CommonJS bailout: ${reason}`
+			);
 		};
 		/** @type {unknown} */
 		let keptAllExportsForState;
@@ -479,6 +472,9 @@ class CommonJsExportsParserPlugin {
 					requireCall.ids,
 					!parser.isStatementLevelExpression(expr)
 				);
+				dep.asiSafe = !parser.isAsiPosition(
+					/** @type {Range} */ (expr.range)[0]
+				);
 				dep.loc = parser.getLocation(expr);
 				dep.optional = Boolean(parser.scope.inTry);
 				parser.state.module.addDependency(dep);
@@ -670,6 +666,9 @@ class CommonJsExportsParserPlugin {
 							false
 						);
 						dep.getter = reexport.getter;
+						dep.asiSafe = !parser.isAsiPosition(
+							/** @type {Range} */ (expr.range)[0]
+						);
 						dep.loc = parser.getLocation(expr);
 						dep.optional = Boolean(parser.scope.inTry);
 						parser.state.module.addDependency(dep);

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -212,6 +212,7 @@ const createRequireCallHandler = (
 				/** @type {Range} */ (expr.range)
 			);
 			if (binding) binding.dep = dep;
+			dep.asiSafe = !parser.isAsiPosition(/** @type {Range} */ (expr.range)[0]);
 			dep.loc = parser.getLocation(expr);
 			dep.optional = Boolean(parser.scope.inTry);
 			parser.state.current.addDependency(dep);
@@ -737,11 +738,10 @@ class CommonJsImportsParserPlugin {
 		// #endregion
 
 		// #region Require bound to a const variable
-		// Track `const NAME = require(LITERAL)` so that static member accesses on
-		// `NAME` (e.g. `NAME.foo`, `NAME.foo()`) are forwarded to the same
-		// `CommonJsRequireDependency` as referenced exports — enabling tree
-		// shaking of CommonJS modules that are imported into a named binding
-		// rather than destructured.
+
+		// Track `const NAME = require(LITERAL)`, so a static member access on `NAME`
+		// forwards to the same dependency as a referenced export and a CommonJS
+		// module bound to a name still tree-shakes.
 		parser.hooks.preDeclarator.tap(PLUGIN_NAME, (declarator, statement) => {
 			if (statement.kind !== "const") return;
 			if (declarator.id.type !== "Identifier") return;

package/lib/dependencies/CommonJsPlugin.js

@@ -254,9 +254,7 @@ class CommonJsPlugin {
 					);
 
 					new CommonJsImportsParserPlugin(parserOptions).apply(parser);
-					new CommonJsExportsParserPlugin(compilation.moduleGraph).apply(
-						parser
-					);
+					new CommonJsExportsParserPlugin().apply(parser);
 				};
 
 				normalModuleFactory.hooks.parser
@@ -285,6 +283,15 @@ class HarmonyModuleDecoratorRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code
@@ -326,6 +333,15 @@ class NodeModuleDecoratorRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/dependencies/CommonJsRequireDependency.js

@@ -36,8 +36,8 @@ const ModuleDependency = require("./ModuleDependency");
 /** @import { UsedByExports } from "../optimize/InnerGraph" */
 /** @import { RuntimeSpec } from "../util/runtime" */
 /** @import { DependencyGuard } from "./HarmonyImportGuard" */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined]>} ObjectSerializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined, boolean | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[RawReferencedExports | null, Range | undefined, DependencyGuard[] | undefined, boolean, boolean, UsedByExports | undefined, boolean | undefined]>} ObjectSerializerContext */
 
 /**
  * Trims a member-access path at the first segment that is definitively not a
@@ -93,6 +93,10 @@ class CommonJsRequireDependency extends ModuleDependency {
 		// `new require(...)`; see the template for the return-value rule
 		/** @type {boolean} */
 		this.callNew = false;
+		// whether the position the call sits at cannot be joined to what precedes
+		// it by ASI; only meaningful once the call renders as a module reference
+		/** @type {boolean | undefined} */
+		this.asiSafe = undefined;
 	}
 
 	get type() {
@@ -226,7 +230,8 @@ class CommonJsRequireDependency extends ModuleDependency {
 			.write(this.branchGuards)
 			.write(this._canConcatenate)
 			.write(this.callNew)
-			.write(this.usedByExports);
+			.write(this.usedByExports)
+			.write(this.asiSafe);
 		super.serialize(context);
 	}
 
@@ -246,7 +251,9 @@ class CommonJsRequireDependency extends ModuleDependency {
 		this.callNew = c4.read();
 		const c5 = c4.rest;
 		this.usedByExports = c5.read();
-		super.deserialize(c5.rest);
+		const c6 = c5.rest;
+		this.asiSafe = c6.read();
+		super.deserialize(c6.rest);
 	}
 }
 
@@ -303,7 +310,9 @@ CommonJsRequireDependency.Template = class CommonJsRequireDependencyTemplate ext
 					ids: isRequireEsmModuleExportsModule(connection.module, moduleGraph)
 						? [ESM_MODULE_EXPORTS_NAME]
 						: undefined,
-					asiSafe: true,
+					// `new` wraps the reference in a call, so only a plain
+					// replacement inherits the original call's position
+					asiSafe: dep.callNew ? true : dep.asiSafe,
 					moduleExportsAccess: true
 				}
 			);

package/lib/dependencies/CommonJsSelfReferenceDependency.js

@@ -207,10 +207,8 @@ CommonJsSelfReferenceDependency.Template = class CommonJsSelfReferenceDependency
 		}
 
 		if (base === dep.base && equals(used, dep.names)) {
-			// Nothing has to be changed
-			// We don't use a replacement for compat reasons
-			// for plugins that update `module._source` which they
-			// shouldn't do!
+			// Nothing has to change, and no replacement is emitted: plugins that
+			// update `module._source`, which they should not, depend on that.
 			return;
 		}
 

package/lib/dependencies/ContextDependency.js

@@ -15,7 +15,7 @@ const getCriticalDependencyWarning = memoize(() =>
 );
 
 /** @import { Range } from "../javascript/JavascriptParser" */
-/** @import { ContextOptions } from "../ContextModule" */
+/** @import { ContextOptions } from "../context/ContextModule" */
 /** @import { TRANSITIVE } from "../Dependency" */
 /** @import ModuleGraph from "../ModuleGraph" */
 /** @import WebpackError from "../errors/WebpackError" */

package/lib/dependencies/ContextDependencyHelpers.js

@@ -107,15 +107,9 @@ module.exports.create = (
 				)
 				.join("");
 
-		// Example: `./context/pre${e}inner${e}inner2${e}post?query#frag`
-		// context: "./context"
-		// prefix: "./pre"
-		// innerQuasis: [BEE("inner"), BEE("inner2")]
-		// (BEE = BasicEvaluatedExpression)
-		// postfix: "post"
-		// query: "?query"
-		// fragment: "#frag"
-		// regExp: /^\.\/pre.*inner.*inner2.*post$/
+		// The template's quasis become the literal anchors of the regexp and its
+		// expressions the gaps between them, so `./context/pre${e}inner${e}post`
+		// matches `/^\.\/pre.*inner.*post$/` under the context `./context`.
 		const regExp = new RegExp(
 			`^${quoteMeta(prefix)}${innerRegExp}${quoteMeta(postfix)}$`
 		);

package/lib/dependencies/ContextElementDependency.js

@@ -9,7 +9,7 @@ const Dependency = require("../Dependency");
 const makeSerializable = require("../util/makeSerializable");
 const ModuleDependency = require("./ModuleDependency");
 
-/** @import ContextModule from "../ContextModule" */
+/** @import ContextModule from "../context/ContextModule" */
 /** @import { RawReferencedExports, ReferencedExports } from "../Dependency" */
 /** @import Module from "../Module" */
 /** @import ModuleGraph from "../ModuleGraph" */

package/lib/dependencies/CssIcssExportDependency.js

@@ -370,10 +370,9 @@ class CssIcssExportDependency extends NullDependency {
 	 * @returns {ReferencedExports} referenced exports
 	 */
 	getReferencedExports(moduleGraph, runtime) {
-		// `composes: foo;` (SELF_REFERENCE) references the composed class
-		// (`entry.value`), not the composing class. Every other entry mode
-		// keeps the whole exports object referenced (legacy behaviour), so the
-		// presence of any such entry subsumes the self-reference names.
+		// `composes: foo;` references the composed class, not the composing one.
+		// Every other entry mode references the whole exports object, so one such
+		// entry subsumes the self-reference names.
 		let hasNonSelfReference = false;
 		/** @type {ReferencedExports} */
 		const referenced = [];
@@ -850,10 +849,9 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 		if (!entry.interpolate) return value;
 		const { moduleGraph, module, chunkGraph, runtimeTemplate } =
 			templateContext;
-		// Key order is by rising cardinality: `moduleGraph.cached` is a trie that
-		// allocates a node per level per new prefix, so the per-export `value` goes
-		// last — otherwise every export name forks the trie and re-allocates the
-		// three elements below it, which are constant for the whole compilation.
+		// Keys are ordered by rising cardinality, since `moduleGraph.cached` is a
+		// trie allocating a node per level per prefix: the per-export `value` last,
+		// or every name forks the trie above the parts constant for the build.
 		return moduleGraph.cached(
 			computeInterpolatedIdentifier,
 			/** @type {CssModule} */ (module),
@@ -916,7 +914,13 @@ CssIcssExportDependency.Template = class CssIcssExportDependencyTemplate extends
 			}
 
 			if (entry.exportType === EXPORT_TYPE.GRID_CUSTOM_IDENTIFIER) {
-				value += `-${entry.name}`;
+				// The suffix names what the identifier was built from, so it follows a
+				// `@value` to its resolved name — both spellings select the same line.
+				value += `-${
+					isReference
+						? /** @type {string[]} */ (entry.value)[0]
+						: /** @type {string} */ (entry.value)
+				}`;
 			}
 
 			if (isJs && entry.exportMode !== EXPORT_MODE.NONE) {

package/lib/dependencies/CssIcssImportDependency.js

@@ -100,12 +100,9 @@ class CssIcssImportDependency extends CssImportDependency {
 
 		if (!module) return null;
 
-		// The target module stores exports under the names produced by its
-		// `exportsConvention`, so a raw `isExportProvided(this.importName)`
-		// would false-positive against `camel-case-only` / `dashes-only` (and
-		// any custom function that drops the original spelling). Expand
-		// `importName` through the *target* module's convention and accept
-		// if any alias is provided.
+		// The target stores exports under its own `exportsConvention`, so asking for
+		// the raw name misses under `camel-case-only` or any convention dropping the
+		// original spelling. Expand through that convention and accept any alias.
 		const generator =
 			/** @type {CssGenerator | undefined} */
 			(module.generator);

package/lib/dependencies/CssUrlDependency.js

@@ -84,11 +84,9 @@ class CssUrlDependency extends ModuleDependency {
 	 * @returns {void}
 	 */
 	updateHash(hash, context) {
-		// The dependency template substitutes the referenced asset's hashed
-		// filename into the rendered CSS at code-generation time. Folding the
-		// asset module's content hash into the dependency hash ensures the
-		// CSS module's hash invalidates — and the CSS chunk's contenthash
-		// updates — whenever the referenced asset's content changes.
+		// The template substitutes the asset's hashed filename into the rendered CSS,
+		// so folding that asset's content hash in here is what makes the CSS module's
+		// hash, and the chunk's contenthash, follow the asset.
 		const { chunkGraph } = context;
 		const module = chunkGraph.moduleGraph.getModule(this);
 		if (!module) return;

package/lib/dependencies/HarmonyCompatibilityDependency.js

@@ -13,15 +13,18 @@ const makeSerializable = require("../util/makeSerializable");
 const memoize = require("../util/memoize");
 const NullDependency = require("./NullDependency");
 
-// Required here rather than at the top: the plugin reaches back into the dependencies.
-const getJavascriptModulesPlugin = memoize(() =>
-	require("../javascript/JavascriptModulesPlugin")
+// Required here rather than at the top: the deferred-namespace runtime imports
+// dependencies from here.
+const getDeferredCycleHelpers = memoize(() =>
+	require("../runtime/MakeDeferredNamespaceObjectRuntime")
 );
 
 /** @import { ReplaceSource } from "webpack-sources" */
 /** @import Dependency from "../Dependency" */
 /** @import { DependencyTemplateContext } from "../DependencyTemplate" */
-/** @import { BuildMeta } from "../Module" */
+/** @import Module, { BuildMeta } from "../Module" */
+/** @import ModuleGraph from "../ModuleGraph" */
+/** @import ChunkGraph, { ModuleId } from "../ChunkGraph" */
 /**
  * @import {
  * 	JavascriptModuleBuildInfo
@@ -39,6 +42,39 @@ makeSerializable(
 	"webpack/lib/dependencies/HarmonyCompatibilityDependency"
 );
 
+/**
+ * Key shared by the async modules of one strongly-connected component. The spec
+ * records one `[[EvaluationError]]` per component, so a member that already
+ * fulfilled still has to report the root's error afterwards.
+ * @param {ModuleGraph} moduleGraph the module graph
+ * @param {ChunkGraph} chunkGraph the chunk graph
+ * @param {Module} module the async module
+ * @returns {ModuleId | null} the group key, or null when it is not in an async cycle
+ */
+const getAsyncCycleGroupId = (moduleGraph, chunkGraph, module) => {
+	const { getDeferredCycleModules } = getDeferredCycleHelpers();
+	const peers = getDeferredCycleModules(moduleGraph, module);
+	if (peers === null) return null;
+	// The component's smallest async member id names the group, so every member
+	// emits the same key and none has to carry the whole peer list.
+	let groupId = null;
+	let asyncPeerCount = 0;
+	for (const peer of peers) {
+		if (!moduleGraph.isAsync(peer)) continue;
+		asyncPeerCount++;
+		const id = chunkGraph.getModuleId(peer);
+		if (id !== null && (groupId === null || `${id}` < `${groupId}`)) {
+			groupId = id;
+		}
+	}
+	if (asyncPeerCount === 0) return null;
+	const ownId = chunkGraph.getModuleId(module);
+	if (ownId !== null && (groupId === null || `${ownId}` < `${groupId}`)) {
+		groupId = ownId;
+	}
+	return groupId;
+};
+
 HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate extends (
 	NullDependency.Template
 ) {
@@ -56,10 +92,12 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 			module,
 			runtimeTemplate,
 			moduleGraph,
+			chunkGraph,
 			initFragments,
 			runtimeRequirements,
 			runtime,
-			concatenationScope
+			concatenationScope,
+			getData
 		}
 	) {
 		// a wrapped module has a real exports object that still needs `__esModule`
@@ -73,20 +111,13 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 				exportsArgument: module.exportsArgument,
 				runtimeRequirements
 			});
-			// A library exporting the same bindings natively never reads the marker back
-			// off the exports object, so it takes the call over and emits it where wrapped.
-			const hooks = getJavascriptModulesPlugin().getCompilationHooks(
-				runtimeTemplate.compilation
-			);
-			const takenOver =
-				hooks.onDemandExportsGeneration.isUsed() &&
-				hooks.onDemandExportsGeneration.call(
-					module,
-					runtime,
-					content,
-					false
-				) === true;
-			if (!takenOver) {
+
+			const meta = moduleGraph.getMetaIfExisting(module);
+			if (!concatenationScope && meta && meta.onDemandExports && getData) {
+				const data = getData();
+				const before = data.get("exportsSource");
+				data.set("exportsSource", before ? `${before}${content}` : content);
+			} else {
 				initFragments.push(
 					new InitFragment(
 						content,
@@ -99,9 +130,23 @@ HarmonyCompatibilityDependency.Template = class HarmonyExportDependencyTemplate
 		}
 		if (moduleGraph.isAsync(module)) {
 			runtimeRequirements.add(RuntimeGlobals.module);
-			const hasAwait = /** @type {BuildMeta} */ (module.buildMeta).async
-				? ", 1"
-				: "";
+			// Only `strictModuleErrorHandling` keeps a recorded error for later
+			// requires, so the component's peers are worth naming only then.
+			const cycleGroupId = runtimeTemplate.outputOptions
+				.strictModuleErrorHandling
+				? getAsyncCycleGroupId(moduleGraph, chunkGraph, module)
+				: null;
+			// The group is keyed by module id, so the runtime needs `module.id`.
+			if (cycleGroupId !== null) {
+				runtimeRequirements.add(RuntimeGlobals.moduleId);
+			}
+			const isAsyncBody = /** @type {BuildMeta} */ (module.buildMeta).async;
+			const hasAwait =
+				cycleGroupId === null
+					? isAsyncBody
+						? ", 1"
+						: ""
+					: `, ${isAsyncBody ? 1 : 0}, ${JSON.stringify(cycleGroupId)}`;
 			// A module-scope `await using` is disposed when its scope ends, so the body
 			// needs a block that closes before the module reports completion —
 			// otherwise dependents run before disposal is awaited.

package/lib/dependencies/HarmonyDetectionParserPlugin.js

@@ -109,10 +109,9 @@ module.exports = class HarmonyDetectionParserPlugin {
 			}
 		});
 
-		// Using `import.meta` only parses as a module, so it marks the module ESM.
-		// Non-bailing; staged before the bailing DefinePlugin and ImportMetaPlugin
-		// replacement taps so it observes every access; unknown members go
-		// through `unhandledExpressionMemberChain`.
+		// `import.meta` parses only as a module, so it marks this one ESM. Staged
+		// before the bailing DefinePlugin and ImportMetaPlugin taps, so it observes
+		// every access without ending the chain.
 		const onImportMeta = () => {
 			enableHarmony(false);
 		};

package/lib/dependencies/HarmonyExportDependencyParserPlugin.js

@@ -112,10 +112,8 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 			return true;
 		});
 		// `export default <namespace binding>` is the same export as
-		// `export { ns as default }`, so it is claimed here and rewritten into the
-		// same re-export. Stage -10 runs before the inner-graph tap, which would
-		// otherwise wrap the identifier in a pure-expression guard whose insertions
-		// outlive the statement this removes.
+		// `export { ns as default }`, so it becomes the same re-export. Stage -10
+		// beats the inner-graph tap, whose guard would outlive the removed statement.
 		parser.hooks.statement.tap(
 			{ name: PLUGIN_NAME, stage: -10 },
 			(statement) => {
@@ -218,14 +216,19 @@ module.exports = class HarmonyExportDependencyParserPlugin {
 						: undefined,
 				constValue
 			);
+			const isAnonymousClass =
+				(node.type === "ClassDeclaration" || node.type === "ClassExpression") &&
+				!node.id;
 			dep.isAnonymousDefault =
 				this.options.anonymousDefaultExportName !== false &&
 				(node.type === "ArrowFunctionExpression" ||
+					isAnonymousClass ||
 					((node.type === "FunctionDeclaration" ||
-						node.type === "FunctionExpression" ||
-						node.type === "ClassDeclaration" ||
-						node.type === "ClassExpression") &&
+						node.type === "FunctionExpression") &&
 						!node.id));
+			// A class observes its own name from a static initializer, which runs
+			// before the name could be patched afterwards, so it is named in place.
+			dep.isAnonymousDefaultClass = dep.isAnonymousDefault && isAnonymousClass;
 			dep.setLocWithIndex(parser.getLocation(statement), -1);
 			parser.state.current.addDependency(dep);
 			getInnerGraphUtils(parser.state.compilation).addVariableUsage(