webpack 5.109.1 → 5.109.2

package/lib/cache/PackFileCacheStrategy.js

@@ -7,6 +7,7 @@
 
 const FileSystemInfo = require("../FileSystemInfo");
 const ProgressPlugin = require("../ProgressPlugin");
+const { getReferencedFilenames } = require("../serialization/FileMiddleware");
 const SerializerMiddleware = require("../serialization/SerializerMiddleware");
 const LazySet = require("../util/LazySet");
 const formatSize = require("../util/formatSize");
@@ -34,6 +35,17 @@ const {
 /** @typedef {Set<string>} Items */
 /** @typedef {Set<string>} BuildDependencies */
 /** @typedef {Map<string, PackItemInfo>} ItemInfo */
+/** @typedef {{ firstSeen: number, size: number }} UnreferencedFile */
+/** @typedef {Map<string, UnreferencedFile>} UnreferencedFiles */
+
+// Unreferenced files are kept for this long to not race concurrent builds sharing the cache directory.
+const CLEANUP_GRACE_PERIOD = 30 * 60 * 1000;
+// Records when each unreferenced file was first seen. Aging by recorded time keeps
+// orphans expiring across caches restored with refreshed modification times.
+const UNREFERENCED_FILE = "unreferenced.json";
+// A file written this recently may belong to a concurrent build that reused the name,
+// in which case the recorded time describes the previous file and must not be trusted.
+const CLEANUP_RECENT_WRITE_PERIOD = 60 * 1000;
 
 class PackContainer {
 	/**
@@ -569,6 +581,41 @@ class Pack {
 		}
 	}
 
+	/**
+	 * Drops every content whose items all expired. Unlike a partial collection this
+	 * never unpacks, so it is not limited to a single content per store and lets a
+	 * long unused cache shrink in one go instead of one pack per build.
+	 */
+	_gcExpiredContent() {
+		const now = Date.now();
+		let packCount = 0;
+		let itemCount = 0;
+		for (let loc = 0; loc < this.content.length; loc++) {
+			const content = this.content[loc];
+			if (!content) continue;
+			let expired = true;
+			for (const identifier of content.items) {
+				const info = this.itemInfo.get(identifier);
+				if (info !== undefined && now - info.lastAccess <= this.maxAge) {
+					expired = false;
+					break;
+				}
+			}
+			if (!expired) continue;
+			for (const identifier of content.items) this.itemInfo.delete(identifier);
+			this.content[loc] = undefined;
+			packCount++;
+			itemCount += content.items.size;
+		}
+		if (packCount > 0) {
+			this.logger.log(
+				"Garbage Collected %d completely expired packs with %d items",
+				packCount,
+				itemCount
+			);
+		}
+	}
+
 	/**
 	 * Find the content with the oldest item and run GC on that.
 	 * Only runs for one content to avoid large invalidation.
@@ -581,11 +628,10 @@ class Pack {
 				oldest = info;
 			}
 		}
-		if (
-			Date.now() - /** @type {PackItemInfo} */ (oldest).lastAccess >
-			this.maxAge
-		) {
-			const loc = /** @type {PackItemInfo} */ (oldest).location;
+		// collecting expired content may have left no items at all
+		if (oldest === undefined) return;
+		if (Date.now() - oldest.lastAccess > this.maxAge) {
+			const loc = oldest.location;
 			if (loc < 0) return;
 			const content = /** @type {PackContent} */ (this.content[loc]);
 			const items = new Set(content.items);
@@ -621,6 +667,7 @@ class Pack {
 		this._persistFreshContent();
 		this._optimizeSmallContent();
 		this._optimizeUnusedContent();
+		this._gcExpiredContent();
 		this._gcOldestContent();
 		for (const identifier of this.itemInfo.keys()) {
 			write(identifier);
@@ -1166,6 +1213,8 @@ class PackFileCacheStrategy {
 		});
 		/** @type {Compiler} */
 		this.compiler = compiler;
+		/** @type {IntermediateFileSystem} */
+		this.fs = fs;
 		/** @type {string} */
 		this.context = context;
 		/** @type {string} */
@@ -1182,6 +1231,10 @@ class PackFileCacheStrategy {
 		this.readonly = readonly;
 		/** @type {boolean | undefined} */
 		this.allowCollectingMemory = allowCollectingMemory;
+		// referenced names per on-disk file, versioned by mtime since concurrent
+		// processes may rewrite packs in place under the same name
+		/** @type {Map<string, { mtimeMs: number, referenced: string[] }>} */
+		this._referencedFilesCache = new Map();
 		/** @type {false | "gzip" | "brotli" | "zstd" | undefined} */
 		this.compression = compression;
 		// eslint-disable-next-line n/no-unsupported-features/node-builtins
@@ -1588,10 +1641,17 @@ class PackFileCacheStrategy {
 						/** @type {Snapshot} */
 						(this.resolveBuildDependenciesSnapshot)
 					);
+					const cleanup = this.fs.unlink !== undefined;
+					/** @type {Set<string> | undefined} */
+					const writtenFiles = cleanup ? new Set() : undefined;
+					/** @type {Set<string> | undefined} */
+					const retainedFiles = cleanup ? new Set() : undefined;
 					return this.fileSerializer
 						.serialize(content, {
 							filename: `${this.cacheLocation}/index${this._extension}`,
 							extension: `${this._extension}`,
+							writtenFiles,
+							retainedFiles,
 							logger: this.logger,
 							profile: this.profile
 						})
@@ -1608,9 +1668,17 @@ class PackFileCacheStrategy {
 								stats.count,
 								Math.round(stats.size / 1024 / 1024)
 							);
+							if (writtenFiles !== undefined) {
+								return this._cleanupUnusedFiles(
+									writtenFiles,
+									/** @type {Set<string>} */ (retainedFiles)
+								);
+							}
 						})
 						.catch((err) => {
 							this.logger.timeEnd("store pack");
+							// files may be in an unknown state after a failed store
+							this._referencedFilesCache.clear();
 							this.logger.warn(`Caching failed for pack: ${err}`);
 							this.logger.debug(err.stack);
 						});
@@ -1622,6 +1690,192 @@ class PackFileCacheStrategy {
 			}));
 	}
 
+	/**
+	 * Reads when the currently unreferenced files were first seen. A missing or
+	 * unreadable file just restarts the grace period for every orphan.
+	 * @returns {Promise<UnreferencedFiles>} first seen time and size per file name
+	 */
+	_readUnreferencedFiles() {
+		return new Promise((resolve) => {
+			this.fs.readFile(
+				`${this.cacheLocation}/${UNREFERENCED_FILE}`,
+				(err, content) => {
+					/** @type {UnreferencedFiles} */
+					const result = new Map();
+					if (err) return resolve(result);
+					try {
+						const data = JSON.parse(
+							/** @type {Buffer} */ (content).toString("utf8")
+						);
+						for (const [file, entry] of Object.entries(data)) {
+							const { firstSeen, size } = /** @type {UnreferencedFile} */ (
+								entry
+							);
+							if (typeof firstSeen === "number" && typeof size === "number") {
+								result.set(file, { firstSeen, size });
+							}
+						}
+					} catch (_err) {
+						result.clear();
+					}
+					resolve(result);
+				}
+			);
+		});
+	}
+
+	/**
+	 * Persists when the still unreferenced files were first seen. Failing to write
+	 * only costs the orphans another grace period, so errors are ignored.
+	 * @param {UnreferencedFiles} unreferenced first seen time and size per file name
+	 * @param {boolean} hadEntries whether a previous state exists that must be replaced
+	 * @returns {Promise<void>} promise
+	 */
+	_writeUnreferencedFiles(unreferenced, hadEntries) {
+		if (unreferenced.size === 0 && !hadEntries) return Promise.resolve();
+		/** @type {Record<string, UnreferencedFile>} */
+		const data = {};
+		for (const [file, entry] of unreferenced) data[file] = entry;
+		return new Promise((resolve) => {
+			this.fs.writeFile(
+				`${this.cacheLocation}/${UNREFERENCED_FILE}`,
+				JSON.stringify(data),
+				() => resolve()
+			);
+		});
+	}
+
+	/**
+	 * Deletes files from the cache directory that are no longer referenced by the
+	 * stored pack. Retained files are walked on disk since nested lazy segments
+	 * reference files not visible during serialization. Errors only log a warning.
+	 * @param {Set<string>} writtenNames names (without extension) written by this store
+	 * @param {Set<string>} retainedNames names (without extension) referenced but not rewritten
+	 * @returns {Promise<void>} promise
+	 */
+	async _cleanupUnusedFiles(writtenNames, retainedNames) {
+		this.logger.time("cleanup unused cache files");
+		const fs = this.fs;
+		const extension = this._extension;
+		const cacheLocation = this.cacheLocation;
+		const referencedFilesCache = this._referencedFilesCache;
+		try {
+			// rewritten files may reference different names now
+			for (const name of writtenNames) referencedFilesCache.delete(name);
+			/** @type {Set<string>} */
+			const liveFiles = new Set([`index${extension}`, UNREFERENCED_FILE]);
+			for (const name of writtenNames) liveFiles.add(`${name}${extension}`);
+			/** @type {string[]} */
+			const queue = [];
+			/**
+			 * Marks a file live and queues it for walking its references.
+			 * @param {string} name file name without extension
+			 */
+			const enqueue = (name) => {
+				const file = `${name}${extension}`;
+				if (liveFiles.has(file)) return;
+				liveFiles.add(file);
+				queue.push(name);
+			};
+			for (const name of retainedNames) enqueue(name);
+			while (queue.length > 0) {
+				const name = /** @type {string} */ (queue.pop());
+				const file = `${cacheLocation}/${name}${extension}`;
+				// an unchanged mtime proves the memo entry still matches the disk
+				const mtimeMs = await new Promise((resolve, reject) => {
+					fs.stat(file, (err, stats) => {
+						if (err) return reject(err);
+						resolve(
+							/** @type {number} */ (
+								/** @type {import("../util/fs").IStats} */ (stats).mtimeMs
+							)
+						);
+					});
+				});
+				const entry = referencedFilesCache.get(name);
+				let referenced;
+				if (entry !== undefined && entry.mtimeMs === mtimeMs) {
+					referenced = entry.referenced;
+				} else {
+					referenced = await getReferencedFilenames(fs, file);
+					referencedFilesCache.set(name, { mtimeMs, referenced });
+				}
+				for (const referencedName of referenced) enqueue(referencedName);
+			}
+			const files = await new Promise((resolve, reject) => {
+				fs.readdir(cacheLocation, (err, files) => {
+					if (err) return reject(err);
+					resolve(/** @type {string[]} */ (files));
+				});
+			});
+			const seenFiles = await this._readUnreferencedFiles();
+			const now = Date.now();
+			// every store rewrites the index backup, so a recorded time would age a file
+			// that is in fact new; renaming carries the previous index mtime onto it
+			const indexBackup = `index${extension}.old`;
+			/** @type {UnreferencedFiles} */
+			const stillUnreferenced = new Map();
+			let deletedCount = 0;
+			for (const file of files) {
+				if (typeof file !== "string" || liveFiles.has(file)) continue;
+				const path = `${cacheLocation}/${file}`;
+				const stats = await new Promise((resolve) => {
+					fs.stat(path, (err, stats) => {
+						resolve(
+							err
+								? undefined
+								: /** @type {import("../util/fs").IStats} */ (stats)
+						);
+					});
+				});
+				if (stats === undefined || !stats.isFile()) continue;
+				const size = /** @type {number} */ (stats.size);
+				const seen = seenFiles.get(file);
+				// a differing size means the name was rewritten, so it is a new orphan
+				const firstSeen =
+					seen !== undefined && seen.size === size ? seen.firstSeen : now;
+				const expireTime = now - CLEANUP_GRACE_PERIOD;
+				const mtimeMs = /** @type {number} */ (stats.mtimeMs);
+				// either signal is enough: modification times are lost when a cache is
+				// restored, and recorded times are lost when the cache directory is new
+				const expired =
+					mtimeMs <= expireTime ||
+					(file !== indexBackup &&
+						firstSeen <= expireTime &&
+						mtimeMs <= now - CLEANUP_RECENT_WRITE_PERIOD);
+				if (expired) {
+					const deleted = await new Promise((resolve) => {
+						/** @type {NonNullable<IntermediateFileSystem["unlink"]>} */
+						(fs.unlink)(path, (err) => resolve(!err));
+					});
+					if (deleted) {
+						deletedCount++;
+						continue;
+					}
+				}
+				if (file !== indexBackup) {
+					stillUnreferenced.set(file, { firstSeen, size });
+				}
+			}
+			await this._writeUnreferencedFiles(stillUnreferenced, seenFiles.size > 0);
+			// drop entries of files that are no longer alive
+			for (const name of referencedFilesCache.keys()) {
+				if (!liveFiles.has(`${name}${extension}`)) {
+					referencedFilesCache.delete(name);
+				}
+			}
+			if (deletedCount > 0) {
+				this.logger.log("Deleted %d unused cache files", deletedCount);
+			}
+		} catch (err) {
+			this.logger.warn(
+				`Cleanup of unused cache files failed: ${/** @type {Error} */ (err)}`
+			);
+			this.logger.debug(/** @type {Error} */ (err).stack);
+		}
+		this.logger.timeEnd("cleanup unused cache files");
+	}
+
 	clear() {
 		this.fileSystemInfo.clear();
 		this.buildDependencies.clear();

package/lib/config/defaults.js

@@ -511,7 +511,13 @@ const applyWebpackOptionsDefaults = (options, compilerIndex) => {
 		/** @type {NonNullable<WebpackOptionsNormalized["loader"]>} */ (
 			options.loader
 		),
-		{ targetProperties, environment: options.output.environment }
+		{
+			targetProperties,
+			environment: options.output.environment,
+			outputModule:
+				/** @type {NonNullable<WebpackOptionsNormalized["output"]["module"]>} */
+				(options.output.module)
+		}
 	);
 
 	F(options, "externalsType", () => {
@@ -2251,9 +2257,13 @@ const applyExternalsPresetsDefaults = (
  * @param {object} options options
  * @param {TargetProperties | false} options.targetProperties target properties
  * @param {Environment} options.environment environment
+ * @param {boolean} options.outputModule is output type is module
  * @returns {void}
  */
-const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
+const applyLoaderDefaults = (
+	loader,
+	{ targetProperties, environment, outputModule }
+) => {
 	F(loader, "target", () => {
 		if (targetProperties) {
 			if (targetProperties.electron) {
@@ -2267,6 +2277,15 @@ const applyLoaderDefaults = (loader, { targetProperties, environment }) => {
 			if (targetProperties.bun) return "bun";
 			if (targetProperties.node) return "node";
 			if (targetProperties.web) return "web";
+			// no single platform to report: the bundle runs on both (target
+			// `"universal"` / `["web", "node"]`), so loaders get `"universal"`
+			if (
+				outputModule &&
+				targetProperties.node === null &&
+				targetProperties.web === null
+			) {
+				return "universal";
+			}
 		}
 	});
 	D(loader, "environment", environment);

package/lib/container/ModuleFederationPlugin.js

@@ -18,11 +18,21 @@ const HoistContainerReferences = require("./HoistContainerReferencesPlugin");
 /** @typedef {import("../Compiler")} Compiler */
 /** @typedef {import("../Dependency")} Dependency */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncHook<Dependency>}
+	 * @since 5.96.0
+	 */
+	addContainerEntryDependency: new SyncHook(["dependency"]),
+	/**
+	 * @type {SyncHook<Dependency>}
+	 * @since 5.96.0
+	 */
+	addFederationRuntimeDependency: new SyncHook(["dependency"])
+});
+
 /**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncHook<Dependency>} addContainerEntryDependency
- * @property {SyncHook<Dependency>} addFederationRuntimeDependency
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
  */
 
 const PLUGIN_NAME = "ModuleFederationPlugin";
@@ -111,11 +121,7 @@ class ModuleFederationPlugin {
 }
 
 ModuleFederationPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			addContainerEntryDependency: new SyncHook(["dependency"]),
-			addFederationRuntimeDependency: new SyncHook(["dependency"])
-		})
+	createCompilationHooks
 );
 
 module.exports = ModuleFederationPlugin;

package/lib/css/CssGenerator.js

@@ -33,6 +33,7 @@ const CssImportDependency = require("../dependencies/CssImportDependency");
 const HarmonyImportSideEffectDependency = require("../dependencies/HarmonyImportSideEffectDependency");
 
 const { encodeMappings } = require("../util/createMappings");
+const { contextifySourceUrl } = require("../util/identifier");
 const memoize = require("../util/memoize");
 const {
 	PUBLIC_PATH_FULL_HASH,
@@ -549,8 +550,13 @@ class CssGenerator extends Generator {
 				}
 
 				const generatedJs = /** @type {string} */ (source.source());
-				const sourceName = module.readableIdentifier(
-					compilation.requestShortener
+				// Context-relative identifier, like `NormalModule.createSource` — so
+				// `SourceMapDevToolPlugin` can match the module and apply the
+				// devtool filename template instead of leaking this raw name
+				const sourceName = contextifySourceUrl(
+					/** @type {string} */ (compilation.options.context),
+					module.identifier(),
+					compilation.compiler.root
 				);
 
 				if (

package/lib/css/CssLoadingRuntimeModule.js

@@ -20,12 +20,31 @@ const { chunkHasCss } = require("./CssModulesPlugin");
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Module").ReadOnlyRuntimeRequirements} ReadOnlyRuntimeRequirements */
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.66.0
+	 */
+	createStylesheet: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.91.0
+	 */
+	linkPreload: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.91.0
+	 */
+	linkPrefetch: new SyncWaterfallHook(["source", "chunk"]),
+	/**
+	 * @type {SyncWaterfallHook<[string, Chunk]>}
+	 * @since 5.107.0
+	 */
+	linkInsert: new SyncWaterfallHook(["source", "chunk"])
+});
+
 /**
- * @typedef {object} CssLoadingRuntimeModulePluginHooks
- * @property {SyncWaterfallHook<[string, Chunk]>} createStylesheet
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPreload
- * @property {SyncWaterfallHook<[string, Chunk]>} linkPrefetch
- * @property {SyncWaterfallHook<[string, Chunk]>} linkInsert
+ * @typedef {ReturnType<typeof createCompilationHooks>} CssLoadingRuntimeModulePluginHooks
  */
 
 class CssLoadingRuntimeModule extends RuntimeModule {
@@ -577,13 +596,7 @@ class CssLoadingRuntimeModule extends RuntimeModule {
 }
 
 CssLoadingRuntimeModule.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CssLoadingRuntimeModulePluginHooks} */ ({
-			createStylesheet: new SyncWaterfallHook(["source", "chunk"]),
-			linkPreload: new SyncWaterfallHook(["source", "chunk"]),
-			linkPrefetch: new SyncWaterfallHook(["source", "chunk"]),
-			linkInsert: new SyncWaterfallHook(["source", "chunk"])
-		})
+	createCompilationHooks
 );
 
 module.exports = CssLoadingRuntimeModule;

package/lib/css/CssModulesPlugin.js

@@ -95,14 +95,6 @@ const CssParser = require("./CssParser");
  * @property {Source} moduleSourceContent content
  */
 
-/**
- * Defines the compilation hooks type used by this module.
- * @typedef {object} CompilationHooks
- * @property {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>} renderModulePackage
- * @property {SyncHook<[Chunk, Hash, ChunkHashContext]>} chunkHash
- * @property {SyncBailHook<[Chunk, Module[], Compilation], Module[] | undefined | void>} orderModules called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default
- */
-
 /**
  * Defines the module factory cache entry type used by this module.
  * @typedef {object} ModuleFactoryCacheEntry
@@ -220,6 +212,34 @@ const generatorValidationOptions = {
 
 const PLUGIN_NAME = "CssModulesPlugin";
 
+const createCompilationHooks = () => ({
+	/**
+	 * @type {SyncWaterfallHook<[Source, Module, ChunkRenderContext]>}
+	 * @since 5.94.0
+	 */
+	renderModulePackage: new SyncWaterfallHook([
+		"source",
+		"module",
+		"renderContext"
+	]),
+	/**
+	 * @type {SyncHook<[Chunk, Hash, ChunkHashContext]>}
+	 * @since 5.94.0
+	 */
+	chunkHash: new SyncHook(["chunk", "hash", "context"]),
+	/**
+	 * Called for each CSS source type (CSS_IMPORT_TYPE, CSS_TYPE) with the chunk's modules pre-sorted by full module name; return an ordered `Module[]` to override the default import-order topological sort, or return `undefined` to keep the default.
+	 * @type {SyncBailHook<[Chunk, Module[], Compilation], Module[] | undefined | void>}
+	 * @since 5.107.0
+	 */
+	orderModules: new SyncBailHook(["chunk", "modules", "compilation"])
+});
+
+/**
+ * Defines the compilation hooks type used by this module.
+ * @typedef {ReturnType<typeof createCompilationHooks>} CompilationHooks
+ */
+
 class CssModulesPlugin {
 	constructor() {
 		/** @type {WeakMap<Source, ModuleFactoryCacheEntry>} */
@@ -1175,16 +1195,7 @@ class CssModulesPlugin {
 }
 
 CssModulesPlugin.getCompilationHooks = createHooksRegistry(
-	() =>
-		/** @type {CompilationHooks} */ ({
-			renderModulePackage: new SyncWaterfallHook([
-				"source",
-				"module",
-				"renderContext"
-			]),
-			chunkHash: new SyncHook(["chunk", "hash", "context"]),
-			orderModules: new SyncBailHook(["chunk", "modules", "compilation"])
-		})
+	createCompilationHooks
 );
 
 module.exports = CssModulesPlugin;

package/lib/dependencies/CommonJsFullRequireDependency.js

@@ -9,6 +9,7 @@ const Template = require("../Template");
 const { equals } = require("../util/ArrayHelpers");
 const { getTrimmedIdsAndRange } = require("../util/chainedImports");
 const makeSerializable = require("../util/makeSerializable");
+const memoize = require("../util/memoize");
 const { propertyAccess } = require("../util/property");
 const {
 	ESM_MODULE_EXPORTS_NAME,
@@ -19,6 +20,7 @@ const ModuleDependency = require("./ModuleDependency");
 
 /** @typedef {import("webpack-sources").ReplaceSource} ReplaceSource */
 /** @typedef {import("../Dependency")} Dependency */
+/** @typedef {import("../Dependency").GetConditionFn} GetConditionFn */
 /** @typedef {import("../Dependency").ReferencedExports} ReferencedExports */
 /** @typedef {import("../DependencyTemplate").DependencyTemplateContext} DependencyTemplateContext */
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
@@ -26,8 +28,11 @@ const ModuleDependency = require("./ModuleDependency");
 /** @typedef {import("../ExportsInfo").ExportInfoName} ExportInfoName */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
 /** @typedef {import("../util/chainedImports").IdRanges} IdRanges */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean]>} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean]>} ObjectSerializerContext */
+/** @typedef {import("./HarmonyImportGuard").DependencyGuard} DependencyGuard */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectDeserializerContext */
+/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext<[ExportInfoName[], IdRanges | undefined, boolean, undefined | boolean, DependencyGuard[] | undefined]>} ObjectSerializerContext */
+
+const getHarmonyImportGuard = memoize(() => require("./HarmonyImportGuard"));
 
 class CommonJsFullRequireDependency extends ModuleDependency {
 	/**
@@ -53,6 +58,20 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		this.call = false;
 		/** @type {undefined | boolean} */
 		this.asiSafe = undefined;
+		/** @type {DependencyGuard[] | undefined} */
+		this.branchGuards = undefined;
+	}
+
+	/**
+	 * Returns function to determine if the connection is active.
+	 * @param {ModuleGraph} moduleGraph module graph
+	 * @returns {null | false | GetConditionFn} function to determine if the connection is active
+	 */
+	getCondition(moduleGraph) {
+		const guards = this.branchGuards;
+		if (guards === undefined) return null;
+		return (connection, runtime) =>
+			!getHarmonyImportGuard().isDeadByGuards(guards, moduleGraph, runtime);
 	}
 
 	/**
@@ -92,7 +111,8 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 			.write(this.names)
 			.write(this.idRanges)
 			.write(this.call)
-			.write(this.asiSafe);
+			.write(this.asiSafe)
+			.write(this.branchGuards);
 		super.serialize(context);
 	}
 
@@ -108,7 +128,9 @@ class CommonJsFullRequireDependency extends ModuleDependency {
 		this.call = c2.read();
 		const c3 = c2.rest;
 		this.asiSafe = c3.read();
-		super.deserialize(c3.rest);
+		const c4 = c3.rest;
+		this.branchGuards = c4.read();
+		super.deserialize(c4.rest);
 	}
 
 	get type() {
@@ -137,6 +159,13 @@ CommonJsFullRequireDependency.Template = class CommonJsFullRequireDependencyTemp
 	) {
 		const dep = /** @type {CommonJsFullRequireDependency} */ (dependency);
 		if (!dep.range) return;
+		const connection = moduleGraph.getConnection(dep);
+		// Dead branch: module is excluded and has no id; code is never executed.
+		if (connection && !connection.isTargetActive(runtime)) {
+			// Replaces the whole member chain, so no property access is left dangling
+			source.replace(dep.range[0], dep.range[1] - 1, "null /* dead branch */");
+			return;
+		}
 		const importedModule = moduleGraph.getModule(dep);
 		let requireExpr = runtimeTemplate.moduleExports({
 			module: importedModule,

package/lib/dependencies/CommonJsImportsParserPlugin.js

@@ -642,6 +642,7 @@ class CommonJsImportsParserPlugin {
 				dep.optional = Boolean(parser.scope.inTry);
 				dep.loc = parser.getLocation(expr);
 				parser.state.current.addDependency(dep);
+				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 				return true;
 			}
 		};
@@ -680,6 +681,7 @@ class CommonJsImportsParserPlugin {
 				dep.optional = Boolean(parser.scope.inTry);
 				dep.loc = parser.getLocation(expr.callee);
 				parser.state.current.addDependency(dep);
+				getHarmonyImportGuard().attachDependencyGuards(parser, dep);
 				parser.walkExpressions(expr.arguments);
 				return true;
 			}

package/lib/dependencies/HarmonyImportGuard.js

@@ -14,6 +14,7 @@ const memoize = require("../util/memoize");
 /** @typedef {import("../ModuleGraph")} ModuleGraph */
 /** @typedef {import("../javascript/JavascriptParser")} JavascriptParser */
 /** @typedef {import("../util/runtime").RuntimeSpec} RuntimeSpec */
+/** @typedef {import("./CommonJsFullRequireDependency")} CommonJsFullRequireDependency */
 /** @typedef {import("./CommonJsRequireDependency")} CommonJsRequireDependency */
 /** @typedef {import("./HarmonyEvaluatedImportSpecifierDependency")} HarmonyEvaluatedImportSpecifierDependency */
 /** @typedef {import("./HarmonyImportSpecifierDependency")} HarmonyImportSpecifierDependency */
@@ -29,7 +30,7 @@ const memoize = require("../util/memoize");
 /** @typedef {["&&" | "||" | "??", GuardFormula, GuardFormula]} GuardLogical */
 /** @typedef {GuardAtom | GuardPresenceAtom | GuardUnknown | GuardNot | GuardLogical} GuardFormula */
 /** @typedef {{ formula: GuardFormula, value: boolean }} DependencyGuard branch guard: the dependency is live only when the formula evaluates to `value` */
-/** @typedef {HarmonyImportSpecifierDependency | CommonJsRequireDependency | ImportDependency} GuardableDependency */
+/** @typedef {HarmonyImportSpecifierDependency | CommonJsRequireDependency | CommonJsFullRequireDependency | ImportDependency} GuardableDependency */
 
 /**
  * A guard frame pushed onto `parser.state.guardStack` for the duration of one