@cj-tech-master/excelts 7.6.0 → 8.0.0

package/dist/browser/modules/archive/compression/streaming-compress.browser.d.ts

@@ -44,3 +44,10 @@ export declare function createUnzlibStream(options?: StreamCompressOptions): Unz
  * bit-stream state across `write()` calls.
  */
 export { PureJsSyncDeflater as SyncDeflater };
+/**
+ * Returns true when the browser supports native `CompressionStream("deflate-raw")`,
+ * signalling that `push()` should prefer the async path over `SyncDeflater`.
+ *
+ * Only checks for compression support — decompression is not needed for writing.
+ */
+export declare function hasNativeAsyncDeflate(): boolean;

package/dist/browser/modules/archive/compression/streaming-compress.browser.js

@@ -11,7 +11,7 @@
  */
 import { EventEmitter } from "../../../utils/event-emitter.js";
 import { deflateRawCompressed, inflateRaw, SyncDeflater as PureJsSyncDeflater } from "./deflate-fallback.js";
-import { hasDeflateRawWebStreams, hasGzipCompressionStream, hasGzipDecompressionStream, hasDeflateCompressionStream, hasDeflateDecompressionStream } from "./compress.base.js";
+import { hasDeflateRawWebStreams, hasDeflateRawCompressionStream, hasGzipCompressionStream, hasGzipDecompressionStream, hasDeflateCompressionStream, hasDeflateDecompressionStream } from "./compress.base.js";
 import { concatUint8Arrays } from "../../../utils/binary.js";
 import { DEFAULT_COMPRESS_LEVEL } from "../shared/defaults.js";
 import { hasWorkerSupport, getDefaultWorkerPool } from "./worker-pool/index.browser.js";
@@ -253,10 +253,13 @@ function createStreamCodec(type, options) {
     if (options.useWorker && hasWorkerSupport()) {
         return createWorkerStreamCodec(type, options.workerPool, level, options.allowTransfer);
     }
-    if (hasDeflateRawWebStreams()) {
+    // Use native CompressionStream/DecompressionStream when the required
+    // direction is available. Compression only needs CompressionStream;
+    // decompression only needs DecompressionStream.
+    if (type === "deflate" ? hasDeflateRawCompressionStream() : hasDeflateRawWebStreams()) {
         return createNativeWebStreamCodec("deflate-raw", type === "deflate");
     }
-    return new BufferedCodec(type === "deflate" ? deflateRawCompressed : inflateRaw);
+    return new BufferedCodec(type === "deflate" ? data => deflateRawCompressed(data, level) : inflateRaw);
 }
 // =============================================================================
 // Public API
@@ -317,3 +320,12 @@ export function createUnzlibStream(options = {}) {
  * bit-stream state across `write()` calls.
  */
 export { PureJsSyncDeflater as SyncDeflater };
+/**
+ * Returns true when the browser supports native `CompressionStream("deflate-raw")`,
+ * signalling that `push()` should prefer the async path over `SyncDeflater`.
+ *
+ * Only checks for compression support — decompression is not needed for writing.
+ */
+export function hasNativeAsyncDeflate() {
+    return hasDeflateRawCompressionStream();
+}

package/dist/browser/modules/archive/compression/streaming-compress.d.ts

@@ -75,3 +75,8 @@ export declare class SyncDeflater implements SyncDeflaterLike {
     finish(): Uint8Array;
     private _flushBatch;
 }
+/**
+ * On Node.js, `zlib.deflateRawSync` is native and fast — no need to detour
+ * through the async streaming path. Always returns false.
+ */
+export declare function hasNativeAsyncDeflate(): boolean;

package/dist/browser/modules/archive/compression/streaming-compress.js

@@ -166,3 +166,10 @@ export class SyncDeflater {
         return new Uint8Array(result);
     }
 }
+/**
+ * On Node.js, `zlib.deflateRawSync` is native and fast — no need to detour
+ * through the async streaming path. Always returns false.
+ */
+export function hasNativeAsyncDeflate() {
+    return false;
+}

package/dist/browser/modules/archive/zip/stream.js

@@ -6,7 +6,7 @@
  * - In browser builds the bundler aliases those imports to their browser variants.
  */
 import { crc32Update, crc32Finalize, ensureZlibSync } from "../compression/crc32.browser.js";
-import { createDeflateStream, SyncDeflater } from "../compression/streaming-compress.browser.js";
+import { createDeflateStream, SyncDeflater, hasNativeAsyncDeflate } from "../compression/streaming-compress.browser.js";
 import { zipCryptoInitKeys, zipCryptoCreateHeader, zipCryptoEncryptByte, aesEncrypt, buildAesExtraField, randomBytes, isAesEncryption, getAesKeyStrength } from "../crypto/index.js";
 import { DEFAULT_ZIP_LEVEL, DEFAULT_ZIP_TIMESTAMPS } from "../shared/defaults.js";
 import { EMPTY_UINT8ARRAY } from "../shared/bytes.js";
@@ -571,6 +571,12 @@ export class ZipDeflateFile {
             this._tapCallback(promise, callback);
             return promise;
         }
+        // If a previous async operation already failed, don't do more work.
+        if (this._completeError) {
+            const promise = Promise.reject(this._completeError);
+            this._tapCallback(promise, callback);
+            return promise;
+        }
         if (this._deflateWanted === null) {
             this._accumulateSampleLen(data);
             if (!this._shouldDecide(final)) {
@@ -613,7 +619,16 @@ export class ZipDeflateFile {
      * memory growth when callers push data in a tight synchronous loop.
      */
     push(data, final = false, callback) {
-        if (!this._deflate && this._encryptionMethod === "none") {
+        // Use the synchronous path only when:
+        //  1. No async deflate stream is already active
+        //  2. No encryption (which requires async crypto)
+        //  3. No native async deflate available (browser CompressionStream)
+        //
+        // When a native async CompressionStream("deflate-raw") is available
+        // (modern browsers), prefer the async path — it produces better
+        // compression (Dynamic Huffman via the browser's native engine) and
+        // doesn't block the main thread.
+        if (!this._deflate && this._encryptionMethod === "none" && !hasNativeAsyncDeflate()) {
             try {
                 this._pushSyncPath(data, final);
                 callback?.();
@@ -624,7 +639,10 @@ export class ZipDeflateFile {
             }
             return Promise.resolve();
         }
-        const promise = (this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback)));
+        // Chain the async push so calls are serialized. Use a recovery wrapper
+        // so that a single failed push does not break the chain for subsequent
+        // pushes — errors are surfaced via onerror/rejectComplete instead.
+        const promise = (this._pushChain = this._pushChain.then(() => this._pushUnchained(data, final, callback), () => this._pushUnchained(data, final, callback)));
         // Prevent unhandled rejection when callers intentionally ignore the Promise.
         promise.catch(() => { });
         return promise;
@@ -695,6 +713,12 @@ export class ZipDeflateFile {
             this._syncDeflater = null;
         }
         this._emitDataDescriptor();
+        // _emitDataDescriptor may call _rejectComplete instead of throwing
+        // (e.g. ZIP64 required but zip64=false). In the sync path, surface
+        // this as a throw so push() can reject properly.
+        if (this._completeError) {
+            throw this._completeError;
+        }
     }
     /**
      * Emit local file header with Data Descriptor flag

package/dist/browser/modules/excel/workbook.browser.d.ts

@@ -16,6 +16,7 @@ import { WorkbookWriter, type WorkbookWriterOptions } from "./stream/workbook-wr
 import { WorkbookReader, type WorkbookReaderOptions } from "./stream/workbook-reader.js";
 import { type DateFormat } from "../../utils/datetime.js";
 import type { CsvParseOptions, CsvFormatOptions } from "../csv/types.js";
+import type { MarkdownOptions } from "../markdown/types.js";
 import type { Readable } from "../stream/index.js";
 import type { IReadable, IWritable } from "../stream/types.js";
 import type { PivotTable } from "./pivot-table.js";
@@ -253,6 +254,77 @@ declare class Workbook {
     private _readCsvFile;
     private _readCsvBlob;
     private _writeCsvString;
+    /**
+     * Populate a worksheet from a parsed Markdown table result.
+     * Shared by readMarkdown and readMarkdownAll.
+     */
+    private _populateMarkdownWorksheet;
+    /**
+     * Read a Markdown table and add as worksheet.
+     *
+     * @example
+     * ```ts
+     * // From a Markdown string
+     * workbook.readMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+     *
+     * // With options
+     * workbook.readMarkdown(markdownString, { sheetName: "Data", map: (v, col) => Number(v) || v });
+     * ```
+     */
+    readMarkdown(input: string, options?: MarkdownOptions): Worksheet;
+    /**
+     * Read all Markdown tables from a document, each becoming a separate worksheet.
+     *
+     * @param input - Markdown string containing one or more tables
+     * @param options - Parse options (sheetName is used as prefix: "sheetName", "sheetName_2", ...)
+     * @returns Array of created worksheets (empty if no tables found)
+     *
+     * @example
+     * ```ts
+     * // Parse a document with multiple tables
+     * const sheets = workbook.readMarkdownAll(markdownDoc);
+     * console.log(`Created ${sheets.length} worksheets`);
+     *
+     * // With a naming prefix
+     * const sheets = workbook.readMarkdownAll(markdownDoc, { sheetName: "Table" });
+     * // Creates "Table", "Table_2", "Table_3", ...
+     * ```
+     */
+    readMarkdownAll(input: string, options?: MarkdownOptions): Worksheet[];
+    /**
+     * Write worksheet as a Markdown table string.
+     *
+     * @example
+     * ```ts
+     * // Write first worksheet
+     * const markdownText = workbook.writeMarkdown();
+     *
+     * // Write specific worksheet with options
+     * const markdownText = workbook.writeMarkdown({ sheetName: "Data", padding: true });
+     * ```
+     */
+    writeMarkdown(options?: MarkdownOptions): string;
+    /**
+     * Write worksheet to Markdown buffer (Uint8Array).
+     *
+     * @example
+     * ```ts
+     * const buffer = workbook.writeMarkdownBuffer();
+     * ```
+     */
+    writeMarkdownBuffer(options?: MarkdownOptions): Uint8Array;
+    /**
+     * Read Markdown from file (Node.js only - throws in browser)
+     */
+    readMarkdownFile(_filename: string, _options?: MarkdownOptions): Promise<Worksheet>;
+    /**
+     * Read all Markdown tables from file (Node.js only - throws in browser)
+     */
+    readMarkdownAllFile(_filename: string, _options?: MarkdownOptions): Promise<Worksheet[]>;
+    /**
+     * Write Markdown to file (Node.js only - throws in browser)
+     */
+    writeMarkdownFile(_filename: string, _options?: MarkdownOptions): Promise<void>;
     /**
      * Create a streaming workbook writer for large files.
      * This is more memory-efficient than using Workbook for large datasets.

package/dist/browser/modules/excel/workbook.browser.js

@@ -19,6 +19,8 @@ import { parseCsv } from "../csv/parse/index.js";
 import { formatCsv } from "../csv/format/index.js";
 import { CsvParserStream, CsvFormatterStream } from "../csv/stream/index.js";
 import { parseNumberFromCsv } from "../csv/utils/number.js";
+import { parseMarkdown, parseMarkdownAll } from "../markdown/parse/index.js";
+import { formatMarkdown } from "../markdown/format/index.js";
 import { ExcelDownloadError, ExcelNotSupportedError } from "./errors.js";
 import { pipeline } from "../stream/index.browser.js";
 import { readableStreamToAsyncIterable } from "../stream/utils.base.js";
@@ -113,6 +115,57 @@ function createDefaultWriteMapper(dateFormat, dateUTC) {
     };
 }
 // =============================================================================
+// Markdown Value Mapper (Internal)
+// =============================================================================
+/**
+ * Create a stringify function for Markdown output.
+ * Handles hyperlinks, formulas, rich text, dates, errors, and objects.
+ */
+function createMarkdownStringify(dateFormat, dateUTC) {
+    const formatter = dateFormat
+        ? DateFormatter.create(dateFormat, { utc: dateUTC })
+        : DateFormatter.iso(dateUTC);
+    return function stringify(value) {
+        if (value === null || value === undefined) {
+            return "";
+        }
+        if (typeof value === "string") {
+            return value;
+        }
+        if (typeof value === "number" || typeof value === "bigint") {
+            return String(value);
+        }
+        if (typeof value === "boolean") {
+            return value ? "true" : "false";
+        }
+        if (value instanceof Date) {
+            return formatter.format(value);
+        }
+        if (typeof value === "object") {
+            const v = value;
+            if (v.text || v.hyperlink) {
+                return v.hyperlink || v.text || "";
+            }
+            if (v.formula || v.result) {
+                return v.result != null ? String(v.result) : "";
+            }
+            if (v.richText && Array.isArray(v.richText)) {
+                return v.richText.map((r) => r.text).join("");
+            }
+            if (v.error) {
+                return v.error;
+            }
+            try {
+                return JSON.stringify(value);
+            }
+            catch {
+                return "[object Object]";
+            }
+        }
+        return String(value);
+    };
+}
+// =============================================================================
 // CSV Input Type Detection (Internal)
 // =============================================================================
 function isUrl(input) {
@@ -560,6 +613,179 @@ class Workbook {
         formatter.end();
         await pipelinePromise;
     }
+    /**
+     * Populate a worksheet from a parsed Markdown table result.
+     * Shared by readMarkdown and readMarkdownAll.
+     */
+    _populateMarkdownWorksheet(worksheet, result, map) {
+        worksheet.addRow(result.headers);
+        worksheet._markdownAlignments = result.alignments;
+        for (const row of result.rows) {
+            if (map) {
+                worksheet.addRow(row.map((v, i) => map(v, i)));
+            }
+            else {
+                worksheet.addRow(row);
+            }
+        }
+    }
+    /**
+     * Read a Markdown table and add as worksheet.
+     *
+     * @example
+     * ```ts
+     * // From a Markdown string
+     * workbook.readMarkdown("| Name | Age |\n| --- | --- |\n| Alice | 30 |");
+     *
+     * // With options
+     * workbook.readMarkdown(markdownString, { sheetName: "Data", map: (v, col) => Number(v) || v });
+     * ```
+     */
+    readMarkdown(input, options) {
+        const parseResult = parseMarkdown(input, {
+            trim: options?.trim,
+            unescape: options?.unescape,
+            skipEmptyRows: options?.skipEmptyRows,
+            maxRows: options?.maxRows,
+            convertBr: options?.convertBr
+        });
+        const worksheet = this.addWorksheet(options?.sheetName);
+        this._populateMarkdownWorksheet(worksheet, parseResult, options?.map);
+        return worksheet;
+    }
+    /**
+     * Read all Markdown tables from a document, each becoming a separate worksheet.
+     *
+     * @param input - Markdown string containing one or more tables
+     * @param options - Parse options (sheetName is used as prefix: "sheetName", "sheetName_2", ...)
+     * @returns Array of created worksheets (empty if no tables found)
+     *
+     * @example
+     * ```ts
+     * // Parse a document with multiple tables
+     * const sheets = workbook.readMarkdownAll(markdownDoc);
+     * console.log(`Created ${sheets.length} worksheets`);
+     *
+     * // With a naming prefix
+     * const sheets = workbook.readMarkdownAll(markdownDoc, { sheetName: "Table" });
+     * // Creates "Table", "Table_2", "Table_3", ...
+     * ```
+     */
+    readMarkdownAll(input, options) {
+        const parseResults = parseMarkdownAll(input, {
+            trim: options?.trim,
+            unescape: options?.unescape,
+            skipEmptyRows: options?.skipEmptyRows,
+            maxRows: options?.maxRows,
+            convertBr: options?.convertBr
+        });
+        const baseName = options?.sheetName;
+        const map = options?.map;
+        const worksheets = [];
+        for (let t = 0; t < parseResults.length; t++) {
+            const name = baseName ? (t === 0 ? baseName : `${baseName}_${t + 1}`) : undefined;
+            const worksheet = this.addWorksheet(name);
+            this._populateMarkdownWorksheet(worksheet, parseResults[t], map);
+            worksheets.push(worksheet);
+        }
+        return worksheets;
+    }
+    /**
+     * Write worksheet as a Markdown table string.
+     *
+     * @example
+     * ```ts
+     * // Write first worksheet
+     * const markdownText = workbook.writeMarkdown();
+     *
+     * // Write specific worksheet with options
+     * const markdownText = workbook.writeMarkdown({ sheetName: "Data", padding: true });
+     * ```
+     */
+    writeMarkdown(options) {
+        const worksheet = this.getWorksheet(options?.sheetName || options?.sheetId);
+        if (!worksheet) {
+            return "";
+        }
+        const dateFormat = options?.dateFormat;
+        const dateUTC = options?.dateUTC;
+        const includeEmptyRows = options?.includeEmptyRows !== false;
+        // Build stringify function
+        const stringify = options?.stringify ?? createMarkdownStringify(dateFormat, dateUTC);
+        // Collect all rows from worksheet
+        const allRows = [];
+        let lastRow = 1;
+        worksheet.eachRow((row, rowNumber) => {
+            if (includeEmptyRows) {
+                while (lastRow++ < rowNumber - 1) {
+                    allRows.push([]);
+                }
+            }
+            // row.values is a 1-indexed sparse array — use Array.from to fill holes
+            // with undefined, then slice(1) to remove the leading 1-indexed slot
+            const values = Array.from(row.values).slice(1);
+            allRows.push(values);
+            lastRow = rowNumber;
+        });
+        if (allRows.length === 0) {
+            return "";
+        }
+        // First row is the header
+        const headerRow = allRows[0];
+        const headers = headerRow.map(v => stringify(v));
+        const dataRows = allRows.slice(1);
+        // Check for stored alignments from a previous readMarkdown
+        const storedAlignments = worksheet
+            ._markdownAlignments;
+        // Build column configs
+        const columns = options?.columns;
+        let resolvedColumns;
+        if (!columns && storedAlignments) {
+            // Use stored alignments from parsed Markdown
+            resolvedColumns = headers.map((h, i) => ({
+                header: h,
+                alignment: i < storedAlignments.length ? storedAlignments[i] : undefined
+            }));
+        }
+        return formatMarkdown(headers, dataRows, {
+            columns: resolvedColumns ?? columns,
+            alignment: options?.alignment,
+            padding: options?.padding,
+            trailingNewline: options?.trailingNewline,
+            escapeContent: options?.escapeContent,
+            stringify
+        });
+    }
+    /**
+     * Write worksheet to Markdown buffer (Uint8Array).
+     *
+     * @example
+     * ```ts
+     * const buffer = workbook.writeMarkdownBuffer();
+     * ```
+     */
+    writeMarkdownBuffer(options) {
+        const markdownString = this.writeMarkdown(options);
+        return new TextEncoder().encode(markdownString);
+    }
+    /**
+     * Read Markdown from file (Node.js only - throws in browser)
+     */
+    async readMarkdownFile(_filename, _options) {
+        throw new ExcelNotSupportedError("readMarkdownFile()", "not available in browser. Use readMarkdown(string) instead.");
+    }
+    /**
+     * Read all Markdown tables from file (Node.js only - throws in browser)
+     */
+    async readMarkdownAllFile(_filename, _options) {
+        throw new ExcelNotSupportedError("readMarkdownAllFile()", "not available in browser. Use readMarkdownAll(string) instead.");
+    }
+    /**
+     * Write Markdown to file (Node.js only - throws in browser)
+     */
+    async writeMarkdownFile(_filename, _options) {
+        throw new ExcelNotSupportedError("writeMarkdownFile()", "not available in browser. Use writeMarkdown() and trigger a download instead.");
+    }
     // ===========================================================================
     // Static Factory Methods for Streaming
     // ===========================================================================

package/dist/browser/modules/excel/workbook.d.ts

@@ -1,10 +1,11 @@
 /**
  * Workbook - Node.js Version
  *
- * Extends browser Workbook with Node.js file system support for CSV operations.
+ * Extends browser Workbook with Node.js file system support for CSV and Markdown operations.
  */
 import { Workbook as WorkbookBrowser, type CsvOptions } from "./workbook.browser.js";
 import type { Worksheet } from "./worksheet.js";
+import type { MarkdownOptions } from "../markdown/types.js";
 declare class Workbook extends WorkbookBrowser {
     /**
      * Read CSV from file (Node.js only)
@@ -27,6 +28,36 @@ declare class Workbook extends WorkbookBrowser {
      * ```
      */
     writeCsvFile(filename: string, options?: CsvOptions): Promise<void>;
+    /**
+     * Read Markdown table from file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownFile("table.md");
+     * await workbook.readMarkdownFile("table.md", { sheetName: "Data" });
+     * ```
+     */
+    readMarkdownFile(filename: string, options?: MarkdownOptions): Promise<Worksheet>;
+    /**
+     * Read all Markdown tables from file, each as a separate worksheet (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownAllFile("doc.md");
+     * await workbook.readMarkdownAllFile("doc.md", { sheetName: "Table" });
+     * ```
+     */
+    readMarkdownAllFile(filename: string, options?: MarkdownOptions): Promise<Worksheet[]>;
+    /**
+     * Write Markdown table to file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.writeMarkdownFile("output.md");
+     * await workbook.writeMarkdownFile("output.md", { sheetName: "Data", padding: true });
+     * ```
+     */
+    writeMarkdownFile(filename: string, options?: MarkdownOptions): Promise<void>;
 }
 export { Workbook };
 export type { CsvOptions, CsvInput, WorkbookModel, WorkbookMedia } from "./workbook.browser.js";

package/dist/browser/modules/excel/workbook.js

@@ -1,9 +1,9 @@
 /**
  * Workbook - Node.js Version
  *
- * Extends browser Workbook with Node.js file system support for CSV operations.
+ * Extends browser Workbook with Node.js file system support for CSV and Markdown operations.
  */
-import { fileExists, createReadStream, createWriteStream } from "../../utils/fs.browser.js";
+import { fileExists, createReadStream, createWriteStream, readFileText, writeFileText } from "../../utils/fs.browser.js";
 import { Workbook as WorkbookBrowser } from "./workbook.browser.js";
 import { ExcelFileError } from "./errors.js";
 // =============================================================================
@@ -57,5 +57,50 @@ class Workbook extends WorkbookBrowser {
         }
         return this._writeCsvStream(writeStream, options);
     }
+    /**
+     * Read Markdown table from file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownFile("table.md");
+     * await workbook.readMarkdownFile("table.md", { sheetName: "Data" });
+     * ```
+     */
+    async readMarkdownFile(filename, options) {
+        if (!(await fileExists(filename))) {
+            throw new ExcelFileError(filename, "read", "file not found");
+        }
+        const content = await readFileText(filename);
+        return this.readMarkdown(content, options);
+    }
+    /**
+     * Read all Markdown tables from file, each as a separate worksheet (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.readMarkdownAllFile("doc.md");
+     * await workbook.readMarkdownAllFile("doc.md", { sheetName: "Table" });
+     * ```
+     */
+    async readMarkdownAllFile(filename, options) {
+        if (!(await fileExists(filename))) {
+            throw new ExcelFileError(filename, "read", "file not found");
+        }
+        const content = await readFileText(filename);
+        return this.readMarkdownAll(content, options);
+    }
+    /**
+     * Write Markdown table to file (Node.js only)
+     *
+     * @example
+     * ```ts
+     * await workbook.writeMarkdownFile("output.md");
+     * await workbook.writeMarkdownFile("output.md", { sheetName: "Data", padding: true });
+     * ```
+     */
+    async writeMarkdownFile(filename, options) {
+        const markdownString = this.writeMarkdown(options);
+        await writeFileText(filename, markdownString);
+    }
 }
 export { Workbook };

package/dist/browser/modules/excel/xlsx/xlsx.browser.js

@@ -46,6 +46,13 @@ class StreamingZipWriterAdapter {
         // Backpressure tracking
         this._needsDrain = false;
         this._drainResolvers = [];
+        // Count of in-flight async write() calls whose backpressure result is unknown.
+        // waitForDrain() must wait for this to reach 0 before checking _needsDrain.
+        this._pendingWrites = 0;
+        this._pendingWriteResolvers = [];
+        // Buffer errors that occur before _finalize registers its error listener,
+        // so async compression errors during writeToZip() are never silently lost.
+        this._earlyError = null;
         this.level = options?.level ?? 6;
         this.modTime = options?.modTime;
         this.timestamps = options?.timestamps;
@@ -69,6 +76,15 @@ class StreamingZipWriterAdapter {
         });
     }
     _emit(event, ...args) {
+        // Buffer error events that fire before any listener is registered,
+        // so _finalize() can surface them even if it registers late.
+        if (event === "error") {
+            const callbacks = this.events.get(event);
+            if (!callbacks || callbacks.size === 0) {
+                this._earlyError = args[0] instanceof Error ? args[0] : new Error(String(args[0]));
+                return;
+            }
+        }
         const callbacks = this.events.get(event);
         if (!callbacks) {
             return;
@@ -83,12 +99,21 @@ class StreamingZipWriterAdapter {
      */
     _checkBackpressure(ok) {
         if (ok instanceof Promise) {
+            this._pendingWrites++;
             ok.then(result => {
                 if (result === false) {
                     this._needsDrain = true;
                 }
             }, () => { } // write errors surface via the stream's error event
-            );
+            ).finally(() => {
+                this._pendingWrites--;
+                if (this._pendingWrites === 0) {
+                    const resolvers = this._pendingWriteResolvers.splice(0);
+                    for (const resolve of resolvers) {
+                        resolve();
+                    }
+                }
+            });
             return;
         }
         if (ok === false) {
@@ -99,6 +124,12 @@ class StreamingZipWriterAdapter {
         const callbacks = this.events.get(event) || new Set();
         callbacks.add(callback);
         this.events.set(event, callbacks);
+        // If an error was buffered before any listener was registered, deliver it now.
+        if (event === "error" && this._earlyError) {
+            const err = this._earlyError;
+            this._earlyError = null;
+            callback(err);
+        }
         return this;
     }
     once(event, callback) {
@@ -134,11 +165,18 @@ class StreamingZipWriterAdapter {
     }
     /**
      * Wait for the downstream writable to drain if it signaled backpressure.
-     * Resolves immediately if no backpressure is active.
+     * If any write() calls are still in-flight (returned a Promise that hasn't
+     * settled), waits for all of them first so the backpressure signal isn't missed.
      */
-    waitForDrain() {
+    async waitForDrain() {
+        // Wait for all in-flight async writes to settle so _needsDrain is up to date.
+        if (this._pendingWrites > 0) {
+            await new Promise(resolve => {
+                this._pendingWriteResolvers.push(resolve);
+            });
+        }
         if (!this._needsDrain || !this.pipedStream) {
-            return Promise.resolve();
+            return;
         }
         return new Promise(resolve => {
             this._drainResolvers.push(resolve);