webpack 5.90.3 → 5.91.0

package/lib/buildChunkGraph.js

@@ -58,6 +58,16 @@ const { getEntryRuntime, mergeRuntime } = require("./util/runtime");
  * @property {ChunkGroup} chunkGroup referenced chunk group
  */
 
+/** @typedef {(Module | ConnectionState | ModuleGraphConnection)[]} BlockModulesInTuples */
+/** @typedef {(Module | ConnectionState | ModuleGraphConnection[])[]} BlockModulesInFlattenTuples */
+/** @typedef {Map<DependenciesBlock, BlockModulesInFlattenTuples>} BlockModulesMap */
+/** @typedef {Map<Chunk, bigint>} MaskByChunk */
+/** @typedef {Set<DependenciesBlock>} BlocksWithNestedBlocks */
+/** @typedef {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} BlockConnections */
+/** @typedef {Map<ChunkGroup, ChunkGroupInfo>} ChunkGroupInfoMap */
+/** @typedef {Set<ChunkGroup>} AllCreatedChunkGroups */
+/** @typedef {Map<Entrypoint, Module[]>} InputEntrypointsAndModules */
+
 const ZERO_BIGINT = BigInt(0);
 const ONE_BIGINT = BigInt(1);
 
@@ -88,15 +98,26 @@ const getActiveStateOfConnections = (connections, runtime) => {
 	return merged;
 };
 
+/**
+ * @param {Module} module module
+ * @param {ModuleGraph} moduleGraph module graph
+ * @param {RuntimeSpec} runtime runtime
+ * @param {BlockModulesMap} blockModulesMap block modules map
+ */
 const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
+	/** @type {DependenciesBlock | undefined} */
 	let blockCache;
+	/** @type {BlockModulesInTuples | undefined} */
 	let modules;
 
+	/** @type {BlockModulesInTuples[]} */
 	const arrays = [];
 
+	/** @type {DependenciesBlock[]} */
 	const queue = [module];
 	while (queue.length > 0) {
-		const block = queue.pop();
+		const block = /** @type {DependenciesBlock} */ (queue.pop());
+		/** @type {Module[]} */
 		const arr = [];
 		arrays.push(arr);
 		blockModulesMap.set(block, arr);
@@ -120,17 +141,26 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 
 		// deprecated fallback
 		if (index < 0) {
-			index = block.dependencies.indexOf(d);
+			index = /** @type {DependenciesBlock} */ (block).dependencies.indexOf(d);
 		}
 
 		if (blockCache !== block) {
-			modules = blockModulesMap.get((blockCache = block));
+			modules =
+				/** @type {BlockModulesInTuples} */
+				(
+					blockModulesMap.get(
+						(blockCache = /** @type {DependenciesBlock} */ (block))
+					)
+				);
 		}
 
 		const i = index * 3;
-		modules[i] = m;
-		modules[i + 1] = connection.getActiveState(runtime);
-		modules[i + 2] = connection;
+		/** @type {BlockModulesInTuples} */
+		(modules)[i] = m;
+		/** @type {BlockModulesInTuples} */
+		(modules)[i + 1] = connection.getActiveState(runtime);
+		/** @type {BlockModulesInTuples} */
+		(modules)[i + 2] = connection;
 	}
 
 	for (const modules of arrays) {
@@ -140,14 +170,15 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 		outer: for (let j = 0; j < modules.length; j += 3) {
 			const m = modules[j];
 			if (m === undefined) continue;
-			const state = modules[j + 1];
-			const connection = modules[j + 2];
+			const state = /** @type {ConnectionState} */ (modules[j + 1]);
+			const connection = /** @type {ModuleGraphConnection} */ (modules[j + 2]);
 			if (indexMap === undefined) {
 				let i = 0;
 				for (; i < length; i += 3) {
 					if (modules[i] === m) {
-						const merged = modules[i + 1];
-						modules[i + 2].push(connection);
+						const merged = /** @type {ConnectionState} */ (modules[i + 1]);
+						/** @type {ModuleGraphConnection[]} */
+						(/** @type {unknown} */ (modules[i + 2])).push(connection);
 						if (merged === true) continue outer;
 						modules[i + 1] = ModuleGraphConnection.addConnectionStates(
 							merged,
@@ -160,7 +191,8 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 				length++;
 				modules[length] = state;
 				length++;
-				modules[length] = [connection];
+				/** @type {ModuleGraphConnection[]} */
+				(/** @type {unknown} */ (modules[length])) = [connection];
 				length++;
 				if (length > 30) {
 					// To avoid worse case performance, we will use an index map for
@@ -174,8 +206,9 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 			} else {
 				const idx = indexMap.get(m);
 				if (idx !== undefined) {
-					const merged = modules[idx];
-					modules[idx + 1].push(connection);
+					const merged = /** @type {ConnectionState} */ (modules[idx]);
+					/** @type {ModuleGraphConnection[]} */
+					(/** @type {unknown} */ (modules[idx + 1])).push(connection);
 					if (merged === true) continue outer;
 					modules[idx] = ModuleGraphConnection.addConnectionStates(
 						merged,
@@ -187,7 +220,11 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
 					modules[length] = state;
 					indexMap.set(m, length);
 					length++;
-					modules[length] = [connection];
+					/** @type {ModuleGraphConnection[]} */
+					(
+						/** @type {unknown} */
+						(modules[length])
+					) = [connection];
 					length++;
 				}
 			}
@@ -200,12 +237,12 @@ const extractBlockModules = (module, moduleGraph, runtime, blockModulesMap) => {
  *
  * @param {Logger} logger a logger
  * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
- * @param {Map<ChunkGroup, ChunkGroupInfo>} chunkGroupInfoMap mapping from chunk group to available modules
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Set<ChunkGroup>} allCreatedChunkGroups filled with all chunk groups that are created here
- * @param {Map<Chunk, bigint>} maskByChunk module content mask by chunk
+ * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @param {ChunkGroupInfoMap} chunkGroupInfoMap mapping from chunk group to available modules
+ * @param {BlockConnections} blockConnections connection for blocks
+ * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {AllCreatedChunkGroups} allCreatedChunkGroups filled with all chunk groups that are created here
+ * @param {MaskByChunk} maskByChunk module content mask by chunk
  */
 const visitModules = (
 	logger,
@@ -221,9 +258,7 @@ const visitModules = (
 
 	const blockModulesRuntimeMap = new Map();
 
-	/** @type {RuntimeSpec | false} */
-	let blockModulesMapRuntime = false;
-	/** @type {Map<DependenciesBlock, (Module | ConnectionState)[]>} */
+	/** @type {BlockModulesMap | undefined} */
 	let blockModulesMap;
 
 	/** @type {Map<Module, number>} */
@@ -254,15 +289,13 @@ const visitModules = (
 	 *
 	 * @param {DependenciesBlock} block block
 	 * @param {RuntimeSpec} runtime runtime
-	 * @returns {(Module | ConnectionState | ModuleGraphConnection[])[]} block modules in flatten tuples
+	 * @returns {BlockModulesInFlattenTuples} block modules in flatten tuples
 	 */
 	const getBlockModules = (block, runtime) => {
-		if (blockModulesMapRuntime !== runtime) {
-			blockModulesMap = blockModulesRuntimeMap.get(runtime);
-			if (blockModulesMap === undefined) {
-				blockModulesMap = new Map();
-				blockModulesRuntimeMap.set(runtime, blockModulesMap);
-			}
+		blockModulesMap = blockModulesRuntimeMap.get(runtime);
+		if (blockModulesMap === undefined) {
+			blockModulesMap = new Map();
+			blockModulesRuntimeMap.set(runtime, blockModulesMap);
 		}
 		let blockModules = blockModulesMap.get(block);
 		if (blockModules !== undefined) return blockModules;
@@ -286,9 +319,11 @@ const visitModules = (
 		} else {
 			logger.time("visitModules: prepare");
 			extractBlockModules(module, moduleGraph, runtime, blockModulesMap);
-			blockModules = blockModulesMap.get(block);
+			blockModules =
+				/** @type {BlockModulesInFlattenTuples} */
+				(blockModulesMap.get(block));
 			logger.timeAggregate("visitModules: prepare");
-			return /** @type {(Module | ConnectionState)[]} */ (blockModules);
+			return blockModules;
 		}
 	};
 
@@ -451,6 +486,7 @@ const visitModules = (
 	const iteratorBlock = b => {
 		// 1. We create a chunk group with single chunk in it for this Block
 		// but only once (blockChunkGroups map)
+		/** @type {ChunkGroupInfo | undefined} */
 		let cgi = blockChunkGroups.get(b);
 		/** @type {ChunkGroup | undefined} */
 		let c;
@@ -465,8 +501,8 @@ const visitModules = (
 					entrypoint = compilation.addAsyncEntrypoint(
 						entryOptions,
 						module,
-						b.loc,
-						b.request
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
 					);
 					maskByChunk.set(entrypoint.chunks[0], ZERO_BIGINT);
 					entrypoint.index = nextChunkGroupIndex++;
@@ -500,7 +536,11 @@ const visitModules = (
 				} else {
 					entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 					// TODO merge entryOptions
-					entrypoint.addOrigin(module, b.loc, b.request);
+					entrypoint.addOrigin(
+						module,
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
+					);
 					chunkGraph.connectBlockAndChunkGroup(b, entrypoint);
 				}
 
@@ -524,13 +564,13 @@ const visitModules = (
 					chunkGroupInfo
 				});
 			} else {
-				cgi = chunkName && namedChunkGroups.get(chunkName);
+				cgi = chunkName ? namedChunkGroups.get(chunkName) : undefined;
 				if (!cgi) {
 					c = compilation.addChunkInGroup(
 						b.groupOptions || b.chunkName,
 						module,
-						b.loc,
-						b.request
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
 					);
 					maskByChunk.set(c.chunks[0], ZERO_BIGINT);
 					c.index = nextChunkGroupIndex++;
@@ -561,19 +601,23 @@ const visitModules = (
 							new AsyncDependencyToInitialChunkError(
 								/** @type {string} */ (chunkName),
 								module,
-								b.loc
+								/** @type {DependencyLocation} */ (b.loc)
 							)
 						);
 						c = chunkGroup;
 					} else {
 						c.addOptions(b.groupOptions);
 					}
-					c.addOrigin(module, b.loc, b.request);
+					c.addOrigin(
+						module,
+						/** @type {DependencyLocation} */ (b.loc),
+						/** @type {string} */ (b.request)
+					);
 				}
 				blockConnections.set(b, []);
 			}
 			blockChunkGroups.set(b, /** @type {ChunkGroupInfo} */ (cgi));
-			blockByChunkGroups.set(cgi, b);
+			blockByChunkGroups.set(/** @type {ChunkGroupInfo} */ (cgi), b);
 		} else if (entryOptions) {
 			entrypoint = /** @type {Entrypoint} */ (cgi.chunkGroup);
 		} else {
@@ -583,7 +627,8 @@ const visitModules = (
 		if (c !== undefined) {
 			// 2. We store the connection for the block
 			// to connect it later if needed
-			blockConnections.get(b).push({
+			/** @type {BlockChunkGroupConnection[]} */
+			(blockConnections.get(b)).push({
 				originChunkGroupInfo: chunkGroupInfo,
 				chunkGroup: c
 			});
@@ -622,7 +667,9 @@ const visitModules = (
 		const blockModules = getBlockModules(block, chunkGroupInfo.runtime);
 
 		if (blockModules !== undefined) {
-			const { minAvailableModules } = chunkGroupInfo;
+			const minAvailableModules =
+				/** @type {bigint} */
+				(chunkGroupInfo.minAvailableModules);
 			// Buffer items because order need to be reversed to get indices correct
 			// Traverse all referenced modules
 			for (let i = 0, len = blockModules.length; i < len; i += 3) {
@@ -770,7 +817,7 @@ const visitModules = (
 					// We connect Module and Chunk
 					chunkGraph.connectChunkAndModule(chunk, module);
 					const moduleOrdinal = getModuleOrdinal(module);
-					let chunkMask = maskByChunk.get(chunk);
+					let chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
 					chunkMask |= ONE_BIGINT << BigInt(moduleOrdinal);
 					maskByChunk.set(chunk, chunkMask);
 				}
@@ -837,11 +884,13 @@ const visitModules = (
 		if (chunkGroupInfo.resultingAvailableModules !== undefined)
 			return chunkGroupInfo.resultingAvailableModules;
 
-		let resultingAvailableModules = chunkGroupInfo.minAvailableModules;
+		let resultingAvailableModules = /** @type {bigint} */ (
+			chunkGroupInfo.minAvailableModules
+		);
 
 		// add the modules from the chunk group to the set
 		for (const chunk of chunkGroupInfo.chunkGroup.chunks) {
-			const mask = maskByChunk.get(chunk);
+			const mask = /** @type {bigint} */ (maskByChunk.get(chunk));
 			resultingAvailableModules |= mask;
 		}
 
@@ -986,7 +1035,8 @@ const visitModules = (
 						const ordinal = getModuleOrdinal(module);
 						info.skippedModuleConnections.delete(entry);
 						if (isOrdinalSetInMask(minAvailableModules, ordinal)) {
-							info.skippedItems.add(module);
+							/** @type {NonNullable<ChunkGroupInfo["skippedItems"]>} */
+							(info.skippedItems).add(module);
 							continue;
 						}
 					}
@@ -1079,13 +1129,11 @@ const visitModules = (
 		let preOrderIndex = 0;
 		let postOrderIndex = 0;
 
+		/**
+		 * @param {DependenciesBlock} current current
+		 * @param {BlocksWithNestedBlocks} visited visited dependencies blocks
+		 */
 		const process = (current, visited) => {
-			if (visited.has(current)) {
-				return;
-			}
-
-			visited.add(current);
-
 			const blockModules = getBlockModules(current, runtime);
 			if (blockModules === undefined) {
 				return;
@@ -1099,6 +1147,11 @@ const visitModules = (
 					continue;
 				}
 				const refModule = /** @type {Module} */ (blockModules[i]);
+				if (visited.has(refModule)) {
+					continue;
+				}
+
+				visited.add(refModule);
 
 				if (refModule) {
 					chunkGroup.setModulePreOrderIndex(refModule, preOrderIndex++);
@@ -1128,9 +1181,9 @@ const visitModules = (
 /**
  *
  * @param {Compilation} compilation the compilation
- * @param {Set<DependenciesBlock>} blocksWithNestedBlocks flag for blocks that have nested blocks
- * @param {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} blockConnections connection for blocks
- * @param {Map<Chunk, bigint>} maskByChunk mapping from chunk to module mask
+ * @param {BlocksWithNestedBlocks} blocksWithNestedBlocks flag for blocks that have nested blocks
+ * @param {BlockConnections} blockConnections connection for blocks
+ * @param {MaskByChunk} maskByChunk mapping from chunk to module mask
  */
 const connectChunkGroups = (
 	compilation,
@@ -1149,7 +1202,7 @@ const connectChunkGroups = (
 	 */
 	const areModulesAvailable = (chunkGroup, availableModules) => {
 		for (const chunk of chunkGroup.chunks) {
-			const chunkMask = maskByChunk.get(chunk);
+			const chunkMask = /** @type {bigint} */ (maskByChunk.get(chunk));
 			if ((chunkMask & availableModules) !== chunkMask) return false;
 		}
 		return true;
@@ -1169,7 +1222,7 @@ const connectChunkGroups = (
 			connections.every(({ chunkGroup, originChunkGroupInfo }) =>
 				areModulesAvailable(
 					chunkGroup,
-					originChunkGroupInfo.resultingAvailableModules
+					/** @type {bigint} */ (originChunkGroupInfo.resultingAvailableModules)
 				)
 			)
 		) {
@@ -1215,7 +1268,7 @@ const cleanupUnconnectedGroups = (compilation, allCreatedChunkGroups) => {
 /**
  * This method creates the Chunk graph from the Module graph
  * @param {Compilation} compilation the compilation
- * @param {Map<Entrypoint, Module[]>} inputEntrypointsAndModules chunk groups which are processed with the modules
+ * @param {InputEntrypointsAndModules} inputEntrypointsAndModules chunk groups which are processed with the modules
  * @returns {void}
  */
 const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
@@ -1223,19 +1276,19 @@ const buildChunkGraph = (compilation, inputEntrypointsAndModules) => {
 
 	// SHARED STATE
 
-	/** @type {Map<AsyncDependenciesBlock, BlockChunkGroupConnection[]>} */
+	/** @type {BlockConnections} */
 	const blockConnections = new Map();
 
-	/** @type {Set<ChunkGroup>} */
+	/** @type {AllCreatedChunkGroups} */
 	const allCreatedChunkGroups = new Set();
 
-	/** @type {Map<ChunkGroup, ChunkGroupInfo>} */
+	/** @type {ChunkGroupInfoMap} */
 	const chunkGroupInfoMap = new Map();
 
-	/** @type {Set<DependenciesBlock>} */
+	/** @type {BlocksWithNestedBlocks} */
 	const blocksWithNestedBlocks = new Set();
 
-	/** @type {Map<Chunk, bigint>} */
+	/** @type {MaskByChunk} */
 	const maskByChunk = new Map();
 
 	// PART ONE

package/lib/cache/IdleFileCachePlugin.js

@@ -9,12 +9,13 @@ const Cache = require("../Cache");
 const ProgressPlugin = require("../ProgressPlugin");
 
 /** @typedef {import("../Compiler")} Compiler */
+/** @typedef {import("./PackFileCacheStrategy")} PackFileCacheStrategy */
 
 const BUILD_DEPENDENCIES_KEY = Symbol();
 
 class IdleFileCachePlugin {
 	/**
-	 * @param {TODO} strategy cache strategy
+	 * @param {PackFileCacheStrategy} strategy cache strategy
 	 * @param {number} idleTimeout timeout
 	 * @param {number} idleTimeoutForInitialStore initial timeout
 	 * @param {number} idleTimeoutAfterLargeChanges timeout after changes
@@ -93,7 +94,9 @@ class IdleFileCachePlugin {
 			{ name: "IdleFileCachePlugin", stage: Cache.STAGE_DISK },
 			dependencies => {
 				pendingIdleTasks.set(BUILD_DEPENDENCIES_KEY, () =>
-					strategy.storeBuildDependencies(dependencies)
+					Promise.resolve().then(() =>
+						strategy.storeBuildDependencies(dependencies)
+					)
 				);
 			}
 		);
@@ -227,7 +230,9 @@ class IdleFileCachePlugin {
 		compiler.hooks.done.tap("IdleFileCachePlugin", stats => {
 			// 10% build overhead is ignored, as it's not cacheable
 			timeSpendInBuild *= 0.9;
-			timeSpendInBuild += stats.endTime - stats.startTime;
+			timeSpendInBuild +=
+				/** @type {number} */ (stats.endTime) -
+				/** @type {number} */ (stats.startTime);
 		});
 	}
 }

package/lib/cache/MemoryCachePlugin.js

@@ -19,7 +19,7 @@ class MemoryCachePlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		/** @type {Map<string, { etag: Etag | null, data: any } | null>} */
 		const cache = new Map();
 		compiler.cache.hooks.store.tap(
 			{ name: "MemoryCachePlugin", stage: Cache.STAGE_MEMORY },

package/lib/cache/MemoryWithGcCachePlugin.js

@@ -13,6 +13,10 @@ const Cache = require("../Cache");
 /** @typedef {import("../Module")} Module */
 
 class MemoryWithGcCachePlugin {
+	/**
+	 * @param {Object} options Options
+	 * @param {number} options.maxGenerations max generations
+	 */
 	constructor({ maxGenerations }) {
 		this._maxGenerations = maxGenerations;
 	}
@@ -23,9 +27,9 @@ class MemoryWithGcCachePlugin {
 	 */
 	apply(compiler) {
 		const maxGenerations = this._maxGenerations;
-		/** @type {Map<string, { etag: Etag | null, data: any }>} */
+		/** @type {Map<string, { etag: Etag | null, data: any } | undefined | null>} */
 		const cache = new Map();
-		/** @type {Map<string, { entry: { etag: Etag | null, data: any }, until: number }>} */
+		/** @type {Map<string, { entry: { etag: Etag | null, data: any } | null, until: number }>} */
 		const oldCache = new Map();
 		let generation = 0;
 		let cachePosition = 0;

package/lib/cache/PackFileCacheStrategy.js

@@ -28,13 +28,16 @@ const {
 /** @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 {string} version version identifier
 	 * @param {Snapshot} buildSnapshot snapshot of all build dependencies
-	 * @param {Set<string>} buildDependencies list of all unresolved build dependencies captured
+	 * @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
 	 */
@@ -54,13 +57,17 @@ 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);
 	}
 
 	/**
@@ -104,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 | undefined)[]} */
 		this.requests = [];
 		this.requestsTimeout = undefined;
-		/** @type {Map<string, PackItemInfo>} */
+		/** @type {ItemInfo} */
 		this.freshContent = new Map();
 		/** @type {(undefined | PackContent)[]} */
 		this.content = [];
@@ -224,12 +235,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);
@@ -263,7 +280,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(),
@@ -372,9 +389,9 @@ class Pack {
 		}
 
 		// 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<void>)[]} */
 		const addToMergedMap = [];
@@ -544,6 +561,9 @@ class Pack {
 		}
 	}
 
+	/**
+	 * @param {ObjectSerializerContext} context context
+	 */
 	serialize({ write, writeSeparate }) {
 		this._persistFreshContent();
 		this._optimizeSmallContent();
@@ -571,6 +591,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;
 		{
@@ -629,6 +652,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);
@@ -695,6 +721,9 @@ class PackContentItems {
 		}
 	}
 
+	/**
+	 * @param {ObjectDeserializerContext & { logger: Logger, profile: boolean | undefined }} context context
+	 */
 	deserialize({ read, logger, profile }) {
 		if (read()) {
 			this.map = read();
@@ -760,17 +789,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;
@@ -778,6 +807,10 @@ class PackContent {
 		this.lazyName = lazyName;
 	}
 
+	/**
+	 * @param {string} identifier identifier
+	 * @returns {string | Promise<string>} result
+	 */
 	get(identifier) {
 		this.used.add(identifier);
 		if (this.content) {
@@ -1049,7 +1082,7 @@ class PackFileCacheStrategy {
 					? ".pack.gz"
 					: ".pack";
 		this.snapshot = snapshot;
-		/** @type {Set<string>} */
+		/** @type {BuildDependencies} */
 		this.buildDependencies = new Set();
 		/** @type {LazySet<string>} */
 		this.newBuildDependencies = new LazySet();
@@ -1081,9 +1114,9 @@ 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;
@@ -1272,7 +1305,7 @@ class PackFileCacheStrategy {
 	}
 
 	/**
-	 * @param {LazySet<string>} dependencies dependencies to store
+	 * @param {LazySet<string> | Iterable<string>} dependencies dependencies to store
 	 */
 	storeBuildDependencies(dependencies) {
 		if (this.readonly) return;