webpack 5.59.0 → 5.94.0

package/lib/cache/PackFileCacheStrategy.js

@@ -20,17 +20,25 @@ const {
 /** @typedef {import("../../declarations/WebpackOptions").SnapshotOptions} SnapshotOptions */
 /** @typedef {import("../Cache").Etag} Etag */
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("../FileSystemInfo").ResolveBuildDependenciesResult} ResolveBuildDependenciesResult */
 /** @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/fs").IntermediateFileSystem} IntermediateFileSystem */
 
+/** @typedef {Map<string, string | false>} ResolveResults */
+/** @typedef {Set<string>} Items */
+/** @typedef {Set<string>} BuildDependencies */
+/** @typedef {Map<string, PackItemInfo>} ItemInfo */
+
 class PackContainer {
 	/**
-	 * @param {Object} data stored data
+	 * @param {object} data stored data
 	 * @param {string} version version identifier
 	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
-	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
-	 * @param {Map<string, string | false>} resolveResults result of the resolved 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
 	 */
 	constructor(
@@ -49,15 +57,22 @@ class PackContainer {
 		this.resolveBuildDependenciesSnapshot = resolveBuildDependenciesSnapshot;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize({ write, writeLazy }) {
 		write(this.version);
 		write(this.buildSnapshot);
 		write(this.buildDependencies);
 		write(this.resolveResults);
 		write(this.resolveBuildDependenciesSnapshot);
-		writeLazy(this.data);
+		/** @type {NonNullable<ObjectSerializerContext["writeLazy"]>} */
+		(writeLazy)(this.data);
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 */
 	deserialize({ read }) {
 		this.version = read();
 		this.buildSnapshot = read();
@@ -96,13 +111,17 @@ class PackItemInfo {
 }
 
 class Pack {
+	/**
+	 * @param {Logger} logger a logger
+	 * @param {number} maxAge max age of cache items
+	 */
 	constructor(logger, maxAge) {
-		/** @type {Map<string, PackItemInfo>} */
+		/** @type {ItemInfo} */
 		this.itemInfo = new Map();
-		/** @type {string[]} */
+		/** @type {(string | undefined)[]} */
 		this.requests = [];
 		this.requestsTimeout = undefined;
-		/** @type {Map<string, PackItemInfo>} */
+		/** @type {ItemInfo} */
 		this.freshContent = new Map();
 		/** @type {(undefined | PackContent)[]} */
 		this.content = [];
@@ -111,6 +130,9 @@ class Pack {
 		this.maxAge = maxAge;
 	}
 
+	/**
+	 * @param {string} identifier identifier
+	 */
 	_addRequest(identifier) {
 		this.requests.push(identifier);
 		if (this.requestsTimeout === undefined) {
@@ -138,19 +160,18 @@ class Pack {
 		const info = this.itemInfo.get(identifier);
 		this._addRequest(identifier);
 		if (info === undefined) {
-			return undefined;
+			return;
 		}
 		if (info.etag !== etag) return null;
 		info.lastAccess = Date.now();
 		const loc = info.location;
 		if (loc === -1) {
 			return info.freshValue;
-		} else {
-			if (!this.content[loc]) {
-				return undefined;
-			}
-			return this.content[loc].get(identifier);
 		}
+		if (!this.content[loc]) {
+			return;
+		}
+		return /** @type {PackContent} */ (this.content[loc]).get(identifier);
 	}
 
 	/**
@@ -175,7 +196,7 @@ class Pack {
 			if (loc >= 0) {
 				this._addRequest(identifier);
 				this.freshContent.set(identifier, info);
-				const content = this.content[loc];
+				const content = /** @type {PackContent} */ (this.content[loc]);
 				content.delete(identifier);
 				if (content.items.size === 0) {
 					this.content[loc] = undefined;
@@ -213,12 +234,18 @@ class Pack {
 		return i;
 	}
 
+	/**
+	 * @private
+	 * @param {Items} items items
+	 * @param {Items} usedItems used items
+	 * @param {number} newLoc new location
+	 */
 	_gcAndUpdateLocation(items, usedItems, newLoc) {
 		let count = 0;
 		let lastGC;
 		const now = Date.now();
 		for (const identifier of items) {
-			const info = this.itemInfo.get(identifier);
+			const info = /** @type {PackItemInfo} */ (this.itemInfo.get(identifier));
 			if (now - info.lastAccess > this.maxAge) {
 				this.itemInfo.delete(identifier);
 				items.delete(identifier);
@@ -252,7 +279,7 @@ class Pack {
 				const loc = this._findLocation();
 				this.content[loc] = null; // reserve
 				const pack = {
-					/** @type {Set<string>} */
+					/** @type {Items} */
 					items: new Set(),
 					/** @type {Map<string, any>} */
 					map: new Map(),
@@ -351,20 +378,21 @@ class Pack {
 			mergedIndices = smallUnusedContents;
 		} else return;
 
+		/** @type {PackContent[] } */
 		const mergedContent = [];
 
 		// 3. Remove old content entries
 		for (const i of mergedIndices) {
-			mergedContent.push(this.content[i]);
+			mergedContent.push(/** @type {PackContent} */ (this.content[i]));
 			this.content[i] = undefined;
 		}
 
 		// 4. Determine merged items
-		/** @type {Set<string>} */
+		/** @type {Items} */
 		const mergedItems = new Set();
-		/** @type {Set<string>} */
+		/** @type {Items} */
 		const mergedUsedItems = new Set();
-		/** @type {(function(Map<string, any>): Promise)[]} */
+		/** @type {(function(Map<string, any>): Promise<void>)[]} */
 		const addToMergedMap = [];
 		for (const content of mergedContent) {
 			for (const identifier of content.items) {
@@ -498,17 +526,20 @@ class Pack {
 	 * Only runs for one content to avoid large invalidation.
 	 */
 	_gcOldestContent() {
-		/** @type {PackItemInfo} */
-		let oldest = undefined;
+		/** @type {PackItemInfo | undefined} */
+		let oldest;
 		for (const info of this.itemInfo.values()) {
 			if (oldest === undefined || info.lastAccess < oldest.lastAccess) {
 				oldest = info;
 			}
 		}
-		if (Date.now() - oldest.lastAccess > this.maxAge) {
-			const loc = oldest.location;
+		if (
+			Date.now() - /** @type {PackItemInfo} */ (oldest).lastAccess >
+			this.maxAge
+		) {
+			const loc = /** @type {PackItemInfo} */ (oldest).location;
 			if (loc < 0) return;
-			const content = this.content[loc];
+			const content = /** @type {PackContent} */ (this.content[loc]);
 			const items = new Set(content.items);
 			const usedItems = new Set(content.used);
 			this._gcAndUpdateLocation(items, usedItems, loc);
@@ -524,11 +555,14 @@ class Pack {
 								map.set(identifier, content.content.get(identifier));
 							}
 							return new PackContentItems(map);
-					  })
+						})
 					: undefined;
 		}
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize({ write, writeSeparate }) {
 		this._persistFreshContent();
 		this._optimizeSmallContent();
@@ -556,6 +590,9 @@ class Pack {
 		write(null); // null as marker of the end of items
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext & { logger: Logger }} context context
+	 */
 	deserialize({ read, logger }) {
 		this.logger = logger;
 		{
@@ -614,6 +651,9 @@ class PackContentItems {
 		this.map = map;
 	}
 
+	/**
+	 * @param {ObjectSerializerContext & { snapshot: TODO, rollback: TODO, logger: Logger, profile: boolean | undefined  }} context context
+	 */
 	serialize({ write, snapshot, rollback, logger, profile }) {
 		if (profile) {
 			write(false);
@@ -636,13 +676,17 @@ class PackContentItems {
 							logger.log(`Serialization of '${key}': ${duration} ms`);
 						else logger.debug(`Serialization of '${key}': ${duration} ms`);
 					}
-				} catch (e) {
+				} catch (err) {
 					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
-					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
-					);
-					logger.debug(e.stack);
+					if (err === NOT_SERIALIZABLE) continue;
+					const msg = "Skipped not serializable cache item";
+					if (err.message.includes("ModuleBuildError")) {
+						logger.log(`${msg} (in build error): ${err.message}`);
+						logger.debug(`${msg} '${key}' (in build error): ${err.stack}`);
+					} else {
+						logger.warn(`${msg}: ${err.message}`);
+						logger.debug(`${msg} '${key}': ${err.stack}`);
+					}
 				}
 			}
 			write(null);
@@ -653,7 +697,7 @@ class PackContentItems {
 		try {
 			write(true);
 			write(this.map);
-		} catch (e) {
+		} catch (_err) {
 			rollback(s);
 
 			// Try to serialize each item on it's own
@@ -663,19 +707,22 @@ class PackContentItems {
 				try {
 					write(key);
 					write(value);
-				} catch (e) {
+				} catch (err) {
 					rollback(s);
-					if (e === NOT_SERIALIZABLE) continue;
+					if (err === NOT_SERIALIZABLE) continue;
 					logger.warn(
-						`Skipped not serializable cache item '${key}': ${e.message}`
+						`Skipped not serializable cache item '${key}': ${err.message}`
 					);
-					logger.debug(e.stack);
+					logger.debug(err.stack);
 				}
 			}
 			write(null);
 		}
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext & { logger: Logger, profile: boolean | undefined }} context context
+	 */
 	deserialize({ read, logger, profile }) {
 		if (read()) {
 			this.map = read();
@@ -741,17 +788,17 @@ class PackContent {
 	*/
 
 	/**
-	 * @param {Set<string>} items keys
-	 * @param {Set<string>} usedItems used keys
+	 * @param {Items} items keys
+	 * @param {Items} usedItems used keys
 	 * @param {PackContentItems | function(): Promise<PackContentItems>} dataOrFn sync or async content
 	 * @param {Logger=} logger logger for logging
 	 * @param {string=} lazyName name of dataOrFn for logging
 	 */
 	constructor(items, usedItems, dataOrFn, logger, lazyName) {
 		this.items = items;
-		/** @type {function(): Promise<PackContentItems> | PackContentItems} */
+		/** @type {(function(): Promise<PackContentItems> | PackContentItems) | undefined} */
 		this.lazy = typeof dataOrFn === "function" ? dataOrFn : undefined;
-		/** @type {Map<string, any>} */
+		/** @type {Map<string, any> | undefined} */
 		this.content = typeof dataOrFn === "function" ? undefined : dataOrFn.map;
 		this.outdated = false;
 		this.used = usedItems;
@@ -759,14 +806,20 @@ class PackContent {
 		this.lazyName = lazyName;
 	}
 
+	/**
+	 * @param {string} identifier identifier
+	 * @returns {string | Promise<string>} result
+	 */
 	get(identifier) {
 		this.used.add(identifier);
 		if (this.content) {
 			return this.content.get(identifier);
 		}
 
+		const logger = /** @type {Logger} */ (this.logger);
 		// We are in state B
 		const { lazyName } = this;
+		/** @type {string | undefined} */
 		let timeMessage;
 		if (lazyName) {
 			// only log once
@@ -774,47 +827,49 @@ class PackContent {
 			timeMessage = `restore cache content ${lazyName} (${formatSize(
 				this.getSize()
 			)})`;
-			this.logger.log(
+			logger.log(
 				`starting to restore cache content ${lazyName} (${formatSize(
 					this.getSize()
 				)}) because of request to: ${identifier}`
 			);
-			this.logger.time(timeMessage);
+			logger.time(timeMessage);
 		}
 		const value = this.lazy();
-		if (value instanceof Promise) {
+		if ("then" in value) {
 			return value.then(data => {
 				const map = data.map;
 				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
+					logger.timeEnd(timeMessage);
 				}
 				// Move to state C
 				this.content = map;
 				this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
 				return map.get(identifier);
 			});
-		} else {
-			const map = value.map;
-			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
-			}
-			// Move to state C
-			this.content = map;
-			this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
-			return map.get(identifier);
 		}
+
+		const map = value.map;
+		if (timeMessage) {
+			logger.timeEnd(timeMessage);
+		}
+		// Move to state C
+		this.content = map;
+		this.lazy = SerializerMiddleware.unMemoizeLazy(this.lazy);
+		return map.get(identifier);
 	}
 
 	/**
 	 * @param {string} reason explanation why unpack is necessary
-	 * @returns {void | Promise} maybe a promise if lazy
+	 * @returns {void | Promise<void>} maybe a promise if lazy
 	 */
 	unpack(reason) {
 		if (this.content) return;
 
+		const logger = /** @type {Logger} */ (this.logger);
 		// Move from state B to C
 		if (this.lazy) {
 			const { lazyName } = this;
+			/** @type {string | undefined} */
 			let timeMessage;
 			if (lazyName) {
 				// only log once
@@ -822,27 +877,26 @@ class PackContent {
 				timeMessage = `unpack cache content ${lazyName} (${formatSize(
 					this.getSize()
 				)})`;
-				this.logger.log(
+				logger.log(
 					`starting to unpack cache content ${lazyName} (${formatSize(
 						this.getSize()
 					)}) because ${reason}`
 				);
-				this.logger.time(timeMessage);
+				logger.time(timeMessage);
 			}
 			const value = this.lazy();
-			if (value instanceof Promise) {
+			if ("then" in value) {
 				return value.then(data => {
 					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
+						logger.timeEnd(timeMessage);
 					}
 					this.content = data.map;
 				});
-			} else {
-				if (timeMessage) {
-					this.logger.timeEnd(timeMessage);
-				}
-				this.content = value.map;
 			}
+			if (timeMessage) {
+				logger.timeEnd(timeMessage);
+			}
+			this.content = value.map;
 		}
 	}
 
@@ -858,6 +912,9 @@ class PackContent {
 		return size;
 	}
 
+	/**
+	 * @param {string} identifier identifier
+	 */
 	delete(identifier) {
 		this.items.delete(identifier);
 		this.used.delete(identifier);
@@ -900,8 +957,10 @@ class PackContent {
 			);
 			return;
 		}
+		const logger = /** @type {Logger} */ (this.logger);
 		// State B2
 		const { lazyName } = this;
+		/** @type {string | undefined} */
 		let timeMessage;
 		if (lazyName) {
 			// only log once
@@ -909,21 +968,21 @@ class PackContent {
 			timeMessage = `unpack cache content ${lazyName} (${formatSize(
 				this.getSize()
 			)})`;
-			this.logger.log(
+			logger.log(
 				`starting to unpack cache content ${lazyName} (${formatSize(
 					this.getSize()
 				)}) because it's outdated and need to be serialized`
 			);
-			this.logger.time(timeMessage);
+			logger.time(timeMessage);
 		}
 		const value = this.lazy();
 		this.outdated = false;
-		if (value instanceof Promise) {
+		if ("then" in value) {
 			// Move to state B1
 			this.lazy = write(() =>
 				value.then(data => {
 					if (timeMessage) {
-						this.logger.timeEnd(timeMessage);
+						logger.timeEnd(timeMessage);
 					}
 					const oldMap = data.map;
 					/** @type {Map<string, any>} */
@@ -941,7 +1000,7 @@ class PackContent {
 		} else {
 			// Move to state C1
 			if (timeMessage) {
-				this.logger.timeEnd(timeMessage);
+				logger.timeEnd(timeMessage);
 			}
 			const oldMap = value.map;
 			/** @type {Map<string, any>} */
@@ -955,6 +1014,10 @@ class PackContent {
 	}
 }
 
+/**
+ * @param {Buffer} buf buffer
+ * @returns {Buffer} buffer that can be collected
+ */
 const allowCollectingMemory = buf => {
 	const wasted = buf.buffer.byteLength - buf.byteLength;
 	if (wasted > 8192 && (wasted > 1048576 || wasted > buf.byteLength)) {
@@ -965,7 +1028,7 @@ const allowCollectingMemory = buf => {
 
 class PackFileCacheStrategy {
 	/**
-	 * @param {Object} options options
+	 * @param {object} options options
 	 * @param {Compiler} options.compiler the compiler
 	 * @param {IntermediateFileSystem} options.fs the filesystem
 	 * @param {string} options.context the context directory
@@ -974,9 +1037,10 @@ class PackFileCacheStrategy {
 	 * @param {Logger} options.logger a logger
 	 * @param {SnapshotOptions} options.snapshot options regarding snapshotting
 	 * @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 {boolean | undefined} options.profile track and log detailed timing information for individual cache items
+	 * @param {boolean | undefined} options.allowCollectingMemory allow to collect unused memory created during deserialization
+	 * @param {false | "gzip" | "brotli" | undefined} options.compression compression used
+	 * @param {boolean | undefined} options.readonly disable storing cache into filesystem
 	 */
 	constructor({
 		compiler,
@@ -989,9 +1053,13 @@ class PackFileCacheStrategy {
 		maxAge,
 		profile,
 		allowCollectingMemory,
-		compression
+		compression,
+		readonly
 	}) {
-		this.fileSerializer = createFileSerializer(fs);
+		this.fileSerializer = createFileSerializer(
+			fs,
+			compiler.options.output.hashFunction
+		);
 		this.fileSystemInfo = new FileSystemInfo(fs, {
 			managedPaths: snapshot.managedPaths,
 			immutablePaths: snapshot.immutablePaths,
@@ -1005,30 +1073,34 @@ class PackFileCacheStrategy {
 		this.logger = logger;
 		this.maxAge = maxAge;
 		this.profile = profile;
+		this.readonly = readonly;
 		this.allowCollectingMemory = allowCollectingMemory;
 		this.compression = compression;
 		this._extension =
 			compression === "brotli"
 				? ".pack.br"
 				: compression === "gzip"
-				? ".pack.gz"
-				: ".pack";
+					? ".pack.gz"
+					: ".pack";
 		this.snapshot = snapshot;
-		/** @type {Set<string>} */
+		/** @type {BuildDependencies} */
 		this.buildDependencies = new Set();
 		/** @type {LazySet<string>} */
 		this.newBuildDependencies = new LazySet();
-		/** @type {Snapshot} */
+		/** @type {Snapshot | undefined} */
 		this.resolveBuildDependenciesSnapshot = undefined;
-		/** @type {Map<string, string | false>} */
+		/** @type {ResolveResults | undefined} */
 		this.resolveResults = undefined;
-		/** @type {Snapshot} */
+		/** @type {Snapshot | undefined} */
 		this.buildSnapshot = undefined;
-		/** @type {Promise<Pack>} */
+		/** @type {Promise<Pack> | undefined} */
 		this.packPromise = this._openPack();
 		this.storePromise = Promise.resolve();
 	}
 
+	/**
+	 * @returns {Promise<Pack>} pack
+	 */
 	_getPack() {
 		if (this.packPromise === undefined) {
 			this.packPromise = this.storePromise.then(() => this._openPack());
@@ -1043,13 +1115,13 @@ class PackFileCacheStrategy {
 		const { logger, profile, cacheLocation, version } = this;
 		/** @type {Snapshot} */
 		let buildSnapshot;
-		/** @type {Set<string>} */
+		/** @type {BuildDependencies} */
 		let buildDependencies;
-		/** @type {Set<string>} */
+		/** @type {BuildDependencies} */
 		let newBuildDependencies;
 		/** @type {Snapshot} */
 		let resolveBuildDependenciesSnapshot;
-		/** @type {Map<string, string | false>} */
+		/** @type {ResolveResults | undefined} */
 		let resolveResults;
 		logger.time("restore cache container");
 		return this.fileSerializer
@@ -1077,19 +1149,19 @@ class PackFileCacheStrategy {
 			})
 			.then(packContainer => {
 				logger.timeEnd("restore cache container");
-				if (!packContainer) return undefined;
+				if (!packContainer) return;
 				if (!(packContainer instanceof PackContainer)) {
 					logger.warn(
 						`Restored pack from ${cacheLocation}${this._extension}, but contained content is unexpected.`,
 						packContainer
 					);
-					return undefined;
+					return;
 				}
 				if (packContainer.version !== version) {
 					logger.log(
 						`Restored pack from ${cacheLocation}${this._extension}, but version doesn't match.`
 					);
-					return undefined;
+					return;
 				}
 				logger.time("check build dependencies");
 				return Promise.all([
@@ -1206,6 +1278,8 @@ class PackFileCacheStrategy {
 	 * @returns {Promise<void>} promise
 	 */
 	store(identifier, etag, data) {
+		if (this.readonly) return Promise.resolve();
+
 		return this._getPack().then(pack => {
 			pack.set(identifier, etag === null ? null : etag.toString(), data);
 		});
@@ -1231,7 +1305,11 @@ class PackFileCacheStrategy {
 			});
 	}
 
+	/**
+	 * @param {LazySet<string> | Iterable<string>} dependencies dependencies to store
+	 */
 	storeBuildDependencies(dependencies) {
+		if (this.readonly) return;
 		this.newBuildDependencies.addAll(dependencies);
 	}
 
@@ -1244,7 +1322,7 @@ class PackFileCacheStrategy {
 				pack.stopCapturingRequests();
 				if (!pack.invalid) return;
 				this.packPromise = undefined;
-				this.logger.log(`Storing pack...`);
+				this.logger.log("Storing pack...");
 				let promise;
 				const newBuildDependencies = new Set();
 				for (const dep of this.newBuildDependencies) {
@@ -1275,7 +1353,7 @@ class PackFileCacheStrategy {
 									missing,
 									resolveResults,
 									resolveDependencies
-								} = result;
+								} = /** @type {ResolveBuildDependenciesResult} */ (result);
 								if (this.resolveResults) {
 									for (const [key, value] of resolveResults) {
 										this.resolveResults.set(key, value);
@@ -1362,7 +1440,7 @@ class PackFileCacheStrategy {
 				}
 				return promise.then(() => {
 					if (reportProgress) reportProgress(0.8, "serialize pack");
-					this.logger.time(`store pack`);
+					this.logger.time("store pack");
 					const updatedBuildDependencies = new Set(this.buildDependencies);
 					for (const dep of newBuildDependencies) {
 						updatedBuildDependencies.add(dep);
@@ -1370,7 +1448,7 @@ class PackFileCacheStrategy {
 					const content = new PackContainer(
 						pack,
 						this.version,
-						this.buildSnapshot,
+						/** @type {Snapshot} */ (this.buildSnapshot),
 						updatedBuildDependencies,
 						this.resolveResults,
 						this.resolveBuildDependenciesSnapshot
@@ -1387,7 +1465,7 @@ class PackFileCacheStrategy {
 								this.buildDependencies.add(dep);
 							}
 							this.newBuildDependencies.clear();
-							this.logger.timeEnd(`store pack`);
+							this.logger.timeEnd("store pack");
 							const stats = pack.getContentStats();
 							this.logger.log(
 								"Stored pack (%d items, %d files, %d MiB)",
@@ -1397,7 +1475,7 @@ class PackFileCacheStrategy {
 							);
 						})
 						.catch(err => {
-							this.logger.timeEnd(`store pack`);
+							this.logger.timeEnd("store pack");
 							this.logger.warn(`Caching failed for pack: ${err}`);
 							this.logger.debug(err.stack);
 						});