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

package/lib/WebpackOptionsApply.js

@@ -85,6 +85,7 @@ const { NODE_MODULES_REGEXP } = require("./util/identifier");
 /** @import { WebpackOptionsInterception } from "./config/normalization" */
 /** @import Compiler from "./Compiler" */
 /** @import { InputFileSystem, IntermediateFileSystem } from "./util/fs" */
+/** @import { ResolveOptionsWithDependencyType } from "./ResolverFactory" */
 
 const CLASS_NAME = "WebpackOptionsApply";
 
@@ -425,6 +426,12 @@ class WebpackOptionsApply extends OptionsApply {
 			).apply(compiler);
 		}
 
+		if (options.output.copy) {
+			const CopyPlugin = require("./CopyPlugin");
+
+			new CopyPlugin(options.output.copy).apply(compiler);
+		}
+
 		if (options.dotenv) {
 			const DotenvPlugin = require("./DotenvPlugin");
 
@@ -496,32 +503,6 @@ class WebpackOptionsApply extends OptionsApply {
 			sideEffectFree: options.experiments.futureDefaults
 		}).apply(compiler);
 
-		if (!options.experiments.outputModule) {
-			if (options.output.module) {
-				throw new Error(
-					"'output.module: true' is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (options.output.enabledLibraryTypes.includes("module")) {
-				throw new Error(
-					"library type \"module\" is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (options.output.enabledLibraryTypes.includes("modern-module")) {
-				throw new Error(
-					"library type \"modern-module\" is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-			if (
-				options.externalsType === "module" ||
-				options.externalsType === "module-import"
-			) {
-				throw new Error(
-					"'externalsType: \"module\"' is only allowed when 'experiments.outputModule' is enabled"
-				);
-			}
-		}
-
 		if (options.output.module) {
 			// Analyzable output is ESM output, so this is every build that can reserve a name.
 			const RuntimeTemplate = require("./RuntimeTemplate");
@@ -738,8 +719,10 @@ class WebpackOptionsApply extends OptionsApply {
 			options.performance && options.performance.circularDependencies
 				? options.performance.hints
 				: false;
+		// ConstExportsPlugin Binding checks need CircularModulesPlugin when this is on.
+		const inlineExports = options.optimization.inlineExports;
 
-		if (options.mode === "production" || circularHints) {
+		if (options.mode === "production" || circularHints || inlineExports) {
 			const CircularModulesPlugin = require("./CircularModulesPlugin");
 
 			new CircularModulesPlugin({ hints: circularHints }).apply(compiler);
@@ -748,7 +731,7 @@ class WebpackOptionsApply extends OptionsApply {
 		const ConstExportsPlugin = require("./optimize/ConstExportsPlugin");
 
 		new ConstExportsPlugin({
-			inlineExports: options.optimization.inlineExports
+			inlineExports
 		}).apply(compiler);
 
 		if (options.optimization.mangleExports) {
@@ -778,7 +761,9 @@ class WebpackOptionsApply extends OptionsApply {
 
 			new NoEmitOnErrorsPlugin().apply(compiler);
 		}
-		if (options.optimization.realContentHash) {
+		// ESM output may bake a name into a chunk whose hashed name would then go stale;
+		// the repair runs for those alone where it was not asked for outright.
+		if (options.optimization.realContentHash || options.output.module) {
 			const RealContentHashPlugin = require("./optimize/RealContentHashPlugin");
 
 			new RealContentHashPlugin({
@@ -787,7 +772,8 @@ class WebpackOptionsApply extends OptionsApply {
 					(options.output.hashFunction),
 				hashDigest:
 					/** @type {NonNullable<WebpackOptions["output"]["hashDigest"]>} */
-					(options.output.hashDigest)
+					(options.output.hashDigest),
+				onDemand: !options.optimization.realContentHash
 			}).apply(compiler);
 		}
 		if (options.optimization.checkWasmTypes) {
@@ -906,7 +892,7 @@ class WebpackOptionsApply extends OptionsApply {
 					? publicPath
 					: "/";
 
-			// Marked internal: these keys are webpack's, so `performance.unusedDefines`
+			// Marked internal: these keys are webpack's, so `performance.unusedConfig`
 			// must not report them against the user.
 			DefinePlugin.markInternal(
 				new DefinePlugin({
@@ -966,18 +952,18 @@ class WebpackOptionsApply extends OptionsApply {
 				new RedundantDynamicImportsPlugin(options.performance).apply(compiler);
 			}
 
-			if (options.performance.entrypointOverlap) {
-				const EntrypointOverlapPlugin = require("./performance/EntrypointOverlapPlugin");
-
-				new EntrypointOverlapPlugin(options.performance).apply(compiler);
-			}
-
 			if (options.performance.largeModules) {
 				const LargeModulesPlugin = require("./performance/LargeModulesPlugin");
 
 				new LargeModulesPlugin(options.performance).apply(compiler);
 			}
 
+			if (options.performance.analyzableBailouts) {
+				const AnalyzableBailoutsPlugin = require("./performance/AnalyzableBailoutsPlugin");
+
+				new AnalyzableBailoutsPlugin(options.performance).apply(compiler);
+			}
+
 			if (options.performance.asyncChunkWaterfalls) {
 				const AsyncChunkWaterfallsPlugin = require("./performance/AsyncChunkWaterfallsPlugin");
 
@@ -1044,12 +1030,6 @@ class WebpackOptionsApply extends OptionsApply {
 				new DynamicExportsPlugin(options.performance).apply(compiler);
 			}
 
-			if (options.performance.embeddedSourceMaps) {
-				const EmbeddedSourceMapsPlugin = require("./performance/EmbeddedSourceMapsPlugin");
-
-				new EmbeddedSourceMapsPlugin(options.performance).apply(compiler);
-			}
-
 			if (options.performance.inlinedAssets) {
 				const InlinedAssetsPlugin = require("./performance/InlinedAssetsPlugin");
 
@@ -1068,42 +1048,56 @@ class WebpackOptionsApply extends OptionsApply {
 				new ScopeHoistingBailoutsPlugin(options.performance).apply(compiler);
 			}
 
-			if (options.performance.unusedReexports) {
-				const UnusedReexportsPlugin = require("./performance/UnusedReexportsPlugin");
+			// One switch for source maps: a devtool that ships the map to everyone,
+			// and a loader that loses it, are both about the map being worth its cost.
+			if (options.performance.sourceMaps) {
+				const EmbeddedSourceMapsPlugin = require("./performance/EmbeddedSourceMapsPlugin");
+				const MissingSourceMapsPlugin = require("./performance/MissingSourceMapsPlugin");
 
-				new UnusedReexportsPlugin(options.performance).apply(compiler);
+				new EmbeddedSourceMapsPlugin(options.performance).apply(compiler);
+				new MissingSourceMapsPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`, like `unusedRules` below: a rule
-			// that only matches on one OS is a configuration mistake, not a size.
-			if (options.performance.osDependentRules) {
-				const OsDependentRuleWarningPlugin = require("./performance/OsDependentRuleWarningPlugin");
+			// One switch for configuration that did nothing: the four read different
+			// parts of the config, but the finding and the fix are the same.
+			if (options.performance.unusedConfig) {
+				const UnusedAliasesPlugin = require("./performance/UnusedAliasesPlugin");
+				const UnusedDefinesPlugin = require("./performance/UnusedDefinesPlugin");
+				const UnusedExternalsPlugin = require("./performance/UnusedExternalsPlugin");
+				const UnusedFederationPlugin = require("./performance/UnusedFederationPlugin");
+				// Reports even where size hints are off: a dead rule is a configuration
+				// mistake either way.
+				const UnusedRuleWarningPlugin = require("./performance/UnusedRuleWarningPlugin");
 
-				new OsDependentRuleWarningPlugin(options.performance).apply(compiler);
+				new UnusedAliasesPlugin(options.performance).apply(compiler);
+				new UnusedDefinesPlugin(options.performance).apply(compiler);
+				new UnusedExternalsPlugin(options.performance).apply(compiler);
+				new UnusedFederationPlugin(options.performance).apply(compiler);
+				new UnusedRuleWarningPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`: an alias nothing matches is a
-			// configuration mistake, not a size.
-			if (options.performance.unusedAliases) {
-				const UnusedAliasesPlugin = require("./performance/UnusedAliasesPlugin");
+			// One switch for a module nothing uses: the two differ only in what kept
+			// it there, and each names the cause it knows about.
+			if (options.performance.unusedModules) {
+				const UnusedModulesPlugin = require("./performance/UnusedModulesPlugin");
+				const UnusedReexportsPlugin = require("./performance/UnusedReexportsPlugin");
 
-				new UnusedAliasesPlugin(options.performance).apply(compiler);
+				new UnusedModulesPlugin(options.performance).apply(compiler);
+				new UnusedReexportsPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`: a key nothing reads is a
-			// configuration mistake, not a size.
-			if (options.performance.unusedDefines) {
-				const UnusedDefinesPlugin = require("./performance/UnusedDefinesPlugin");
+			// Deliberately not gated on `hints`, like `unusedConfig` above: a rule
+			// that only matches on one OS is a configuration mistake, not a size.
+			if (options.performance.osDependentRules) {
+				const OsDependentRuleWarningPlugin = require("./performance/OsDependentRuleWarningPlugin");
 
-				new UnusedDefinesPlugin(options.performance).apply(compiler);
+				new OsDependentRuleWarningPlugin(options.performance).apply(compiler);
 			}
 
-			// Deliberately not gated on `hints`: a misspelled external gets bundled
-			// instead, which no size limit would explain.
-			if (options.performance.unusedExternals) {
-				const UnusedExternalsPlugin = require("./performance/UnusedExternalsPlugin");
+			if (options.performance.unusedAssets) {
+				const UnusedAssetsPlugin = require("./performance/UnusedAssetsPlugin");
 
-				new UnusedExternalsPlugin(options.performance).apply(compiler);
+				new UnusedAssetsPlugin(options.performance).apply(compiler);
 			}
 
 			// Deliberately not gated on `hints`: asking for both directives on one
@@ -1113,14 +1107,6 @@ class WebpackOptionsApply extends OptionsApply {
 
 				new ConflictingResourceHintsPlugin(options.performance).apply(compiler);
 			}
-
-			// Deliberately not gated on `hints`: a dead rule is a configuration
-			// mistake worth reporting even where size hints are off.
-			if (options.performance.unusedRules) {
-				const UnusedRuleWarningPlugin = require("./performance/UnusedRuleWarningPlugin");
-
-				new UnusedRuleWarningPlugin(options.performance).apply(compiler);
-			}
 		}
 
 		new TemplatedPathPlugin().apply(compiler);
@@ -1258,34 +1244,41 @@ class WebpackOptionsApply extends OptionsApply {
 		if (!compiler.inputFileSystem) {
 			throw new Error("No input filesystem provided");
 		}
-		compiler.resolverFactory.hooks.resolveOptions
-			.for("normal")
-			.tap(CLASS_NAME, (resolveOptions) => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
+		/**
+		 * Supplies the compiler's input filesystem as the default for a resolver.
+		 * A filesystem set in the configuration is kept, so that `resolve.fileSystem`
+		 * reaches enhanced-resolve the way `resolve.resolver` already does.
+		 * @param {ResolveOptionsWithDependencyType} resolveOptions merged resolve options
+		 * @returns {ResolveOptionsWithDependencyType} the same options
+		 */
+		const withFileSystem = (resolveOptions) => {
+			if (!resolveOptions.fileSystem) {
 				resolveOptions.fileSystem =
 					/** @type {InputFileSystem} */
 					(compiler.inputFileSystem);
-				return resolveOptions;
-			});
+			}
+			return resolveOptions;
+		};
+
+		compiler.resolverFactory.hooks.resolveOptions
+			.for("normal")
+			.tap(CLASS_NAME, (resolveOptions) =>
+				withFileSystem(cleverMerge(options.resolve, resolveOptions))
+			);
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("context")
 			.tap(CLASS_NAME, (resolveOptions) => {
-				resolveOptions = cleverMerge(options.resolve, resolveOptions);
-				resolveOptions.fileSystem =
-					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem);
+				resolveOptions = withFileSystem(
+					cleverMerge(options.resolve, resolveOptions)
+				);
 				resolveOptions.resolveToContext = true;
 				return resolveOptions;
 			});
 		compiler.resolverFactory.hooks.resolveOptions
 			.for("loader")
-			.tap(CLASS_NAME, (resolveOptions) => {
-				resolveOptions = cleverMerge(options.resolveLoader, resolveOptions);
-				resolveOptions.fileSystem =
-					/** @type {InputFileSystem} */
-					(compiler.inputFileSystem);
-				return resolveOptions;
-			});
+			.tap(CLASS_NAME, (resolveOptions) =>
+				withFileSystem(cleverMerge(options.resolveLoader, resolveOptions))
+			);
 		compiler.hooks.afterResolvers.call(compiler);
 		return options;
 	}

package/lib/asset/AssetBytesGenerator.js

@@ -114,7 +114,13 @@ class AssetBytesGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			default:
 				return null;

package/lib/asset/AssetGenerator.js

@@ -28,7 +28,7 @@ const URLDependency = require("../dependencies/URLDependency");
 const { getScheme } = require("../util/URLAbsoluteSpecifier");
 const createHash = require("../util/createHash");
 const { languageOfMediaType } = require("../util/dataURL");
-const { makePathsRelative } = require("../util/identifier");
+const { makePathsRelative, parseResource } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const nonNumericOnlyHash = require("../util/nonNumericOnlyHash");
 const {
@@ -55,7 +55,6 @@ const getMimeTypes = memoize(() => require("../util/mimeTypes"));
 /** @import { GenerateContext, UpdateHashContext } from "../Generator" */
 /**
  * @import Module, {
- * 	NameForCondition,
  * 	ConcatenationBailoutReasonContext,
  * 	SourceType,
  * 	SourceTypes
@@ -250,12 +249,27 @@ class AssetGenerator extends Generator {
 	static getSourceFileName(module, runtimeTemplate) {
 		return makePathsRelative(
 			runtimeTemplate.compilation.compiler.context,
-			/** @type {string} */
-			(module.getResource()),
+			AssetGenerator.getAssetResource(module),
 			runtimeTemplate.compilation.compiler.root
 		).replace(/^\.\//, "");
 	}
 
+	/**
+	 * The resource this asset is named after, which something that re-encoded it
+	 * may have changed. Its emitted name and inlined media type both read this.
+	 * @param {NormalModule} module module
+	 * @returns {string} the resource
+	 */
+	static getAssetResource(module) {
+		const buildInfo = /** @type {AssetModuleBuildInfo | undefined} */ (
+			module.buildInfo
+		);
+
+		return /** @type {string} */ (
+			(buildInfo && buildInfo.assetResource) || module.getResource()
+		);
+	}
+
 	/**
 	 * Gets the source file name as seen by a filename template. With
 	 * `experiments.futureDefaults` (webpack 6 default) `[path]` and `[file]` of a
@@ -504,11 +518,14 @@ class AssetGenerator extends Generator {
 			/** @type {AssetGeneratorDataUrlOptions} */
 			(this.dataUrlOptions).mimetype;
 		if (mimeType === undefined) {
-			const ext = path.extname(
-				/** @type {NameForCondition} */
-				(module.nameForCondition())
-			);
+			// The resource as it now is, minus the query and fragment a request
+			// carries into it.
+			const resource = AssetGenerator.getAssetResource(module);
+			const ext = path.extname(parseResource(resource).path);
+			// `resourceResolveData` describes what was read; once something
+			// re-encoded it, only the new extension says what the bytes are.
 			if (
+				resource === module.getResource() &&
 				module.resourceResolveData &&
 				module.resourceResolveData.mimetype !== undefined
 			) {
@@ -774,10 +791,21 @@ class AssetGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case "asset": {
-				return new RawSource(error.message);
+				return new RawSource(
+					Generator.buildErrorMessage(
+						error,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			default:
 				return null;
@@ -819,13 +847,14 @@ class AssetGenerator extends Generator {
 				/** @type {AssetModuleBuildInfo} */ (module.buildInfo).dataUrl
 			) && this.emit !== false;
 
-		// Only analyzable ESM output can drop a bare `new URL()` to an asset-url; without
-		// it every JS consumer needs the wrapper, so skip the per-connection dependency
-		// probe entirely and keep the pre-existing cheap path. Must match the condition
-		// `URLDependency` uses to emit the literal, or the wrapper is dropped while the
-		// call site still requires the module — except where the fallback spells the name
-		// itself (`.p + <file>`), which needs no wrapper to read it out of.
-		// Build-time execution instead emulates the wrapper (`AssetModulesPlugin`).
+		// WHY: only analyzable ESM output can drop a bare `new URL()` to an asset
+		// url; without it every JS consumer needs the wrapper, so the per-connection
+		// dependency probe is skipped entirely and the cheap path stands. This must
+		// match the condition `URLDependency` emits the literal under, or the wrapper
+		// is dropped while the call site still requires the module — except where the
+		// fallback spells the name itself (`.p + <file>`), which needs no wrapper to
+		// read it out of. Build-time execution emulates the wrapper instead
+		// (`AssetModulesPlugin`).
 		const isModule = Boolean(
 			this._compilation &&
 			this._compilation.runtimeTemplate.supportsAnalyzable(
@@ -857,9 +886,8 @@ class AssetGenerator extends Generator {
 				hasUrl = true;
 			} else if (
 				// Only a bare `new URL()` becomes the analyzable literal; a relative ref
-				// keeps the runtime form and still needs the wrapper. Prefetch/preload
-				// refs don't: their `<link>` is emitted at chunk startup, which resolves
-				// the href from the asset filename when there is no wrapper.
+				// keeps the runtime form and its wrapper. A prefetch or preload ref needs
+				// none: its `<link>` resolves the href at chunk startup.
 				isModule &&
 				dependency instanceof URLDependency &&
 				!dependency.relative
@@ -944,10 +972,8 @@ class AssetGenerator extends Generator {
 						return 0;
 					}
 
-					// roughly for data url
-					// Example: m.exports="data:image/png;base64,ag82/f+2=="
-					// 4/3 = base64 encoding
-					// 34 = ~ data url header + footer + rounding
+					// Rough data-url size: 4/3 for the base64 encoding, plus about 34 bytes
+					// of header, footer and rounding.
 					return originalSource.size() * 1.34 + 36;
 				}
 				// it's only estimated so this number is probably fine

package/lib/asset/AssetModule.js

@@ -22,6 +22,9 @@ const makeSerializable = require("../util/makeSerializable");
  * @property {string=} filename
  * @property {AssetInfo=} assetInfo
  * @property {string=} fullContentHash
+ * @property {string=} assetResource the resource this asset is named after, when
+ * something re-encoded it. Unlike `matchResource` this is serialized, so a
+ * rename set while building survives the persistent cache
  */
 
 /** @typedef {NormalModuleBuildInfo & KnownAssetModuleBuildInfo} AssetModuleBuildInfo */

package/lib/asset/AssetSourceGenerator.js

@@ -158,7 +158,13 @@ class AssetSourceGenerator extends Generator {
 	generateError(error, module, generateContext) {
 		switch (generateContext.type) {
 			case JAVASCRIPT_TYPE: {
-				return new RawSource(Generator.throwBuildErrorCode(error));
+				return new RawSource(
+					Generator.throwBuildErrorCode(
+						error,
+						undefined,
+						generateContext.runtimeTemplate.requestShortener
+					)
+				);
 			}
 			default:
 				return null;

package/lib/asset/WebManifestParser.js

@@ -5,15 +5,15 @@
 
 "use strict";
 
-const { parse } = require("acorn");
 const Parser = require("../Parser");
 const HtmlSourceDependency = require("../dependencies/HtmlSourceDependency");
+const { parse } = require("../javascript/syntax");
 
 /** @import { Expression, ObjectExpression, Program, Property } from "estree" */
 /** @import { BuildInfo } from "../Module" */
 /** @import { ParserState, PreparsedAst } from "../Parser" */
 
-// acorn decorates every node with numeric source offsets (absent from the estree types).
+// the parser decorates every node with numeric source offsets (absent from the estree types).
 /** @typedef {{ start: number, end: number }} Positioned */
 
 // A URL carrying its own scheme (`https:`, `data:`, …) is external; it is only
@@ -70,9 +70,11 @@ class WebManifestParser extends Parser {
 		let ast;
 		try {
 			// Wrap in parens so the top-level object is an expression, not a block.
-			ast = /** @type {Program} */ (
-				/** @type {unknown} */ (parse(`(${source})`, { ecmaVersion: "latest" }))
-			);
+			ast = parse(`(${source})`, {
+				ecmaVersion: "latest",
+				sourceType: "script",
+				lazyNodes: true
+			});
 		} catch (_err) {
 			// Not valid JSON — leave the file untouched (still emitted as-is).
 			ast = undefined;

package/lib/async-modules/AsyncModuleHelpers.js

@@ -32,16 +32,22 @@ const getOutgoingAsyncModules = (moduleGraph, module) => {
 			const outgoingConnectionMap =
 				moduleGraph.getOutgoingConnectionsByModule(module);
 			if (outgoingConnectionMap) {
-				for (const [module, connections] of outgoingConnectionMap) {
+				// Walk the imports in source order: the spec gathers these from
+				// `[[RequestedModules]]`, and their evaluation order is observable.
+				for (const dependency of module.dependencies) {
+					if (!(dependency instanceof HarmonyImportDependency)) continue;
+					const referenced = moduleGraph.getModule(dependency);
+					if (!referenced || seen.has(referenced)) continue;
+					const connections = outgoingConnectionMap.get(referenced);
 					if (
+						connections &&
 						connections.some(
 							(c) =>
 								c.dependency instanceof HarmonyImportDependency &&
 								c.isTargetActive(undefined)
-						) &&
-						module
+						)
 					) {
-						g(module);
+						g(referenced);
 					}
 				}
 			}

package/lib/buildChunkGraph.js

@@ -641,16 +641,13 @@ const visitModules = (
 					}
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
-					// Fill in options the existing entrypoint hasn't set yet. We never
-					// overwrite: blocks that dedupe to one entrypoint (e.g. several
-					// workers pointing at the same module) legitimately carry distinct
-					// values such as `runtime`, so the first block to create the
-					// entrypoint wins and later ones only contribute missing keys.
-					// `name` is excluded: it is the entrypoint's identity, fixed at
-					// creation (and used to key namedChunkGroups), so back-filling it
-					// from a block that deduped in via its module would leave
-					// `entrypoint.name` out of sync and make module codegen
-					// order-dependent, which breaks persistent caching.
+					// Fill in only the options still unset: blocks deduping to one
+					// entrypoint may carry different values, so the first to create it
+					// wins.
+
+					// `name` is excluded, being the entrypoint's identity and fixed at
+					// creation. Back-filling it would make codegen order-dependent, which
+					// breaks persistent caching.
 					const existingOptions = entrypoint.options;
 					for (const key_ of Object.keys(entryOptions)) {
 						const key =
@@ -1370,11 +1367,10 @@ const connectChunkGroups = (
 
 	// For each edge in the basic chunk graph
 	for (const [block, connections] of blockConnections) {
-		// 1. Check if connection is needed
-		// When none of the dependencies need to be connected
-		// we can skip all of them
-		// It's not possible to filter each item so it doesn't create inconsistent
-		// connections and modules can only create one version
+		// Skip the whole set when no dependency needs connecting. They cannot be
+		// filtered one by one without inconsistent connections, since a module can
+		// only carry one version.
+
 		// TODO maybe decide this per runtime
 		if (
 			// Blocks with nested blocks must stay connected — skipping orphans the

package/lib/cache/AddBuildDependenciesPlugin.js

@@ -9,14 +9,36 @@
 
 const PLUGIN_NAME = "AddBuildDependenciesPlugin";
 
+/**
+ * @typedef {object} NormalizedBuildDependencyItem
+ * @property {string} dependency request to resolve
+ * @property {boolean} optional when true the dependency may be missing
+ */
+
+/**
+ * @param {string | { dependency: string, optional?: boolean }} item build dependency
+ * @returns {NormalizedBuildDependencyItem} normalized build dependency
+ */
+const normalizeBuildDependencyItem = (item) => {
+	if (typeof item === "string") {
+		return { dependency: item, optional: false };
+	}
+	return {
+		dependency: item.dependency,
+		optional: Boolean(item.optional)
+	};
+};
+
 class AddBuildDependenciesPlugin {
 	/**
 	 * Creates an instance of AddBuildDependenciesPlugin.
-	 * @param {Iterable<string>} buildDependencies list of build dependencies
+	 * @param {Iterable<string | { dependency: string, optional?: boolean }>} buildDependencies list of build dependencies
 	 */
 	constructor(buildDependencies) {
-		/** @type {Set<string>} */
-		this.buildDependencies = new Set(buildDependencies);
+		/** @type {NormalizedBuildDependencyItem[]} */
+		this.buildDependencies = [...buildDependencies].map(
+			normalizeBuildDependencyItem
+		);
 	}
 
 	/**
@@ -26,7 +48,14 @@ class AddBuildDependenciesPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
-			compilation.buildDependencies.addAll(this.buildDependencies);
+			for (const { dependency, optional } of this.buildDependencies) {
+				compilation.buildDependencies.add(dependency);
+				if (optional) {
+					compilation.optionalBuildDependencies.add(dependency);
+					compilation.missingDependencies.add(dependency);
+					compilation.fileDependencies.add(dependency);
+				}
+			}
 		});
 	}
 }

package/lib/cache/IdleFileCachePlugin.js

@@ -98,10 +98,10 @@ class IdleFileCachePlugin {
 
 		compiler.cache.hooks.storeBuildDependencies.tap(
 			{ name: PLUGIN_NAME, stage: Cache.STAGE_DISK },
-			(dependencies) => {
+			(dependencies, optionalDependencies) => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
 					Promise.resolve().then(() =>
-						strategy.storeBuildDependencies(dependencies)
+						strategy.storeBuildDependencies(dependencies, optionalDependencies)
 					)
 				);
 			}