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

package/lib/esm/ModuleChunkLoadingPlugin.js

@@ -78,7 +78,6 @@ class ModuleChunkLoadingPlugin {
 				RuntimeGlobals.ensureChunkHandlers,
 				RuntimeGlobals.baseURI,
 				RuntimeGlobals.externalInstallChunk,
-				RuntimeGlobals.analyzableChunkImport,
 				RuntimeGlobals.onChunksLoaded,
 				RuntimeGlobals.hmrDownloadUpdateHandlers,
 				RuntimeGlobals.hmrDownloadManifest
@@ -90,7 +89,6 @@ class ModuleChunkLoadingPlugin {
 			for (const requirement of [
 				RuntimeGlobals.ensureChunkHandlers,
 				RuntimeGlobals.externalInstallChunk,
-				RuntimeGlobals.analyzableChunkImport,
 				RuntimeGlobals.hmrDownloadUpdateHandlers
 			]) {
 				compilation.hooks.runtimeRequirementInTree
@@ -135,11 +133,29 @@ class ModuleChunkLoadingPlugin {
 			}
 
 			// 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.
+			// builds a URL from a chunk id, and a baked specifier carries its own.
 			compilation.hooks.runtimeRequirementInTree
 				.for(RuntimeGlobals.ensureChunk)
-				.tap(PLUGIN_NAME, (chunk, set) => {
-					if (!isEnabledForChunk(chunk)) return;
+				.tap(PLUGIN_NAME, (chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) {
+						compilation.runtimeTemplate.reportChunkImportBailout(
+							chunk,
+							chunkGraph
+						);
+						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 (
+						runtimeTemplate.analyzableChunkImports(chunk, chunkGraph, set) !==
+							null &&
+						!set.has(RuntimeGlobals.hmrDownloadUpdateHandlers) &&
+						!runtimeTemplate.chunkImportsNeedRuntimeUrl(chunk, chunkGraph)
+					) {
+						return;
+					}
 
 					if (compilation.outputOptions.publicPath !== "auto") {
 						set.add(RuntimeGlobals.publicPath);

package/lib/esm/ModuleChunkLoadingRuntimeModule.js

@@ -17,6 +17,7 @@ const { getInitialChunkIds } = require("../javascript/StartupHelpers");
 const { renderBaseUri } = require("../runtime/baseUri");
 const compileBooleanMatcher = require("../util/compileBooleanMatcher");
 const createHooksRegistry = require("../util/createHooksRegistry");
+const { RESOLVABLE_SPECIFIER_REGEXP } = require("../util/identifier");
 const memoize = require("../util/memoize");
 
 const getAPIPlugin = memoize(() => require("../APIPlugin"));
@@ -53,6 +54,54 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		this._runtimeRequirements = runtimeRequirements;
 	}
 
+	/**
+	 * 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() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const chunkGraph = /** @type {ChunkGraph} */ (this.chunkGraph);
+		const chunk = /** @type {Chunk} */ (this.chunk);
+		const runtimeRequirements = this._runtimeRequirements;
+		const withHmr = runtimeRequirements.has(
+			RuntimeGlobals.hmrDownloadUpdateHandlers
+		);
+		const withHint =
+			compilation.outputOptions.environment.document ||
+			compilation.runtimeTemplate.isNeutralPlatform();
+		/** @type {[string, string][]} */
+		const handlers = [];
+		if (
+			runtimeRequirements.has(RuntimeGlobals.ensureChunkHandlers) &&
+			(runtimeRequirements.has(RuntimeGlobals.ensureChunk) || withHmr)
+		) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "j"]);
+		}
+		// The hot update flow installs this one onto the same map while it runs.
+		if (withHmr) {
+			handlers.push([RuntimeGlobals.ensureChunkHandlers, "moduleHmr"]);
+		}
+		if (
+			withHint &&
+			runtimeRequirements.has(RuntimeGlobals.prefetchChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "prefetch", true, chunkHasJs)
+		) {
+			handlers.push([RuntimeGlobals.prefetchChunkHandlers, "j"]);
+		}
+		if (
+			withHint &&
+			runtimeRequirements.has(RuntimeGlobals.preloadChunkHandlers) &&
+			chunk.hasChildByOrder(chunkGraph, "preload", true, chunkHasJs)
+		) {
+			handlers.push([RuntimeGlobals.preloadChunkHandlers, "j"]);
+		}
+		if (runtimeRequirements.has(RuntimeGlobals.onChunksLoaded)) {
+			handlers.push([RuntimeGlobals.onChunksLoaded, "j"]);
+		}
+		return handlers;
+	}
+
 	/**
 	 * Returns generated code.
 	 * @private
@@ -96,9 +145,6 @@ 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
 		);
@@ -111,8 +157,8 @@ 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.
+		// `.f.j` serves `ensureChunk`. HMR's force-load knows only a chunk id, so it
+		// needs the loader too.
 		const withJsLoading =
 			withLoading &&
 			(this._runtimeRequirements.has(RuntimeGlobals.ensureChunk) || withHmr);
@@ -138,6 +184,16 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 						this
 					)
 				: null;
+		// Under module output every chunk the loader reaches is a known file, so it
+		// imports a literal specifier read by id instead of a url built from that id.
+		const chunkImports = withJsLoading
+			? runtimeTemplate.analyzableChunkImports(
+					chunk,
+					chunkGraph,
+					this._runtimeRequirements,
+					this
+				)
+			: null;
 		const conditionMap = chunkGraph.getChunkConditionMap(chunk, chunkHasJs);
 		const hasJsMatcher = compileBooleanMatcher(conditionMap);
 		const initialChunkIds = getInitialChunkIds(chunk, chunkGraph, chunkHasJs);
@@ -152,7 +208,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			publicPath === "auto"
 				? JSON.stringify(rootOutputDir)
 				: typeof publicPath === "string" &&
-					  !/^(?:\.{0,2}\/|[a-zA-Z][\w+.-]*:)/.test(publicPath) &&
+					  !RESOLVABLE_SPECIFIER_REGEXP.test(publicPath) &&
 					  !getAPIPlugin().usesRuntimePublicPathOverride(compilation)
 					? `"./" + ${RuntimeGlobals.publicPath}`
 					: RuntimeGlobals.publicPath;
@@ -173,7 +229,6 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 		const withInstalledChunks =
 			withLoading ||
 			withExternalInstallChunk ||
-			withAnalyzableImport ||
 			withOnChunkLoad ||
 			withHmr ||
 			withPrefetch ||
@@ -188,6 +243,19 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 			chunkUrls === null
 				? `${RuntimeGlobals.publicPath} + ${RuntimeGlobals.getChunkScriptFilename}(${id})`
 				: `chunkUrls[${id}]()`;
+		const runtimeImport = `${importFunctionName}(${chunkImportBase} + ${RuntimeGlobals.getChunkScriptFilename}(chunkId))`;
+		// 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
+				: withRuntimeUrl
+					? `(${RuntimeGlobals.hasOwnProperty}(chunkImports, chunkId) ? chunkImports[chunkId]() : ${runtimeImport})`
+					: "chunkImports[chunkId]()";
 		return Template.asString([
 			withBaseURI
 				? this._generateBaseUri(chunk, rootOutputDir)
@@ -205,6 +273,20 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 						""
 					]
 				: []),
+			...(chunkImports
+				? [
+						`${cst} chunkImports = {\n${Template.indent(
+							Array.from(
+								chunkImports,
+								([id, specifier]) =>
+									`${JSON.stringify(String(id))}: ${runtimeTemplate.returningFunction(
+										`${importFunctionName}(${specifier})`
+									)}`
+							).join(",\n")
+						)}\n};`,
+						""
+					]
+				: []),
 			withInstalledChunks
 				? Template.asString([
 						"// object to store loaded and loading chunks",
@@ -221,7 +303,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					])
 				: "// no installed chunks",
 			"",
-			withLoading || withExternalInstallChunk || withAnalyzableImport
+			withLoading || withExternalInstallChunk
 				? `${cst} installChunk = ${runtimeTemplate.basicFunction("data", [
 						runtimeTemplate.destructureObject(
 							[
@@ -280,9 +362,7 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 													: `if(${hasJsMatcher("chunkId")}) {`,
 												Template.indent([
 													"// setup Promise in chunk cache",
-													`${lt} promise = ${importFunctionName}(${chunkImportBase} + ${
-														RuntimeGlobals.getChunkScriptFilename
-													}(chunkId)).then(installChunk, ${runtimeTemplate.basicFunction(
+													`${lt} promise = ${chunkImport}.then(installChunk, ${runtimeTemplate.basicFunction(
 														"e",
 														[
 															"if(installedChunks[chunkId] !== 0) installedChunks[chunkId] = undefined;",
@@ -422,48 +502,6 @@ class ModuleChunkLoadingRuntimeModule extends RuntimeModule {
 					])
 				: "// no external install chunk",
 			"",
-			withAnalyzableImport
-				? `${
-						RuntimeGlobals.analyzableChunkImport
-					} = ${runtimeTemplate.basicFunction("chunkId, importFn", [
-						// `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) { // 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",
-			"",
 			withOnChunkLoad
 				? `${
 						RuntimeGlobals.onChunksLoaded

package/lib/hmr/HotModuleReplacement.runtime.js

@@ -26,14 +26,20 @@
 
 /** @typedef {(options: ApplyOptions) => ApplyResult} ApplyHandler */
 /** @typedef {(moduleId: ModuleId, applyHandlers: ApplyHandler[]) => void} InvalidateModuleHandler */
-/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: Promise<unknown>[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: ModuleId[] | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
+/**
+ * @typedef {object} CssUpdateManifest
+ * @property {ModuleId[]} r updated chunk ids that no longer have a stylesheet
+ * @property {Record<string, string>=} n the stylesheet name of each updated chunk whose name moved with its content
+ */
+
+/** @typedef {(chunkIds: ModuleId[], removedChunks: ModuleId[], removedModules: ModuleId[], promises: Promise<unknown>[], applyHandlers: ApplyHandler[], updatedModulesList: ModuleId[], css: CssUpdateManifest | undefined, forceLoadChunks: ModuleId[] | undefined) => void} DownloadUpdateHandler */
 
 /**
  * @typedef {object} HMRManifest
  * @property {ModuleId[]} c updated chunk ids
  * @property {ModuleId[]} r removed chunk ids
  * @property {ModuleId[]} m removed module ids
- * @property {ModuleId[]=} css updated css chunk ids
+ * @property {CssUpdateManifest=} css what the stylesheet loader needs to know about the update
  * @property {ModuleId[]=} f chunk ids to force-load
  */
 

package/lib/hmr/HotModuleReplacementRuntimeModule.js

@@ -16,6 +16,15 @@ class HotModuleReplacementRuntimeModule extends RuntimeModule {
 		super("hot module replacement", RuntimeModule.STAGE_BASIC);
 	}
 
+	/**
+	 * 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/hmr/LazyCompilationPlugin.js

@@ -335,11 +335,9 @@ class LazyCompilationProxyModule extends Module {
 			block.addDependency(dep);
 			this.addBlock(block);
 		} else if (hasClosureLibrary(compilation.options.output)) {
-			// Reserve statically-declared externals as dependencies of the inactive
-			// proxy so the initial entry chunk's library wrapper already exposes
-			// their closure identifiers (e.g. `__WEBPACK_EXTERNAL_MODULE_react__`).
-			// Once the proxy activates and the lazily-built module references those
-			// externals, the identifiers resolve normally instead of throwing.
+			// Reserve the statically declared externals on the inactive proxy, so the
+			// entry chunk's library wrapper already exposes their closure identifiers
+			// and they resolve rather than throw once the proxy activates.
 			const requests = collectStaticExternalRequests(
 				options.externals,
 				this.layer

package/lib/html/HtmlGenerator.js

@@ -9,6 +9,7 @@ const ConcatenationScope = require("../ConcatenationScope");
 const Generator = require("../Generator");
 const {
 	HTML_TYPE,
+	HTML_TYPES,
 	JAVASCRIPT_TYPE,
 	JAVASCRIPT_TYPES
 } = require("../ModuleSourceTypeConstants");
@@ -225,12 +226,9 @@ const CHUNK_URL_SENTINEL_REGEXP =
 const HTML_PAGE_URL_SENTINEL_REGEXP =
 	/__WEBPACK_HTML_PAGE_URL__([0-9a-f]+)__END__/g;
 
-// Sentinel for a URL-referenced asset (font/image/…) emitted into a resource-hint
-// `<link>` tag by `HtmlEntryDependency`; resolved to the asset's real emitted
-// URL from its codegen data during `HtmlModulesPlugin` render. Deferred because
-// HtmlEntry deps run *while* the HTML module is being codegen'd — the asset
-// module's own codegen might not have completed yet. Keyed by the asset
-// module's identifier, hex-encoded so any character in it is safe in a URL.
+// Sentinel for a URL-referenced asset in a resource-hint `<link>`, resolved at
+// `HtmlModulesPlugin` render because HtmlEntry deps run while the HTML module
+// is codegen'd, before the asset's own. Keyed by hex-encoded identifier.
 const ASSET_URL_SENTINEL_REGEXP =
 	/__WEBPACK_HTML_ASSET_URL__([0-9a-f]+)__END__/g;
 
@@ -239,11 +237,9 @@ const ASSET_URL_SENTINEL_REGEXP =
 /** @type {WeakSet<Compilation>} */
 const integritySentinelCompilations = new WeakSet();
 
-// Matches the whole ` integrity="<sentinel>"` so the attribute can be dropped
-// entirely when the per-asset `integrity` function returns `false`. Minification
-// runs first and may have unquoted the value (§13.1.2.3), so the quote is
-// optional and back-referenced to keep the pair matched; the replacement always
-// re-quotes, since an SRI list carries spaces and `=` padding.
+// Matches the whole ` integrity="<sentinel>"`, so the attribute can be dropped
+// when the per-asset `integrity` returns `false`. Minification runs first and
+// may have unquoted it, hence the optional back-referenced quote.
 const INTEGRITY_SENTINEL_REGEXP =
 	/ integrity=(["']?)__WEBPACK_HTML_INTEGRITY__([0-9a-f]+)__([a-z]+)__END__\1/g;
 
@@ -252,10 +248,9 @@ const INTEGRITY_SENTINEL_REGEXP =
 const INTEGRITY_SENTINEL_STRIP_REGEXP =
 	/ integrity=(\\?["']|)__WEBPACK_HTML_INTEGRITY__[0-9a-f]+__[a-z]+__END__\1/g;
 
-// The trailing `(?:__<hash>)?` is the inlined chunk's content hash, embedded by
-// `embedInlineChunkHashes` so the host HTML's bytes (and its `[contenthash]`,
-// incl. RealContentHashPlugin's recompute) change with the inlined content; the
-// resolver ignores it.
+// The trailing `(?:__<hash>)?` is the inlined chunk's content hash, embedded so
+// the host page's bytes and `[contenthash]` change with the inlined content.
+// The resolver ignores it.
 const INLINE_SENTINEL_REGEXP =
 	/__WEBPACK_HTML_INLINE__([0-9a-f]+)__([a-z]+)(?:__[0-9a-f]+)?__END__/g;
 
@@ -448,12 +443,9 @@ class HtmlGenerator extends Generator {
 			const url =
 				/** @type {Record<string, string | undefined> | undefined} */
 				(data.get("url"));
-			// Prefer the `asset-url` channel — it's the actual URL string
-			// (publicPath + filename). Also handled: assets reached only from JS
-			// have no `asset-url` channel (their only URL is the JS expression
-			// `__webpack_require__.p + "…"`); for those we reconstruct the URL
-			// from the emitted `filename` + `PUBLIC_PATH_AUTO` so the same
-			// undo-path substitution runs at asset render.
+			// Prefer the `asset-url` channel, which is the real URL string. An asset
+			// reached only from JS has none — its URL is a JS expression — so rebuild
+			// one from `filename` and let the undo-path substitution run.
 			if (url && url["asset-url"]) return url["asset-url"];
 			const filename = /** @type {string | undefined} */ (data.get("filename"));
 			if (filename) return `${PUBLIC_PATH_AUTO}${filename}`;
@@ -692,10 +684,9 @@ class HtmlGenerator extends Generator {
 							bodyDepth++;
 						}
 					},
-					// Collected on exit: an element's `end` is only final once it
-					// closes, and the streamed walk enters it while it is still open.
-					// `script` / `style` / `link` / `meta` never nest in each other, so
-					// exiting keeps them in source order.
+					// Collected on exit, since an element's `end` is final only once it
+					// closes. `script`, `style`, `link` and `meta` never nest in each
+					// other, so exiting keeps them in source order.
 					exit: (path) => {
 						const name = path.tagName();
 						if (name === "head") {
@@ -1047,19 +1038,19 @@ class HtmlGenerator extends Generator {
 	 * Creates an instance of HtmlGenerator.
 	 * @param {HtmlGeneratorOptions=} options generator options
 	 * @param {ModuleGraph=} moduleGraph the module graph; used to detect when an HTML module is reached as a compilation entry so `extract` can default to `true` for it
+	 * @param {((module: NormalModule) => boolean)=} isPageOnly tells whether the module's only output is its emitted page, so it exposes no JavaScript
 	 */
-	constructor(options, moduleGraph) {
+	constructor(options, moduleGraph, isPageOnly) {
 		super();
 		/** @type {HtmlGeneratorOptions} */
 		this.options = options || {};
 		/** @type {ModuleGraph | undefined} */
 		this._moduleGraph = moduleGraph;
-		// Raw dependency-template render (before `[webpack/auto]` resolution),
-		// shared between the JS and HTML type passes of a single
-		// `codeGeneration()` call. Keyed by that call's `runtimeRequirements`
-		// Set — created once per call and passed to every type's `generate()`,
-		// so it uniquely scopes the cache to one module's one code generation
-		// and releases with it. The two passes differ only in `undoPath`.
+		/** @type {((module: NormalModule) => boolean) | undefined} */
+		this._isPageOnly = isPageOnly;
+		// Raw render shared between the JS and HTML passes of one `codeGeneration()`
+		// call, which differ only in `undoPath`. Keyed by that call's
+		// `runtimeRequirements` Set, so the entry is scoped to it and releases with it.
 		/** @type {WeakMap<RuntimeRequirements, string>} */
 		this._rawRenderCache = new WeakMap();
 	}
@@ -1071,11 +1062,9 @@ class HtmlGenerator extends Generator {
 	 * @returns {string | undefined} reason why this module can't be concatenated, undefined when it can be concatenated
 	 */
 	getConcatenationBailoutReason(module, context) {
-		// The HMR shim references the per-module `module.hot` object — when an
-		// HTML module is concatenated, that scope is gone (the merged file
-		// shares a single `module`), so the self-accept / DOM-patch wiring
-		// would target the wrong module id. Bail out of concatenation so the
-		// HMR-aware HTML module keeps its own module scope.
+		// The HMR shim references the per-module `module.hot`, and a concatenated
+		// file shares one `module`, so the self-accept wiring would target the wrong
+		// id. Bail out, keeping the module's own scope.
 		if (module.hot) {
 			return "HTML module needs its own module scope for HMR";
 		}
@@ -1134,6 +1123,9 @@ class HtmlGenerator extends Generator {
 	 */
 	getTypes(module) {
 		if (this._shouldExposeHtmlType(module)) {
+			// A page nothing else reads has no JavaScript side: that chunk would
+			// only re-export the markup already emitted as the `.html` asset.
+			if (this._isPageOnly && this._isPageOnly(module)) return HTML_TYPES;
 			return JAVASCRIPT_AND_HTML_TYPES;
 		}
 		return JAVASCRIPT_TYPES;
@@ -1143,10 +1135,9 @@ class HtmlGenerator extends Generator {
 	 * @returns {boolean} whether getTypes() depends on the module's incoming connections
 	 */
 	getTypesDependOnIncomingConnections() {
-		// A fixed extract (`true` / `false` / `"inline"`) gives a stable type set;
-		// only the unset default reads `_isEntryModule` (incoming connections).
-		const { extract } = this.options;
-		return extract !== true && extract !== false && extract !== "inline";
+		// Every page that can expose the html type reads incoming connections —
+		// for the `extract` default, and for the page-only JavaScript drop.
+		return this.options.extract !== false;
 	}
 
 	/**
@@ -1272,10 +1263,9 @@ class HtmlGenerator extends Generator {
 	 * @returns {string} the rewritten HTML
 	 */
 	_renderHtml(module, generateContext, undoPath) {
-		// The dependency-template pass is identical for both type passes (no
-		// template branches on `type` or writes `runtimeRequirements`), so
-		// compute the raw render once per `codeGeneration()` and reuse it; the
-		// passes diverge only in the `[webpack/auto]` substitution below.
+		// No dependency template branches on `type` or writes
+		// `runtimeRequirements`, so the raw render is computed once per
+		// `codeGeneration()`; the passes diverge only in the substitution below.
 		const cacheKey = generateContext.runtimeRequirements;
 		let rawContent = this._rawRenderCache.get(cacheKey);
 		if (rawContent === undefined) {
@@ -1339,11 +1329,9 @@ class HtmlGenerator extends Generator {
 
 		/** @type {string} */
 		let sourceContent;
-		// `module.hot` is set by `HotModuleReplacementPlugin` on every module
-		// when HMR is enabled. When set, we cannot use the concatenation path
-		// (it merges into a parent's module scope, where `module.hot.accept`
-		// would target the wrong id) — `getConcatenationBailoutReason` keeps
-		// us out of concatenation in that case.
+		// `module.hot` marks HMR being enabled, and concatenation merges into a
+		// parent's scope where `module.hot.accept` would target the wrong id.
+		// `getConcatenationBailoutReason` keeps such a module out of it.
 		if (generateContext.concatenationScope && !module.hot) {
 			generateContext.concatenationScope.registerNamespaceExport(
 				ConcatenationScope.NAMESPACE_OBJECT_EXPORT
@@ -1417,15 +1405,11 @@ class HtmlGenerator extends Generator {
 		const acceptBlock = extracting
 			? [
 					"module.hot.accept();",
-					// Mask `<!-- … -->` comments — replace their characters
-					// with spaces, preserving length — before any tag regex
-					// runs. Masking (rather than deleting) keeps string offsets
-					// stable, so the body/title content can be sliced back out
-					// of the original HTML with comments intact, while a
-					// `<body>`/`</body>`/`<title>` inside a comment can no
-					// longer fool the tag regexes (the non-greedy `*?` would
-					// otherwise stop at the FIRST `</body>` it sees, even one
-					// inside a comment).
+					// WHY: a `</body>` inside a comment stops the non-greedy `*?` at the
+					// wrong place, so comments are masked before any tag regex runs.
+					// Masking rather than deleting keeps offsets stable, so the body and
+					// title can still be sliced out of the original HTML with their
+					// comments intact.
 					`${declare} __webpack_mask_comments__ = ${runtimeTemplate.returningFunction(
 						`h.replace(/<!--[\\s\\S]*?-->/g, ${runtimeTemplate.returningFunction(
 							'c.replace(/[^\\n]/g, " ")',
@@ -1469,9 +1453,8 @@ class HtmlGenerator extends Generator {
 						]
 					)};`,
 					// A `<script>` parsed out of a string carries the already-started flag,
-					// so appending that element would never run it. A fresh one with the
-					// same attributes and body does — which is what the reload this
-					// replaces would have done.
+					// so appending it would never run. A fresh one with the same attributes
+					// and body does, as the reload this replaces would have.
 					`${declare} __webpack_revive_script__ = ${runtimeTemplate.basicFunction(
 						"node",
 						[
@@ -1487,11 +1470,9 @@ class HtmlGenerator extends Generator {
 							"return script;"
 						]
 					)};`,
-					// Apply only the difference between the two authored heads, keyed on
-					// serialized markup: the runtime's own injected `<script>` / `<link>`
-					// are in neither string, so replacing `document.head` wholesale would
-					// tear them down while a delta never touches them. Reports whether it
-					// could — the caller reloads when it could not.
+					// Apply only the difference between the two authored heads: the
+					// runtime's own injected tags are in neither string, so replacing
+					// `document.head` wholesale would tear them down where a delta cannot.
 					`${declare} __webpack_patch_head__ = ${runtimeTemplate.basicFunction(
 						"oldHtml, newHtml",
 						[
@@ -1527,14 +1508,12 @@ class HtmlGenerator extends Generator {
 							`${declare} removed = surplus(oldChildren, newChildren);`,
 							`${declare} added = surplus(newChildren, oldChildren);`,
 							"if (removed.length === 0 && added.length === 0) return true;",
-							// A script that has run cannot be un-run, so dropping one is the
-							// one edit still worth a reload — but only a script that ran. A
-							// `type` that is neither a JavaScript MIME type nor `module` /
-							// `importmap` / `speculationrules` makes the element a data block
-							// (`application/ld+json`, `text/template`, …) the browser never
-							// executed, so removing it is as safe as removing a `<meta>`.
-							// Every JavaScript MIME essence ends in `script`, and a type
-							// nothing here recognizes falls back to the reload.
+							// WHY: a script that has run cannot be un-run, so dropping one is the
+							// single edit still worth a reload — but only a script that ran. A
+							// `type` that is neither a JavaScript MIME essence, all of which end
+							// in `script`, nor `module`, `importmap` or `speculationrules` is a
+							// data block the browser never executed, as safe to remove as a
+							// `<meta>`. An unrecognized type falls back to the reload.
 							`if (removed.some(${runtimeTemplate.basicFunction("node", [
 								'if (node.nodeName !== "SCRIPT") return false;',
 								`${declare} type = (node.getAttribute("type") || "").trim().toLowerCase();`,
@@ -1558,11 +1537,9 @@ class HtmlGenerator extends Generator {
 							]),
 							"}",
 							`for (${mutable} i = 0; i < live.length; i++) document.head.removeChild(live[i]);`,
-							// Pair each retained element with its live node, scanning only
-							// forward: an authored element that has moved relative to the
-							// others finds no match from there on, and a reorder the delta
-							// cannot express falls back to the reload. Injected nodes simply
-							// never match, so they neither anchor nor block anything.
+							// Pair each retained element with its live node, scanning forward
+							// only: a moved element then finds no match and falls back to the
+							// reload, while an injected node never matches either way.
 							`${declare} liveByNew = [];`,
 							`${mutable} searchFrom = 0;`,
 							`for (${mutable} i = 0; i < newChildren.length; i++) {`,
@@ -1642,13 +1619,22 @@ class HtmlGenerator extends Generator {
 	 */
 	generateError(error, module, generateContext) {
 		if (generateContext.type === HTML_TYPE) {
-			// Strip `<`, `>`, `--` runs from `error.message` so it can't escape the comment.
-			const safe = String(error.message)
+			// Strip `<`, `>`, `--` runs from the message so it can't escape the comment.
+			const safe = Generator.buildErrorMessage(
+				error,
+				generateContext.runtimeTemplate.requestShortener
+			)
 				.replace(/[<>]/g, "")
 				.replace(/-{2,}/g, (m) => `${"-".repeat(m.length - 1)} `);
 			return new RawSource(`<!-- webpack error: ${safe} -->`);
 		}
-		return new RawSource(Generator.throwBuildErrorCode(error));
+		return new RawSource(
+			Generator.throwBuildErrorCode(
+				error,
+				undefined,
+				generateContext.runtimeTemplate.requestShortener
+			)
+		);
 	}
 
 	/**
@@ -1658,10 +1644,9 @@ class HtmlGenerator extends Generator {
 	 */
 	updateHash(hash, updateHashContext) {
 		hash.update("html");
-		// Source-type set changes when html-type exposure flips; the HMR shim's
-		// `extracting` branch changes when the emit decision flips. They differ
-		// only for `"inline"` (exposes html, but does not emit), so hash both.
-		// One `_shouldExtract` walk covers both checks (expose = extract ∪ inline).
+		// The source-type set turns on html-type exposure and the HMR shim's
+		// `extracting` branch on the emit decision. They differ only for
+		// `"inline"`, which exposes html without emitting, so hash both.
 		const extract = this._shouldExtract(updateHashContext.module);
 		if (extract || this.options.extract === "inline") {
 			hash.update("html-type");