@depup/webpack 5.106.1-depup.0 → 5.109.2-depup.0

package/lib/serialization/DateObjectSerializer.js

@@ -4,11 +4,12 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<[number]>} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<[number]>} ObjectSerializerContext */
 
 class DateObjectSerializer {
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {Date} obj date
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -17,6 +18,7 @@ class DateObjectSerializer {
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {Date} date
 	 */

package/lib/serialization/ErrorObjectSerializer.js

@@ -4,13 +4,15 @@
 
 "use strict";
 
-/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext} ObjectDeserializerContext */
-/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext} ObjectSerializerContext */
+/** @typedef {import("./types").ComplexSerializableType} ComplexSerializableType */
+/** @typedef {import("./ObjectMiddleware").ObjectDeserializerContext<ComplexSerializableType[]>} ObjectDeserializerContext */
+/** @typedef {import("./ObjectMiddleware").ObjectSerializerContext<ComplexSerializableType[]>} ObjectSerializerContext */
 
 /** @typedef {Error & { cause?: unknown }} ErrorWithCause */
 
 class ErrorObjectSerializer {
 	/**
+	 * Creates an instance of ErrorObjectSerializer.
 	 * @param {ErrorConstructor | EvalErrorConstructor | RangeErrorConstructor | ReferenceErrorConstructor | SyntaxErrorConstructor | TypeErrorConstructor} Type error type
 	 */
 	constructor(Type) {
@@ -18,6 +20,7 @@ class ErrorObjectSerializer {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError} obj error
 	 * @param {ObjectSerializerContext} context context
 	 */
@@ -25,20 +28,21 @@ class ErrorObjectSerializer {
 		context.write(obj.message);
 		context.write(obj.stack);
 		context.write(
-			/** @type {ErrorWithCause} */
-			(obj).cause
+			/** @type {ComplexSerializableType} */
+			(/** @type {ErrorWithCause} */ (obj).cause)
 		);
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {ObjectDeserializerContext} context context
 	 * @returns {Error | EvalError | RangeError | ReferenceError | SyntaxError | TypeError} error
 	 */
 	deserialize(context) {
 		const err = new this.Type();
 
-		err.message = context.read();
-		err.stack = context.read();
+		err.message = /** @type {string} */ (context.read());
+		err.stack = /** @type {string | undefined} */ (context.read());
 		/** @type {ErrorWithCause} */
 		(err).cause = context.read();
 

package/lib/serialization/FileMiddleware.js

@@ -7,13 +7,23 @@
 const { constants } = require("buffer");
 const { pipeline } = require("stream");
 const {
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
+	brotliDecompress,
 	constants: zConstants,
 	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	createBrotliCompress,
 	// eslint-disable-next-line n/no-unsupported-features/node-builtins
 	createBrotliDecompress,
 	createGunzip,
-	createGzip
+	createGzip,
+	// zstd is only available on Node.js >= 22.15; guarded at use sites
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
+	createZstdCompress,
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
+	createZstdDecompress,
+	gunzip,
+	// eslint-disable-next-line n/no-unsupported-features/node-builtins
+	zstdDecompress
 } = require("zlib");
 const { DEFAULTS } = require("../config/defaults");
 const createHash = require("../util/createHash");
@@ -46,8 +56,11 @@ Section -> Buffer
 const VERSION = 0x01637077;
 const WRITE_LIMIT_TOTAL = 0x7fff0000;
 const WRITE_LIMIT_CHUNK = 511 * 1024 * 1024;
+// headers and pointer sections are tiny; anything above this is a corrupt file
+const MAX_HEADER_OR_POINTER_SIZE = 256 * 1024 * 1024;
 
 /**
+ * Returns hash.
  * @param {Buffer[]} buffers buffers
  * @param {HashFunction} hashFunction hash function to use
  * @returns {string} hash
@@ -85,6 +98,7 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
 /** @typedef {Promise<void | void[]>} BackgroundJob */
 
 /**
+ * Defines the serialize result type used by this module.
  * @typedef {object} SerializeResult
  * @property {string | false} name
  * @property {number} size
@@ -93,15 +107,18 @@ const readUInt64LE = Buffer.prototype.readBigUInt64LE
 
 /** @typedef {{ name: string, size: number }} LazyOptions */
 /**
+ * Defines the lazy function type used by this module.
  * @typedef {import("./SerializerMiddleware").LazyFunction<BufferSerializableType[], Buffer, FileMiddleware, LazyOptions>} LazyFunction
  */
 
 /**
+ * Serializes this instance into the provided serializer context.
  * @param {FileMiddleware} middleware this
  * @param {(BufferSerializableType | LazyFunction)[]} data data to be serialized
  * @param {string | boolean} name file base name
  * @param {(name: string | false, buffers: Buffer[], size: number) => Promise<void>} writeFile writes a file
  * @param {HashFunction=} hashFunction hash function to use
+ * @param {Set<string>=} retainedNames collects names of files that stay referenced without being rewritten
  * @returns {Promise<SerializeResult>} resulting file pointer and promise
  */
 const serialize = async (
@@ -109,7 +126,8 @@ const serialize = async (
 	data,
 	name,
 	writeFile,
-	hashFunction = DEFAULTS.HASH_FUNCTION
+	hashFunction = DEFAULTS.HASH_FUNCTION,
+	retainedNames = undefined
 ) => {
 	/** @type {(Buffer[] | Buffer | Promise<SerializeResult>)[]} */
 	const processedData = [];
@@ -135,6 +153,10 @@ const serialize = async (
 						"Unexpected lazy value with non-this target (can't pass through lazy values)"
 					);
 				} else {
+					if (retainedNames !== undefined) {
+						// pointer buffer layout: u64 size + utf-8 file name
+						retainedNames.add(serializedInfo.toString("utf8", 8));
+					}
 					processedData.push(serializedInfo);
 				}
 			} else {
@@ -148,7 +170,8 @@ const serialize = async (
 							(content),
 							(options && options.name) || true,
 							writeFile,
-							hashFunction
+							hashFunction,
+							retainedNames
 						).then((result) => {
 							/** @type {LazyOptions} */
 							(item.options).size = result.size;
@@ -243,6 +266,7 @@ const serialize = async (
 };
 
 /**
+ * Restores this instance from the provided deserializer context.
  * @param {FileMiddleware} middleware this
  * @param {string | false} name filename
  * @param {(name: string | false) => Promise<Buffer[]>} readFile read content of a file
@@ -263,6 +287,7 @@ const deserialize = async (middleware, name, readFile) => {
 		contentPosition = 0;
 	};
 	/**
+	 * Processes the provided n.
 	 * @param {number} n number of bytes to ensure
 	 */
 	const ensureData = (n) => {
@@ -294,6 +319,7 @@ const deserialize = async (middleware, name, readFile) => {
 		}
 	};
 	/**
+	 * Returns value value.
 	 * @returns {number} value value
 	 */
 	const readUInt32LE = () => {
@@ -303,6 +329,7 @@ const deserialize = async (middleware, name, readFile) => {
 		return value;
 	};
 	/**
+	 * Returns value value.
 	 * @returns {number} value value
 	 */
 	const readInt32LE = () => {
@@ -312,6 +339,7 @@ const deserialize = async (middleware, name, readFile) => {
 		return value;
 	};
 	/**
+	 * Returns buffer.
 	 * @param {number} l length
 	 * @returns {Buffer} buffer
 	 */
@@ -369,9 +397,13 @@ const deserialize = async (middleware, name, readFile) => {
 				);
 			result.push(lazy);
 		} else {
+			// A section may start exactly at a content-buffer boundary; advance
+			// first, then read from the fresh buffer (don't fall through to the
+			// `while` below, which would skip it).
 			if (contentPosition === contentItemLength) {
 				nextContent();
-			} else if (contentPosition !== 0) {
+			}
+			if (contentPosition !== 0) {
 				if (length <= contentItemLength - contentPosition) {
 					result.push(
 						Buffer.from(
@@ -426,13 +458,22 @@ const deserialize = async (middleware, name, readFile) => {
 
 /** @typedef {BufferSerializableType[]} DeserializedType */
 /** @typedef {true} SerializedType */
-/** @typedef {{ filename: string, extension?: string }} Context */
+/**
+ * `writtenFiles`/`retainedFiles` collect file names (without extension) during
+ * `serialize`: files written in this run and files that stay referenced by
+ * lazy pointers without being rewritten. Retained files may reference further
+ * files on disk not listed here (nested lazy segments); use
+ * `getReferencedFilenames` to walk them.
+ * @typedef {{ filename: string, extension?: string, writtenFiles?: Set<string>, retainedFiles?: Set<string> }} Context
+ */
 
 /**
+ * Represents FileMiddleware.
  * @extends {SerializerMiddleware<DeserializedType, SerializedType, Context>}
  */
 class FileMiddleware extends SerializerMiddleware {
 	/**
+	 * Creates an instance of FileMiddleware.
 	 * @param {IntermediateFileSystem} fs filesystem
 	 * @param {HashFunction} hashFunction hash function to use
 	 */
@@ -445,12 +486,13 @@ class FileMiddleware extends SerializerMiddleware {
 	}
 
 	/**
+	 * Serializes this instance into the provided serializer context.
 	 * @param {DeserializedType} data data
 	 * @param {Context} context context object
 	 * @returns {SerializedType | Promise<SerializedType> | null} serialized data
 	 */
 	serialize(data, context) {
-		const { filename, extension = "" } = context;
+		const { filename, extension = "", writtenFiles, retainedFiles } = context;
 		return new Promise((resolve, reject) => {
 			mkdirp(this.fs, dirname(this.fs, filename), (err) => {
 				if (err) return reject(err);
@@ -460,6 +502,7 @@ class FileMiddleware extends SerializerMiddleware {
 				/** @type {Set<string>} */
 				const allWrittenFiles = new Set();
 				/**
+				 * Processes the provided name.
 				 * @param {string | false} name name
 				 * @param {Buffer[]} content content
 				 * @param {number} size size
@@ -471,12 +514,13 @@ class FileMiddleware extends SerializerMiddleware {
 						: filename;
 					await new Promise(
 						/**
+						 * Handles the callback logic for this hook.
 						 * @param {(value?: undefined) => void} resolve resolve
 						 * @param {(reason?: Error | null) => void} reject reject
 						 */
 						(resolve, reject) => {
 							let stream = this.fs.createWriteStream(`${file}_`);
-							/** @type {undefined | import("zlib").Gzip | import("zlib").BrotliCompress} */
+							/** @type {undefined | import("zlib").Gzip | import("zlib").BrotliCompress | import("zlib").ZstdCompress} */
 							let compression;
 							if (file.endsWith(".gz")) {
 								compression = createGzip({
@@ -493,6 +537,17 @@ class FileMiddleware extends SerializerMiddleware {
 										[zConstants.BROTLI_PARAM_SIZE_HINT]: size
 									}
 								});
+							} else if (file.endsWith(".zst")) {
+								// eslint-disable-next-line n/no-unsupported-features/node-builtins
+								const levelParam = zConstants.ZSTD_c_compressionLevel;
+								// default level 3; some runtimes (e.g. Deno) don't expose ZSTD_CLEVEL_DEFAULT
+								// eslint-disable-next-line n/no-unsupported-features/node-builtins
+								const defaultLevel = zConstants.ZSTD_CLEVEL_DEFAULT;
+								const level = defaultLevel === undefined ? 3 : defaultLevel;
+								compression = createZstdCompress({
+									chunkSize: COMPRESSION_CHUNK_SIZE,
+									params: { [levelParam]: level }
+								});
 							}
 							if (compression) {
 								pipeline(compression, stream, reject);
@@ -518,6 +573,7 @@ class FileMiddleware extends SerializerMiddleware {
 							const len = chunks.length;
 							let i = 0;
 							/**
+							 * Processes the provided err.
 							 * @param {(Error | null)=} err err
 							 */
 							const batchWrite = (err) => {
@@ -546,69 +602,81 @@ class FileMiddleware extends SerializerMiddleware {
 							batchWrite();
 						}
 					);
-					if (name) allWrittenFiles.add(file);
+					if (name) {
+						allWrittenFiles.add(file);
+						if (writtenFiles !== undefined) writtenFiles.add(name);
+					}
 				};
 
 				resolve(
-					serialize(this, data, false, writeFile, this._hashFunction).then(
-						async ({ backgroundJob }) => {
-							await backgroundJob;
-
-							// Rename the index file to disallow access during inconsistent file state
-							await new Promise(
-								/**
-								 * @param {(value?: undefined) => void} resolve resolve
-								 */
-								(resolve) => {
-									this.fs.rename(filename, `${filename}.old`, (_err) => {
-										resolve();
-									});
-								}
-							);
+					serialize(
+						this,
+						data,
+						false,
+						writeFile,
+						this._hashFunction,
+						retainedFiles
+					).then(async ({ backgroundJob }) => {
+						await backgroundJob;
 
-							// update all written files
-							await Promise.all(
-								Array.from(
-									allWrittenFiles,
-									(file) =>
-										new Promise(
-											/**
-											 * @param {(value?: undefined) => void} resolve resolve
-											 * @param {(reason?: Error | null) => void} reject reject
-											 * @returns {void}
-											 */
-											(resolve, reject) => {
-												this.fs.rename(`${file}_`, file, (err) => {
-													if (err) return reject(err);
-													resolve();
-												});
-											}
-										)
-								)
-							);
+						// Rename the index file to disallow access during inconsistent file state
+						await new Promise(
+							/**
+							 * Handles the callback logic for this hook.
+							 * @param {(value?: undefined) => void} resolve resolve
+							 */
+							(resolve) => {
+								this.fs.rename(filename, `${filename}.old`, (_err) => {
+									resolve();
+								});
+							}
+						);
 
-							// As final step automatically update the index file to have a consistent pack again
-							await new Promise(
-								/**
-								 * @param {(value?: undefined) => void} resolve resolve
-								 * @returns {void}
-								 */
-								(resolve) => {
-									this.fs.rename(`${filename}_`, filename, (err) => {
-										if (err) return reject(err);
-										resolve();
-									});
-								}
-							);
-							return /** @type {true} */ (true);
-						}
-					)
+						// update all written files
+						await Promise.all(
+							Array.from(
+								allWrittenFiles,
+								(file) =>
+									new Promise(
+										/**
+										 * Handles the callback logic for this hook.
+										 * @param {(value?: undefined) => void} resolve resolve
+										 * @param {(reason?: Error | null) => void} reject reject
+										 * @returns {void}
+										 */
+										(resolve, reject) => {
+											this.fs.rename(`${file}_`, file, (err) => {
+												if (err) return reject(err);
+												resolve();
+											});
+										}
+									)
+							)
+						);
+
+						// As final step automatically update the index file to have a consistent pack again
+						await new Promise(
+							/**
+							 * Handles the callback logic for this hook.
+							 * @param {(value?: undefined) => void} resolve resolve
+							 * @returns {void}
+							 */
+							(resolve) => {
+								this.fs.rename(`${filename}_`, filename, (err) => {
+									if (err) return reject(err);
+									resolve();
+								});
+							}
+						);
+						return /** @type {true} */ (true);
+					})
 				);
 			});
 		});
 	}
 
 	/**
+	 * Restores this instance from the provided deserializer context.
 	 * @param {SerializedType} data data
 	 * @param {Context} context context object
 	 * @returns {DeserializedType | Promise<DeserializedType>} deserialized data
@@ -616,6 +684,7 @@ class FileMiddleware extends SerializerMiddleware {
 	deserialize(data, context) {
 		const { filename, extension = "" } = context;
 		/**
+		 * Returns result.
 		 * @param {string | boolean} name name
 		 * @returns {Promise<Buffer[]>} result
 		 */
@@ -646,6 +715,10 @@ class FileMiddleware extends SerializerMiddleware {
 						decompression = createBrotliDecompress({
 							chunkSize: DECOMPRESSION_CHUNK_SIZE
 						});
+					} else if (file.endsWith(".zst")) {
+						decompression = createZstdDecompress({
+							chunkSize: DECOMPRESSION_CHUNK_SIZE
+						});
 					}
 					if (decompression) {
 						/** @typedef {(value: Buffer[] | PromiseLike<Buffer[]>) => void} NewResolve */
@@ -663,6 +736,7 @@ class FileMiddleware extends SerializerMiddleware {
 								}),
 								new Promise(
 									/**
+									 * Handles the chunk size callback for this hook.
 									 * @param {(value?: undefined) => void} resolve resolve
 									 * @param {(reason?: Error) => void} reject reject
 									 */
@@ -763,4 +837,216 @@ class FileMiddleware extends SerializerMiddleware {
 	}
 }
 
+/**
+ * Extracts the file names referenced by lazy pointer sections from serialized content.
+ * @param {Buffer} buf decompressed file content
+ * @returns {string[]} referenced file names (without extension)
+ */
+const parsePointerNames = (buf) => {
+	const version = buf.readUInt32LE(0);
+	if (version !== VERSION) {
+		throw new Error(`Invalid file version ${version}`);
+	}
+	const sectionCount = buf.readUInt32LE(4);
+	let offset = 8 + sectionCount * 4;
+	// a corrupt section table must abort the walk, never silently drop a name
+	if (offset > buf.length) {
+		throw new Error(`Invalid section count ${sectionCount}`);
+	}
+	/** @type {string[]} */
+	const names = [];
+	for (let i = 0; i < sectionCount; i++) {
+		const length = buf.readInt32LE(8 + i * 4);
+		if (length < 0) {
+			// pointer section: u64 size + utf-8 file name
+			const end = offset - length;
+			if (end > buf.length) {
+				throw new Error("Truncated pointer section");
+			}
+			names.push(buf.toString("utf8", offset + 8, end));
+			offset = end;
+		} else {
+			offset += length;
+		}
+	}
+	if (offset !== buf.length) {
+		throw new Error("Section table does not match file size");
+	}
+	return names;
+};
+
+/**
+ * Reads the pointer names of a compressed file by decompressing it fully
+ * (compressed content cannot be read by byte range).
+ * @param {IntermediateFileSystem} fs a file system
+ * @param {string} file absolute path of the serialized file
+ * @returns {Promise<string[]>} referenced file names (without extension)
+ */
+const getReferencedFilenamesCompressed = (fs, file) =>
+	new Promise((resolve, reject) => {
+		fs.readFile(file, (err, rawContent) => {
+			if (err) return reject(err);
+			/**
+			 * Parses the decompressed content.
+			 * @param {Error | null} err error
+			 * @param {Buffer=} content decompressed content
+			 * @returns {void}
+			 */
+			const onContent = (err, content) => {
+				if (err) return reject(err);
+				try {
+					resolve(parsePointerNames(/** @type {Buffer} */ (content)));
+				} catch (err_) {
+					reject(/** @type {Error} */ (err_));
+				}
+			};
+			const buf = /** @type {Buffer} */ (rawContent);
+			if (file.endsWith(".gz")) {
+				gunzip(buf, onContent);
+			} else if (file.endsWith(".br")) {
+				brotliDecompress(buf, onContent);
+			} else {
+				if (!zstdDecompress) {
+					return reject(
+						new Error("zstd decompression requires Node.js >= 22.15.0")
+					);
+				}
+				zstdDecompress(buf, onContent);
+			}
+		});
+	});
+
+/**
+ * Reads the pointer names of an uncompressed file by reading only the header
+ * and the pointer sections instead of the whole file.
+ * @param {IntermediateFileSystem} fs a file system
+ * @param {string} file absolute path of the serialized file
+ * @returns {Promise<string[]>} referenced file names (without extension)
+ */
+const getReferencedFilenamesUncompressed = (fs, file) =>
+	new Promise((resolve, reject) => {
+		fs.open(file, "r", (err, _fd) => {
+			if (err) return reject(err);
+			const fd = /** @type {number} */ (_fd);
+			/**
+			 * Closes the file descriptor and rejects.
+			 * @param {Error} err error
+			 */
+			const fail = (err) => {
+				fs.close(fd, () => reject(err));
+			};
+			/**
+			 * Reads exactly `length` bytes at `position`.
+			 * @param {number} position file position
+			 * @param {number} length byte count
+			 * @param {(buffer: Buffer) => void} callback called with the filled buffer
+			 * @returns {void}
+			 */
+			const readAt = (position, length, callback) => {
+				// corrupt headers can request absurd sizes; must reject, not crash
+				if (length > MAX_HEADER_OR_POINTER_SIZE) {
+					return fail(new Error(`Invalid section size ${length} in ${file}`));
+				}
+				/** @type {Buffer} */
+				let buffer;
+				try {
+					buffer = Buffer.allocUnsafe(length);
+				} catch (err) {
+					return fail(/** @type {Error} */ (err));
+				}
+				let bytesDone = 0;
+				const readMore = () => {
+					fs.read(
+						fd,
+						buffer,
+						bytesDone,
+						length - bytesDone,
+						position + bytesDone,
+						(err, bytesRead) => {
+							if (err) return fail(err);
+							if (bytesRead === 0) {
+								return fail(new Error(`Unexpected end of file ${file}`));
+							}
+							bytesDone += bytesRead;
+							if (bytesDone < length) return readMore();
+							callback(buffer);
+						}
+					);
+				};
+				readMore();
+			};
+			readAt(0, 8, (header) => {
+				const version = header.readUInt32LE(0);
+				if (version !== VERSION) {
+					return fail(new Error(`Invalid file version ${version}`));
+				}
+				const sectionCount = header.readUInt32LE(4);
+				if (sectionCount === 0) {
+					return fs.close(fd, (err) => (err ? reject(err) : resolve([])));
+				}
+				readAt(8, sectionCount * 4, (lengthsBuffer) => {
+					/** @type {{ position: number, length: number }[]} */
+					const pointerSections = [];
+					let position = 8 + sectionCount * 4;
+					for (let i = 0; i < sectionCount; i++) {
+						const length = lengthsBuffer.readInt32LE(i * 4);
+						if (length < 0) {
+							pointerSections.push({ position, length: -length });
+							position -= length;
+						} else {
+							position += length;
+						}
+					}
+					// the section table must account for exactly the whole file,
+					// otherwise pointer reads land on wrong bytes and under-report
+					fs.stat(file, (err, stats) => {
+						if (err) return fail(err);
+						const stat = /** @type {import("../util/fs").IStats} */ (stats);
+						if (stat.size !== position) {
+							return fail(
+								new Error(`Section table does not match size of ${file}`)
+							);
+						}
+						/** @type {string[]} */
+						const names = [];
+						/**
+						 * Reads the pointer section at `index`, then the next one.
+						 * @param {number} index pointer section index
+						 * @returns {void}
+						 */
+						const readNext = (index) => {
+							if (index >= pointerSections.length) {
+								return fs.close(fd, (err) =>
+									err ? reject(err) : resolve(names)
+								);
+							}
+							const section = pointerSections[index];
+							readAt(section.position, section.length, (buffer) => {
+								// pointer section: u64 size + utf-8 file name
+								names.push(buffer.toString("utf8", 8));
+								readNext(index + 1);
+							});
+						};
+						readNext(0);
+					});
+				});
+			});
+		});
+	});
+
+/**
+ * Reads the file names referenced by a serialized file (its lazy pointer sections)
+ * without deserializing its content. Referenced files may reference further files.
+ * @param {IntermediateFileSystem} fs a file system
+ * @param {string} file absolute path of the serialized file
+ * @returns {Promise<string[]>} referenced file names (without extension)
+ */
+const getReferencedFilenames = (fs, file) =>
+	file.endsWith(".gz") || file.endsWith(".br") || file.endsWith(".zst")
+		? getReferencedFilenamesCompressed(fs, file)
+		: getReferencedFilenamesUncompressed(fs, file);
+
 module.exports = FileMiddleware;
+// Exposed for testing the content-buffer boundary handling in `deserialize`.
+module.exports._deserialize = deserialize;
+module.exports.getReferencedFilenames = getReferencedFilenames;