@@ -3769,6 +3769,22 @@ class RuntimeTemplate {
 		}
 	}
 
+	/**
+	 * Whether the loader still needs to build a url from a chunk id: a chunk carrying
+	 * a runtime of its own is reached by a static import and so is never named in the
+	 * map, and only a runtime that can reach one has to keep the fallback.
+	 * @param {Chunk} runtimeChunk the chunk holding the chunk loader
+	 * @param {ChunkGraph} chunkGraph the chunk graph
+	 * @returns {boolean} true when an id the map does not hold can reach the loader
+	 */
+	chunkImportsNeedRuntimeUrl(runtimeChunk, chunkGraph) {
+		for (const chunk of runtimeChunk.getAllReferencedChunks()) {
+			if (chunk === runtimeChunk || !chunk.hasRuntime()) continue;
+			if (JavascriptModulesPlugin.chunkHasJs(chunk, chunkGraph)) return true;
+		}
+		return false;
+	}
+
 	/**
 	 * A literal `import()` specifier for every javascript chunk a runtime loads on
 	 * demand, keyed by chunk id, or `null` when one of them cannot be named here. The
@@ -3798,13 +3814,14 @@ class RuntimeTemplate {
 		) {
 			return null;
 		}
-		// An initial chunk is installed before the loader runs and a chunk carrying a
-		// runtime is reached by a static import, so neither is ever looked up here.
+		// An initial chunk and one carrying a runtime are both reached by a static
+		// import, so naming either here would only make two hashes chase each other.
 		const installed = new Set(runtimeChunk.getAllInitialChunks());
 		/** @type {Chunk[]} */
 		const chunks = [];
 		for (const chunk of runtimeChunk.getAllReferencedChunks()) {
 			if (
+				chunk === runtimeChunk ||
 				chunk.hasRuntime() ||
 				installed.has(chunk) ||
 				!JavascriptModulesPlugin.chunkHasJs(chunk, chunkGraph)
 
@@ -144,14 +144,15 @@ class ModuleChunkLoadingPlugin {
 						);
 						return;
 					}
+
 					// Asked as the runtime module asks, so the two always agree on whether
 					// a chunk id is ever turned into a url here.
+					const { runtimeTemplate } = compilation;
 					if (
-						compilation.runtimeTemplate.analyzableChunkImports(
-							chunk,
-							chunkGraph,
-							set
-						) !== null
+						runtimeTemplate.analyzableChunkImports(chunk, chunkGraph, set) !==
+							null &&
+						!set.has(RuntimeGlobals.hmrDownloadUpdateHandlers) &&
+						!runtimeTemplate.chunkImportsNeedRuntimeUrl(chunk, chunkGraph)
 					) {
 						return;
 					}
 
@@ -195,12 +195,16 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 				? `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(${id})`
 				: `chunkUrls[${id}]()`;
 		const runtimeImport = `${importFunctionName}(${chunkImportBase} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`;
-		// A hot update can force-load a chunk id this build never saw, which no baked
-		// map holds; `getChunkScriptFilename` is asked for alongside the hot handlers.
+		// A hot update can force-load an id this build never saw, and a chunk with a
+		// runtime of its own is never named, so only those keep the url form.
+		const withRuntimeUrl =
+			chunkImports === null ||
+			withHmr ||
+			runtimeTemplate.chunkImportsNeedRuntimeUrl(chunk, chunkGraph);
 		const chunkImport =
 			chunkImports === null
 				? runtimeImport
-				: withHmr
+				: withRuntimeUrl
 					? `(${RuntimeGlobals.hasOwnProperty}(chunkImports, chunkId) ? chunkImports[chunkId]() : ${runtimeImport})`
 					: "chunkImports[chunkId]()";
 		return Template.asString([
 
@@ -42,6 +42,8 @@ it("should bake the import even though the block names no module of its own", ()
 	const region = bundle.slice(start, bundle.indexOf("};", start));
 
 	// One per emitter: `require.ensure`, AMD `require([...])` and the lazy-once context.
-	expect(region.split("import(")).toHaveLength(4);
+	for (const name of ["ensured", "amd_js", "ctx"]) {
+		expect([name, region.includes(name)]).toEqual([name, true]);
+	}
 	expect(bundle).toContain(`${"__webpack_require__"}.e(`);
 });
@@ -26,5 +26,4 @@ it("should keep the loaders ahead of the deferred slot", () => {
 	expect(bundle).toContain(`import("./${__NAME__}-defer_async_js.mjs")`);
 	expect(bundle).toContain("], null]");
 	expect(bundle).toContain(`${"__webpack_require__"}.e =`);
-	expect(bundle).not.toContain(`${"__webpack_require__"}.u =`);
 });
@@ -24,5 +24,4 @@ it("should keep the loaders behind the fake-map slot", () => {
 	// The exports type sits at 1, so the loaders moved one along.
 	expect(bundle).toContain("return ids[2][0]()");
 	expect(bundle).toContain(`${"__webpack_require__"}.e =`);
-	expect(bundle).not.toContain(`${"__webpack_require__"}.u =`);
 });
@@ -26,8 +26,5 @@ it("should write a static import next to each request", () => {
 	expect(bundle).toContain(`import("./${__NAME__}-locales_en_js.mjs")`);
 	// A single chunk per request needs no `Promise.all` around it.
 	expect(bundle).toContain(`return ${"__webpack_require__"}.e(ids[1][0])`);
-	// The request map holds chunk ids, so the loader reads them — but it imports a
-	// name from its own map, so no id is ever turned into a filename.
 	expect(bundle).toContain(`${"__webpack_require__"}.e =`);
-	expect(bundle).not.toContain(`${"__webpack_require__"}.u =`);
 });
@@ -27,5 +27,4 @@ it("should write one static import per chunk of the request", () => {
 	expect(bundle).toContain(`import("./${__NAME__}-split_de_js.mjs")`);
 	expect(bundle).toContain(`Promise.all(ids[1].map(${"__webpack_require__"}.e))`);
 	expect(bundle).toContain(`${"__webpack_require__"}.e =`);
-	expect(bundle).not.toContain(`${"__webpack_require__"}.u =`);
 });
@@ -13,8 +13,6 @@ it("should name that chunk with a specifier a foreign bundler can follow", () =>
 	);
 	expect(bundle).toContain(`${"chunkImports"} = {`);
 	expect(bundle).toContain('import("./lazy-css.mjs")');
-	// The name is in the loader's map, so no chunk id is turned into one.
-	expect(bundle).not.toContain(`${"__webpack_require__"}.u =`);
 });
 
 it("should bake the href of the css that chunk carries", () => {
 
@@ -21,6 +21,7 @@ it("should emit an analyzable literal import() for module output", () => {
 	expect(bundle).toContain(importMap);
 	expect(bundle).toContain('import("./dynamic.mjs")');
 	expect(bundle).toContain(`${"__webpack_require__"}.e(`);
-	// The runtime builds no name from a chunk id, so it ships no map of them.
+	// Every chunk the loader can be asked for is named here, so it builds no url from
+	// a chunk id and the table mapping one to a filename is not emitted.
 	expect(bundle).not.toContain(`${"__webpack_require__"}.u =`);
 });