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

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");
@@ -17,33 +18,51 @@ const {
 	createFileSerializer
 } = require("../util/serialization");
 
-/** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../Compilation").FileSystemDependencies} FileSystemDependencies */
-/** @typedef {import("../Cache").Data} Data */
-/** @typedef {import("../Cache").Etag} Etag */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
-/** @typedef {import("../FileSystemInfo").ResolveResults} ResolveResults */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../logging/Logger").Logger} Logger */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
-/** @typedef {import("../util/fs").IntermediateFileSystem} IntermediateFileSystem */
+/** @import { SnapshotOptions } from "../../declarations/WebpackOptions" */
+/** @import { FileSystemDependencies } from "../Compilation" */
+/** @import { Data, Etag } from "../Cache" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import {
+ * 	ResolveBuildDependenciesResult,
+ * 	ResolveResults,
+ * 	Snapshot
+ * } from "../FileSystemInfo"
+ */
+/** @import { Logger } from "../logging/Logger" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
+/** @import { HashFunction } from "../util/Hash" */
+/** @import { IntermediateFileSystem } from "../util/fs" */
 
 /** @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 {
 	/**
 	 * Creates an instance of PackContainer.
 	 * @param {Pack} data stored data
 	 * @param {string} version version identifier
-	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
+	 * @param {InstanceType<Snapshot>} buildSnapshot snapshot of all build dependencies
 	 * @param {BuildDependencies} buildDependencies list of all unresolved build dependencies captured
 	 * @param {ResolveResults} resolveResults result of the resolved build dependencies
-	 * @param {Snapshot} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
+	 * @param {InstanceType<Snapshot>} resolveBuildDependenciesSnapshot snapshot of the dependencies of the build dependencies resolving
 	 */
 	constructor(
 		data,
@@ -57,13 +76,13 @@ class PackContainer {
 		this.data = data;
 		/** @type {string} */
 		this.version = version;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		this.buildSnapshot = buildSnapshot;
 		/** @type {BuildDependencies} */
 		this.buildDependencies = buildDependencies;
 		/** @type {ResolveResults} */
 		this.resolveResults = resolveResults;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
 	}
 
@@ -569,6 +588,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 +635,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 +674,7 @@ class Pack {
 		this._persistFreshContent();
 		this._optimizeSmallContent();
 		this._optimizeUnusedContent();
+		this._gcExpiredContent();
 		this._gcOldestContent();
 		for (const identifier of this.itemInfo.keys()) {
 			write(identifier);
@@ -1166,6 +1220,8 @@ class PackFileCacheStrategy {
 		});
 		/** @type {Compiler} */
 		this.compiler = compiler;
+		/** @type {IntermediateFileSystem} */
+		this.fs = fs;
 		/** @type {string} */
 		this.context = context;
 		/** @type {string} */
@@ -1182,6 +1238,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
@@ -1203,11 +1263,11 @@ class PackFileCacheStrategy {
 		this.buildDependencies = new Set();
 		/** @type {FileSystemDependencies} */
 		this.newBuildDependencies = new LazySet();
-		/** @type {Snapshot | undefined} */
+		/** @type {InstanceType<Snapshot> | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
 		/** @type {ResolveResults | undefined} */
 		this.resolveResults = undefined;
-		/** @type {Snapshot | undefined} */
+		/** @type {InstanceType<Snapshot> | undefined} */
 		this.buildSnapshot = undefined;
 		/** @type {Promise<Pack> | undefined} */
 		this.packPromise = this._openPack();
@@ -1232,13 +1292,13 @@ class PackFileCacheStrategy {
 	 */
 	_openPack() {
 		const { logger, profile, cacheLocation, version } = this;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		let buildSnapshot;
 		/** @type {BuildDependencies} */
 		let buildDependencies;
 		/** @type {BuildDependencies} */
 		let newBuildDependencies;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		let resolveBuildDependenciesSnapshot;
 		/** @type {ResolveResults | undefined} */
 		let resolveResults;
@@ -1580,18 +1640,25 @@ class PackFileCacheStrategy {
 					const content = new PackContainer(
 						pack,
 						this.version,
-						/** @type {Snapshot} */
+						/** @type {InstanceType<Snapshot>} */
 						(this.buildSnapshot),
 						updatedBuildDependencies,
 						/** @type {ResolveResults} */
 						(this.resolveResults),
-						/** @type {Snapshot} */
+						/** @type {InstanceType<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 +1675,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 +1697,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/cache/ResolverCachePlugin.js

@@ -8,18 +8,29 @@
 const LazySet = require("../util/LazySet");
 const makeSerializable = require("../util/makeSerializable");
 
-/** @typedef {import("enhanced-resolve").ResolveContext} ResolveContext */
-/** @typedef {import("enhanced-resolve").ResolveOptions} ResolveOptions */
-/** @typedef {import("enhanced-resolve").ResolveRequest} ResolveRequest */
-/** @typedef {import("enhanced-resolve").Resolver} Resolver */
-/** @typedef {import("../CacheFacade").ItemCacheFacade} ItemCacheFacade */
-/** @typedef {import("../Compiler")} Compiler */
-/** @typedef {import("../FileSystemInfo")} FileSystemInfo */
-/** @typedef {import("../FileSystemInfo").Snapshot} Snapshot */
-/** @typedef {import("../FileSystemInfo").SnapshotOptions} SnapshotOptions */
-/** @typedef {import("../ResolverFactory").ResolveOptionsWithDependencyType} ResolveOptionsWithDependencyType */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("../serialization/ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/**
+ * @import {
+ * 	ResolveContext,
+ * 	ResolveOptions,
+ * 	ResolveRequest,
+ * 	Resolver
+ * } from "enhanced-resolve"
+ */
+/** @import { ItemCacheFacade } from "../CacheFacade" */
+/** @import Compiler from "../Compiler" */
+/**
+ * @import FileSystemInfo, {
+ * 	Snapshot,
+ * 	SnapshotOptions
+ * } from "../FileSystemInfo"
+ */
+/** @import { ResolveOptionsWithDependencyType } from "../ResolverFactory" */
+/**
+ * @import {
+ * 	ObjectDeserializerContext,
+ * 	ObjectSerializerContext
+ * } from "../serialization/ObjectMiddleware"
+ */
 
 /**
  * Defines the sync hook type used by this module.
@@ -33,12 +44,12 @@ class CacheEntry {
 	/**
 	 * Creates an instance of CacheEntry.
 	 * @param {ResolveRequest} result result
-	 * @param {Snapshot} snapshot snapshot
+	 * @param {InstanceType<Snapshot>} snapshot snapshot
 	 */
 	constructor(result, snapshot) {
 		/** @type {ResolveRequest} */
 		this.result = result;
-		/** @type {Snapshot} */
+		/** @type {InstanceType<Snapshot>} */
 		this.snapshot = snapshot;
 	}
 
@@ -112,7 +123,7 @@ class ResolverCachePlugin {
 	 */
 	apply(compiler) {
 		const cache = compiler.getCache(PLUGIN_NAME);
-		/** @type {FileSystemInfo} */
+		/** @type {FileSystemInfo | undefined} */
 		let fileSystemInfo;
 		/** @type {SnapshotOptions | undefined} */
 		let snapshotOptions;
@@ -120,6 +131,12 @@ class ResolverCachePlugin {
 		let cachedResolves = 0;
 		let cacheInvalidResolves = 0;
 		let concurrentResolves = 0;
+		// FileSystemInfo reaches the whole Compilation through its logger, so this
+		// compiler-lifetime closure would outlive what `Compiler.close()` releases.
+		compiler.hooks.shutdown.tap(PLUGIN_NAME, () => {
+			fileSystemInfo = undefined;
+			snapshotOptions = undefined;
+		});
 		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, (compilation) => {
 			snapshotOptions = compilation.options.snapshot.resolve;
 			fileSystemInfo = compilation.fileSystemInfo;
@@ -144,7 +161,7 @@ class ResolverCachePlugin {
 
 		/**
 		 * Processes the provided item cache.
-		 * @param {ItemCacheFacade} itemCache cache
+		 * @param {InstanceType<ItemCacheFacade>} itemCache cache
 		 * @param {Resolver} resolver the resolver
 		 * @param {ResolveContext} resolveContext context for resolving meta info
 		 * @param {ResolveRequest} request the request info object
@@ -209,7 +226,9 @@ class ResolverCachePlugin {
 					const fileDependencies = newResolveContext.fileDependencies;
 					const contextDependencies = newResolveContext.contextDependencies;
 					const missingDependencies = newResolveContext.missingDependencies;
-					fileSystemInfo.createSnapshot(
+					// Only reachable past the `!fileSystemInfo` guard on the resolve tap.
+					const fsInfo = /** @type {FileSystemInfo} */ (fileSystemInfo);
+					fsInfo.createSnapshot(
 						resolveTime,
 						/** @type {Dependencies} */
 						(fileDependencies),
@@ -395,7 +414,8 @@ class ResolverCachePlugin {
 
 								if (cacheEntry) {
 									const { snapshot, result } = cacheEntry;
-									fileSystemInfo.checkSnapshotValid(snapshot, (err, valid) => {
+									const fsInfo = /** @type {FileSystemInfo} */ (fileSystemInfo);
+									fsInfo.checkSnapshotValid(snapshot, (err, valid) => {
 										if (err || !valid) {
 											cacheInvalidResolves++;
 											return doRealResolve(

package/lib/cache/getLazyHashedEtag.js

@@ -8,9 +8,8 @@
 const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
 
-/** @typedef {import("../util/Hash")} Hash */
+/** @import Hash, { HashFunction } from "../util/Hash" */
 /** @typedef {typeof import("../util/Hash")} HashConstructor */
-/** @typedef {import("../util/Hash").HashFunction} HashFunction */
 
 /**
  * Represents the lazy hashed etag runtime component.

package/lib/cache/mergeEtags.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-/** @typedef {import("../Cache").Etag} Etag */
+/** @import { Etag } from "../Cache" */
 
 class MergedEtag {
 	/**

package/lib/cli.js

@@ -11,9 +11,7 @@ const webpackSchema =
 	/** @type {EXPECTED_ANY} */
 	(require("../schemas/WebpackOptions.json"));
 
-/** @typedef {import("json-schema").JSONSchema4} JSONSchema4 */
-/** @typedef {import("json-schema").JSONSchema6} JSONSchema6 */
-/** @typedef {import("json-schema").JSONSchema7} JSONSchema7 */
+/** @import { JSONSchema4, JSONSchema6, JSONSchema7 } from "json-schema" */
 /** @typedef {JSONSchema4 | JSONSchema6 | JSONSchema7} JSONSchema */
 /** @typedef {JSONSchema & { absolutePath: boolean, instanceof: string, cli: { helper?: boolean, exclude?: boolean, description?: string, negatedDescription?: string, resetDescription?: string } }} Schema */
 

package/lib/config/browserslistTargetHandler.js

@@ -8,13 +8,23 @@
 const path = require("path");
 const browserslist = require("browserslist");
 
-/** @typedef {import("./target").ApiTargetProperties} ApiTargetProperties */
-/** @typedef {import("./target").EcmaTargetProperties} EcmaTargetProperties */
-/** @typedef {import("./target").PlatformTargetProperties} PlatformTargetProperties */
+/**
+ * @import {
+ * 	ApiTargetProperties,
+ * 	EcmaTargetProperties,
+ * 	PlatformTargetProperties
+ * } from "./target"
+ */
 
 // [[C:]/path/to/config][:env]
 const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
 
+// One resolution per `[input, context]` — several callers ask for the same
+// target, and each miss re-reads the config and re-runs the queries. The list is
+// handed out as it stands, so no caller may write to it.
+/** @type {Map<string, string[] | undefined> | null} */
+const cache = process.env.BROWSERSLIST_DISABLE_CACHE ? null : new Map();
+
 /**
  * Returns selected browsers.
  * @param {string | null | undefined} input input string
@@ -22,6 +32,25 @@ const inputRx = /^(?:((?:[A-Z]:)?[/\\].*?))?(?::(.+?))?$/i;
  * @returns {string[] | undefined} selected browsers
  */
 const load = (input, context) => {
+	if (cache === null) return loadBrowsers(input, context);
+	// A newline separates the two: an input carries a config path, an env or a
+	// query, and a directory carries none.
+	const key = `${input || ""}\n${context}`;
+	let browsers = cache.get(key);
+	if (browsers === undefined && !cache.has(key)) {
+		browsers = loadBrowsers(input, context);
+		cache.set(key, browsers);
+	}
+	return browsers;
+};
+
+/**
+ * Read the selection out of the browserslist config or query.
+ * @param {string | null | undefined} input input string
+ * @param {string} context the context directory
+ * @returns {string[] | undefined} selected browsers
+ */
+const loadBrowsers = (input, context) => {
 	// browserslist:path-to-config
 	// browserslist:path-to-config:env
 	if (input && path.isAbsolute(input)) {
@@ -69,8 +98,15 @@ const resolve = (browsers) => {
 	 * @param {Record<string, number | [number, number]>} versions first supported version
 	 * @returns {boolean} true if supports
 	 */
-	const rawChecker = (versions) =>
-		browsers.every((v) => {
+	const rawChecker = (versions) => checkAll(browsers, versions);
+	/**
+	 * Checks a subset of the list against a version number
+	 * @param {string[]} list the browsers to check
+	 * @param {Record<string, number | [number, number]>} versions first supported version
+	 * @returns {boolean} true if all support
+	 */
+	const checkAll = (list, versions) =>
+		list.every((v) => {
 			const [name, parsedVersion] = v.split(" ");
 			if (!name) return false;
 			const requiredVersion = versions[name];