webpack 5.108.3 → 5.109.0

package/lib/dependencies/WorkerDependency.js

@@ -12,6 +12,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Chunk")} Chunk */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
@@ -23,12 +24,23 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../util/Hash")} Hash */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 
+/**
+ * @typedef {object} ResourceHint
+ * @property {true=} prefetch emit `<link rel="prefetch">`
+ * @property {true=} preload emit `<link rel="preload">` (wins over prefetch when both are set)
+ * @property {("high" | "low" | "auto")=} fetchPriority value for the `fetchpriority` attribute
+ * @property {string=} as override for the `as` attribute (defaults to `"script"`)
+ * @property {string=} type value for the `type` attribute
+ * @property {string=} media value for the `media` attribute
+ */
+
 /**
  * Represents the worker dependency runtime component.
  * @typedef {object} WorkerDependencyOptions
  * @property {string=} publicPath public path for the worker
  * @property {boolean=} needNewUrl true when need generate `new URL(...)`, otherwise false
  * @property {Range=} workerConstructorRange range of the global `Worker` constructor, set only for the `new Worker()` global syntax that needs a node-target rewrite
+ * @property {ResourceHint=} resourceHint resource hint to inject for the worker chunk
  */
 
 class WorkerDependency extends ModuleDependency {
@@ -120,24 +132,77 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			chunkGraph.getBlockChunkGroup(block)
 		);
 		const chunk = entrypoint.getEntrypointChunk();
-		// We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
-		const workerImportBaseUrl = dep.options.publicPath
-			? `"${dep.options.publicPath}"`
-			: RuntimeGlobals.publicPath;
-
-		runtimeRequirements.add(RuntimeGlobals.publicPath);
-		runtimeRequirements.add(RuntimeGlobals.baseURI);
-		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
-
-		const workerImportStr = `/* worker import */ ${workerImportBaseUrl} + ${
-			RuntimeGlobals.getChunkScriptFilename
-		}(${JSON.stringify(chunk.id)}), ${RuntimeGlobals.baseURI}`;
-
-		source.replace(
-			dep.range[0],
-			dep.range[1] - 1,
-			dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
-		);
+
+		// For ESM module output emit the analyzable `new URL("./worker.<name>.js",
+		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
+		// and webpack itself can statically follow the worker. Resource-hint workers keep
+		// the runtime form because the hint needs the runtime chunk reference.
+		const analyzableSpecifier =
+			!dep.options.resourceHint && runtimeTemplate.supportsAnalyzableEsm()
+				? runtimeTemplate._getAnalyzableChunkSpecifier(
+						dep.options.publicPath,
+						chunk,
+						templateContext.module,
+						chunkGraph
+					)
+				: null;
+
+		if (analyzableSpecifier !== null) {
+			const urlArgs = `/* worker import */ ${analyzableSpecifier}, ${runtimeTemplate.outputOptions.importMetaName}.url`;
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				dep.options.needNewUrl ? `new URL(${urlArgs})` : urlArgs
+			);
+		} else {
+			// We use the workerPublicPath option if provided, else we fallback to the RuntimeGlobal publicPath
+			const workerImportBaseUrl = dep.options.publicPath
+				? `"${dep.options.publicPath}"`
+				: RuntimeGlobals.publicPath;
+
+			runtimeRequirements.add(RuntimeGlobals.publicPath);
+			runtimeRequirements.add(RuntimeGlobals.baseURI);
+			runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+			const hrefExpr = `${workerImportBaseUrl} + ${
+				RuntimeGlobals.getChunkScriptFilename
+			}(${JSON.stringify(chunk.id)})`;
+
+			const hint = dep.options.resourceHint;
+			const rel =
+				hint && hint.preload
+					? "preload"
+					: hint && hint.prefetch
+						? "prefetch"
+						: null;
+			let wrappedHref;
+			if (rel && hint) {
+				const fn =
+					rel === "preload"
+						? RuntimeGlobals.preloadAsset
+						: RuntimeGlobals.prefetchAsset;
+				runtimeRequirements.add(fn);
+				const as = hint.as || "script";
+				const args = [
+					hrefExpr,
+					JSON.stringify(as),
+					hint.type ? JSON.stringify(hint.type) : "undefined",
+					hint.media ? JSON.stringify(hint.media) : "undefined",
+					hint.fetchPriority ? JSON.stringify(hint.fetchPriority) : "undefined"
+				];
+				wrappedHref = `${fn}(${args.join(", ")})`;
+			} else {
+				wrappedHref = hrefExpr;
+			}
+
+			const workerImportStr = `/* worker import */ ${wrappedHref}, ${RuntimeGlobals.baseURI}`;
+
+			source.replace(
+				dep.range[0],
+				dep.range[1] - 1,
+				dep.options.needNewUrl ? `new URL(${workerImportStr})` : workerImportStr
+			);
+		}
 
 		// `Worker` is global only on the web, so route node (universal or node-only) through `worker_threads`
 		const { platform } = runtimeTemplate.compilation.compiler;
@@ -146,6 +211,9 @@ WorkerDependency.Template = class WorkerDependencyTemplate extends (
 			ctorRange &&
 			(runtimeTemplate.isUniversalTarget() || (platform.node && !platform.web))
 		) {
+			// `__webpack_require__.wc` attaches to `__webpack_require__`; the analyzable
+			// branch adds no other requirement that would emit it, so require it here.
+			runtimeRequirements.add(RuntimeGlobals.require);
 			runtimeRequirements.add(RuntimeGlobals.worker);
 			source.replace(ctorRange[0], ctorRange[1] - 1, RuntimeGlobals.worker);
 		}

package/lib/dependencies/WorkletDependency.js

@@ -0,0 +1,278 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author sheo13666q
+*/
+
+"use strict";
+
+const Dependency = require("../Dependency");
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const makeSerializable = require("../util/makeSerializable");
+const ModuleDependency = require("./ModuleDependency");
+
+/** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
+/** @typedef {import("../AsyncDependenciesBlock")} AsyncDependenciesBlock */
+/** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
+/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
+/** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
+/** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../javascript/JavascriptParser").Range} Range */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[WorkletDependencyOptions, Range]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[WorkletDependencyOptions, Range]>} ObjectSerializerContext */
+/** @typedef {import("../util/Hash")} Hash */
+/** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+
+/**
+ * @typedef {object} WorkletDependencyOptions
+ * @property {string=} publicPath public path for the worklet
+ */
+
+// The wrapper param forwarded as the module argument to the original `addModule`.
+const WORKLET_MODULE = "__webpack_worklet_module__";
+
+class WorkletDependency extends ModuleDependency {
+	/**
+	 * Creates an instance of WorkletDependency.
+	 * @param {string} request request
+	 * @param {Range} range range of the zero-width insertion point (before the call)
+	 * @param {Range} callRange range of the call argument list `(<url>)`
+	 * @param {WorkletDependencyOptions} workletDependencyOptions options
+	 */
+	constructor(request, range, callRange, workletDependencyOptions) {
+		super(request);
+		this.range = range;
+		/** @type {Range} */
+		this.callRange = callRange;
+		// If options are updated, don't forget to update the hash and serialization functions
+		/** @type {WorkletDependencyOptions} */
+		this.options = workletDependencyOptions;
+		/** Cache the hash */
+		/** @type {undefined | string} */
+		this._hashUpdate = undefined;
+	}
+
+	/**
+	 * Returns list of exports referenced by this dependency
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @param {RuntimeSpec} runtime the runtime for which the module is analysed
+	 * @returns {ReferencedExports} referenced exports
+	 */
+	getReferencedExports(moduleGraph, runtime) {
+		return Dependency.NO_EXPORTS_REFERENCED;
+	}
+
+	get type() {
+		return "Worklet.addModule()";
+	}
+
+	get category() {
+		return "worker";
+	}
+
+	/**
+	 * 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) {
+		if (this._hashUpdate === undefined) {
+			this._hashUpdate = JSON.stringify(this.options);
+		}
+		hash.update(this._hashUpdate);
+	}
+
+	/**
+	 * Serializes this instance into the provided serializer context.
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(context) {
+		context.write(this.options).write(this.callRange);
+		super.serialize(context);
+	}
+
+	/**
+	 * Restores this instance from the provided deserializer context.
+	 * @param {ObjectDeserializerContext} context context
+	 */
+	deserialize(context) {
+		this.options = context.read();
+		const rest = context.rest;
+		this.callRange = rest.read();
+		super.deserialize(rest.rest);
+	}
+}
+
+WorkletDependency.Template = class WorkletDependencyTemplate extends (
+	ModuleDependency.Template
+) {
+	/**
+	 * Applies the plugin by registering its hooks on the compiler.
+	 * @param {Dependency} dependency the dependency for which the template should be applied
+	 * @param {ReplaceSource} source the current replace source which can be modified
+	 * @param {DependencyTemplateContext} templateContext the context object
+	 * @returns {void}
+	 */
+	apply(dependency, source, templateContext) {
+		const {
+			module,
+			chunkGraph,
+			moduleGraph,
+			runtimeRequirements,
+			runtimeTemplate
+		} = templateContext;
+		const dep = /** @type {WorkletDependency} */ (dependency);
+		const block = /** @type {AsyncDependenciesBlock} */ (
+			moduleGraph.getParentBlock(dependency)
+		);
+		const entrypoint = /** @type {Entrypoint} */ (
+			chunkGraph.getBlockChunkGroup(block)
+		);
+
+		const entryChunk = entrypoint.getEntrypointChunk();
+		const runtimeChunk = entrypoint.getRuntimeChunk();
+		const referencedChunks = entryChunk.getAllReferencedChunks();
+		const runtimeChunkId =
+			runtimeChunk && runtimeChunk.id !== null ? runtimeChunk.id : null;
+
+		// For ESM module output emit the analyzable `new URL("./worklet.<name>.js",
+		// import.meta.url)` form (literal specifier, no runtime helpers) so other bundlers
+		// and webpack itself can statically follow the worklet. The worklet chunk links its
+		// splits via native `import`, so only the entry chunk is referenced.
+		const analyzableSpecifier =
+			runtimeTemplate.supportsAnalyzableEsm() && entryChunk.id !== null
+				? runtimeTemplate._getAnalyzableChunkSpecifier(
+						dep.options.publicPath,
+						entryChunk,
+						module,
+						chunkGraph
+					)
+				: null;
+		if (analyzableSpecifier !== null) {
+			source.replace(
+				dep.callRange[0],
+				dep.callRange[1] - 1,
+				`(new URL(/* worklet import */ ${analyzableSpecifier}, ${runtimeTemplate.outputOptions.importMetaName}.url))`
+			);
+			return;
+		}
+
+		const workletImportBaseUrl = dep.options.publicPath
+			? JSON.stringify(dep.options.publicPath)
+			: RuntimeGlobals.publicPath;
+
+		runtimeRequirements.add(RuntimeGlobals.publicPath);
+		runtimeRequirements.add(RuntimeGlobals.baseURI);
+		runtimeRequirements.add(RuntimeGlobals.getChunkScriptFilename);
+
+		/**
+		 * @param {string | number} id chunk id
+		 * @returns {string} `new URL(...)` expression for the chunk file
+		 */
+		const toUrl = (id) =>
+			`new URL(${workletImportBaseUrl} + ${
+				RuntimeGlobals.getChunkScriptFilename
+			}(${JSON.stringify(id)}), ${RuntimeGlobals.baseURI})`;
+
+		// Module output: the worklet chunk is an ES module that links its split
+		// chunks via native `import`, which `addModule` resolves — so add just the
+		// entry chunk, with no worker-scope shim and no chunk pre-loading.
+		if (runtimeTemplate.isModule() && entryChunk.id !== null) {
+			source.replace(
+				dep.callRange[0],
+				dep.callRange[1] - 1,
+				`(${toUrl(entryChunk.id)})`
+			);
+			return;
+		}
+
+		// Fast path: a self-contained worklet (a single chunk, no splits or async
+		// `import()`) needs no chunk-loading runtime and no worker-scope shim, so the
+		// chunk is `addModule`-d directly with no bootstrap.
+		if (referencedChunks.size === 1 && runtimeChunkId !== null) {
+			source.replace(
+				dep.callRange[0],
+				dep.callRange[1] - 1,
+				`(${toUrl(runtimeChunkId)})`
+			);
+			return;
+		}
+
+		// A worklet can't load chunks at runtime, so every reachable chunk (initial
+		// splits and async `import()` targets alike) is pre-added via `addModule`
+		// from the calling scope. The runtime chunk is added last so it installs the
+		// chunks pushed before it and runs entry startup with every module present
+		// (see ImportScriptsChunkLoadingRuntimeModule).
+		/** @type {(string | number)[]} */
+		const restChunkIds = [];
+		for (const chunk of referencedChunks) {
+			if (chunk !== runtimeChunk && chunk.id !== null) {
+				restChunkIds.push(chunk.id);
+			}
+		}
+
+		runtimeRequirements.add(RuntimeGlobals.getWorkletBootstrap);
+
+		const add = "__webpack_worklet_add__";
+		const boot = `${add}(${RuntimeGlobals.getWorkletBootstrap}())`;
+		// Non-runtime chunks have no ordering constraint, so add them concurrently.
+		const addOne = runtimeTemplate.returningFunction(`${add}(u)`, "u");
+		const parallel =
+			restChunkIds.length > 0
+				? `Promise.all([${restChunkIds.map(toUrl).join(", ")}].map(${addOne}))`
+				: undefined;
+		// The runtime chunk is added last: it runs entry startup with every module present.
+		const runtimeAdd =
+			runtimeChunkId !== null ? `${add}(${toUrl(runtimeChunkId)})` : undefined;
+
+		// Emit `async`/`await` only where the target supports async functions;
+		// otherwise fall back to an equivalent Promise chain (boot → rest → runtime).
+		let bootstrap;
+		if (runtimeTemplate.supportsAsyncFunction()) {
+			bootstrap = Template.asString([
+				`async function(${add}) {`,
+				Template.indent(
+					[
+						`await ${boot};`,
+						parallel ? `await ${parallel};` : "",
+						runtimeAdd ? `await ${runtimeAdd};` : ""
+					].filter(Boolean)
+				),
+				"}"
+			]);
+		} else {
+			let chain = boot;
+			if (parallel) {
+				chain += `.then(${runtimeTemplate.returningFunction(parallel)})`;
+			}
+			if (runtimeAdd) {
+				chain += `.then(${runtimeTemplate.returningFunction(runtimeAdd)})`;
+			}
+			bootstrap = `function(${add}) { return ${chain}; }`;
+		}
+
+		// The wrapper forwards to the original `addModule` (its callee stays in the
+		// source, so the receiver is preserved); a plain function keeps it valid on
+		// ES targets without arrow functions.
+		source.insert(
+			dep.range[0],
+			`(/* worklet bootstrap */ ${bootstrap})(function(${WORKLET_MODULE}) { return `
+		);
+		source.replace(
+			dep.callRange[0],
+			dep.callRange[1] - 1,
+			`(${WORKLET_MODULE}); })`
+		);
+	}
+};
+
+makeSerializable(
+	WorkletDependency,
+	"webpack/lib/dependencies/WorkletDependency"
+);
+
+module.exports = WorkletDependency;
+module.exports.WORKLET_MODULE = WORKLET_MODULE;

package/lib/dll/DelegatedModuleFactoryPlugin.js

@@ -93,6 +93,25 @@ class DelegatedModuleFactoryPlugin {
 								);
 							}
 						}
+						// Directory request: resolve to its index file, like the default resolver.
+						for (let i = 0; i < extensions.length; i++) {
+							const extension = extensions[i];
+							const requestPlusExt = `${innerRequest}/index${extension}`;
+							if (requestPlusExt in this.options.content) {
+								resolved = this.options.content[requestPlusExt];
+								return callback(
+									null,
+									new DelegatedModule(
+										this.options.source,
+										resolved,
+										/** @type {DelegatedModuleType} */
+										(this.options.type),
+										requestPlusExt,
+										`${request}/index${extension}`
+									)
+								);
+							}
+						}
 					}
 					return callback();
 				}

package/lib/errors/EnvironmentNotSupportAsyncWarning.js

@@ -10,7 +10,7 @@ const WebpackError = require("./WebpackError");
 
 /** @typedef {import("../Module")} Module */
 /** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
-/** @typedef {"asyncWebAssembly" | "topLevelAwait" | "external promise" | "external script" | "external import" | "external module"} Feature */
+/** @typedef {"asyncWebAssembly" | "topLevelAwait" | "external promise" | "external script" | "external import" | "external module" | "external amd-async"} Feature */
 
 class EnvironmentNotSupportAsyncWarning extends WebpackError {
 	/**

package/lib/errors/LoaderLoadingError.js

@@ -0,0 +1,20 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const WebpackError = require("./WebpackError");
+
+class LoaderLoadingError extends WebpackError {
+	/**
+	 * @param {string} message message
+	 */
+	constructor(message) {
+		super(message);
+		this.name = "LoaderRunnerError";
+	}
+}
+
+module.exports = LoaderLoadingError;

package/lib/errors/ModuleParseError.js

@@ -41,19 +41,24 @@ class ModuleParseError extends WebpackError {
 				"\nYou need to enable one of the WebAssembly experiments via 'experiments.asyncWebAssembly: true' (based on async modules) or 'experiments.syncWebAssembly: true' (like webpack 4, deprecated).";
 			message +=
 				"\nFor files that transpile to WebAssembly, make sure to set the module type in the 'module.rules' section of the config (e. g. 'type: \"webassembly/async\"').";
-		} else if (!loaders) {
-			message +=
-				"\nYou may need an appropriate loader to handle this file type. " +
-				"See https://webpack.js.org/concepts/loaders";
-		} else if (loaders.length >= 1) {
-			message += `\nFile was processed with these loaders:${loaders
-				.map((loader) => `\n * ${loader}`)
-				.join("")}`;
-			message +=
-				"\nYou may need an additional loader to handle the result of these loaders.";
 		} else {
-			message +=
-				"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+			message += `\nFile was parsed as module type '${type}'.`;
+			// `loaders` is undefined when the serializer re-runs this constructor
+			// during cache deserialization — keep that branch so it never throws.
+			if (!loaders) {
+				message +=
+					"\nYou may need an appropriate loader to handle this file type. " +
+					"See https://webpack.js.org/concepts/loaders";
+			} else if (loaders.length >= 1) {
+				message += `\nFile was processed with these loaders:${loaders
+					.map((loader) => `\n * ${loader}`)
+					.join("")}`;
+				message +=
+					"\nYou may need an additional loader to handle the result of these loaders.";
+			} else {
+				message +=
+					"\nYou may need an appropriate loader to handle this file type, currently no loaders are configured to process this file. See https://webpack.js.org/concepts#loaders";
+			}
 		}
 
 		if (
@@ -73,16 +78,28 @@ class ModuleParseError extends WebpackError {
 				message += "\n(Source code omitted for this binary file)";
 			} else {
 				const sourceLines = source.split(/\r?\n/);
-				const start = Math.max(0, lineNumber - 3);
-				const linesBefore = sourceLines.slice(start, lineNumber - 1);
-				const theLine = sourceLines[lineNumber - 1];
-				const linesAfter = sourceLines.slice(lineNumber, lineNumber + 2);
-
-				message += `${linesBefore
-					.map((l) => `\n| ${l}`)
-					.join(
-						""
-					)}\n> ${theLine}${linesAfter.map((l) => `\n| ${l}`).join("")}`;
+				if (lineNumber >= 1 && lineNumber <= sourceLines.length) {
+					// babel-like code frame: numbered gutter, `>` on the error line
+					// and a `^` caret at the error column
+					const column =
+						typeof err.loc.column === "number" ? err.loc.column : undefined;
+					const start = Math.max(1, lineNumber - 1);
+					const end = Math.min(sourceLines.length, lineNumber + 1);
+					const width = `${end}`.length;
+					for (let n = start; n <= end; n++) {
+						const line = sourceLines[n - 1];
+						const gutter = `${n}`.padStart(width);
+						message +=
+							n === lineNumber
+								? `\n> ${gutter} | ${line}`
+								: `\n  ${gutter} | ${line}`;
+						if (n === lineNumber && column !== undefined) {
+							// keep tabs so the caret stays aligned under tab-indented code
+							const align = line.slice(0, column).replace(/[^\t]/g, " ");
+							message += `\n  ${" ".repeat(width)} | ${align}^`;
+						}
+					}
+				}
 			}
 
 			loc = { start: err.loc };

package/lib/errors/NodeStuffInWebError.js

@@ -32,6 +32,6 @@ ${description}`
 	}
 }
 
-makeSerializable(NodeStuffInWebError, "webpack/lib/NodeStuffInWebError");
+makeSerializable(NodeStuffInWebError, "webpack/lib/errors/NodeStuffInWebError");
 
 module.exports = NodeStuffInWebError;

package/lib/esm/ModuleChunkFormatPlugin.js

@@ -27,6 +27,8 @@ const { getUndoPath } = require("../util/identifier");
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Entrypoint")} Entrypoint */
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../javascript/JavascriptModulesPlugin").ChunkRenderContext} ChunkRenderContext */
 
 /**
  * Gets relative path.
@@ -78,7 +80,9 @@ const getRelativePath = (compilation, chunk, runtimeChunk) => {
  * @returns {string} the import source
  */
 function renderChunkImport(compilation, chunk, namedImport, runtimeChunk) {
-	return `import ${namedImport ? `* as ${namedImport}` : `{ ${RuntimeGlobals.require} }`} from ${JSON.stringify(
+	return `import ${
+		namedImport ? `* as ${namedImport}` : `{ ${RuntimeGlobals.require} }`
+	} from ${JSON.stringify(
 		getRelativePath(compilation, chunk, runtimeChunk || chunk)
 	)};\n`;
 }
@@ -182,10 +186,14 @@ class ModuleChunkFormatPlugin {
 				const hotUpdateChunk = chunk instanceof HotUpdateChunk ? chunk : null;
 				const source = new ConcatSource();
 				source.add(
-					`export const ${RuntimeGlobals.esmId} = ${JSON.stringify(chunk.id)};\n`
+					`export const ${RuntimeGlobals.esmId} = ${JSON.stringify(
+						chunk.id
+					)};\n`
 				);
 				source.add(
-					`export const ${RuntimeGlobals.esmIds} = ${JSON.stringify(chunk.ids)};\n`
+					`export const ${RuntimeGlobals.esmIds} = ${JSON.stringify(
+						chunk.ids
+					)};\n`
 				);
 				source.add(`export const ${RuntimeGlobals.esmModules} = `);
 				source.add(modules);
@@ -202,6 +210,8 @@ class ModuleChunkFormatPlugin {
 				}
 				const { entries, runtimeChunk } = getChunkInfo(chunk, chunkGraph);
 				if (runtimeChunk) {
+					const { inlinedEntryModule, inlinedEntrySource } =
+						/** @type {ChunkRenderContext} */ (renderContext);
 					const entrySource = new ConcatSource();
 					entrySource.add(source);
 					entrySource.add(";\n\n// load runtime\n");
@@ -209,12 +219,21 @@ class ModuleChunkFormatPlugin {
 						renderChunkImport(compilation, runtimeChunk, "", chunk)
 					);
 					const startupSource = new ConcatSource();
-					startupSource.add(
-						`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
-							`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
-							"moduleId"
-						)}\n`
+					// The `__webpack_exec__` helper is only needed for entries that
+					// are executed through the registry, not for inlined entries.
+					const needExec = entries.some(
+						([module]) =>
+							module !== inlinedEntryModule &&
+							chunkGraph.getModuleSourceTypes(module).has(JAVASCRIPT_TYPE)
 					);
+					if (needExec) {
+						startupSource.add(
+							`var __webpack_exec__ = ${runtimeTemplate.returningFunction(
+								`${RuntimeGlobals.require}(${RuntimeGlobals.entryModuleId} = moduleId)`,
+								"moduleId"
+							)}\n`
+						);
+					}
 
 					/** @type {Set<Chunk>} */
 					const loadedChunks = new Set();
@@ -248,18 +267,32 @@ class ModuleChunkFormatPlugin {
 							startupSource.add("\n");
 							startupSource.add(sourceWithDependentChunks);
 						}
-						startupSource.add(
-							`${
-								final ? `var ${RuntimeGlobals.exports} = ` : ""
-							}__webpack_exec__(${JSON.stringify(moduleId)});\n`
-						);
+						if (module === inlinedEntryModule && inlinedEntrySource) {
+							// Inline the entry at the top level so its declarations stay
+							// live ESM bindings (exports appended by `renderStartup`).
+							startupSource.add(
+								`${runtimeTemplate.renderLet()} ${
+									RuntimeGlobals.exports
+								} = {};\n`
+							);
+							startupSource.add(inlinedEntrySource);
+							startupSource.add("\n");
+						} else {
+							startupSource.add(
+								`${
+									final ? `var ${RuntimeGlobals.exports} = ` : ""
+								}__webpack_exec__(${JSON.stringify(moduleId)});\n`
+							);
+						}
 					}
 
 					entrySource.add(
 						hooks.renderStartup.call(
 							startupSource,
 							entries[entries.length - 1][0],
-							renderContext
+							inlinedEntryModule
+								? { ...renderContext, inlined: true, inlinedInIIFE: false }
+								: renderContext
 						)
 					);
 					return entrySource;