webpack 5.108.4 → 5.109.1

package/lib/async-modules/AwaitDependenciesInitFragment.js

@@ -22,8 +22,9 @@ class AwaitDependenciesInitFragment extends InitFragment {
 	/**
 	 * Creates an instance of AwaitDependenciesInitFragment.
 	 * @param {Dependencies} dependencies maps an import var to an async module that needs to be awaited
+	 * @param {boolean=} generatorLowered module is emitted as a generator, so use `yield` instead of `await`
 	 */
-	constructor(dependencies) {
+	constructor(dependencies, generatorLowered = false) {
 		super(
 			undefined,
 			InitFragment.STAGE_ASYNC_DEPENDENCIES,
@@ -32,6 +33,8 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		);
 		/** @type {Dependencies} */
 		this.dependencies = dependencies;
+		/** @type {boolean} */
+		this.generatorLowered = generatorLowered;
 	}
 
 	/**
@@ -44,7 +47,10 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		for (const [key, value] of this.dependencies) {
 			dependencies.set(key, value);
 		}
-		return new AwaitDependenciesInitFragment(dependencies);
+		return new AwaitDependenciesInitFragment(
+			dependencies,
+			this.generatorLowered || other.generatorLowered
+		);
 	}
 
 	/**
@@ -61,6 +67,10 @@ class AwaitDependenciesInitFragment extends InitFragment {
 		const importVars = [...this.dependencies.keys()];
 		const asyncModuleValues = [...this.dependencies.values()].join(", ");
 
+		// In a generator-lowered module (no `async`/`await`, but generators) the
+		// dependency `await` becomes `yield`; the body stays a single scope.
+		const suspend = this.generatorLowered ? "yield" : "await";
+
 		const templateInput = [
 			`var __webpack_async_dependencies__ = __webpack_handle_async_dependencies__([${asyncModuleValues}]);`
 		];
@@ -70,7 +80,7 @@ class AwaitDependenciesInitFragment extends InitFragment {
 			!runtimeTemplate.supportsDestructuring()
 		) {
 			templateInput.push(
-				"var __webpack_async_dependencies_result__ = (__webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);"
+				`var __webpack_async_dependencies_result__ = (__webpack_async_dependencies__.then ? (${suspend} __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
 			);
 			for (const [index, importVar] of importVars.entries()) {
 				templateInput.push(
@@ -81,7 +91,7 @@ class AwaitDependenciesInitFragment extends InitFragment {
 			const importVarsStr = importVars.join(", ");
 
 			templateInput.push(
-				`([${importVarsStr}] = __webpack_async_dependencies__.then ? (await __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
+				`([${importVarsStr}] = __webpack_async_dependencies__.then ? (${suspend} __webpack_async_dependencies__)() : __webpack_async_dependencies__);`
 			);
 		}
 

package/lib/async-modules/isGeneratorLowered.js

@@ -0,0 +1,26 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("../ModuleGraph")} ModuleGraph */
+/** @typedef {import("../RuntimeTemplate")} RuntimeTemplate */
+
+/**
+ * Whether an async module is lowered to a generator: the target has no
+ * `async`/`await` but supports generators, and the module contains no
+ * top-level `for await…of` (which generators can't express).
+ * @param {Module} module module
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {RuntimeTemplate} runtimeTemplate runtime template
+ * @returns {boolean} true when the module should be emitted as a generator
+ */
+const isGeneratorLowered = (module, moduleGraph, runtimeTemplate) =>
+	moduleGraph.isAsync(module) &&
+	!runtimeTemplate.supportsAsyncFunction() &&
+	Boolean(runtimeTemplate.supportsGenerator()) &&
+	!(module.buildInfo && module.buildInfo.usesTopLevelAwaitForOf);
+
+module.exports = isGeneratorLowered;

package/lib/cache/PackFileCacheStrategy.js

@@ -1134,7 +1134,7 @@ class PackFileCacheStrategy {
 	 * @param {number} options.maxAge max age of cache items
 	 * @param {boolean=} options.profile track and log detailed timing information for individual cache items
 	 * @param {boolean=} options.allowCollectingMemory allow to collect unused memory created during deserialization
-	 * @param {false | "gzip" | "brotli"=} options.compression compression used
+	 * @param {false | "gzip" | "brotli" | "zstd"=} options.compression compression used
 	 * @param {boolean=} options.readonly disable storing cache into filesystem
 	 */
 	constructor({
@@ -1182,15 +1182,21 @@ class PackFileCacheStrategy {
 		this.readonly = readonly;
 		/** @type {boolean | undefined} */
 		this.allowCollectingMemory = allowCollectingMemory;
-		/** @type {false | "gzip" | "brotli" | undefined} */
+		/** @type {false | "gzip" | "brotli" | "zstd" | undefined} */
 		this.compression = compression;
+		// eslint-disable-next-line n/no-unsupported-features/node-builtins
+		if (compression === "zstd" && !require("zlib").createZstdCompress) {
+			throw new Error("cache.compression: 'zstd' requires Node.js >= 22.15.0");
+		}
 		/** @type {string} */
 		this._extension =
 			compression === "brotli"
 				? ".pack.br"
 				: compression === "gzip"
 					? ".pack.gz"
-					: ".pack";
+					: compression === "zstd"
+						? ".pack.zst"
+						: ".pack";
 		/** @type {SnapshotOptions} */
 		this.snapshot = snapshot;
 		/** @type {BuildDependencies} */

package/lib/config/browserslistTargetHandler.js

@@ -449,6 +449,25 @@ const resolve = (browsers) => {
 			kaios: 3,
 			node: [7, 6]
 		}),
+		generator: rawChecker({
+			chrome: 39,
+			and_chr: 39,
+			edge: 13,
+			firefox: 26,
+			and_ff: 26,
+			// ie: Not supported,
+			opera: 26,
+			op_mob: 26,
+			safari: 10,
+			ios_saf: 10,
+			samsung: [3, 4],
+			android: 39,
+			and_qq: [10, 4],
+			baidu: [7, 12],
+			and_uc: [12, 12],
+			kaios: [2, 5],
+			node: 4
+		}),
 		/* eslint-enable camelcase */
 		browser: browserProperty,
 		electron: false,
@@ -458,6 +477,27 @@ const resolve = (browsers) => {
 		webworker: false,
 
 		document: browserProperty,
+		modulePreload:
+			browserProperty &&
+			/* eslint-disable camelcase */
+			rawChecker({
+				chrome: 66,
+				and_chr: 66,
+				edge: 79,
+				firefox: 115,
+				and_ff: 115,
+				opera: 53,
+				op_mob: 47,
+				safari: 17,
+				ios_saf: 17,
+				samsung: [9, 0],
+				android: 66,
+				and_qq: [13, 1],
+				baidu: [13, 18],
+				and_uc: [15, 5],
+				kaios: [3, 1]
+			}),
+		/* eslint-enable camelcase */
 		fetchWasm: browserProperty,
 		global: nodeProperty,
 		importScripts: false,

package/lib/config/defaults.js

@@ -31,6 +31,7 @@ const {
 	WEBASSEMBLY_MODULE_TYPE_SYNC
 } = require("../ModuleTypeConstants");
 const Template = require("../Template");
+const RuleSetCompiler = require("../rules/RuleSetCompiler");
 const { cleverMerge } = require("../util/cleverMerge");
 const {
 	getDefaultTarget,
@@ -71,6 +72,7 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").ParserOptionsByModuleTypeKnown} ParserOptionsByModuleTypeKnown */
 /** @typedef {import("../../declarations/WebpackOptions").Performance} Performance */
 /** @typedef {import("../../declarations/WebpackOptions").ResolveOptions} ResolveOptions */
+/** @typedef {import("../../declarations/WebpackOptions").RuleSetRule} RuleSetRule */
 /** @typedef {import("../../declarations/WebpackOptions").RuleSetRules} RuleSetRules */
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
 /** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
@@ -341,6 +343,26 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		}
 	}
 
+	D(options, "watch", false);
+	D(options, "profile", false);
+	D(options, "parallelism", 100);
+	D(options, "recordsInputPath", false);
+	D(options, "recordsOutputPath", false);
+
+	// Capture the raw html intent before "auto" is resolved: only an explicit
+	// `html: true` (or futureDefaults) keeps `.html` ahead of `.js` when resolving.
+	const htmlExplicitlyEnabled = options.experiments.html === true;
+	const htmlWasUnset = options.experiments.html === undefined;
+
+	applyExperimentsDefaults(options.experiments, {
+		production,
+		development,
+		targetProperties,
+		rules: options.module.rules
+	});
+
+	// After experiments are resolved: the default dev source map depends on the
+	// (possibly "auto"-resolved) `experiments.css` value.
 	F(
 		options,
 		"devtool",
@@ -363,24 +385,20 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			)
 	);
 
-	D(options, "watch", false);
-	D(options, "profile", false);
-	D(options, "parallelism", 100);
-	D(options, "recordsInputPath", false);
-	D(options, "recordsOutputPath", false);
-
-	applyExperimentsDefaults(options.experiments, {
-		production,
-		development,
-		targetProperties
-	});
-
 	const futureDefaults =
 		/** @type {NonNullable<ExperimentsNormalized["futureDefaults"]>} */
 		(options.experiments.futureDefaults);
 
+	// `.html` outranks `.js` only for an explicit opt-in (`html: true`, or the
+	// futureDefaults-forced default), never for the auto-enabled default.
+	const htmlFirst = htmlExplicitlyEnabled || (htmlWasUnset && futureDefaults);
+
 	F(options, "validate", () => !(futureDefaults === true && production));
 
+	// Progress lives on infrastructureLogging; webpack@6 shows the interactive
+	// bar by default (`"auto"` = TTY only), webpack@5 stays opt-in.
+	D(options.infrastructureLogging, "progress", futureDefaults ? "auto" : false);
+
 	F(options, "cache", () =>
 		development ? { type: /** @type {"memory"} */ ("memory") } : false
 	);
@@ -414,7 +432,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		entry: options.entry,
 		futureDefaults,
 		asyncWebAssembly:
-			/** @type {NonNullable<ExperimentsNormalized["asyncWebAssembly"]>} */
+			/** @type {boolean} */
 			(options.experiments.asyncWebAssembly)
 	});
 
@@ -430,16 +448,16 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			/** @type {NonNullable<ExperimentsNormalized["syncWebAssembly"]>} */
 			(options.experiments.syncWebAssembly),
 		asyncWebAssembly:
-			/** @type {NonNullable<ExperimentsNormalized["asyncWebAssembly"]>} */
+			/** @type {boolean} */
 			(options.experiments.asyncWebAssembly),
 		css:
-			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+			/** @type {boolean} */
 			(options.experiments.css),
 		html:
-			/** @type {NonNullable<ExperimentsNormalized["html"]>} */
+			/** @type {boolean} */
 			(options.experiments.html),
 		typescript:
-			/** @type {NonNullable<ExperimentsNormalized["typescript"]>} */
+			/** @type {boolean} */
 			(options.experiments.typescript),
 		deferImport:
 			/** @type {NonNullable<ExperimentsNormalized["deferImport"]>} */
@@ -458,6 +476,29 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		library: options.output.library
 	});
 
+	// `output.resourceHints.urlHints` shorthand: fan the project-wide rules out
+	// as the base `urlHints` of every URL-emitting parser (JS `new URL`, CSS
+	// `url()`, HTML `<img src>`). They go first so parser-scoped
+	// `parser.<type>.urlHints` rules — matched later, last-match-wins — override.
+	const outputUrlHints =
+		options.output.resourceHints && options.output.resourceHints.urlHints;
+	if (outputUrlHints && outputUrlHints.length > 0) {
+		for (const type of [
+			"javascript",
+			CSS_MODULE_TYPE,
+			CSS_MODULE_TYPE_AUTO,
+			CSS_MODULE_TYPE_MODULE,
+			CSS_MODULE_TYPE_GLOBAL,
+			HTML_MODULE_TYPE
+		]) {
+			const parser =
+				/** @type {{ urlHints?: import("../../declarations/WebpackOptions").UrlHintRule[] } | undefined} */
+				(options.module.parser[type]);
+			if (!parser) continue;
+			parser.urlHints = [...outputUrlHints, ...(parser.urlHints || [])];
+		}
+	}
+
 	applyExternalsPresetsDefaults(options.externalsPresets, {
 		targetProperties,
 		buildHttp: Boolean(options.experiments.buildHttp),
@@ -514,7 +555,7 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		development,
 		production,
 		css:
-			/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+			/** @type {boolean} */
 			(options.experiments.css),
 		records: Boolean(options.recordsInputPath || options.recordsOutputPath)
 	});
@@ -526,13 +567,14 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 			targetProperties,
 			mode: /** @type {Mode} */ (options.mode),
 			css:
-				/** @type {NonNullable<ExperimentsNormalized["css"]>} */
+				/** @type {boolean} */
 				(options.experiments.css),
 			html:
-				/** @type {NonNullable<ExperimentsNormalized["html"]>} */
+				/** @type {boolean} */
 				(options.experiments.html),
+			htmlFirst,
 			typescript:
-				/** @type {NonNullable<ExperimentsNormalized["typescript"]>} */
+				/** @type {boolean} */
 				(options.experiments.typescript)
 		}),
 		options.resolve
@@ -570,17 +612,22 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
  * @param {boolean} options.production is production
  * @param {boolean} options.development is development mode
  * @param {TargetProperties | false} options.targetProperties target properties
+ * @param {RuleSetRules} options.rules user `module.rules`, used to resolve the css/html/asyncWebAssembly/typescript "auto" defaults
  * @returns {void}
  */
 const applyExperimentsDefaults = (
 	experiments,
-	{ production, development, targetProperties }
+	{ production, development, targetProperties, rules }
 ) => {
 	D(experiments, "futureDefaults", false);
 	D(experiments, "backCompat", !experiments.futureDefaults);
 	// TODO do we need sync web assembly in webpack@6?
 	D(experiments, "syncWebAssembly", false);
-	D(experiments, "asyncWebAssembly", experiments.futureDefaults);
+	D(
+		experiments,
+		"asyncWebAssembly",
+		experiments.futureDefaults ? true : "auto"
+	);
 	// the universal target (web + node, neither specific) only works as ESM
 	const universal =
 		Boolean(targetProperties) &&
@@ -599,12 +646,52 @@ const applyExperimentsDefaults = (
 	D(experiments, "cacheUnaffected", experiments.futureDefaults);
 	D(experiments, "deferImport", false);
 	D(experiments, "sourceImport", false);
-	F(experiments, "css", () => (experiments.futureDefaults ? true : undefined));
-	F(experiments, "html", () => (experiments.futureDefaults ? true : undefined));
+	F(experiments, "css", () => (experiments.futureDefaults ? true : "auto"));
+	F(experiments, "html", () => (experiments.futureDefaults ? true : "auto"));
 	F(experiments, "typescript", () =>
-		experiments.futureDefaults ? true : undefined
+		experiments.futureDefaults ? true : "auto"
 	);
 
+	// Resolve the "auto" default: enable the built-in css/html module type unless
+	// the user already registered a loader (or explicit type) for these files, so
+	// enabling them by default does not break existing css-loader/html-loader setups.
+	// The built-in `/\.css$/i` rule also covers `.module.css`, so a loader scoped to
+	// CSS modules must disable the built-in type too — sample both extensions.
+	// When enabled implicitly the value stays `"auto"` (truthy): Css/HtmlModulesPlugin
+	// then step aside per-module for requests that loaders were applied to
+	// (inline requests or loaders injected via hooks, e.g. html-webpack-plugin).
+	// TODO webpack 6: css/html default to `true`, drop the `"auto"` marker.
+	if (experiments.css === "auto") {
+		experiments.css =
+			!(
+				RuleSetCompiler.hasRuleForResource(rules, "/file.css") ||
+				RuleSetCompiler.hasRuleForResource(rules, "/file.module.css")
+			) && "auto";
+	}
+	if (experiments.html === "auto") {
+		experiments.html =
+			!RuleSetCompiler.hasRuleForResource(rules, "/file.html") && "auto";
+	}
+	// Auto-enable only when the built-in TypeScript support can actually run:
+	// it needs `module.stripTypeScriptTypes` (Node.js >= 22.6) and must step
+	// aside for a loader registered for `.ts`/`.mts`/`.cts` (e.g. ts-loader).
+	if (experiments.typescript === "auto") {
+		experiments.typescript =
+			// eslint-disable-next-line n/no-unsupported-features/node-builtins
+			typeof require("module").stripTypeScriptTypes === "function" &&
+			!(
+				RuleSetCompiler.hasRuleForResource(rules, "/file.ts") ||
+				RuleSetCompiler.hasRuleForResource(rules, "/file.mts") ||
+				RuleSetCompiler.hasRuleForResource(rules, "/file.cts")
+			);
+	}
+	// `syncWebAssembly` already claims `.wasm`, so don't let "auto" override it.
+	if (experiments.asyncWebAssembly === "auto") {
+		experiments.asyncWebAssembly =
+			!experiments.syncWebAssembly &&
+			!RuleSetCompiler.hasRuleForResource(rules, "/file.wasm");
+	}
+
 	if (typeof experiments.buildHttp === "object") {
 		D(experiments.buildHttp, "frozen", production);
 		D(experiments.buildHttp, "upgrade", false);
@@ -820,6 +907,7 @@ const applyJavascriptParserOptionsDefaults = (
 	D(parserOptions, "sourceImport", sourceImport);
 	D(parserOptions, "typescript", typescript);
 	if (futureDefaults) D(parserOptions, "exportsPresence", "error");
+	D(parserOptions, "strictModeViolations", futureDefaults ? "error" : "warn");
 	D(parserOptions, "anonymousDefaultExportName", !library);
 };
 
@@ -989,6 +1077,18 @@ const applyModuleDefaults = (
 			"namedExports",
 			true
 		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"customMedia",
+			true
+		);
+		D(
+			/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE]>} */
+			(module.parser[CSS_MODULE_TYPE]),
+			"customSelectors",
+			true
+		);
 
 		for (const type of [
 			CSS_MODULE_TYPE_AUTO,
@@ -1033,6 +1133,18 @@ const applyModuleDefaults = (
 				"grid",
 				true
 			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"customMedia",
+				true
+			);
+			D(
+				/** @type {NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_AUTO]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_MODULE]> | NonNullable<ParserOptionsByModuleTypeKnown[CSS_MODULE_TYPE_GLOBAL]>} */
+				(module.parser[type]),
+				"customSelectors",
+				true
+			);
 		}
 
 		F(module.generator, CSS_MODULE_TYPE, () => ({}));
@@ -1407,6 +1519,46 @@ const applyModuleDefaults = (
 				type: ASSET_MODULE_TYPE_BYTES
 			}
 		);
+		if (html) {
+			// A `.webmanifest` referenced by `<link rel="manifest">` is a `url`
+			// dependency; route it to the `asset/webmanifest` type so its icon URLs
+			// are parsed. Must come after the generic `url` → asset rule so it wins.
+			rules.push({
+				dependency: "url",
+				test: /\.webmanifest$/i,
+				type: "asset/webmanifest"
+			});
+			// A generated manifest (`output.html.manifest` object) is injected as a
+			// `data:application/manifest+json` URL with no `.webmanifest` extension;
+			// route it by mimetype so its icons are parsed and hashed too.
+			rules.push({
+				dependency: "url",
+				mimetype: "application/manifest+json",
+				type: "asset/webmanifest"
+			});
+		}
+		if (futureDefaults) {
+			rules.push({
+				oneOf: [
+					{
+						resourceQuery: /(\?|&)raw(&|$)/,
+						type: ASSET_MODULE_TYPE_SOURCE
+					},
+					{
+						resourceQuery: /(\?|&)url(&|$)/,
+						type: ASSET_MODULE_TYPE_RESOURCE
+					},
+					{
+						resourceQuery: /(\?|&)no-inline(&|$)/,
+						type: ASSET_MODULE_TYPE_RESOURCE
+					},
+					{
+						resourceQuery: /(\?|&)inline(&|$)/,
+						type: ASSET_MODULE_TYPE_INLINE
+					}
+				]
+			});
+		}
 		return rules;
 	});
 };
@@ -1565,6 +1717,11 @@ const applyOutputDefaults = (
 		() =>
 			tp && optimistic(/** @type {boolean | undefined} */ (tp.asyncFunction))
 	);
+	F(
+		environment,
+		"generator",
+		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.generator))
+	);
 	F(
 		environment,
 		"forOf",
@@ -1639,6 +1796,30 @@ const applyOutputDefaults = (
 		"document",
 		() => tp && optimistic(/** @type {boolean | undefined} */ (tp.document))
 	);
+	F(
+		environment,
+		"modulePreload",
+		() =>
+			tp && optimistic(/** @type {boolean | undefined} */ (tp.modulePreload))
+	);
+
+	// Vite-style default for ESM output (`output.module`): preload the entry's
+	// initial dependency graph, which native `import()` would otherwise fetch in
+	// a waterfall. Classic output loads initial chunks via parallel `<script>`
+	// tags (no waterfall), so it stays opt-in.
+	if (output.module && output.resourceHints === undefined) {
+		output.resourceHints = {};
+	}
+	if (output.resourceHints) {
+		if (output.module) D(output.resourceHints, "initial", true);
+		// `modulePreloadPolyfill` defaults from the target's modulepreload
+		// support: inject the polyfill iff the environment lacks it.
+		D(
+			output.resourceHints,
+			"modulePreloadPolyfill",
+			!environment.modulePreload
+		);
+	}
 
 	D(output, "filename", output.module ? "[name].mjs" : "[name].js");
 	F(output, "iife", () => !output.module);
@@ -1718,6 +1899,8 @@ const applyOutputDefaults = (
 	D(output, "html", false);
 	D(output, "assetModuleFilename", "[hash][ext][query][fragment]");
 	D(output, "webassemblyModuleFilename", "[hash].module.wasm");
+	// On by default like other wasm toolchains; set false to drop the fallback runtime code.
+	D(output, "wasmStreamingFallback", true);
 	D(output, "compareBeforeEmit", true);
 	D(output, "charset", !futureDefaults);
 	const uniqueNameId = Template.toIdentifier(
@@ -1863,7 +2046,9 @@ const applyOutputDefaults = (
 	D(
 		output,
 		"hotUpdateMainFilename",
-		`[runtime].[fullhash].hot-update.${output.module ? "json.mjs" : "json"}`
+		// Only `chunkLoading: "import"` loads the manifest via `import()` (needs an
+		// `export default` ES module); every other loader fetches it as raw JSON.
+		`[runtime].[fullhash].hot-update.${output.chunkLoading === "import" ? "json.mjs" : "json"}`
 	);
 	D(output, "crossOriginLoading", false);
 	F(output, "scriptType", () => (output.module ? "module" : false));
@@ -2255,6 +2440,7 @@ const applyOptimizationDefaults = (
  * @param {Mode} options.mode mode
  * @param {boolean} options.css is css enabled
  * @param {boolean} options.html is html enabled
+ * @param {boolean} options.htmlFirst whether `.html` should outrank `.js` when resolving (only when html was explicitly enabled)
  * @param {boolean} options.typescript is typescript enabled
  * @returns {ResolveOptions} resolve options
  */
@@ -2265,6 +2451,7 @@ const getResolveDefaults = ({
 	mode,
 	css,
 	html,
+	htmlFirst,
 	typescript
 }) => {
 	/** @type {string[]} */
@@ -2286,10 +2473,13 @@ const getResolveDefaults = ({
 		? [".ts", ".js", ".json", ".wasm"]
 		: [".js", ".json", ".wasm"];
 
-	// HTML-first when enabled: `.html` outranks `.js`, `.css` is the last fallback.
+	// Explicitly enabling html keeps `.html` ahead of `.js` (html-as-entry feature).
+	// Auto-enabled html/css are lower-priority fallbacks after `.js`, so enabling
+	// them by default never makes `x.html`/`x.css` shadow `x.js`.
 	const esmResolveExtensions = [
-		...(html ? [".html"] : []),
+		...(html && htmlFirst ? [".html"] : []),
 		...jsExtensions,
+		...(html && !htmlFirst ? [".html"] : []),
 		...(css ? [".css"] : [])
 	];
 

package/lib/config/normalization.js

@@ -133,6 +133,30 @@ const keyedNestedConfig = (value, fn, customKeys) => {
 	return result;
 };
 
+/**
+ * Normalize `output.resourceHints` into its object form: the scalar / array /
+ * function shorthand becomes `{ initial: <value> }` (with `"preload"` aliased to
+ * `true`); an object is passed through, its `initial` getting the same alias.
+ * @param {import("../../declarations/WebpackOptions").ResourceHints=} resourceHints raw value
+ * @returns {import("../../declarations/WebpackOptions").ResourceHintsOptions | undefined} normalized object form
+ */
+const normalizeResourceHints = (resourceHints) => {
+	if (resourceHints === undefined) return undefined;
+	/**
+	 * @param {import("../../declarations/WebpackOptions").ResourceHintsInitial=} value initial value
+	 * @returns {import("../../declarations/WebpackOptions").ResourceHintsInitial | undefined} `"preload"` aliased to `true`
+	 */
+	const alias = (value) => (value === "preload" ? true : value);
+	if (
+		typeof resourceHints === "object" &&
+		!Array.isArray(resourceHints) &&
+		typeof resourceHints !== "function"
+	) {
+		return { ...resourceHints, initial: alias(resourceHints.initial) };
+	}
+	return { initial: alias(resourceHints) };
+};
+
 /**
  * Gets normalized webpack options.
  * @param {WebpackOptions} config input config
@@ -404,6 +428,7 @@ const getNormalizedWebpackOptions = (config) => ({
 			path: output.path,
 			pathinfo: output.pathinfo,
 			publicPath: output.publicPath,
+			resourceHints: normalizeResourceHints(output.resourceHints),
 			sourceMapFilename: output.sourceMapFilename,
 			sourcePrefix: output.sourcePrefix,
 			strictModuleErrorHandling: output.strictModuleErrorHandling,
@@ -421,6 +446,7 @@ const getNormalizedWebpackOptions = (config) => ({
 			),
 			uniqueName: output.uniqueName,
 			wasmLoading: output.wasmLoading,
+			wasmStreamingFallback: output.wasmStreamingFallback,
 			webassemblyModuleFilename: output.webassemblyModuleFilename,
 			workerPublicPath: output.workerPublicPath,
 			workerChunkFilename: output.workerChunkFilename,