webpack 5.99.5 → 5.99.7

package/lib/prefetch/ChunkPrefetchPreloadPlugin.js

@@ -15,83 +15,82 @@ const ChunkPreloadTriggerRuntimeModule = require("./ChunkPreloadTriggerRuntimeMo
 /** @typedef {import("../ChunkGroup").RawChunkGroupOptions} RawChunkGroupOptions */
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "ChunkPrefetchPreloadPlugin";
+
 class ChunkPrefetchPreloadPlugin {
 	/**
 	 * @param {Compiler} compiler the compiler
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"ChunkPrefetchPreloadPlugin",
-			compilation => {
-				compilation.hooks.additionalChunkRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
-						const startupChildChunks = chunk.getChildrenOfTypeInOrder(
-							chunkGraph,
-							"prefetchOrder"
+		compiler.hooks.compilation.tap(PLUGIN_NAME, compilation => {
+			compilation.hooks.additionalChunkRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (chunkGraph.getNumberOfEntryModules(chunk) === 0) return;
+					const startupChildChunks = chunk.getChildrenOfTypeInOrder(
+						chunkGraph,
+						"prefetchOrder"
+					);
+					if (startupChildChunks) {
+						set.add(RuntimeGlobals.prefetchChunk);
+						set.add(RuntimeGlobals.onChunksLoaded);
+						set.add(RuntimeGlobals.exports);
+						compilation.addRuntimeModule(
+							chunk,
+							new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
 						);
-						if (startupChildChunks) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							set.add(RuntimeGlobals.onChunksLoaded);
-							set.add(RuntimeGlobals.exports);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchStartupRuntimeModule(startupChildChunks)
-							);
-						}
 					}
-				);
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"ChunkPrefetchPreloadPlugin",
-					(chunk, set, { chunkGraph }) => {
-						const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
+				}
+			);
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					const chunkMap = chunk.getChildIdsByOrdersMap(chunkGraph);
 
-						if (chunkMap.prefetch) {
-							set.add(RuntimeGlobals.prefetchChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
-							);
-						}
-						if (chunkMap.preload) {
-							set.add(RuntimeGlobals.preloadChunk);
-							compilation.addRuntimeModule(
-								chunk,
-								new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.prefetchChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+					if (chunkMap.prefetch) {
+						set.add(RuntimeGlobals.prefetchChunk);
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"prefetch",
-								RuntimeGlobals.prefetchChunk,
-								RuntimeGlobals.prefetchChunkHandlers
-							)
+							new ChunkPrefetchTriggerRuntimeModule(chunkMap.prefetch)
 						);
-						set.add(RuntimeGlobals.prefetchChunkHandlers);
-					});
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.preloadChunk)
-					.tap("ChunkPrefetchPreloadPlugin", (chunk, set) => {
+					}
+					if (chunkMap.preload) {
+						set.add(RuntimeGlobals.preloadChunk);
 						compilation.addRuntimeModule(
 							chunk,
-							new ChunkPrefetchFunctionRuntimeModule(
-								"preload",
-								RuntimeGlobals.preloadChunk,
-								RuntimeGlobals.preloadChunkHandlers
-							)
+							new ChunkPreloadTriggerRuntimeModule(chunkMap.preload)
 						);
-						set.add(RuntimeGlobals.preloadChunkHandlers);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.prefetchChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkPrefetchFunctionRuntimeModule(
+							"prefetch",
+							RuntimeGlobals.prefetchChunk,
+							RuntimeGlobals.prefetchChunkHandlers
+						)
+					);
+					set.add(RuntimeGlobals.prefetchChunkHandlers);
+				});
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.preloadChunk)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					compilation.addRuntimeModule(
+						chunk,
+						new ChunkPrefetchFunctionRuntimeModule(
+							"preload",
+							RuntimeGlobals.preloadChunk,
+							RuntimeGlobals.preloadChunkHandlers
+						)
+					);
+					set.add(RuntimeGlobals.preloadChunkHandlers);
+				});
+		});
 	}
 }
 

package/lib/runtime/GetChunkFilenameRuntimeModule.js

@@ -10,6 +10,7 @@ const Template = require("../Template");
 const { first } = require("../util/SetHelpers");
 
 /** @typedef {import("../Chunk")} Chunk */
+/** @typedef {import("../Chunk").ChunkId} ChunkId */
 /** @typedef {import("../ChunkGraph")} ChunkGraph */
 /** @typedef {import("../Compilation")} Compilation */
 /** @typedef {import("../Compilation").AssetInfo} AssetInfo */
@@ -156,14 +157,12 @@ class GetChunkFilenameRuntimeModule extends RuntimeModule {
 				hashWithLength: length =>
 					`" + ${RuntimeGlobals.getFullHash}().slice(0, ${length}) + "`,
 				chunk: {
-					id: unquotedStringify(/** @type {number | string} */ (c.id)),
+					id: unquotedStringify(/** @type {ChunkId} */ (c.id)),
 					hash: unquotedStringify(/** @type {string} */ (c.renderedHash)),
 					hashWithLength: unquotedStringifyWithLength(
 						/** @type {string} */ (c.renderedHash)
 					),
-					name: unquotedStringify(
-						c.name || /** @type {number | string} */ (c.id)
-					),
+					name: unquotedStringify(c.name || /** @type {ChunkId} */ (c.id)),
 					contentHash: {
 						[contentType]: unquotedStringify(c.contentHash[contentType])
 					},

package/lib/runtime/StartupChunkDependenciesPlugin.js

@@ -18,6 +18,8 @@ const StartupEntrypointRuntimeModule = require("./StartupEntrypointRuntimeModule
  * @property {boolean=} asyncChunkLoading
  */
 
+const PLUGIN_NAME = "StartupChunkDependenciesPlugin";
+
 class StartupChunkDependenciesPlugin {
 	/**
 	 * @param {Options} options options
@@ -36,53 +38,48 @@ class StartupChunkDependenciesPlugin {
 	 * @returns {void}
 	 */
 	apply(compiler) {
-		compiler.hooks.thisCompilation.tap(
-			"StartupChunkDependenciesPlugin",
-			compilation => {
-				const globalChunkLoading = compilation.outputOptions.chunkLoading;
-				/**
-				 * @param {Chunk} chunk chunk to check
-				 * @returns {boolean} true, when the plugin is enabled for the chunk
-				 */
-				const isEnabledForChunk = chunk => {
-					const options = chunk.getEntryOptions();
-					const chunkLoading =
-						options && options.chunkLoading !== undefined
-							? options.chunkLoading
-							: globalChunkLoading;
-					return chunkLoading === this.chunkLoading;
-				};
-				compilation.hooks.additionalTreeRuntimeRequirements.tap(
-					"StartupChunkDependenciesPlugin",
-					(chunk, set, { chunkGraph }) => {
-						if (!isEnabledForChunk(chunk)) return;
-						if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
-							set.add(RuntimeGlobals.startup);
-							set.add(RuntimeGlobals.ensureChunk);
-							set.add(RuntimeGlobals.ensureChunkIncludeEntries);
-							compilation.addRuntimeModule(
-								chunk,
-								new StartupChunkDependenciesRuntimeModule(
-									this.asyncChunkLoading
-								)
-							);
-						}
-					}
-				);
-				compilation.hooks.runtimeRequirementInTree
-					.for(RuntimeGlobals.startupEntrypoint)
-					.tap("StartupChunkDependenciesPlugin", (chunk, set) => {
-						if (!isEnabledForChunk(chunk)) return;
-						set.add(RuntimeGlobals.require);
+		compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+			const globalChunkLoading = compilation.outputOptions.chunkLoading;
+			/**
+			 * @param {Chunk} chunk chunk to check
+			 * @returns {boolean} true, when the plugin is enabled for the chunk
+			 */
+			const isEnabledForChunk = chunk => {
+				const options = chunk.getEntryOptions();
+				const chunkLoading =
+					options && options.chunkLoading !== undefined
+						? options.chunkLoading
+						: globalChunkLoading;
+				return chunkLoading === this.chunkLoading;
+			};
+			compilation.hooks.additionalTreeRuntimeRequirements.tap(
+				PLUGIN_NAME,
+				(chunk, set, { chunkGraph }) => {
+					if (!isEnabledForChunk(chunk)) return;
+					if (chunkGraph.hasChunkEntryDependentChunks(chunk)) {
+						set.add(RuntimeGlobals.startup);
 						set.add(RuntimeGlobals.ensureChunk);
 						set.add(RuntimeGlobals.ensureChunkIncludeEntries);
 						compilation.addRuntimeModule(
 							chunk,
-							new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+							new StartupChunkDependenciesRuntimeModule(this.asyncChunkLoading)
 						);
-					});
-			}
-		);
+					}
+				}
+			);
+			compilation.hooks.runtimeRequirementInTree
+				.for(RuntimeGlobals.startupEntrypoint)
+				.tap(PLUGIN_NAME, (chunk, set) => {
+					if (!isEnabledForChunk(chunk)) return;
+					set.add(RuntimeGlobals.require);
+					set.add(RuntimeGlobals.ensureChunk);
+					set.add(RuntimeGlobals.ensureChunkIncludeEntries);
+					compilation.addRuntimeModule(
+						chunk,
+						new StartupEntrypointRuntimeModule(this.asyncChunkLoading)
+					);
+				});
+		});
 	}
 }
 

package/lib/schemes/DataUriPlugin.js

@@ -37,6 +37,8 @@ const decodeDataURI = uri => {
 	}
 };
 
+const PLUGIN_NAME = "DataUriPlugin";
+
 class DataUriPlugin {
 	/**
 	 * Apply the plugin
@@ -45,11 +47,11 @@ class DataUriPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"DataUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("data")
-					.tap("DataUriPlugin", resourceData => {
+					.tap(PLUGIN_NAME, resourceData => {
 						const match = URIRegEx.exec(resourceData.resource);
 						if (match) {
 							resourceData.data.mimetype = match[1] || "";
@@ -60,7 +62,7 @@ class DataUriPlugin {
 					});
 				NormalModule.getCompilationHooks(compilation)
 					.readResourceForScheme.for("data")
-					.tap("DataUriPlugin", resource => decodeDataURI(resource));
+					.tap(PLUGIN_NAME, resource => decodeDataURI(resource));
 			}
 		);
 	}

package/lib/schemes/FileUriPlugin.js

@@ -10,6 +10,8 @@ const { NormalModule } = require("..");
 
 /** @typedef {import("../Compiler")} Compiler */
 
+const PLUGIN_NAME = "FileUriPlugin";
+
 class FileUriPlugin {
 	/**
 	 * Apply the plugin
@@ -18,11 +20,11 @@ class FileUriPlugin {
 	 */
 	apply(compiler) {
 		compiler.hooks.compilation.tap(
-			"FileUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				normalModuleFactory.hooks.resolveForScheme
 					.for("file")
-					.tap("FileUriPlugin", resourceData => {
+					.tap(PLUGIN_NAME, resourceData => {
 						const url = new URL(resourceData.resource);
 						const path = fileURLToPath(url);
 						const query = url.search;
@@ -36,7 +38,7 @@ class FileUriPlugin {
 				const hooks = NormalModule.getCompilationHooks(compilation);
 				hooks.readResource
 					.for(undefined)
-					.tapAsync("FileUriPlugin", (loaderContext, callback) => {
+					.tapAsync(PLUGIN_NAME, (loaderContext, callback) => {
 						const { resourcePath } = loaderContext;
 						loaderContext.addDependency(resourcePath);
 						loaderContext.fs.readFile(resourcePath, callback);

package/lib/schemes/HttpUriPlugin.js

@@ -405,6 +405,8 @@ const cachedWithKey = (fn, forceFn = fn) => {
 /** @typedef {FetchResultMeta & { entry: LockfileEntry, content: Buffer }} ContentFetchResult */
 /** @typedef {RedirectFetchResult | ContentFetchResult} FetchResult */
 
+const PLUGIN_NAME = "HttpUriPlugin";
+
 class HttpUriPlugin {
 	/**
 	 * @param {HttpUriPluginOptions} options options
@@ -440,14 +442,14 @@ class HttpUriPlugin {
 		/** @type {LockfileCache} */
 		let lockfileCache;
 		compiler.hooks.compilation.tap(
-			"HttpUriPlugin",
+			PLUGIN_NAME,
 			(compilation, { normalModuleFactory }) => {
 				const intermediateFs =
 					/** @type {IntermediateFileSystem} */
 					(compiler.intermediateFileSystem);
 				const fs = compilation.inputFileSystem;
-				const cache = compilation.getCache("webpack.HttpUriPlugin");
-				const logger = compilation.getLogger("webpack.HttpUriPlugin");
+				const cache = compilation.getCache(`webpack.${PLUGIN_NAME}`);
+				const logger = compilation.getLogger(`webpack.${PLUGIN_NAME}`);
 				/** @type {string} */
 				const lockfileLocation =
 					this._lockfileLocation ||
@@ -1154,19 +1156,16 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					};
 					normalModuleFactory.hooks.resolveForScheme
 						.for(scheme)
-						.tapAsync(
-							"HttpUriPlugin",
-							(resourceData, resolveData, callback) => {
-								respondWithUrlModule(
-									new URL(resourceData.resource),
-									resourceData,
-									callback
-								);
-							}
-						);
+						.tapAsync(PLUGIN_NAME, (resourceData, resolveData, callback) => {
+							respondWithUrlModule(
+								new URL(resourceData.resource),
+								resourceData,
+								callback
+							);
+						});
 					normalModuleFactory.hooks.resolveInScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resourceData, data, callback) => {
+						.tapAsync(PLUGIN_NAME, (resourceData, data, callback) => {
 							// Only handle relative urls (./xxx, ../xxx, /xxx, //xxx)
 							if (
 								data.dependencyType !== "url" &&
@@ -1183,7 +1182,7 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 					const hooks = NormalModule.getCompilationHooks(compilation);
 					hooks.readResourceForScheme
 						.for(scheme)
-						.tapAsync("HttpUriPlugin", (resource, module, callback) =>
+						.tapAsync(PLUGIN_NAME, (resource, module, callback) =>
 							getInfo(resource, (err, _result) => {
 								if (err) return callback(err);
 								const result = /** @type {Info} */ (_result);
@@ -1192,33 +1191,27 @@ Run build with un-frozen lockfile to automatically fix lockfile.`
 								callback(null, result.content);
 							})
 						);
-					hooks.needBuild.tapAsync(
-						"HttpUriPlugin",
-						(module, context, callback) => {
-							if (
-								module.resource &&
-								module.resource.startsWith(`${scheme}://`)
-							) {
-								getInfo(module.resource, (err, _result) => {
-									if (err) return callback(err);
-									const result = /** @type {Info} */ (_result);
-									if (
-										result.entry.integrity !==
-										/** @type {BuildInfo} */
-										(module.buildInfo).resourceIntegrity
-									) {
-										return callback(null, true);
-									}
-									callback();
-								});
-							} else {
-								return callback();
-							}
+					hooks.needBuild.tapAsync(PLUGIN_NAME, (module, context, callback) => {
+						if (module.resource && module.resource.startsWith(`${scheme}://`)) {
+							getInfo(module.resource, (err, _result) => {
+								if (err) return callback(err);
+								const result = /** @type {Info} */ (_result);
+								if (
+									result.entry.integrity !==
+									/** @type {BuildInfo} */
+									(module.buildInfo).resourceIntegrity
+								) {
+									return callback(null, true);
+								}
+								callback();
+							});
+						} else {
+							return callback();
 						}
-					);
+					});
 				}
 				compilation.hooks.finishModules.tapAsync(
-					"HttpUriPlugin",
+					PLUGIN_NAME,
 					(modules, callback) => {
 						if (!lockfileUpdates) return callback();
 						const ext = extname(lockfileLocation);

package/lib/serialization/AggregateErrorSerializer.js

@@ -0,0 +1,42 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+*/
+
+"use strict";
+
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+
+/** @typedef {Error & { cause: unknown, errors: EXPECTED_ANY[] }} AggregateError */
+
+class AggregateErrorSerializer {
+	/**
+	 * @param {AggregateError} obj error
+	 * @param {ObjectSerializerContext} context context
+	 */
+	serialize(obj, context) {
+		context.write(obj.errors);
+		context.write(obj.message);
+		context.write(obj.stack);
+		context.write(obj.cause);
+	}
+
+	/**
+	 * @param {ObjectDeserializerContext} context context
+	 * @returns {AggregateError} error
+	 */
+	deserialize(context) {
+		const errors = context.read();
+		// @ts-expect-error ES2018 doesn't `AggregateError`, but it can be used by developers
+		// eslint-disable-next-line n/no-unsupported-features/es-builtins, n/no-unsupported-features/es-syntax
+		const err = new AggregateError(errors);
+
+		err.message = context.read();
+		err.stack = context.read();
+		err.cause = context.read();
+
+		return err;
+	}
+}
+
+module.exports = AggregateErrorSerializer;

package/lib/serialization/BinaryMiddleware.js

@@ -7,15 +7,9 @@
 const memoize = require("../util/memoize");
 const SerializerMiddleware = require("./SerializerMiddleware");
 
-/** @typedef {import("./SerializerMiddleware").Context} Context */
 /** @typedef {import("./types").BufferSerializableType} BufferSerializableType */
 /** @typedef {import("./types").PrimitiveSerializableType} PrimitiveSerializableType */
 
-/**
- * @template LAZY_RESULT
- * @typedef {import("./SerializerMiddleware").LazyFunction<LAZY_RESULT>} LazyFunction
- */
-
 /*
 Format:
 
@@ -141,10 +135,18 @@ const identifyBigInt = n => {
 	return 2;
 };
 
+/** @typedef {PrimitiveSerializableType[]} DeserializedType */
+/** @typedef {BufferSerializableType[]} SerializedType} */
+/** @typedef {{ retainedBuffer?: (x: Buffer) => Buffer }} Context} */
+
 /**
- * @typedef {PrimitiveSerializableType[]} DeserializedType
- * @typedef {BufferSerializableType[]} SerializedType
- * @extends {SerializerMiddleware<DeserializedType, SerializedType>}
+ * @template LazyInputValue
+ * @template LazyOutputValue
+ * @typedef {import("./SerializerMiddleware").LazyFunction<LazyInputValue, LazyOutputValue, BinaryMiddleware, undefined>} LazyFunction
+ */
+
+/**
+ * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class BinaryMiddleware extends SerializerMiddleware {
 	/**
@@ -157,9 +159,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 	}
 
 	/**
-	 * @param {LazyFunction<DeserializedType>} fn lazy function
+	 * @param {LazyFunction<DeserializedType, SerializedType>} fn lazy function
 	 * @param {Context} context serialize function
-	 * @returns {LazyFunction<SerializedType>} new lazy
+	 * @returns {LazyFunction<SerializedType, DeserializedType>} new lazy
 	 */
 	_serializeLazy(fn, context) {
 		return SerializerMiddleware.serializeLazy(fn, data =>
@@ -281,7 +283,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 				case "function": {
 					if (!SerializerMiddleware.isLazy(thing))
 						throw new Error(`Unexpected function ${thing}`);
-					/** @type {SerializedType | LazyFunction<SerializedType>} */
+					/** @type {SerializedType | LazyFunction<SerializedType, DeserializedType> | undefined} */
 					let serializedData =
 						SerializerMiddleware.getLazySerializedValue(thing);
 					if (serializedData === undefined) {
@@ -294,18 +296,10 @@ class BinaryMiddleware extends SerializerMiddleware {
 							const data = this._serialize(result, context, allocationScope);
 							leftOverBuffer = allocationScope.leftOverBuffer;
 							allocationScope.leftOverBuffer = null;
-							SerializerMiddleware.setLazySerializedValue(
-								/** @type {LazyFunction<DeserializedType>} */
-								(thing),
-								data
-							);
+							SerializerMiddleware.setLazySerializedValue(thing, data);
 							serializedData = data;
 						} else {
-							serializedData = this._serializeLazy(
-								/** @type {LazyFunction<DeserializedType>} */
-								(thing),
-								context
-							);
+							serializedData = this._serializeLazy(thing, context);
 							flush();
 							buffers.push(serializedData);
 							break;
@@ -666,7 +660,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 	 * @private
 	 * @param {SerializedType} content content
 	 * @param {Context} context context object
-	 * @returns {LazyFunction<DeserializedType>} lazy function
+	 * @returns {LazyFunction<DeserializedType, SerializedType>} lazy function
 	 */
 	_createLazyDeserialized(content, context) {
 		return SerializerMiddleware.createLazy(
@@ -679,9 +673,9 @@ class BinaryMiddleware extends SerializerMiddleware {
 
 	/**
 	 * @private
-	 * @param {LazyFunction<SerializedType>} fn lazy function
+	 * @param {LazyFunction<SerializedType, DeserializedType>} fn lazy function
 	 * @param {Context} context context object
-	 * @returns {LazyFunction<DeserializedType>} new lazy
+	 * @returns {LazyFunction<DeserializedType, SerializedType>} new lazy
 	 */
 	_deserializeLazy(fn, context) {
 		return SerializerMiddleware.deserializeLazy(fn, data =>
@@ -701,7 +695,6 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let currentIsBuffer = Buffer.isBuffer(currentBuffer);
 		let currentPosition = 0;
 
-		/** @type {(x: Buffer) => Buffer} */
 		const retainedBuffer = context.retainedBuffer || (x => x);
 
 		const checkOverflow = () => {
@@ -818,17 +811,14 @@ class BinaryMiddleware extends SerializerMiddleware {
 					return () => {
 						const count = readU32();
 						const lengths = Array.from({ length: count }).map(() => readU32());
-						/** @type {(Buffer | LazyFunction<BufferSerializableType[]>)[]} */
+						/** @type {(Buffer | LazyFunction<SerializedType, DeserializedType>)[]} */
 						const content = [];
 						for (let l of lengths) {
 							if (l === 0) {
 								if (typeof currentBuffer !== "function") {
 									throw new Error("Unexpected non-lazy element in stream");
 								}
-								content.push(
-									/** @type {LazyFunction<BufferSerializableType[]>} */
-									(currentBuffer)
-								);
+								content.push(currentBuffer);
 								currentDataItem++;
 								currentBuffer =
 									currentDataItem < data.length ? data[currentDataItem] : null;
@@ -1144,13 +1134,7 @@ class BinaryMiddleware extends SerializerMiddleware {
 		let result = [];
 		while (currentBuffer !== null) {
 			if (typeof currentBuffer === "function") {
-				result.push(
-					this._deserializeLazy(
-						/** @type {LazyFunction<SerializedType>} */
-						(currentBuffer),
-						context
-					)
-				);
+				result.push(this._deserializeLazy(currentBuffer, context));
 				currentDataItem++;
 				currentBuffer =
 					currentDataItem < data.length ? data[currentDataItem] : null;

package/lib/serialization/ErrorObjectSerializer.js

@@ -7,6 +7,8 @@
 /** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
 /** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
 
+/** @typedef {Error & { cause?: unknown }} ErrorWithCause */
+
 class ErrorObjectSerializer {
 	/**
 	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
@@ -22,7 +24,10 @@ class ErrorObjectSerializer {
 	serialize(obj, context) {
 		context.write(obj.message);
 		context.write(obj.stack);
-		context.write(/** @type {Error & { cause: "unknown" }} */ (obj).cause);
+		context.write(
+			/** @type {ErrorWithCause} */
+			(obj).cause
+		);
 	}
 
 	/**
@@ -34,7 +39,7 @@ class ErrorObjectSerializer {
 
 		err.message = context.read();
 		err.stack = context.read();
-		/** @type {Error & { cause: "unknown" }} */
+		/** @type {ErrorWithCause} */
 		(err).cause = context.read();
 
 		return err;