@rushstack/zipsync 0.1.0

package/lib/pack.js

@@ -0,0 +1,415 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pack = pack;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const crypto = __importStar(require("node:crypto"));
+const zlib = __importStar(require("node:zlib"));
+const crc32_1 = require("./crc32");
+const fs_1 = require("./fs");
+const compress_1 = require("./compress");
+const perf_1 = require("./perf");
+const zipUtils_1 = require("./zipUtils");
+const hash_1 = require("./hash");
+const zipSyncUtils_1 = require("./zipSyncUtils");
+/**
+ * File extensions for which additional DEFLATE/ZSTD compression is unlikely to help.
+ * Used by the 'auto' compression heuristic to avoid wasting CPU on data that is already
+ * compressed (images, media, existing archives, fonts, etc.).
+ */
+const LIKELY_COMPRESSED_EXTENSION_REGEX = /\.(?:zip|gz|tgz|bz2|xz|7z|rar|jpg|jpeg|png|gif|webp|avif|mp4|m4v|mov|mkv|webm|mp3|ogg|aac|flac|pdf|woff|woff2)$/;
+/**
+ * Basic heuristic: skip re-compressing file types that are already compressed.
+ */
+function isLikelyAlreadyCompressed(filename) {
+    return LIKELY_COMPRESSED_EXTENSION_REGEX.test(filename.toLowerCase());
+}
+/**
+ * Map zip compression method code -> incremental zlib mode label
+ */
+const zlibPackModes = {
+    [zipUtils_1.ZSTD_COMPRESSION]: 'zstd-compress',
+    [zipUtils_1.DEFLATE_COMPRESSION]: 'deflate',
+    [zipUtils_1.STORE_COMPRESSION]: undefined
+};
+/**
+ * Public facing CLI option -> actual zip method used for a file we decide to compress.
+ */
+const zipSyncCompressionOptions = {
+    store: zipUtils_1.STORE_COMPRESSION,
+    deflate: zipUtils_1.DEFLATE_COMPRESSION,
+    zstd: zipUtils_1.ZSTD_COMPRESSION,
+    auto: zipUtils_1.DEFLATE_COMPRESSION
+};
+/**
+ * Create a zipsync archive by enumerating target directories, then streaming each file into the
+ * output zip using the local file header + (optional compressed data) + data descriptor pattern.
+ *
+ * Performance characteristics:
+ *  - Single pass per file (no read-then-compress-then-write buffering). CRC32 + SHA-1 are computed
+ *    while streaming so the metadata JSON can later be used for selective unpack.
+ *  - Data descriptor usage (bit 3) allows writing headers before we know sizes or CRC32.
+ *  - A single timestamp (captured once) is applied to all entries for determinism.
+ *  - Metadata entry is added as a normal zip entry at the end (before central directory) so legacy
+ *    tools can still list/extract it, while zipsync can quickly parse file hashes.
+ */
+function pack({ archivePath, targetDirectories: rawTargetDirectories, baseDir: rawBaseDir, compression, terminal, inputBuffer = Buffer.allocUnsafeSlow(zipSyncUtils_1.defaultBufferSize), outputBuffer = Buffer.allocUnsafeSlow(zipSyncUtils_1.defaultBufferSize) }) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const baseDir = path.resolve(rawBaseDir);
+        const targetDirectories = rawTargetDirectories.map((dir) => path.join(baseDir, dir));
+        terminal.writeLine(`Packing to ${archivePath} from ${rawTargetDirectories.join(', ')}`);
+        (0, perf_1.markStart)('pack.total');
+        terminal.writeDebugLine('Starting pack');
+        // Pass 1: enumerate files with a queue to avoid deep recursion
+        (0, perf_1.markStart)('pack.enumerate');
+        const filePaths = [];
+        const queue = targetDirectories.map((dir) => ({ dir, depth: 0 }));
+        while (queue.length) {
+            const { dir: currentDir, depth } = queue.shift();
+            terminal.writeDebugLine(`Enumerating directory: ${currentDir}`);
+            const padding = depth === 0 ? '' : '-↳'.repeat(depth);
+            let items;
+            try {
+                items = fs.readdirSync(currentDir, { withFileTypes: true });
+            }
+            catch (e) {
+                if (e &&
+                    (e.code === 'ENOENT' || e.code === 'ENOTDIR')) {
+                    terminal.writeWarningLine(`Failed to read directory: ${currentDir}. Ignoring.`);
+                    continue;
+                }
+                else {
+                    throw e;
+                }
+            }
+            for (const item of items) {
+                const fullPath = path.join(currentDir, item.name);
+                if (item.isFile()) {
+                    const relativePath = path.relative(baseDir, fullPath).replace(/\\/g, '/');
+                    terminal.writeVerboseLine(`${padding}${item.name}`);
+                    filePaths.push(relativePath);
+                }
+                else if (item.isDirectory()) {
+                    terminal.writeVerboseLine(`${padding}${item.name}/`);
+                    queue.push({ dir: fullPath, depth: depth + 1 });
+                }
+                else {
+                    throw new Error(`Unexpected item (not file or directory): ${fullPath}. Aborting.`);
+                }
+            }
+        }
+        terminal.writeLine(`Found ${filePaths.length} files to pack (enumerated)`);
+        (0, perf_1.markEnd)('pack.enumerate');
+        // Pass 2: stream each file: read chunks -> hash + (maybe) compress -> write local header + data descriptor.
+        (0, perf_1.markStart)('pack.prepareEntries');
+        terminal.writeDebugLine(`Opening archive for write: ${archivePath}`);
+        const zipFile = __addDisposableResource(env_1, (0, fs_1.getDisposableFileHandle)(archivePath, 'w'), false);
+        let currentOffset = 0;
+        /**
+         * Write a raw chunk to the archive file descriptor, updating current offset.
+         */
+        function writeChunkToZip(chunk, lengthBytes = chunk.byteLength) {
+            let offset = 0;
+            while (lengthBytes > 0 && offset < chunk.byteLength) {
+                // In practice this call always writes all data at once, but the spec says it is not an error
+                // for it to not do so. Possibly that situation comes up when writing to something that is not
+                // an ordinary file.
+                const written = fs.writeSync(zipFile.fd, chunk, offset, lengthBytes);
+                lengthBytes -= written;
+                offset += written;
+            }
+            currentOffset += offset;
+        }
+        /** Convenience wrapper for writing multiple buffers sequentially. */
+        function writeChunksToZip(chunks) {
+            for (const chunk of chunks) {
+                writeChunkToZip(chunk);
+            }
+        }
+        const dosDateTimeNow = (0, zipUtils_1.dosDateTime)(new Date());
+        /**
+         * Stream a single file into the archive.
+         * Steps:
+         *  1. Decide compression (based on user choice + heuristic).
+         *  2. Emit local file header (sizes/CRC zeroed because we use a data descriptor).
+         *  3. Read file in 32 MiB chunks: update SHA-1 + CRC32; optionally feed compressor or write raw.
+         *  4. Flush compressor (if any) and write trailing data descriptor containing sizes + CRC.
+         *  5. Return populated entry metadata for later central directory + JSON metadata.
+         */
+        function writeFileEntry(relativePath) {
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                const fullPath = path.join(baseDir, relativePath);
+                /**
+                 * Read file in large fixed-size buffer; invoke callback for each filled chunk.
+                 */
+                const readInputInChunks = (onChunk) => {
+                    const env_3 = { stack: [], error: void 0, hasError: false };
+                    try {
+                        const inputDisposable = __addDisposableResource(env_3, (0, fs_1.getDisposableFileHandle)(fullPath, 'r'), false);
+                        let bytesInInputBuffer = 0;
+                        // The entire input buffer will be drained in each loop iteration
+                        // So run until EOF
+                        while (!isNaN(inputDisposable.fd)) {
+                            bytesInInputBuffer = fs.readSync(inputDisposable.fd, inputBuffer, 0, inputBuffer.byteLength, -1);
+                            if (bytesInInputBuffer <= 0) {
+                                // EOF, close the input fd
+                                inputDisposable[fs_1.DISPOSE_SYMBOL]();
+                            }
+                            onChunk(bytesInInputBuffer);
+                        }
+                    }
+                    catch (e_3) {
+                        env_3.error = e_3;
+                        env_3.hasError = true;
+                    }
+                    finally {
+                        __disposeResources(env_3);
+                    }
+                };
+                let shouldCompress = false;
+                if (compression === 'deflate' || compression === 'zstd') {
+                    shouldCompress = true;
+                }
+                else if (compression === 'auto') {
+                    // Heuristic: skip compression for small files or likely-already-compressed files
+                    if (!isLikelyAlreadyCompressed(relativePath)) {
+                        shouldCompress = true;
+                    }
+                    else {
+                        terminal.writeVerboseLine(`Skip compression heuristically (already-compressed) for ${relativePath} (size unknown at this point)`);
+                    }
+                }
+                const compressionMethod = shouldCompress
+                    ? zipSyncCompressionOptions[compression]
+                    : zipSyncCompressionOptions.store;
+                const entry = {
+                    filename: relativePath,
+                    size: 0,
+                    compressedSize: 0,
+                    crc32: 0,
+                    sha1Hash: '',
+                    localHeaderOffset: currentOffset,
+                    compressionMethod,
+                    dosDateTime: dosDateTimeNow
+                };
+                writeChunksToZip((0, zipUtils_1.writeLocalFileHeader)(entry));
+                const sha1HashBuilder = crypto.createHash('sha1');
+                let crc32 = 0;
+                let uncompressedSize = 0;
+                let compressedSize = 0;
+                /**
+                 * Compressor instance (deflate or zstd) created only if needed.
+                 */
+                const incrementalZlib = __addDisposableResource(env_2, shouldCompress
+                    ? (0, compress_1.createIncrementalZlib)(outputBuffer, (chunk, lengthBytes) => {
+                        writeChunkToZip(chunk, lengthBytes);
+                        compressedSize += lengthBytes;
+                    }, zlibPackModes[compressionMethod])
+                    : undefined, false);
+                // Read input file in chunks, update hashes, and either compress or write raw.
+                readInputInChunks((bytesInInputBuffer) => {
+                    const slice = inputBuffer.subarray(0, bytesInInputBuffer);
+                    sha1HashBuilder.update(slice);
+                    crc32 = (0, crc32_1.crc32Builder)(slice, crc32);
+                    if (incrementalZlib) {
+                        incrementalZlib.update(slice);
+                    }
+                    else {
+                        writeChunkToZip(slice, bytesInInputBuffer);
+                    }
+                    uncompressedSize += bytesInInputBuffer;
+                });
+                // finalize hashes, compression
+                incrementalZlib === null || incrementalZlib === void 0 ? void 0 : incrementalZlib.update(Buffer.alloc(0));
+                crc32 = crc32 >>> 0;
+                const sha1Hash = sha1HashBuilder.digest('hex');
+                if (!shouldCompress) {
+                    compressedSize = uncompressedSize;
+                }
+                entry.size = uncompressedSize;
+                entry.compressedSize = compressedSize;
+                entry.crc32 = crc32;
+                entry.sha1Hash = sha1Hash;
+                // Trailing data descriptor now that final CRC/sizes are known.
+                writeChunkToZip((0, zipUtils_1.writeDataDescriptor)(entry));
+                terminal.writeVerboseLine(`${relativePath} (sha1=${entry.sha1Hash}, crc32=${entry.crc32.toString(16)}, size=${entry.size}, compressed=${entry.compressedSize}, method=${entry.compressionMethod}, compressed ${(100 -
+                    (entry.compressedSize / entry.size) * 100).toFixed(1)}%)`);
+                return entry;
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                __disposeResources(env_2);
+            }
+        }
+        const entries = [];
+        // Emit all file entries in enumeration order.
+        for (const relativePath of filePaths) {
+            entries.push(writeFileEntry(relativePath));
+        }
+        (0, perf_1.markEnd)('pack.prepareEntries');
+        terminal.writeLine(`Prepared ${entries.length} file entries`);
+        (0, perf_1.markStart)('pack.metadata.build');
+        const metadata = { version: zipSyncUtils_1.METADATA_VERSION, files: {} };
+        // Build metadata map used for selective unpack (size + SHA‑1 per file).
+        for (const entry of entries) {
+            metadata.files[entry.filename] = { size: entry.size, sha1Hash: entry.sha1Hash };
+        }
+        const metadataContent = JSON.stringify(metadata);
+        const metadataBuffer = Buffer.from(metadataContent, 'utf8');
+        terminal.writeDebugLine(`Metadata size=${metadataBuffer.length} bytes, fileCount=${Object.keys(metadata.files).length}`);
+        let metadataCompressionMethod = zipSyncCompressionOptions.store;
+        let metadataData = metadataBuffer;
+        let metadataCompressedSize = metadataBuffer.length;
+        // Compress metadata (deflate) iff user allowed compression and it helps (>64 bytes & smaller result).
+        if (compression !== 'store' && metadataBuffer.length > 64) {
+            const compressed = zlib.deflateRawSync(metadataBuffer, { level: 9 });
+            if (compressed.length < metadataBuffer.length) {
+                metadataCompressionMethod = zipSyncCompressionOptions.deflate;
+                metadataData = compressed;
+                metadataCompressedSize = compressed.length;
+                terminal.writeDebugLine(`Metadata compressed (orig=${metadataBuffer.length}, compressed=${compressed.length})`);
+            }
+            else {
+                terminal.writeDebugLine('Metadata compression skipped (not smaller)');
+            }
+        }
+        const metadataEntry = {
+            filename: zipSyncUtils_1.METADATA_FILENAME,
+            size: metadataBuffer.length,
+            compressedSize: metadataCompressedSize,
+            crc32: (0, crc32_1.crc32Builder)(metadataBuffer),
+            sha1Hash: (0, hash_1.calculateSHA1)(metadataBuffer),
+            localHeaderOffset: currentOffset,
+            compressionMethod: metadataCompressionMethod,
+            dosDateTime: dosDateTimeNow
+        };
+        writeChunksToZip((0, zipUtils_1.writeLocalFileHeader)(metadataEntry));
+        writeChunkToZip(metadataData, metadataCompressedSize);
+        writeChunkToZip((0, zipUtils_1.writeDataDescriptor)(metadataEntry));
+        entries.push(metadataEntry);
+        terminal.writeVerboseLine(`Total entries including metadata: ${entries.length}`);
+        (0, perf_1.markEnd)('pack.metadata.build');
+        (0, perf_1.markStart)('pack.write.entries');
+        const outputDir = path.dirname(archivePath);
+        fs.mkdirSync(outputDir, { recursive: true });
+        (0, perf_1.markEnd)('pack.write.entries');
+        (0, perf_1.markStart)('pack.write.centralDirectory');
+        const centralDirOffset = currentOffset;
+        // Emit central directory records.
+        for (const entry of entries) {
+            writeChunksToZip((0, zipUtils_1.writeCentralDirectoryHeader)(entry));
+        }
+        const centralDirSize = currentOffset - centralDirOffset;
+        (0, perf_1.markEnd)('pack.write.centralDirectory');
+        // Write end of central directory
+        (0, perf_1.markStart)('pack.write.eocd');
+        writeChunkToZip((0, zipUtils_1.writeEndOfCentralDirectory)(centralDirOffset, centralDirSize, entries.length));
+        terminal.writeDebugLine('EOCD record written');
+        (0, perf_1.markEnd)('pack.write.eocd');
+        (0, perf_1.markEnd)('pack.total');
+        const total = (0, perf_1.getDuration)('pack.total');
+        (0, perf_1.emitSummary)('pack', terminal);
+        terminal.writeLine(`Successfully packed ${entries.length} files in ${(0, perf_1.formatDuration)(total)}`);
+        return { filesPacked: entries.length, metadata };
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+//# sourceMappingURL=pack.js.map

package/lib/pack.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.js","sourceRoot":"","sources":["../src/pack.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport * as fs from 'node:fs';\nimport * as path from 'node:path';\nimport * as crypto from 'node:crypto';\nimport * as zlib from 'node:zlib';\n\nimport type { ITerminal } from '@rushstack/terminal/lib/ITerminal';\n\nimport { crc32Builder } from './crc32';\nimport { DISPOSE_SYMBOL, getDisposableFileHandle, type IDisposableFileHandle } from './fs';\nimport { type IIncrementalZlib, type IncrementalZlibMode, createIncrementalZlib } from './compress';\nimport { markStart, markEnd, getDuration, emitSummary, formatDuration } from './perf';\nimport {\n  writeLocalFileHeader,\n  writeDataDescriptor,\n  writeCentralDirectoryHeader,\n  writeEndOfCentralDirectory,\n  ZSTD_COMPRESSION,\n  DEFLATE_COMPRESSION,\n  STORE_COMPRESSION,\n  type ZipMetaCompressionMethod,\n  type IFileEntry,\n  dosDateTime\n} from './zipUtils';\nimport { calculateSHA1 } from './hash';\nimport {\n  type ZipSyncOptionCompression,\n  type IMetadata,\n  type IDirQueueItem,\n  METADATA_VERSION,\n  METADATA_FILENAME,\n  defaultBufferSize\n} from './zipSyncUtils';\n\n/**\n * File extensions for which additional DEFLATE/ZSTD compression is unlikely to help.\n * Used by the 'auto' compression heuristic to avoid wasting CPU on data that is already\n * compressed (images, media, existing archives, fonts, etc.).\n */\nconst LIKELY_COMPRESSED_EXTENSION_REGEX: RegExp =\n  /\\.(?:zip|gz|tgz|bz2|xz|7z|rar|jpg|jpeg|png|gif|webp|avif|mp4|m4v|mov|mkv|webm|mp3|ogg|aac|flac|pdf|woff|woff2)$/;\n\n/**\n * Basic heuristic: skip re-compressing file types that are already compressed.\n */\nfunction isLikelyAlreadyCompressed(filename: string): boolean {\n  return LIKELY_COMPRESSED_EXTENSION_REGEX.test(filename.toLowerCase());\n}\n\n/**\n * Map zip compression method code -> incremental zlib mode label\n */\nconst zlibPackModes: Record<ZipMetaCompressionMethod, IncrementalZlibMode | undefined> = {\n  [ZSTD_COMPRESSION]: 'zstd-compress',\n  [DEFLATE_COMPRESSION]: 'deflate',\n  [STORE_COMPRESSION]: undefined\n} as const;\n\n/**\n * Public facing CLI option -> actual zip method used for a file we decide to compress.\n */\nconst zipSyncCompressionOptions: Record<ZipSyncOptionCompression, ZipMetaCompressionMethod> = {\n  store: STORE_COMPRESSION,\n  deflate: DEFLATE_COMPRESSION,\n  zstd: ZSTD_COMPRESSION,\n  auto: DEFLATE_COMPRESSION\n} as const;\n\n/**\n * @public\n * Options for zipsync\n */\nexport interface IZipSyncPackOptions {\n  /**\n   * \\@rushstack/terminal compatible terminal for logging\n   */\n  terminal: ITerminal;\n  /**\n   * Zip file path\n   */\n  archivePath: string;\n  /**\n   * Target directories to pack (relative to baseDir)\n   */\n  targetDirectories: ReadonlyArray<string>;\n  /**\n   * Base directory for relative paths within the archive (defaults to common parent of targetDirectories)\n   */\n  baseDir: string;\n  /**\n   * Compression mode. If set to 'deflate', file data will be compressed using raw DEFLATE (method 8) when this\n   * produces a smaller result; otherwise it will fall back to 'store' per-file.\n   */\n  compression: ZipSyncOptionCompression;\n  /**\n   * Optional buffer that can be provided to avoid internal allocations.\n   */\n  inputBuffer?: Buffer<ArrayBuffer>;\n  /**\n   * Optional buffer that can be provided to avoid internal allocations.\n   */\n  outputBuffer?: Buffer<ArrayBuffer>;\n}\n\nexport interface IZipSyncPackResult {\n  filesPacked: number;\n  metadata: IMetadata;\n}\n\n/**\n * Create a zipsync archive by enumerating target directories, then streaming each file into the\n * output zip using the local file header + (optional compressed data) + data descriptor pattern.\n *\n * Performance characteristics:\n *  - Single pass per file (no read-then-compress-then-write buffering). CRC32 + SHA-1 are computed\n *    while streaming so the metadata JSON can later be used for selective unpack.\n *  - Data descriptor usage (bit 3) allows writing headers before we know sizes or CRC32.\n *  - A single timestamp (captured once) is applied to all entries for determinism.\n *  - Metadata entry is added as a normal zip entry at the end (before central directory) so legacy\n *    tools can still list/extract it, while zipsync can quickly parse file hashes.\n */\nexport function pack({\n  archivePath,\n  targetDirectories: rawTargetDirectories,\n  baseDir: rawBaseDir,\n  compression,\n  terminal,\n  inputBuffer = Buffer.allocUnsafeSlow(defaultBufferSize),\n  outputBuffer = Buffer.allocUnsafeSlow(defaultBufferSize)\n}: IZipSyncPackOptions): IZipSyncPackResult {\n  const baseDir: string = path.resolve(rawBaseDir);\n  const targetDirectories: string[] = rawTargetDirectories.map((dir) => path.join(baseDir, dir));\n  terminal.writeLine(`Packing to ${archivePath} from ${rawTargetDirectories.join(', ')}`);\n\n  markStart('pack.total');\n  terminal.writeDebugLine('Starting pack');\n  // Pass 1: enumerate files with a queue to avoid deep recursion\n  markStart('pack.enumerate');\n\n  const filePaths: string[] = [];\n  const queue: IDirQueueItem[] = targetDirectories.map((dir) => ({ dir, depth: 0 }));\n\n  while (queue.length) {\n    const { dir: currentDir, depth } = queue.shift()!;\n    terminal.writeDebugLine(`Enumerating directory: ${currentDir}`);\n\n    const padding: string = depth === 0 ? '' : '-↳'.repeat(depth);\n\n    let items: fs.Dirent[];\n    try {\n      items = fs.readdirSync(currentDir, { withFileTypes: true });\n    } catch (e) {\n      if (\n        e &&\n        ((e as NodeJS.ErrnoException).code === 'ENOENT' || (e as NodeJS.ErrnoException).code === 'ENOTDIR')\n      ) {\n        terminal.writeWarningLine(`Failed to read directory: ${currentDir}. Ignoring.`);\n        continue;\n      } else {\n        throw e;\n      }\n    }\n\n    for (const item of items) {\n      const fullPath: string = path.join(currentDir, item.name);\n      if (item.isFile()) {\n        const relativePath: string = path.relative(baseDir, fullPath).replace(/\\\\/g, '/');\n        terminal.writeVerboseLine(`${padding}${item.name}`);\n        filePaths.push(relativePath);\n      } else if (item.isDirectory()) {\n        terminal.writeVerboseLine(`${padding}${item.name}/`);\n        queue.push({ dir: fullPath, depth: depth + 1 });\n      } else {\n        throw new Error(`Unexpected item (not file or directory): ${fullPath}. Aborting.`);\n      }\n    }\n  }\n\n  terminal.writeLine(`Found ${filePaths.length} files to pack (enumerated)`);\n  markEnd('pack.enumerate');\n\n  // Pass 2: stream each file: read chunks -> hash + (maybe) compress -> write local header + data descriptor.\n  markStart('pack.prepareEntries');\n\n  terminal.writeDebugLine(`Opening archive for write: ${archivePath}`);\n  using zipFile: IDisposableFileHandle = getDisposableFileHandle(archivePath, 'w');\n  let currentOffset: number = 0;\n  /**\n   * Write a raw chunk to the archive file descriptor, updating current offset.\n   */\n  function writeChunkToZip(chunk: Uint8Array, lengthBytes: number = chunk.byteLength): void {\n    let offset: number = 0;\n    while (lengthBytes > 0 && offset < chunk.byteLength) {\n      // In practice this call always writes all data at once, but the spec says it is not an error\n      // for it to not do so. Possibly that situation comes up when writing to something that is not\n      // an ordinary file.\n      const written: number = fs.writeSync(zipFile.fd, chunk, offset, lengthBytes);\n      lengthBytes -= written;\n      offset += written;\n    }\n    currentOffset += offset;\n  }\n  /** Convenience wrapper for writing multiple buffers sequentially. */\n  function writeChunksToZip(chunks: Uint8Array[]): void {\n    for (const chunk of chunks) {\n      writeChunkToZip(chunk);\n    }\n  }\n\n  const dosDateTimeNow: { time: number; date: number } = dosDateTime(new Date());\n  /**\n   * Stream a single file into the archive.\n   * Steps:\n   *  1. Decide compression (based on user choice + heuristic).\n   *  2. Emit local file header (sizes/CRC zeroed because we use a data descriptor).\n   *  3. Read file in 32 MiB chunks: update SHA-1 + CRC32; optionally feed compressor or write raw.\n   *  4. Flush compressor (if any) and write trailing data descriptor containing sizes + CRC.\n   *  5. Return populated entry metadata for later central directory + JSON metadata.\n   */\n  function writeFileEntry(relativePath: string): IFileEntry {\n    const fullPath: string = path.join(baseDir, relativePath);\n\n    /**\n     * Read file in large fixed-size buffer; invoke callback for each filled chunk.\n     */\n    const readInputInChunks: (onChunk: (bytesInInputBuffer: number) => void) => void = (\n      onChunk: (bytesInInputBuffer: number) => void\n    ): void => {\n      using inputDisposable: IDisposableFileHandle = getDisposableFileHandle(fullPath, 'r');\n\n      let bytesInInputBuffer: number = 0;\n      // The entire input buffer will be drained in each loop iteration\n      // So run until EOF\n      while (!isNaN(inputDisposable.fd)) {\n        bytesInInputBuffer = fs.readSync(inputDisposable.fd, inputBuffer, 0, inputBuffer.byteLength, -1);\n\n        if (bytesInInputBuffer <= 0) {\n          // EOF, close the input fd\n          inputDisposable[DISPOSE_SYMBOL]();\n        }\n\n        onChunk(bytesInInputBuffer);\n      }\n    };\n\n    let shouldCompress: boolean = false;\n    if (compression === 'deflate' || compression === 'zstd') {\n      shouldCompress = true;\n    } else if (compression === 'auto') {\n      // Heuristic: skip compression for small files or likely-already-compressed files\n      if (!isLikelyAlreadyCompressed(relativePath)) {\n        shouldCompress = true;\n      } else {\n        terminal.writeVerboseLine(\n          `Skip compression heuristically (already-compressed) for ${relativePath} (size unknown at this point)`\n        );\n      }\n    }\n\n    const compressionMethod: ZipMetaCompressionMethod = shouldCompress\n      ? zipSyncCompressionOptions[compression]\n      : zipSyncCompressionOptions.store;\n\n    const entry: IFileEntry = {\n      filename: relativePath,\n      size: 0,\n      compressedSize: 0,\n      crc32: 0,\n      sha1Hash: '',\n      localHeaderOffset: currentOffset,\n      compressionMethod,\n      dosDateTime: dosDateTimeNow\n    };\n\n    writeChunksToZip(writeLocalFileHeader(entry));\n\n    const sha1HashBuilder: crypto.Hash = crypto.createHash('sha1');\n    let crc32: number = 0;\n    let uncompressedSize: number = 0;\n    let compressedSize: number = 0;\n\n    /**\n     * Compressor instance (deflate or zstd) created only if needed.\n     */\n    using incrementalZlib: IIncrementalZlib | undefined = shouldCompress\n      ? createIncrementalZlib(\n          outputBuffer,\n          (chunk, lengthBytes) => {\n            writeChunkToZip(chunk, lengthBytes);\n            compressedSize += lengthBytes;\n          },\n          zlibPackModes[compressionMethod]!\n        )\n      : undefined;\n\n    // Read input file in chunks, update hashes, and either compress or write raw.\n    readInputInChunks((bytesInInputBuffer: number) => {\n      const slice: Buffer = inputBuffer.subarray(0, bytesInInputBuffer);\n      sha1HashBuilder.update(slice);\n      crc32 = crc32Builder(slice, crc32);\n      if (incrementalZlib) {\n        incrementalZlib.update(slice);\n      } else {\n        writeChunkToZip(slice, bytesInInputBuffer);\n      }\n      uncompressedSize += bytesInInputBuffer;\n    });\n\n    // finalize hashes, compression\n    incrementalZlib?.update(Buffer.alloc(0));\n    crc32 = crc32 >>> 0;\n    const sha1Hash: string = sha1HashBuilder.digest('hex');\n\n    if (!shouldCompress) {\n      compressedSize = uncompressedSize;\n    }\n\n    entry.size = uncompressedSize;\n    entry.compressedSize = compressedSize;\n    entry.crc32 = crc32;\n    entry.sha1Hash = sha1Hash;\n\n    // Trailing data descriptor now that final CRC/sizes are known.\n    writeChunkToZip(writeDataDescriptor(entry));\n\n    terminal.writeVerboseLine(\n      `${relativePath} (sha1=${entry.sha1Hash}, crc32=${entry.crc32.toString(16)}, size=${\n        entry.size\n      }, compressed=${entry.compressedSize}, method=${entry.compressionMethod}, compressed ${(\n        100 -\n        (entry.compressedSize / entry.size) * 100\n      ).toFixed(1)}%)`\n    );\n    return entry;\n  }\n\n  const entries: IFileEntry[] = [];\n  // Emit all file entries in enumeration order.\n  for (const relativePath of filePaths) {\n    entries.push(writeFileEntry(relativePath));\n  }\n\n  markEnd('pack.prepareEntries');\n  terminal.writeLine(`Prepared ${entries.length} file entries`);\n\n  markStart('pack.metadata.build');\n  const metadata: IMetadata = { version: METADATA_VERSION, files: {} };\n  // Build metadata map used for selective unpack (size + SHA‑1 per file).\n  for (const entry of entries) {\n    metadata.files[entry.filename] = { size: entry.size, sha1Hash: entry.sha1Hash };\n  }\n\n  const metadataContent: string = JSON.stringify(metadata);\n  const metadataBuffer: Buffer = Buffer.from(metadataContent, 'utf8');\n  terminal.writeDebugLine(\n    `Metadata size=${metadataBuffer.length} bytes, fileCount=${Object.keys(metadata.files).length}`\n  );\n\n  let metadataCompressionMethod: ZipMetaCompressionMethod = zipSyncCompressionOptions.store;\n  let metadataData: Buffer = metadataBuffer;\n  let metadataCompressedSize: number = metadataBuffer.length;\n  // Compress metadata (deflate) iff user allowed compression and it helps (>64 bytes & smaller result).\n  if (compression !== 'store' && metadataBuffer.length > 64) {\n    const compressed: Buffer = zlib.deflateRawSync(metadataBuffer, { level: 9 });\n    if (compressed.length < metadataBuffer.length) {\n      metadataCompressionMethod = zipSyncCompressionOptions.deflate;\n      metadataData = compressed;\n      metadataCompressedSize = compressed.length;\n      terminal.writeDebugLine(\n        `Metadata compressed (orig=${metadataBuffer.length}, compressed=${compressed.length})`\n      );\n    } else {\n      terminal.writeDebugLine('Metadata compression skipped (not smaller)');\n    }\n  }\n\n  const metadataEntry: IFileEntry = {\n    filename: METADATA_FILENAME,\n    size: metadataBuffer.length,\n    compressedSize: metadataCompressedSize,\n    crc32: crc32Builder(metadataBuffer),\n    sha1Hash: calculateSHA1(metadataBuffer),\n    localHeaderOffset: currentOffset,\n    compressionMethod: metadataCompressionMethod,\n    dosDateTime: dosDateTimeNow\n  };\n\n  writeChunksToZip(writeLocalFileHeader(metadataEntry));\n  writeChunkToZip(metadataData, metadataCompressedSize);\n  writeChunkToZip(writeDataDescriptor(metadataEntry));\n\n  entries.push(metadataEntry);\n  terminal.writeVerboseLine(`Total entries including metadata: ${entries.length}`);\n\n  markEnd('pack.metadata.build');\n\n  markStart('pack.write.entries');\n  const outputDir: string = path.dirname(archivePath);\n  fs.mkdirSync(outputDir, { recursive: true });\n\n  markEnd('pack.write.entries');\n\n  markStart('pack.write.centralDirectory');\n  const centralDirOffset: number = currentOffset;\n  // Emit central directory records.\n  for (const entry of entries) {\n    writeChunksToZip(writeCentralDirectoryHeader(entry));\n  }\n  const centralDirSize: number = currentOffset - centralDirOffset;\n  markEnd('pack.write.centralDirectory');\n\n  // Write end of central directory\n  markStart('pack.write.eocd');\n  writeChunkToZip(writeEndOfCentralDirectory(centralDirOffset, centralDirSize, entries.length));\n  terminal.writeDebugLine('EOCD record written');\n  markEnd('pack.write.eocd');\n\n  markEnd('pack.total');\n  const total: number = getDuration('pack.total');\n  emitSummary('pack', terminal);\n  terminal.writeLine(`Successfully packed ${entries.length} files in ${formatDuration(total)}`);\n  return { filesPacked: entries.length, metadata };\n}\n"]}

package/lib/packWorker.d.ts

@@ -0,0 +1,31 @@
+import { type IZipSyncPackOptions, type IZipSyncPackResult } from './pack';
+export { type IZipSyncPackOptions, type IZipSyncPackResult } from './pack';
+export interface IHashWorkerData {
+    basePath: string;
+}
+export interface IZipSyncPackCommandMessage {
+    type: 'zipsync-pack';
+    id: number;
+    options: Omit<IZipSyncPackOptions, 'terminal'>;
+}
+export interface IZipSyncPackWorkerResult {
+    zipSyncReturn: IZipSyncPackResult;
+    zipSyncLogs: string;
+}
+interface IZipSyncSuccessMessage {
+    id: number;
+    type: 'zipsync-pack';
+    result: IZipSyncPackWorkerResult;
+}
+export interface IZipSyncPackErrorMessage {
+    type: 'error';
+    id: number;
+    args: {
+        message: string;
+        stack: string;
+        zipSyncLogs: string;
+    };
+}
+export type IHostToWorkerMessage = IZipSyncPackCommandMessage;
+export type IWorkerToHostMessage = IZipSyncSuccessMessage | IZipSyncPackErrorMessage;
+//# sourceMappingURL=packWorker.d.ts.map

package/lib/packWorker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packWorker.d.ts","sourceRoot":"","sources":["../src/packWorker.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,kBAAkB,EAAQ,MAAM,QAAQ,CAAC;AAGjF,OAAO,EAAE,KAAK,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAE3E,MAAM,WAAW,eAAe;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,0BAA0B;IACzC,IAAI,EAAE,cAAc,CAAC;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,CAAC;CAChD;AAED,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,kBAAkB,CAAC;IAClC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,UAAU,sBAAsB;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,cAAc,CAAC;IACrB,MAAM,EAAE,wBAAwB,CAAC;CAClC;AAED,MAAM,WAAW,wBAAwB;IACvC,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE;QACJ,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;KACrB,CAAC;CACH;AAED,MAAM,MAAM,oBAAoB,GAAG,0BAA0B,CAAC;AAC9D,MAAM,MAAM,oBAAoB,GAAG,sBAAsB,GAAG,wBAAwB,CAAC"}

package/lib/packWorker.js

@@ -0,0 +1,60 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_worker_threads_1 = require("node:worker_threads");
+const Terminal_1 = require("@rushstack/terminal/lib/Terminal");
+const StringBufferTerminalProvider_1 = require("@rushstack/terminal/lib/StringBufferTerminalProvider");
+const pack_1 = require("./pack");
+const zipSyncUtils_1 = require("./zipSyncUtils");
+if (!node_worker_threads_1.parentPort) {
+    throw new Error('This module must be run in a worker thread.');
+}
+const parentPort = node_worker_threads_1.parentPort;
+let inputBuffer = undefined;
+let outputBuffer = undefined;
+function handleMessage(message) {
+    if (message === false) {
+        parentPort.removeAllListeners();
+        parentPort.close();
+        return;
+    }
+    const terminalProvider = new StringBufferTerminalProvider_1.StringBufferTerminalProvider();
+    const terminal = new Terminal_1.Terminal(terminalProvider);
+    try {
+        switch (message.type) {
+            case 'zipsync-pack': {
+                const { options } = message;
+                if (!inputBuffer) {
+                    inputBuffer = Buffer.allocUnsafeSlow(zipSyncUtils_1.defaultBufferSize);
+                }
+                if (!outputBuffer) {
+                    outputBuffer = Buffer.allocUnsafeSlow(zipSyncUtils_1.defaultBufferSize);
+                }
+                const successMessage = {
+                    type: message.type,
+                    id: message.id,
+                    result: {
+                        zipSyncReturn: (0, pack_1.pack)({ ...options, terminal, inputBuffer, outputBuffer }),
+                        zipSyncLogs: terminalProvider.getOutput()
+                    }
+                };
+                return parentPort.postMessage(successMessage);
+            }
+        }
+    }
+    catch (err) {
+        const errorMessage = {
+            type: 'error',
+            id: message.id,
+            args: {
+                message: err.message,
+                stack: err.stack || '',
+                zipSyncLogs: terminalProvider.getOutput()
+            }
+        };
+        parentPort.postMessage(errorMessage);
+    }
+}
+parentPort.on('message', handleMessage);
+//# sourceMappingURL=packWorker.js.map

package/lib/packWorker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"packWorker.js","sourceRoot":"","sources":["../src/packWorker.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;AAE3D,6DAAoF;AAEpF,+DAA4D;AAC5D,uGAAoG;AAEpG,iCAAiF;AACjF,iDAAmD;AAsCnD,IAAI,CAAC,gCAAa,EAAE,CAAC;IACnB,MAAM,IAAI,KAAK,CAAC,6CAA6C,CAAC,CAAC;AACjE,CAAC;AACD,MAAM,UAAU,GAAgB,gCAAa,CAAC;AAE9C,IAAI,WAAW,GAAoC,SAAS,CAAC;AAC7D,IAAI,YAAY,GAAoC,SAAS,CAAC;AAE9D,SAAS,aAAa,CAAC,OAAqC;IAC1D,IAAI,OAAO,KAAK,KAAK,EAAE,CAAC;QACtB,UAAU,CAAC,kBAAkB,EAAE,CAAC;QAChC,UAAU,CAAC,KAAK,EAAE,CAAC;QACnB,OAAO;IACT,CAAC;IAED,MAAM,gBAAgB,GAAiC,IAAI,2DAA4B,EAAE,CAAC;IAC1F,MAAM,QAAQ,GAAa,IAAI,mBAAQ,CAAC,gBAAgB,CAAC,CAAC;IAE1D,IAAI,CAAC;QACH,QAAQ,OAAO,CAAC,IAAI,EAAE,CAAC;YACrB,KAAK,cAAc,CAAC,CAAC,CAAC;gBACpB,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;gBAC5B,IAAI,CAAC,WAAW,EAAE,CAAC;oBACjB,WAAW,GAAG,MAAM,CAAC,eAAe,CAAC,gCAAiB,CAAC,CAAC;gBAC1D,CAAC;gBACD,IAAI,CAAC,YAAY,EAAE,CAAC;oBAClB,YAAY,GAAG,MAAM,CAAC,eAAe,CAAC,gCAAiB,CAAC,CAAC;gBAC3D,CAAC;gBAED,MAAM,cAAc,GAA2B;oBAC7C,IAAI,EAAE,OAAO,CAAC,IAAI;oBAClB,EAAE,EAAE,OAAO,CAAC,EAAE;oBACd,MAAM,EAAE;wBACN,aAAa,EAAE,IAAA,WAAI,EAAC,EAAE,GAAG,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,YAAY,EAAE,CAAC;wBACxE,WAAW,EAAE,gBAAgB,CAAC,SAAS,EAAE;qBAC1C;iBACF,CAAC;gBACF,OAAO,UAAU,CAAC,WAAW,CAAC,cAAc,CAAC,CAAC;YAChD,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,YAAY,GAA6B;YAC7C,IAAI,EAAE,OAAO;YACb,EAAE,EAAE,OAAO,CAAC,EAAE;YACd,IAAI,EAAE;gBACJ,OAAO,EAAG,GAAa,CAAC,OAAO;gBAC/B,KAAK,EAAG,GAAa,CAAC,KAAK,IAAI,EAAE;gBACjC,WAAW,EAAE,gBAAgB,CAAC,SAAS,EAAE;aAC1C;SACF,CAAC;QACF,UAAU,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC;IACvC,CAAC;AACH,CAAC;AAED,UAAU,CAAC,EAAE,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\nimport { parentPort as rawParentPort, type MessagePort } from 'node:worker_threads';\n\nimport { Terminal } from '@rushstack/terminal/lib/Terminal';\nimport { StringBufferTerminalProvider } from '@rushstack/terminal/lib/StringBufferTerminalProvider';\n\nimport { type IZipSyncPackOptions, type IZipSyncPackResult, pack } from './pack';\nimport { defaultBufferSize } from './zipSyncUtils';\n\nexport { type IZipSyncPackOptions, type IZipSyncPackResult } from './pack';\n\nexport interface IHashWorkerData {\n  basePath: string;\n}\n\nexport interface IZipSyncPackCommandMessage {\n  type: 'zipsync-pack';\n  id: number;\n  options: Omit<IZipSyncPackOptions, 'terminal'>;\n}\n\nexport interface IZipSyncPackWorkerResult {\n  zipSyncReturn: IZipSyncPackResult;\n  zipSyncLogs: string;\n}\n\ninterface IZipSyncSuccessMessage {\n  id: number;\n  type: 'zipsync-pack';\n  result: IZipSyncPackWorkerResult;\n}\n\nexport interface IZipSyncPackErrorMessage {\n  type: 'error';\n  id: number;\n  args: {\n    message: string;\n    stack: string;\n    zipSyncLogs: string;\n  };\n}\n\nexport type IHostToWorkerMessage = IZipSyncPackCommandMessage;\nexport type IWorkerToHostMessage = IZipSyncSuccessMessage | IZipSyncPackErrorMessage;\n\nif (!rawParentPort) {\n  throw new Error('This module must be run in a worker thread.');\n}\nconst parentPort: MessagePort = rawParentPort;\n\nlet inputBuffer: Buffer<ArrayBuffer> | undefined = undefined;\nlet outputBuffer: Buffer<ArrayBuffer> | undefined = undefined;\n\nfunction handleMessage(message: IHostToWorkerMessage | false): void {\n  if (message === false) {\n    parentPort.removeAllListeners();\n    parentPort.close();\n    return;\n  }\n\n  const terminalProvider: StringBufferTerminalProvider = new StringBufferTerminalProvider();\n  const terminal: Terminal = new Terminal(terminalProvider);\n\n  try {\n    switch (message.type) {\n      case 'zipsync-pack': {\n        const { options } = message;\n        if (!inputBuffer) {\n          inputBuffer = Buffer.allocUnsafeSlow(defaultBufferSize);\n        }\n        if (!outputBuffer) {\n          outputBuffer = Buffer.allocUnsafeSlow(defaultBufferSize);\n        }\n\n        const successMessage: IZipSyncSuccessMessage = {\n          type: message.type,\n          id: message.id,\n          result: {\n            zipSyncReturn: pack({ ...options, terminal, inputBuffer, outputBuffer }),\n            zipSyncLogs: terminalProvider.getOutput()\n          }\n        };\n        return parentPort.postMessage(successMessage);\n      }\n    }\n  } catch (err) {\n    const errorMessage: IZipSyncPackErrorMessage = {\n      type: 'error',\n      id: message.id,\n      args: {\n        message: (err as Error).message,\n        stack: (err as Error).stack || '',\n        zipSyncLogs: terminalProvider.getOutput()\n      }\n    };\n    parentPort.postMessage(errorMessage);\n  }\n}\n\nparentPort.on('message', handleMessage);\n"]}

package/lib/packWorkerAsync.d.ts

@@ -0,0 +1,4 @@
+import type { IZipSyncPackWorkerResult, IZipSyncPackOptions } from './packWorker';
+export type { IZipSyncPackWorkerResult } from './packWorker';
+export declare function packWorkerAsync(options: Omit<IZipSyncPackOptions, 'terminal'>): Promise<IZipSyncPackWorkerResult>;
+//# sourceMappingURL=packWorkerAsync.d.ts.map

package/lib/packWorkerAsync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"packWorkerAsync.d.ts","sourceRoot":"","sources":["../src/packWorkerAsync.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAGV,wBAAwB,EACxB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,YAAY,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAE7D,wBAAsB,eAAe,CACnC,OAAO,EAAE,IAAI,CAAC,mBAAmB,EAAE,UAAU,CAAC,GAC7C,OAAO,CAAC,wBAAwB,CAAC,CA4CnC"}