webpack 5.108.4 → 5.109.1

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -64,6 +64,9 @@ class ModuleChunkLoadingPlugin {
 			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);
@@ -83,12 +86,15 @@ class ModuleChunkLoadingPlugin {
 					);
 				});
 
-			// We need public path only when we prefetch/preload chunk or public path is not `auto`
+			// 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
@@ -96,6 +102,7 @@ class ModuleChunkLoadingPlugin {
 				.tap(PLUGIN_NAME, (chunk, set) => {
 					if (!isEnabledForChunk(chunk)) return;
 					set.add(RuntimeGlobals.publicPath);
+					set.add(RuntimeGlobals.getChunkScriptFilename);
 				});
 
 			compilation.hooks.runtimeRequirementInTree

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -82,6 +82,9 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withExternalInstallChunk = this._runtimeRequirements.has(
 			RuntimeGlobals.externalInstallChunk
 		);
+		const withAnalyzableImport = this._runtimeRequirements.has(
+			RuntimeGlobals.analyzableChunkImport
+		);
 		const withLoading = this._runtimeRequirements.has(
 			RuntimeGlobals.ensureChunkHandlers
 		);
@@ -147,7 +150,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					: installedChunksObject
 			};`,
 			"",
-			withLoading || withExternalInstallChunk
+			withLoading || withExternalInstallChunk || withAnalyzableImport
 				? `${cst} installChunk = ${runtimeTemplate.basicFunction("data", [
 						runtimeTemplate.destructureObject(
 							[
@@ -333,6 +336,31 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					])
 				: "// no external install chunk",
 			"",
+			withAnalyzableImport
+				? `${
+						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.
+						`${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);"
+					])};`
+				: "// no analyzable chunk import",
+			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded

package/lib/hmr/lazyCompilationBackend.js

@@ -27,6 +27,9 @@ module.exports = (options) => (compiler, callback) => {
 	const logger = compiler.getInfrastructureLogger("LazyCompilationBackend");
 	/** @type {Map<string, number>} */
 	const activeModules = new Map();
+	/** @type {Set<NodeJS.Timeout>} */
+	const idleTimers = new Set();
+	let isClosing = false;
 	const prefix = "/lazy-compilation-using-";
 
 	const isHttps =
@@ -67,19 +70,33 @@ module.exports = (options) => (compiler, callback) => {
 		if (req.url === undefined) return;
 		const keys = req.url.slice(prefix.length).split("@");
 		req.socket.on("close", () => {
-			setTimeout(() => {
+			// Shutting down: skip the idle-decrement timer entirely.
+			if (isClosing) return;
+			const timer = setTimeout(() => {
+				idleTimers.delete(timer);
 				for (const key of keys) {
 					const oldValue = activeModules.get(key) || 0;
-					activeModules.set(key, oldValue - 1);
-					if (oldValue === 1) {
-						logger.log(
-							`${key} is no longer in use. Next compilation will skip this module.`
-						);
+					// Drop the entry at zero so the map doesn't retain idle modules
+					// and the count can't drift negative.
+					if (oldValue <= 1) {
+						activeModules.delete(key);
+						if (oldValue === 1) {
+							logger.log(
+								`${key} is no longer in use. Next compilation will skip this module.`
+							);
+						}
+					} else {
+						activeModules.set(key, oldValue - 1);
 					}
 				}
 			}, 120000);
+			// Don't keep the process alive just to decrement idle counters.
+			if (timer.unref) timer.unref();
+			idleTimers.add(timer);
 		});
-		req.socket.setNoDelay(true);
+		// Not all runtimes expose `setNoDelay` on the request socket (e.g. Deno's
+		// HTTP server); it's only a latency optimization, so skip it when absent.
+		if (req.socket.setNoDelay) req.socket.setNoDelay(true);
 		res.writeHead(200, {
 			"content-type": "text/event-stream",
 			"Access-Control-Allow-Origin": "*",
@@ -102,7 +119,6 @@ module.exports = (options) => (compiler, callback) => {
 	const server = createServer();
 	server.on("request", requestListener);
 
-	let isClosing = false;
 	/** @type {Set<import("net").Socket>} */
 	const sockets = new Set();
 	server.on("connection", (socket) => {
@@ -113,7 +129,15 @@ module.exports = (options) => (compiler, callback) => {
 		if (isClosing) socket.destroy();
 	});
 	server.on("clientError", (e) => {
-		if (e.message !== "Server is disposing") logger.warn(e);
+		// A closing browser tab or a test tearing down aborts the request and
+		// resets the socket; that surfaces here as ECONNRESET and is benign.
+		if (
+			e.message === "Server is disposing" ||
+			/** @type {NodeJS.ErrnoException} */ (e).code === "ECONNRESET"
+		) {
+			return;
+		}
+		logger.warn(e);
 	});
 
 	server.on(
@@ -142,14 +166,29 @@ module.exports = (options) => (compiler, callback) => {
 			callback(null, {
 				dispose(callback) {
 					isClosing = true;
+					for (const timer of idleTimers) clearTimeout(timer);
+					idleTimers.clear();
 					// Removing the listener is a workaround for a memory leak in node.js
 					server.off("request", requestListener);
-					server.close((err) => {
-						callback(err);
-					});
 					for (const socket of sockets) {
 						socket.destroy(new Error("Server is disposing"));
 					}
+					// Some runtimes (e.g. Deno) don't emit "connection", so `sockets`
+					// misses the open SSE connections and `server.close` would hang;
+					// force-close everything before waiting for it.
+					if (server.closeAllConnections) server.closeAllConnections();
+					server.close((err) => {
+						// `closeAllConnections()` already stops the server on some runtimes
+						// (e.g. Bun), so `close` then reports ERR_SERVER_NOT_RUNNING; the
+						// server is closed either way, so that's not a dispose failure.
+						callback(
+							err &&
+								/** @type {NodeJS.ErrnoException} */ (err).code !==
+									"ERR_SERVER_NOT_RUNNING"
+								? err
+								: null
+						);
+					});
 				},
 				module(originalModule) {
 					const key = `${encodeURIComponent(