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

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -6,12 +6,19 @@
 "use strict";
 
 const RuntimeGlobals = require("../RuntimeGlobals");
-const ExportWebpackRequireRuntimeModule = require("./ExportWebpackRequireRuntimeModule");
-const ModuleChunkLoadingRuntimeModule = require("./ModuleChunkLoadingRuntimeModule");
+const lazyModule = require("../util/lazyModule");
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import Compiler from "../Compiler" */
+/** @import { RuntimeRequirements } from "../Module" */
+
+// only a chunk that loads other chunks at runtime emits these
+const getExportWebpackRequireRuntimeModule = lazyModule(() =>
+	require("./ExportWebpackRequireRuntimeModule")
+);
+const getModuleChunkLoadingRuntimeModule = lazyModule(() =>
+	require("./ModuleChunkLoadingRuntimeModule")
+);
 
 const PLUGIN_NAME = "ModuleChunkLoadingPlugin";
 
@@ -48,65 +55,89 @@ class ModuleChunkLoadingPlugin {
 				if (onceForChunkSet.has(chunk)) return;
 				onceForChunkSet.add(chunk);
 				if (!isEnabledForChunk(chunk)) return;
-				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
-				set.add(RuntimeGlobals.hasOwnProperty);
-				compilation.addRuntimeModule(
+				compilation.addLazyRuntimeModule(
 					chunk,
-					new ModuleChunkLoadingRuntimeModule(set)
+					getModuleChunkLoadingRuntimeModule,
+					(Ctor) => new Ctor(set)
 				);
 			};
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.baseURI)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.externalInstallChunk)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.analyzableChunkImport)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.onChunksLoaded)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadUpdateHandlers)
-				.tap(PLUGIN_NAME, handler);
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.hmrDownloadManifest)
-				.tap(PLUGIN_NAME, handler);
+			/**
+			 * Installing a chunk is the only part that writes the module factories and
+			 * looks a chunk id up; a base uri, `onChunksLoaded` or the hot manifest come
+			 * without either. Kept off `handler`, which runs once per chunk and so cannot
+			 * see which of the requirements below the chunk ends up with.
+			 * @param {Chunk} chunk chunk to check
+			 * @param {RuntimeRequirements} set runtime requirements
+			 */
+			const installHandler = (chunk, set) => {
+				if (!isEnabledForChunk(chunk)) return;
+				set.add(RuntimeGlobals.moduleFactoriesAddOnly);
+				set.add(RuntimeGlobals.hasOwnProperty);
+			};
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.baseURI,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.analyzableChunkImport,
+				RuntimeGlobals.onChunksLoaded,
+				RuntimeGlobals.hmrDownloadUpdateHandlers,
+				RuntimeGlobals.hmrDownloadManifest
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, handler);
+			}
+			for (const requirement of [
+				RuntimeGlobals.ensureChunkHandlers,
+				RuntimeGlobals.externalInstallChunk,
+				RuntimeGlobals.analyzableChunkImport,
+				RuntimeGlobals.hmrDownloadUpdateHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, installHandler);
+			}
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.externalInstallChunk)
 				.tap(PLUGIN_NAME, (chunk) => {
 					if (!isEnabledForChunk(chunk)) return;
-					compilation.addRuntimeModule(
+					compilation.addLazyRuntimeModule(
 						chunk,
-						new ExportWebpackRequireRuntimeModule()
+						getExportWebpackRequireRuntimeModule,
+						(Ctor) => new Ctor()
 					);
 				});
 
-			// The prefetch/preload handlers build the chunk URL themselves, so they need
-			// the public path and script filename directly — without relying on
-			// `ensureChunkHandlers` to pull them in (an analyzable `import()` may replace it).
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.prefetchChunkHandlers)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.getChunkScriptFilename);
-				});
-
-			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.preloadChunkHandlers)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					if (!isEnabledForChunk(chunk)) return;
-					set.add(RuntimeGlobals.publicPath);
-					set.add(RuntimeGlobals.getChunkScriptFilename);
-				});
+			// A handler that builds its url asks for both directly: an analyzable
+			// `import()` may replace `ensureChunkHandlers`, which otherwise pulls them in.
+			for (const requirement of [
+				RuntimeGlobals.prefetchChunkHandlers,
+				RuntimeGlobals.preloadChunkHandlers
+			]) {
+				compilation.hooks.runtimeRequirementInTree
+					.for(requirement)
+					.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+						if (!isEnabledForChunk(chunk)) return;
+						// A baked url carries where the chunk is, so neither is read for it.
+						// Asked as the runtime module asks, so the two always agree.
+						if (
+							compilation.runtimeTemplate.analyzableChunkScriptUrls(
+								chunk,
+								chunkGraph,
+								set
+							) !== null
+						) {
+							return;
+						}
+						set.add(RuntimeGlobals.publicPath);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					});
+			}
 
+			// Keyed on `ensureChunk`, not on the handler map: only the runtime chunk loader
+			// builds a URL from a chunk id, and an analyzable `import()` carries its own.
 			compilation.hooks.runtimeRequirementInTree
-				.for(RuntimeGlobals.ensureChunkHandlers)
+				.for(RuntimeGlobals.ensureChunk)
 				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
 
@@ -123,6 +154,13 @@ class ModuleChunkLoadingPlugin {
 					if (!isEnabledForChunk(chunk)) return;
 					set.add(RuntimeGlobals.publicPath);
 					set.add(RuntimeGlobals.getChunkUpdateScriptFilename);
+					// The hot runtime force-loads through the handler map by bare chunk id, so
+					// the map and loader stay however analyzable — but only where there are
+					// async chunks to force-load.
+					if (chunk.hasAsyncChunks()) {
+						set.add(RuntimeGlobals.ensureChunkHandlers);
+						set.add(RuntimeGlobals.getChunkScriptFilename);
+					}
 					set.add(RuntimeGlobals.moduleCache);
 					set.add(RuntimeGlobals.hmrModuleData);
 					set.add(RuntimeGlobals.moduleFactoriesAddOnly);

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -5,25 +5,25 @@
 "use strict";
 
 const { SyncWaterfallHook } = require("tapable");
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 const {
 	generateJavascriptHMR
 } = require("../hmr/JavascriptHotModuleReplacementHelper");
-const {
-	chunkHasJs,
-	getChunkFilenameTemplate
-} = require("../javascript/JavascriptModulesPlugin");
+const { chunkHasJs } = require("../javascript/JavascriptModulesPlugin");
 const { getInitialChunkIds } = require("../javascript/StartupHelpers");
+const { renderBaseUri } = require("../runtime/baseUri");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const createHooksRegistry = require("../util/createHooksRegistry");
-const { getUndoPath } = require("../util/identifier");
+const memoize = require("../util/memoize");
+
+const getAPIPlugin = memoize(() => require("../APIPlugin"));
 
-/** @typedef {import("../Chunk")} Chunk */
-/** @typedef {import("../ChunkGraph")} ChunkGraph */
-/** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
+/** @import Chunk from "../Chunk" */
+/** @import ChunkGraph from "../ChunkGraph" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 const createCompilationHooks = () => ({
 	/**
@@ -62,16 +62,14 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 	 */
 	_generateBaseUri(chunk, rootOutputDir) {
 		const options = chunk.getEntryOptions();
-		if (options && options.baseUri) {
-			return `${RuntimeGlobals.baseURI} = ${JSON.stringify(options.baseUri)};`;
-		}
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const {
 			outputOptions: { importMetaName }
 		} = compilation;
-		return `${RuntimeGlobals.baseURI} = new URL(${JSON.stringify(
-			rootOutputDir
-		)}, ${importMetaName}.url);`;
+		return renderBaseUri(
+			options ? options.baseUri : undefined,
+			`new URL(${JSON.stringify(rootOutputDir)}, ${importMetaName}.url)`
+		);
 	}
 
 	/**
@@ -85,8 +83,14 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const environment = compilation.outputOptions.environment;
 		const {
 			runtimeTemplate,
-			outputOptions: { importFunctionName, crossOriginLoading, charset }
+			outputOptions: {
+				importFunctionName,
+				crossOriginLoading,
+				charset,
+				resourceHints
+			}
 		} = compilation;
+		const dedupePrefetch = Boolean(resourceHints && resourceHints.dedupe);
 		const fn = RuntimeGlobals.ensureChunkHandlers;
 		const withBaseURI = this._runtimeRequirements.has(RuntimeGlobals.baseURI);
 		const withExternalInstallChunk = this._runtimeRequirements.has(
@@ -107,6 +111,11 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withHmrManifest = this._runtimeRequirements.has(
 			RuntimeGlobals.hmrDownloadManifest
 		);
+		// `.f.j` serves `ensureChunk`: an analyzable import dispatches every handler but
+		// this one. HMR's force-load knows only a chunk id, so it needs the loader too.
+		const withJsLoading =
+			withLoading &&
+			(this._runtimeRequirements.has(RuntimeGlobals.ensureChunk) || withHmr);
 		const { linkPreload, linkPrefetch } =
 			ModuleChunkLoadingRuntimeModule.getCompilationHooks(compilation);
 		const isNeutralPlatform = runtimeTemplate.isNeutralPlatform();
@@ -118,22 +127,35 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			(environment.document || isNeutralPlatform) &&
 			this._runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
 			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs);
+		// Under module output each hinted chunk is a known file, so the urls are written
+		// out and read by id rather than built from the chunk id at runtime.
+		const chunkUrls =
+			withPrefetch || withPreload
+				? runtimeTemplate.analyzableChunkScriptUrls(
+						chunk,
+						chunkGraph,
+						this._runtimeRequirements,
+						this
+					)
+				: null;
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
 
-		const outputName = compilation.getPath(
-			getChunkFilenameTemplate(chunk, compilation.outputOptions),
-			{
-				chunk,
-				contentHashType: "javascript"
-			}
-		);
-		const rootOutputDir = getUndoPath(
-			outputName,
-			compilation.outputOptions.path,
-			true
-		);
+		const rootOutputDir = runtimeTemplate.chunkRootOutputDir(chunk, true);
+
+		const { publicPath } = compilation.outputOptions;
+		// `import()` resolves a bare specifier as a package name, so a public path that
+		// leaves one — empty, or a plain relative directory — needs an explicit `./`.
+		// A runtime override can swap in an absolute path, so leave those alone.
+		const chunkImportBase =
+			publicPath === "auto"
+				? JSON.stringify(rootOutputDir)
+				: typeof publicPath === "string" &&
+					  !/^(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(publicPath) &&
+					  !getAPIPlugin().usesRuntimePublicPathOverride(compilation)
+					? `"./" + ${RuntimeGlobals.publicPath}`
+					: RuntimeGlobals.publicPath;
 
 		const stateExpression = withHmr
 			? `${RuntimeGlobals.hmrRuntimeStatePrefix}_module`
@@ -146,19 +168,58 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				",\n"
 			)
 		)}\n}`;
+		// Every part below that reads the table. A chunk asking only for `.b` gets this
+		// module for the base uri alone, and then has nothing to look up.
+		const withInstalledChunks =
+			withLoading ||
+			withExternalInstallChunk ||
+			withAnalyzableImport ||
+			withOnChunkLoad ||
+			withHmr ||
+			withPrefetch ||
+			withPreload;
+		// The url is read through a thunk so a runtime hinting at many chunks builds only
+		// the one it appends.
+		/**
+		 * @param {string} id expression naming the chunk whose url is wanted
+		 * @returns {string} expression evaluating to its url
+		 */
+		const chunkUrl = (id) =>
+			chunkUrls === null
+				? `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(${id})`
+				: `chunkUrls[${id}]()`;
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir)
 				: "// no baseURI",
 			"",
-			"// object to store loaded and loading chunks",
-			"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
-			"// [resolve, Promise] = chunk loading, 0 = chunk loaded",
-			`${cst} installedChunks = ${
-				stateExpression
-					? runtimeTemplate.assignOr(stateExpression, installedChunksObject)
-					: installedChunksObject
-			};`,
+			...(chunkUrls
+				? [
+						`${cst} chunkUrls = {\n${Template.indent(
+							Array.from(
+								chunkUrls,
+								([id, url]) =>
+									`${JSON.stringify(String(id))}: ${runtimeTemplate.returningFunction(url)}`
+							).join(",\n")
+						)}\n};`,
+						""
+					]
+				: []),
+			withInstalledChunks
+				? Template.asString([
+						"// object to store loaded and loading chunks",
+						"// undefined = chunk not loaded, null = chunk preloaded/prefetched",
+						"// [resolve, Promise] = chunk loading, 0 = chunk loaded",
+						`${cst} installedChunks = ${
+							stateExpression
+								? runtimeTemplate.assignOr(
+										stateExpression,
+										installedChunksObject
+									)
+								: installedChunksObject
+						};`
+					])
+				: "// no installed chunks",
 			"",
 			withLoading || withExternalInstallChunk || withAnalyzableImport
 				? `${cst} installChunk = ${runtimeTemplate.basicFunction("data", [
@@ -189,14 +250,14 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							`if(${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) && installedChunks[chunkId]) {`,
 							Template.indent("installedChunks[chunkId][0]();"),
 							"}",
-							`installedChunks[${RuntimeGlobals.esmIds}[i]] = 0;`
+							"installedChunks[chunkId] = 0;"
 						]),
 						"}",
 						withOnChunkLoad ? `${RuntimeGlobals.onChunksLoaded}();` : ""
 					])}`
 				: "// no install chunk",
 			"",
-			withLoading
+			withJsLoading
 				? Template.asString([
 						`${fn}.j = ${runtimeTemplate.basicFunction(
 							"chunkId, promises",
@@ -219,11 +280,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 													: `if(${hasJsMatcher("chunkId")}) {`,
 												Template.indent([
 													"// setup Promise in chunk cache",
-													`${lt} promise = ${importFunctionName}(${
-														compilation.outputOptions.publicPath === "auto"
-															? JSON.stringify(rootOutputDir)
-															: RuntimeGlobals.publicPath
-													} + ${
+													`${lt} promise = ${importFunctionName}(${chunkImportBase} + ${
 														RuntimeGlobals.getChunkScriptFilename
 													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
 														"e",
@@ -265,6 +322,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
 						}) {`,
 						Template.indent([
+							// A hint is best-effort, so an id no url was written for is
+							// skipped rather than turned into a bogus href.
+							...(chunkUrls ? ["if(!chunkUrls[chunkId]) return;"] : []),
 							"installedChunks[chunkId] = null;",
 							linkPrefetch.call(
 								Template.asString([
@@ -282,10 +342,23 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 									"}",
 									'link.rel = "prefetch";',
 									'link.as = "script";',
-									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`
+									`link.href = ${chunkUrl("chunkId")};`
 								]),
 								chunk
 							),
+							dedupePrefetch
+								? Template.asString([
+										// Chrome re-requests a resource when a prefetch link is added
+										// after it was already (pre)loaded via markup; skip in that case.
+										`${cst} links = document.getElementsByTagName("link");`,
+										`for(${lt} i = 0; i < links.length; i++) {`,
+										Template.indent([
+											`${cst} l = links[i];`,
+											'if(l.href === link.href && (l.rel === "prefetch" || l.rel === "preload" || l.rel === "modulepreload")) return;'
+										]),
+										"}"
+									])
+								: "",
 							"document.head.appendChild(link);"
 						]),
 						"}"
@@ -306,6 +379,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 							hasJsMatcher === true ? "true" : hasJsMatcher("chunkId")
 						}) {`,
 						Template.indent([
+							// A hint is best-effort, so an id no url was written for is
+							// skipped rather than turned into a bogus href.
+							...(chunkUrls ? ["if(!chunkUrls[chunkId]) return;"] : []),
 							"installedChunks[chunkId] = null;",
 							linkPreload.call(
 								Template.asString([
@@ -317,7 +393,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 									),
 									"}",
 									'link.rel = "modulepreload";',
-									`link.href = ${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId);`,
+									`link.href = ${chunkUrl("chunkId")};`,
 									crossOriginLoading
 										? crossOriginLoading === "use-credentials"
 											? 'link.crossOrigin = "use-credentials";'
@@ -350,24 +426,41 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				? `${
 						RuntimeGlobals.analyzableChunkImport
 					} = ${runtimeTemplate.basicFunction("chunkId, importFn", [
-						// A literal `import()` a foreign bundler can follow, wrapped to keep
-						// `ensureChunk` timing and deduplication: resolved chunk → resolve now, in-flight →
-						// reuse its promise, else run `importFn()` and install it.
+						// `ensureChunk` with its `.j` half replaced by a literal `import()` a foreign
+						// bundler can follow. The remaining handlers still run, so a chunk's css and
+						// its prefetch/preload children are not lost by taking this path.
+						`${lt} promises = [];`,
 						`${lt} installedChunkData = ${RuntimeGlobals.hasOwnProperty}(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;`,
-						"if(installedChunkData === 0) return Promise.resolve();",
-						"if(installedChunkData) return installedChunkData[1];",
-						`${lt} promise = importFn().then(installChunk, ${runtimeTemplate.basicFunction(
-							"e",
-							[
-								"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
-								"throw e;"
-							]
-						)});`,
-						`promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
-							"installedChunkData = installedChunks[chunkId] = [resolve]",
-							"resolve"
-						)})]);`,
-						"return (installedChunkData[1] = promise);"
+						'if(installedChunkData !== 0) { // 0 means "already installed".',
+						Template.indent([
+							'// a Promise means "currently loading".',
+							"if(installedChunkData) {",
+							Template.indent(["promises.push(installedChunkData[1]);"]),
+							"} else {",
+							Template.indent([
+								`${lt} promise = importFn().then(installChunk, ${runtimeTemplate.basicFunction(
+									"e",
+									[
+										"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
+										"throw e;"
+									]
+								)});`,
+								`promise = Promise.race([promise, new Promise(${runtimeTemplate.expressionFunction(
+									"installedChunkData = installedChunks[chunkId] = [resolve]",
+									"resolve"
+								)})]);`,
+								"promises.push((installedChunkData[1] = promise));"
+							]),
+							"}"
+						]),
+						"}",
+						withLoading
+							? `Object.keys(${fn}).forEach(${runtimeTemplate.basicFunction(
+									"key",
+									[`if(key !== "j") ${fn}[key](chunkId, promises);`]
+								)});`
+							: "// no other chunk loading handlers",
+						"return Promise.all(promises);"
 					])};`
 				: "// no analyzable chunk import",
 			"",

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -13,7 +13,9 @@
 /** @typedef {(status: string) => (Promise<void> | void)} StatusHandler */
 /** @typedef {Record<string, unknown>} ApplyOptions */
 /** @typedef {(reportError: (err: Error) => void) => Promise<ModuleId[]>} ApplyFn */
-/** @typedef {{ (id: ModuleId): unknown, e: (chunkId: ModuleId, fetchPriority?: string) => Promise<unknown>, [name: string]: unknown }} WebpackRequire */
+/** @typedef {(chunkId: ModuleId, fetchPriority?: string) => Promise<unknown>} EnsureChunk */
+/** @typedef {(chunkId: ModuleId, importFn: () => Promise<unknown>) => Promise<unknown>} AnalyzableChunkImport */
+/** @typedef {{ (id: ModuleId): unknown, e?: EnsureChunk, ei?: AnalyzableChunkImport, [name: string]: unknown }} WebpackRequire */
 
 /**
  * @typedef {object} ApplyResult
@@ -185,13 +187,30 @@ module.exports = function () {
 			};
 		};
 		for (var name in require) {
-			if (Object.prototype.hasOwnProperty.call(require, name) && name !== "e") {
+			if (
+				Object.prototype.hasOwnProperty.call(require, name) &&
+				name !== "e" &&
+				name !== "ei"
+			) {
 				Object.defineProperty(fn, name, createPropertyDescriptor(name));
 			}
 		}
-		/** @type {WebpackRequire} */ (fn).e = function (chunkId, fetchPriority) {
-			return trackBlockingPromise(require.e(chunkId, fetchPriority));
-		};
+		// A chunk load blocks the update until it settles, and `.ei` is the analyzable
+		// half of `.e`. A runtime that loads no chunks has neither to wrap.
+		if (require.e) {
+			/** @type {WebpackRequire} */ (fn).e = function (chunkId, fetchPriority) {
+				return trackBlockingPromise(
+					/** @type {EnsureChunk} */ (require.e)(chunkId, fetchPriority)
+				);
+			};
+		}
+		if (require.ei) {
+			/** @type {WebpackRequire} */ (fn).ei = function (chunkId, importFn) {
+				return trackBlockingPromise(
+					/** @type {AnalyzableChunkImport} */ (require.ei)(chunkId, importFn)
+				);
+			};
+		}
 		return /** @type {WebpackRequire} */ (fn);
 	}
 

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -9,7 +9,7 @@ const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
 
-/** @typedef {import("../Compilation")} Compilation */
+/** @import Compilation from "../Compilation" */
 
 class HotModuleReplacementRuntimeModule extends RuntimeModule {
 	constructor() {

package/lib/hmr/LazyCompilationPlugin.js

@@ -21,29 +21,41 @@ const CommonJsRequireDependency = require("../dependencies/CommonJsRequireDepend
 const { resolveByProperty } = require("../util/cleverMerge");
 const { registerNotSerializable } = require("../util/serialization");
 
-/** @typedef {import("../config/defaults").WebpackOptionsNormalizedWithDefaults} WebpackOptions */
-/** @typedef {import("../Compilation")} Compilation */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../Dependency").UpdateHashContext} UpdateHashContext */
-/** @typedef {import("../Module").BuildCallback} BuildCallback */
-/** @typedef {import("../Module").BuildInfo} BuildInfo */
-/** @typedef {import("../Module").BuildMeta} BuildMeta */
-/** @typedef {import("../Module").CodeGenerationContext} CodeGenerationContext */
-/** @typedef {import("../Module").CodeGenerationResult} CodeGenerationResult */
-/** @typedef {import("../Module").LibIdentOptions} LibIdentOptions */
-/** @typedef {import("../Module").LibIdent} LibIdent */
-/** @typedef {import("../Module").NeedBuildCallback} NeedBuildCallback */
-/** @typedef {import("../Module").NeedBuildContext} NeedBuildContext */
-/** @typedef {import("../Module").SourceTypes} SourceTypes */
-/** @typedef {import("../Module").Sources} Sources */
-/** @typedef {import("../Module").RuntimeRequirements} RuntimeRequirements */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCallback} ModuleFactoryCallback */
-/** @typedef {import("../ModuleFactory").ModuleFactoryCreateData} ModuleFactoryCreateData */
-/** @typedef {import("../RequestShortener")} RequestShortener */
-/** @typedef {import("../ResolverFactory").ResolverWithOptions} ResolverWithOptions */
-/** @typedef {import("../dependencies/HarmonyImportDependency")} HarmonyImportDependency */
-/** @typedef {import("../util/Hash")} Hash */
-/** @typedef {import("../util/fs").InputFileSystem} InputFileSystem */
+/**
+ * @import {
+ * 	WebpackOptionsNormalizedWithDefaults as WebpackOptions
+ * } from "../config/defaults"
+ */
+/** @import Compilation from "../Compilation" */
+/** @import Compiler from "../Compiler" */
+/** @import { UpdateHashContext } from "../Dependency" */
+/**
+ * @import {
+ * 	BuildCallback,
+ * 	BuildInfo,
+ * 	BuildMeta,
+ * 	CodeGenerationContext,
+ * 	CodeGenerationResult,
+ * 	LibIdentOptions,
+ * 	LibIdent,
+ * 	NeedBuildCallback,
+ * 	NeedBuildContext,
+ * 	SourceTypes,
+ * 	Sources,
+ * 	RuntimeRequirements
+ * } from "../Module"
+ */
+/**
+ * @import {
+ * 	ModuleFactoryCallback,
+ * 	ModuleFactoryCreateData
+ * } from "../ModuleFactory"
+ */
+/** @import RequestShortener from "../RequestShortener" */
+/** @import { ResolverWithOptions } from "../ResolverFactory" */
+/** @import HarmonyImportDependency from "../dependencies/HarmonyImportDependency" */
+/** @import Hash from "../util/Hash" */
+/** @import { InputFileSystem } from "../util/fs" */
 
 /** @typedef {{ client: string, data: string, active: boolean }} ModuleResult */
 
@@ -403,7 +415,8 @@ class LazyCompilationProxyModule extends Module {
 					dependency: dep,
 					strict: false, // TODO this should be inherited from the original module
 					message: "import()",
-					runtimeRequirements
+					runtimeRequirements,
+					originModule: this
 				})};`,
 				"if (module.hot) {",
 				Template.indent([
@@ -547,6 +560,14 @@ class LazyCompilationPlugin {
 		compiler.hooks.thisCompilation.tap(
 			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
+				// A proxy already loaded in the client outlives the build that required
+				// `ensureChunk`, so every runtime keeps it or the proxy calls a dropped global.
+				compilation.hooks.additionalTreeRuntimeRequirements.tap(
+					PLUGIN_NAME,
+					(chunk, set) => {
+						set.add(RuntimeGlobals.ensureChunk);
+					}
+				);
 				normalModuleFactory.hooks.module.tap(
 					PLUGIN_NAME,
 					(module, createData, resolveData) => {