@cj-tech-master/excelts 6.0.0-beta.4 → 6.0.0-beta.5

package/dist/cjs/modules/archive/{io → unzip}/remote-zip-reader.js

@@ -19,13 +19,13 @@ exports.RemoteZipReader = exports.Crc32MismatchError = void 0;
 const binary_1 = require("../zip-spec/binary.js");
 const crc32_1 = require("../compression/crc32.js");
 const crypto_1 = require("../crypto/index.js");
-const zip_extract_core_1 = require("../unzip/zip-extract-core.js");
+const zip_extract_core_1 = require("./zip-extract-core.js");
 const bytes_1 = require("../shared/bytes.js");
-const archive_sink_1 = require("./archive-sink.js");
+const archive_sink_1 = require("../io/archive-sink.js");
 const zip_parser_core_1 = require("../zip-spec/zip-parser-core.js");
 const text_1 = require("../shared/text.js");
 const zip_records_1 = require("../zip-spec/zip-records.js");
-const random_access_1 = require("./random-access");
+const random_access_1 = require("../io/random-access.js");
 /**
  * Error thrown when CRC32 validation fails
  */

package/dist/cjs/modules/archive/unzip/zip-reader.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipReader = exports.UnzipEntry = void 0;
-exports.createZipReader = createZipReader;
 const zip_parser_1 = require("./zip-parser.js");
 const zip_extract_core_1 = require("./zip-extract-core.js");
 const stream_1 = require("./stream.js");
@@ -521,6 +520,3 @@ class ZipReader {
     }
 }
 exports.ZipReader = ZipReader;
-function createZipReader(source, options) {
-    return new ZipReader(source, options);
-}

package/dist/cjs/modules/archive/zip/index.js

@@ -1,8 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipArchive = exports.ZipEditPlan = exports.editZipUrl = exports.editZip = exports.ZipEditor = void 0;
-exports.zip = zip;
-const formats_1 = require("../formats/index.js");
 var zip_editor_1 = require("./zip-editor");
 Object.defineProperty(exports, "ZipEditor", { enumerable: true, get: function () { return zip_editor_1.ZipEditor; } });
 Object.defineProperty(exports, "editZip", { enumerable: true, get: function () { return zip_editor_1.editZip; } });
@@ -11,6 +9,3 @@ var zip_edit_plan_1 = require("./zip-edit-plan");
 Object.defineProperty(exports, "ZipEditPlan", { enumerable: true, get: function () { return zip_edit_plan_1.ZipEditPlan; } });
 var zip_archive_1 = require("./zip-archive");
 Object.defineProperty(exports, "ZipArchive", { enumerable: true, get: function () { return zip_archive_1.ZipArchive; } });
-function zip(options) {
-    return (0, formats_1.createArchive)(options);
-}

package/dist/cjs/modules/archive/zip/zip-archive.js

@@ -1,15 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZipArchive = void 0;
-exports.createZipArchive = createZipArchive;
 const defaults_1 = require("../shared/defaults.js");
 const stream_1 = require("./stream.js");
 const zip_bytes_1 = require("./zip-bytes.js");
 const archive_sink_1 = require("../io/archive-sink.js");
 const archive_source_1 = require("../io/archive-source.js");
-const async_queue_1 = require("../shared/async-queue.js");
 const errors_1 = require("../shared/errors.js");
-const progress_1 = require("../shared/progress.js");
+const zip_output_pipeline_1 = require("./zip-output-pipeline");
 const binary_1 = require("../../../utils/binary.js");
 const zip_records_1 = require("../zip-spec/zip-records.js");
 const env_1 = require("../../../utils/env.js");
@@ -92,147 +90,53 @@ class ZipArchive {
         const signalOpt = options.signal ?? this._streamDefaults.signal;
         const onProgress = options.onProgress ?? this._streamDefaults.onProgress;
         const progressIntervalMs = options.progressIntervalMs ?? this._streamDefaults.progressIntervalMs;
-        const { controller, cleanup: cleanupAbortLink } = (0, errors_1.createLinkedAbortController)(signalOpt);
-        const signal = controller.signal;
-        const progress = new progress_1.ProgressEmitter({
-            type: "zip",
-            phase: "running",
-            entriesTotal: this._entries.length,
-            entriesDone: 0,
-            bytesIn: 0,
-            bytesOut: 0,
-            zip64: this._options.zip64
-        }, onProgress, { intervalMs: progressIntervalMs });
-        const queue = (0, async_queue_1.createAsyncQueue)({
-            onCancel: () => {
-                // Consumer stopped reading; abort upstream work to avoid buffering.
-                try {
-                    controller.abort("cancelled");
-                }
-                catch {
-                    // ignore
-                }
-            }
-        });
-        const zip = new stream_1.StreamingZip((err, data, final) => {
-            if (err) {
-                progress.update({ phase: progress.snapshot.phase === "aborted" ? "aborted" : "error" });
-                queue.fail(err);
-                return;
-            }
-            if (data.length) {
-                progress.mutate(s => {
-                    s.bytesOut += data.length;
-                });
-                queue.push(data);
-            }
-            if (final) {
-                if (progress.snapshot.phase === "running") {
-                    progress.update({ phase: "done" });
-                }
-                queue.close();
-            }
-        }, {
+        return (0, zip_output_pipeline_1.createZipOperation)(this._entries.length, {
             comment: this._options.comment,
             zip64: this._options.zip64,
             encoding: this._options.encoding
-        });
-        const onAbort = () => {
-            const err = (0, errors_1.createAbortError)(signal.reason);
-            progress.update({ phase: "aborted" });
-            try {
-                zip.abort(err);
-            }
-            catch {
-                // ignore
-            }
-            queue.fail(err);
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-        (async () => {
-            try {
-                for (let i = 0; i < this._entries.length; i++) {
-                    (0, errors_1.throwIfAborted)(signal);
-                    const entry = this._entries[i];
-                    let entryBytesIn = 0;
-                    progress.update({ currentEntry: { name: entry.name, index: i, bytesIn: 0 } });
-                    const file = new stream_1.ZipDeflateFile(entry.name, (0, zip_entry_options_1.buildZipDeflateFileOptions)(entry.options, {
-                        level: this._options.level,
-                        modTime: this._options.modTime,
-                        timestamps: this._options.timestamps,
-                        smartStore: this._options.smartStore,
-                        zip64: this._options.zip64,
-                        path: this._options.path,
-                        encoding: this._options.encoding
-                    }));
-                    zip.add(file);
-                    const onChunk = (chunk) => {
-                        entryBytesIn += chunk.length;
-                        progress.mutate(s => {
-                            s.bytesIn += chunk.length;
-                            s.currentEntry = { name: entry.name, index: i, bytesIn: entryBytesIn };
-                        });
-                    };
-                    if ((0, archive_source_1.isSyncArchiveSource)(entry.source)) {
-                        const bytes = (0, archive_source_1.toUint8ArraySync)(entry.source);
-                        (0, errors_1.throwIfAborted)(signal);
-                        onChunk(bytes);
-                        await file.push(bytes, true);
-                    }
-                    else {
-                        for await (const chunk of (0, archive_source_1.toAsyncIterable)(entry.source, { signal, onChunk })) {
-                            (0, errors_1.throwIfAborted)(signal);
-                            await file.push(chunk, false);
-                        }
-                        (0, errors_1.throwIfAborted)(signal);
-                        await file.push(new Uint8Array(0), true);
-                    }
-                    await file.complete();
-                    progress.set("entriesDone", progress.snapshot.entriesDone + 1);
-                }
+        }, { signal: signalOpt, onProgress, progressIntervalMs }, async ({ zip, signal, progress }) => {
+            for (let i = 0; i < this._entries.length; i++) {
                 (0, errors_1.throwIfAborted)(signal);
-                zip.end();
-            }
-            catch (e) {
-                const err = (0, errors_1.toError)(e);
-                if (err.name === "AbortError") {
-                    progress.update({ phase: "aborted" });
-                    try {
-                        zip.abort(err);
-                    }
-                    catch {
-                        // ignore
-                    }
+                const entry = this._entries[i];
+                let entryBytesIn = 0;
+                progress.update({ currentEntry: { name: entry.name, index: i, bytesIn: 0 } });
+                const file = new stream_1.ZipDeflateFile(entry.name, (0, zip_entry_options_1.buildZipDeflateFileOptions)(entry.options, {
+                    level: this._options.level,
+                    modTime: this._options.modTime,
+                    timestamps: this._options.timestamps,
+                    smartStore: this._options.smartStore,
+                    zip64: this._options.zip64,
+                    path: this._options.path,
+                    encoding: this._options.encoding
+                }));
+                zip.add(file);
+                const onChunk = (chunk) => {
+                    entryBytesIn += chunk.length;
+                    progress.mutate(s => {
+                        s.bytesIn += chunk.length;
+                        s.currentEntry = { name: entry.name, index: i, bytesIn: entryBytesIn };
+                    });
+                };
+                if ((0, archive_source_1.isSyncArchiveSource)(entry.source)) {
+                    const bytes = (0, archive_source_1.toUint8ArraySync)(entry.source);
+                    (0, errors_1.throwIfAborted)(signal);
+                    onChunk(bytes);
+                    await file.push(bytes, true);
                 }
                 else {
-                    progress.update({ phase: "error" });
-                }
-                queue.fail(err);
-            }
-            finally {
-                try {
-                    signal.removeEventListener("abort", onAbort);
-                }
-                catch {
-                    // ignore
+                    for await (const chunk of (0, archive_source_1.toAsyncIterable)(entry.source, { signal, onChunk })) {
+                        (0, errors_1.throwIfAborted)(signal);
+                        await file.push(chunk, false);
+                    }
+                    (0, errors_1.throwIfAborted)(signal);
+                    await file.push(new Uint8Array(0), true);
                 }
-                cleanupAbortLink();
-                progress.emitNow();
+                await file.complete();
+                progress.set("entriesDone", progress.snapshot.entriesDone + 1);
             }
-        })();
-        return {
-            iterable: queue.iterable,
-            signal,
-            abort(reason) {
-                controller.abort(reason);
-            },
-            pointer() {
-                return progress.snapshot.bytesOut;
-            },
-            progress() {
-                return progress.snapshotCopy();
-            }
-        };
+            (0, errors_1.throwIfAborted)(signal);
+            zip.end();
+        });
     }
     /**
      * Browser-only fast path: stream sources through CompressionStream while
@@ -448,6 +352,3 @@ class ZipArchive {
     }
 }
 exports.ZipArchive = ZipArchive;
-function createZipArchive(options) {
-    return new ZipArchive(options);
-}

package/dist/cjs/modules/archive/zip/zip-editor.js

@@ -7,12 +7,11 @@ const timestamps_1 = require("../zip-spec/timestamps.js");
 const text_1 = require("../shared/text.js");
 const defaults_1 = require("../shared/defaults.js");
 const random_access_1 = require("../io/random-access.js");
-const remote_zip_reader_1 = require("../io/remote-zip-reader.js");
+const remote_zip_reader_1 = require("../unzip/remote-zip-reader.js");
 const archive_source_1 = require("../io/archive-source.js");
 const archive_sink_1 = require("../io/archive-sink.js");
-const async_queue_1 = require("../shared/async-queue.js");
 const errors_1 = require("../shared/errors.js");
-const progress_1 = require("../shared/progress.js");
+const zip_output_pipeline_1 = require("./zip-output-pipeline");
 const stream_1 = require("./stream.js");
 const zip_bytes_1 = require("./zip-bytes.js");
 const zip_records_1 = require("../zip-spec/zip-records.js");
@@ -365,226 +364,137 @@ class ZipEditor {
         const signalOpt = options.signal ?? this._streamDefaults.signal;
         const onProgress = options.onProgress ?? this._streamDefaults.onProgress;
         const progressIntervalMs = options.progressIntervalMs ?? this._streamDefaults.progressIntervalMs;
-        const { controller, cleanup: cleanupAbortLink } = (0, errors_1.createLinkedAbortController)(signalOpt);
-        const signal = controller.signal;
         const preservedMeta = this._buildRawPreservedEntries();
         const sets = this._buildSetEntries();
-        const preservedRaw = [];
-        const preservedRecompressed = [];
-        for (const p of preservedMeta) {
-            const compressedData = this._remote.getRawCompressedStream(p.info.path, { signal });
-            if (compressedData) {
-                preservedRaw.push({ ...p, compressedData });
-                continue;
-            }
-            this._emitWarning(p.info.path, "raw_unavailable", `Cannot read raw compressed payload for entry "${p.info.path}".`);
-            if (this._options.preserve === "strict") {
-                throw new Error(`Cannot preserve entry "${p.info.path}" because its raw compressed payload is unavailable.`);
+        return (0, zip_output_pipeline_1.createZipOperation)(preservedMeta.length + sets.length, {
+            comment: this._options.comment,
+            zip64: this._options.zip64,
+            codec: this._stringCodec
+        }, { signal: signalOpt, onProgress, progressIntervalMs }, async ({ zip, signal, progress }) => {
+            // Classify preserved entries using the pipeline's linked signal so that
+            // abort() properly cancels raw compressed streams.
+            const preservedRaw = [];
+            const preservedRecompressed = [];
+            for (const p of preservedMeta) {
+                const compressedData = this._remote.getRawCompressedStream(p.info.path, { signal });
+                if (compressedData) {
+                    preservedRaw.push({ ...p, compressedData });
+                    continue;
+                }
+                this._emitWarning(p.info.path, "raw_unavailable", `Cannot read raw compressed payload for entry "${p.info.path}".`);
+                if (this._options.preserve === "strict") {
+                    throw new Error(`Cannot preserve entry "${p.info.path}" because its raw compressed payload is unavailable.`);
+                }
+                // We cannot re-encrypt entries; best-effort must not silently output decrypted content.
+                if (p.info.isEncrypted) {
+                    this._emitWarning(p.info.path, "encryption_unsupported", `Cannot best-effort preserve encrypted entry "${p.info.path}" without raw passthrough.`);
+                    continue;
+                }
+                // Best-effort fallback: extract and re-add the entry.
+                preservedRecompressed.push({ name: p.outName, info: p.info });
             }
-            // We cannot re-encrypt entries; best-effort must not silently output decrypted content.
-            if (p.info.isEncrypted) {
-                this._emitWarning(p.info.path, "encryption_unsupported", `Cannot best-effort preserve encrypted entry "${p.info.path}" without raw passthrough.`);
-                continue;
+            // Update entriesTotal now that we know how many entries survived classification.
+            const actualTotal = preservedRaw.length + preservedRecompressed.length + sets.length;
+            progress.set("entriesTotal", actualTotal);
+            // 1) Preserved entries: passthrough raw payload.
+            for (let i = 0; i < preservedRaw.length; i++) {
+                (0, errors_1.throwIfAborted)(signal);
+                const entry = preservedRaw[i];
+                progress.update({ currentEntry: { name: entry.outName, index: i, bytesIn: 0 } });
+                const rawFile = this._buildPreservedRawFile(entry.outName, entry.info, entry.compressedData, this._options.zip64);
+                zip.add(rawFile);
+                // StreamingZip auto-starts passthrough files; await completion for accurate progress.
+                await rawFile.done();
+                progress.set("entriesDone", progress.snapshot.entriesDone + 1);
             }
-            // Best-effort fallback: extract and re-add the entry.
-            // This may require holding the entry in memory.
-            preservedRecompressed.push({ name: p.outName, info: p.info });
-        }
-        const progress = new progress_1.ProgressEmitter({
-            type: "zip",
-            phase: "running",
-            entriesTotal: preservedRaw.length + preservedRecompressed.length + sets.length,
-            entriesDone: 0,
-            bytesIn: 0,
-            bytesOut: 0,
-            zip64: this._options.zip64
-        }, onProgress, { intervalMs: progressIntervalMs });
-        const queue = (0, async_queue_1.createAsyncQueue)({
-            onCancel: () => {
+            // 1b) Best-effort preserved entries: extract and re-add.
+            for (let k = 0; k < preservedRecompressed.length; k++) {
+                (0, errors_1.throwIfAborted)(signal);
+                const idx = preservedRaw.length + k;
+                const entry = preservedRecompressed[k];
+                let entryBytesIn = 0;
+                progress.update({ currentEntry: { name: entry.name, index: idx, bytesIn: 0 } });
+                let data;
                 try {
-                    controller.abort("cancelled");
+                    data = await this._remote.extractEntry(entry.info);
                 }
-                catch {
-                    // ignore
+                catch (e) {
+                    const err = (0, errors_1.toError)(e);
+                    this._emitWarning(entry.info.path, "unknown", `Failed to extract entry "${entry.info.path}" for best-effort preserve: ${err.message}`);
+                    progress.set("entriesDone", progress.snapshot.entriesDone + 1);
+                    continue;
                 }
-            }
-        });
-        const zip = new stream_1.StreamingZip((err, data, final) => {
-            if (err) {
-                progress.update({ phase: progress.snapshot.phase === "aborted" ? "aborted" : "error" });
-                queue.fail(err);
-                return;
-            }
-            if (data.length) {
+                const fallbackLevel = entry.info.compressionMethod === 0 ? 0 : this._options.level;
+                const file = new stream_1.ZipDeflateFile(entry.name, (0, zip_entry_options_1.buildZipDeflateFileOptions)({
+                    level: fallbackLevel,
+                    modTime: entry.info.lastModified,
+                    comment: entry.info.comment,
+                    externalAttributes: entry.info.externalAttributes,
+                    versionMadeBy: entry.info.versionMadeBy
+                }, {
+                    level: this._options.level,
+                    modTime: this._options.modTime,
+                    timestamps: this._options.timestamps,
+                    smartStore: this._options.smartStore,
+                    zip64: this._options.zip64,
+                    path: this._options.path,
+                    encoding: this._options.encoding
+                }));
+                zip.add(file);
+                entryBytesIn += data.length;
                 progress.mutate(s => {
-                    s.bytesOut += data.length;
+                    s.bytesIn += data.length;
+                    s.currentEntry = { name: entry.name, index: idx, bytesIn: entryBytesIn };
                 });
-                queue.push(data);
-            }
-            if (final) {
-                if (progress.snapshot.phase === "running") {
-                    progress.update({ phase: "done" });
-                }
-                queue.close();
+                await file.push(data, true);
+                await file.complete();
+                progress.set("entriesDone", progress.snapshot.entriesDone + 1);
             }
-        }, {
-            comment: this._options.comment,
-            zip64: this._options.zip64,
-            codec: this._stringCodec
-        });
-        const onAbort = () => {
-            const err = (0, errors_1.createAbortError)(signal.reason);
-            progress.update({ phase: "aborted" });
-            try {
-                zip.abort(err);
-            }
-            catch {
-                // ignore
-            }
-            queue.fail(err);
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-        (async () => {
-            try {
-                // 1) Preserved entries: passthrough raw payload.
-                for (let i = 0; i < preservedRaw.length; i++) {
-                    (0, errors_1.throwIfAborted)(signal);
-                    const entry = preservedRaw[i];
-                    progress.update({ currentEntry: { name: entry.outName, index: i, bytesIn: 0 } });
-                    const rawFile = this._buildPreservedRawFile(entry.outName, entry.info, entry.compressedData, this._options.zip64);
-                    zip.add(rawFile);
-                    // StreamingZip auto-starts passthrough files; await completion for accurate progress.
-                    await rawFile.done();
-                    progress.set("entriesDone", progress.snapshot.entriesDone + 1);
-                }
-                // 1b) Best-effort preserved entries: extract and re-add.
-                for (let k = 0; k < preservedRecompressed.length; k++) {
-                    (0, errors_1.throwIfAborted)(signal);
-                    const idx = preservedRaw.length + k;
-                    const entry = preservedRecompressed[k];
-                    let entryBytesIn = 0;
-                    progress.update({ currentEntry: { name: entry.name, index: idx, bytesIn: 0 } });
-                    let data;
-                    try {
-                        data = await this._remote.extractEntry(entry.info);
-                    }
-                    catch (e) {
-                        const err = (0, errors_1.toError)(e);
-                        this._emitWarning(entry.info.path, "unknown", `Failed to extract entry "${entry.info.path}" for best-effort preserve: ${err.message}`);
-                        progress.set("entriesDone", progress.snapshot.entriesDone + 1);
-                        continue;
-                    }
-                    const fallbackLevel = entry.info.compressionMethod === 0 ? 0 : this._options.level;
-                    const file = new stream_1.ZipDeflateFile(entry.name, (0, zip_entry_options_1.buildZipDeflateFileOptions)({
-                        level: fallbackLevel,
-                        modTime: entry.info.lastModified,
-                        comment: entry.info.comment,
-                        externalAttributes: entry.info.externalAttributes,
-                        versionMadeBy: entry.info.versionMadeBy
-                    }, {
-                        level: this._options.level,
-                        modTime: this._options.modTime,
-                        timestamps: this._options.timestamps,
-                        smartStore: this._options.smartStore,
-                        zip64: this._options.zip64,
-                        path: this._options.path,
-                        encoding: this._options.encoding
-                    }));
-                    zip.add(file);
-                    entryBytesIn += data.length;
+            // 2) Set/update entries: compress from source.
+            for (let j = 0; j < sets.length; j++) {
+                (0, errors_1.throwIfAborted)(signal);
+                const idx = preservedRaw.length + preservedRecompressed.length + j;
+                const entry = sets[j];
+                let entryBytesIn = 0;
+                progress.update({ currentEntry: { name: entry.name, index: idx, bytesIn: 0 } });
+                const file = new stream_1.ZipDeflateFile(entry.name, (0, zip_entry_options_1.buildZipDeflateFileOptions)(entry.options, {
+                    level: this._options.level,
+                    modTime: this._options.modTime,
+                    timestamps: this._options.timestamps,
+                    smartStore: this._options.smartStore,
+                    zip64: this._options.zip64,
+                    path: this._options.path,
+                    encoding: this._options.encoding
+                }));
+                zip.add(file);
+                const onChunk = (chunk) => {
+                    entryBytesIn += chunk.length;
                     progress.mutate(s => {
-                        s.bytesIn += data.length;
+                        s.bytesIn += chunk.length;
                         s.currentEntry = { name: entry.name, index: idx, bytesIn: entryBytesIn };
                     });
-                    await file.push(data, true);
-                    await file.complete();
-                    progress.set("entriesDone", progress.snapshot.entriesDone + 1);
-                }
-                // 2) Set/update entries: compress from source.
-                for (let j = 0; j < sets.length; j++) {
+                };
+                if ((0, archive_source_1.isSyncArchiveSource)(entry.source)) {
+                    const bytes = (0, archive_source_1.toUint8ArraySync)(entry.source);
                     (0, errors_1.throwIfAborted)(signal);
-                    const idx = preservedRaw.length + preservedRecompressed.length + j;
-                    const entry = sets[j];
-                    let entryBytesIn = 0;
-                    progress.update({ currentEntry: { name: entry.name, index: idx, bytesIn: 0 } });
-                    const file = new stream_1.ZipDeflateFile(entry.name, (0, zip_entry_options_1.buildZipDeflateFileOptions)(entry.options, {
-                        level: this._options.level,
-                        modTime: this._options.modTime,
-                        timestamps: this._options.timestamps,
-                        smartStore: this._options.smartStore,
-                        zip64: this._options.zip64,
-                        path: this._options.path,
-                        encoding: this._options.encoding
-                    }));
-                    zip.add(file);
-                    const onChunk = (chunk) => {
-                        entryBytesIn += chunk.length;
-                        progress.mutate(s => {
-                            s.bytesIn += chunk.length;
-                            s.currentEntry = { name: entry.name, index: idx, bytesIn: entryBytesIn };
-                        });
-                    };
-                    if ((0, archive_source_1.isSyncArchiveSource)(entry.source)) {
-                        const bytes = (0, archive_source_1.toUint8ArraySync)(entry.source);
-                        (0, errors_1.throwIfAborted)(signal);
-                        onChunk(bytes);
-                        await file.push(bytes, true);
-                    }
-                    else {
-                        // Streaming path (includes Blob via toAsyncIterable(Blob) which prefers Blob.stream())
-                        for await (const chunk of (0, archive_source_1.toAsyncIterable)(entry.source, { signal, onChunk })) {
-                            (0, errors_1.throwIfAborted)(signal);
-                            await file.push(chunk, false);
-                        }
-                        (0, errors_1.throwIfAborted)(signal);
-                        await file.push(new Uint8Array(0), true);
-                    }
-                    await file.complete();
-                    progress.set("entriesDone", progress.snapshot.entriesDone + 1);
-                }
-                (0, errors_1.throwIfAborted)(signal);
-                zip.end();
-            }
-            catch (e) {
-                const err = (0, errors_1.toError)(e);
-                if (err.name === "AbortError") {
-                    progress.update({ phase: "aborted" });
-                    try {
-                        zip.abort(err);
-                    }
-                    catch {
-                        // ignore
-                    }
+                    onChunk(bytes);
+                    await file.push(bytes, true);
                 }
                 else {
-                    progress.update({ phase: "error" });
-                }
-                queue.fail(err);
-            }
-            finally {
-                try {
-                    signal.removeEventListener("abort", onAbort);
-                }
-                catch {
-                    // ignore
+                    // Streaming path (includes Blob via toAsyncIterable(Blob) which prefers Blob.stream())
+                    for await (const chunk of (0, archive_source_1.toAsyncIterable)(entry.source, { signal, onChunk })) {
+                        (0, errors_1.throwIfAborted)(signal);
+                        await file.push(chunk, false);
+                    }
+                    (0, errors_1.throwIfAborted)(signal);
+                    await file.push(new Uint8Array(0), true);
                 }
-                cleanupAbortLink();
-                progress.emitNow();
+                await file.complete();
+                progress.set("entriesDone", progress.snapshot.entriesDone + 1);
             }
-        })();
-        return {
-            iterable: queue.iterable,
-            signal,
-            abort(reason) {
-                controller.abort(reason);
-            },
-            pointer() {
-                return progress.snapshot.bytesOut;
-            },
-            progress() {
-                return progress.snapshotCopy();
-            }
-        };
+            (0, errors_1.throwIfAborted)(signal);
+            zip.end();
+        });
     }
     /**
      * Get the output as a single Uint8Array.