7z-iterator 1.1.1 → 1.2.0

package/dist/cjs/FileEntry.d.cts

@@ -1,11 +1,19 @@
+/**
+ * FileEntry for 7z archives
+ *
+ * Wraps a lazy stream - decompression happens when the stream is read.
+ * API consistent with zip-iterator and tar-iterator.
+ */
 import { type FileAttributes, FileEntry, type Lock, type NoParamCallback } from 'extract-base-iterator';
-import type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.js';
 import type { ExtractOptions } from './types.js';
 export default class SevenZipFileEntry extends FileEntry {
     private lock;
-    private entry;
-    private parser;
-    constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: Lock);
+    private stream;
+    /**
+     * Whether this entry's folder supports streaming decompression.
+     */
+    readonly _canStream: boolean;
+    constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean);
     create(dest: string, callback: NoParamCallback): void;
     create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;
     create(dest: string, options?: ExtractOptions): Promise<boolean>;

package/dist/cjs/FileEntry.d.ts

@@ -1,11 +1,19 @@
+/**
+ * FileEntry for 7z archives
+ *
+ * Wraps a lazy stream - decompression happens when the stream is read.
+ * API consistent with zip-iterator and tar-iterator.
+ */
 import { type FileAttributes, FileEntry, type Lock, type NoParamCallback } from 'extract-base-iterator';
-import type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.js';
 import type { ExtractOptions } from './types.js';
 export default class SevenZipFileEntry extends FileEntry {
     private lock;
-    private entry;
-    private parser;
-    constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: Lock);
+    private stream;
+    /**
+     * Whether this entry's folder supports streaming decompression.
+     */
+    readonly _canStream: boolean;
+    constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean);
     create(dest: string, callback: NoParamCallback): void;
     create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;
     create(dest: string, options?: ExtractOptions): Promise<boolean>;

package/dist/cjs/FileEntry.js

@@ -1,4 +1,9 @@
-"use strict";
+/**
+ * FileEntry for 7z archives
+ *
+ * Wraps a lazy stream - decompression happens when the stream is read.
+ * API consistent with zip-iterator and tar-iterator.
+ */ "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -8,6 +13,7 @@ Object.defineProperty(exports, "default", {
         return SevenZipFileEntry;
     }
 });
+var _calloncefn = /*#__PURE__*/ _interop_require_default(require("call-once-fn"));
 var _extractbaseiterator = require("extract-base-iterator");
 var _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
 var _onone = /*#__PURE__*/ _interop_require_default(require("on-one"));
@@ -78,27 +84,24 @@ function _is_native_reflect_construct() {
 var SevenZipFileEntry = /*#__PURE__*/ function(FileEntry) {
     "use strict";
     _inherits(SevenZipFileEntry, FileEntry);
-    function SevenZipFileEntry(attributes, entry, parser, lock) {
+    function SevenZipFileEntry(attributes, stream, lock, canStream) {
         _class_call_check(this, SevenZipFileEntry);
         var _this;
         _this = _call_super(this, SevenZipFileEntry, [
             attributes
         ]);
-        _this.entry = entry;
-        _this.parser = parser;
+        _this.stream = stream;
         _this.lock = lock;
         _this.lock.retain();
+        _this._canStream = canStream;
         return _this;
     }
     var _proto = SevenZipFileEntry.prototype;
     _proto.create = function create(dest, options, callback) {
         var _this = this;
-        if (typeof options === 'function') {
-            callback = options;
-            options = null;
-        }
+        callback = typeof options === 'function' ? options : callback;
+        options = typeof options === 'function' ? {} : options || {};
         if (typeof callback === 'function') {
-            options = options || {};
             return _extractbaseiterator.FileEntry.prototype.create.call(this, dest, options, function(err) {
                 callback(err);
                 if (_this.lock) {
@@ -108,34 +111,59 @@ var SevenZipFileEntry = /*#__PURE__*/ function(FileEntry) {
             });
         }
         return new Promise(function(resolve, reject) {
-            _this.create(dest, options, function(err, done) {
+            return _this.create(dest, options, function(err, done) {
                 err ? reject(err) : resolve(done);
             });
         });
     };
     _proto._writeFile = function _writeFile(fullPath, _options, callback) {
-        if (!this.entry || !this.parser) {
-            callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));
+        if (!this.stream) {
+            callback(new Error('7z FileEntry missing stream. Check for calling create multiple times'));
             return;
         }
-        // Use callback-based async decompression
-        this.parser.getEntryStreamAsync(this.entry, function(err, stream) {
-            if (err) return callback(err);
-            if (!stream) return callback(new Error('No stream returned'));
-            var res = stream.pipe(_fs.default.createWriteStream(fullPath));
-            (0, _onone.default)(res, [
+        var stream = this.stream;
+        this.stream = null; // Prevent reuse
+        // Use once since errors can come from either stream
+        var cb = (0, _calloncefn.default)(function(err) {
+            err ? callback(err) : (0, _extractbaseiterator.waitForAccess)(fullPath, callback);
+        });
+        try {
+            var writeStream = _fs.default.createWriteStream(fullPath);
+            // Listen for errors on source stream (errors don't propagate through pipe)
+            stream.on('error', function(streamErr) {
+                // Destroy the write stream on source error.
+                // On Node 0.8, destroy() emits 'close' before 'error'. Since on-one is listening
+                // for ['error', 'close', 'finish'], it catches 'close' first, calls our callback,
+                // and removes ALL listeners - including the 'error' listener. The subsequent EBADF
+                // error then fires with no handler, causing an uncaught exception.
+                // Adding a no-op error handler ensures there's always a listener for any error.
+                var ws = writeStream;
+                writeStream.on('error', function() {});
+                if (typeof ws.destroy === 'function') ws.destroy();
+                cb(streamErr);
+            });
+            // Pipe and listen for write stream completion/errors
+            stream.pipe(writeStream);
+            (0, _onone.default)(writeStream, [
                 'error',
                 'close',
                 'finish'
-            ], function(writeErr) {
-                writeErr ? callback(writeErr) : (0, _extractbaseiterator.waitForAccess)(fullPath, callback);
-            });
-        });
+            ], cb);
+        } catch (pipeErr) {
+            cb(pipeErr);
+        }
     };
     _proto.destroy = function destroy() {
         _extractbaseiterator.FileEntry.prototype.destroy.call(this);
-        this.entry = null;
-        this.parser = null;
+        if (this.stream) {
+            // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)
+            // Fallback to resume() for older Node versions without destroy()
+            var s = this.stream;
+            if (typeof s.destroy === 'function') {
+                s.destroy();
+            }
+            this.stream = null;
+        }
         if (this.lock) {
             this.lock.release();
             this.lock = null;

package/dist/cjs/FileEntry.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["import { type FileAttributes, FileEntry, type Lock, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'fs';\nimport oo from 'on-one';\nimport type { SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\nimport type { ExtractOptions } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: Lock;\n  private entry: SevenZipEntry;\n  private parser: SevenZipParser;\n\n  constructor(attributes: FileAttributes, entry: SevenZipEntry, parser: SevenZipParser, lock: Lock) {\n    super(attributes);\n    this.entry = entry;\n    this.parser = parser;\n    this.lock = lock;\n    this.lock.retain();\n  }\n\n  create(dest: string, callback: NoParamCallback): void;\n  create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;\n  create(dest: string, options?: ExtractOptions): Promise<boolean>;\n  create(dest: string, options?: ExtractOptions | NoParamCallback, callback?: NoParamCallback): void | Promise<boolean> {\n    if (typeof options === 'function') {\n      callback = options;\n      options = null;\n    }\n\n    if (typeof callback === 'function') {\n      options = options || {};\n      return FileEntry.prototype.create.call(this, dest, options, (err?: Error) => {\n        callback(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      });\n    }\n    return new Promise((resolve, reject) => {\n      this.create(dest, options as ExtractOptions, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      });\n    });\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): void {\n    if (!this.entry || !this.parser) {\n      callback(new Error('7z FileEntry missing entry. Check for calling create multiple times'));\n      return;\n    }\n\n    // Use callback-based async decompression\n    this.parser.getEntryStreamAsync(this.entry, (err, stream) => {\n      if (err) return callback(err);\n      if (!stream) return callback(new Error('No stream returned'));\n\n      const res = stream.pipe(fs.createWriteStream(fullPath));\n      oo(res, ['error', 'close', 'finish'], (writeErr?: Error) => {\n        writeErr ? callback(writeErr) : waitForAccess(fullPath, callback);\n      });\n    });\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    this.entry = null;\n    this.parser = null;\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["SevenZipFileEntry","attributes","entry","parser","lock","retain","create","dest","options","callback","FileEntry","prototype","call","err","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","Error","getEntryStreamAsync","stream","res","pipe","fs","createWriteStream","oo","writeErr","waitForAccess","destroy"],"mappings":";;;;;;;eAMqBA;;;mCAN0E;yDAChF;4DACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIA,IAAA,AAAMA,kCAAN;;cAAMA;aAAAA,kBAKPC,UAA0B,EAAEC,KAAoB,EAAEC,MAAsB,EAAEC,IAAU;gCAL7EJ;;gBAMjB,kBANiBA;YAMXC;;QACN,MAAKC,KAAK,GAAGA;QACb,MAAKC,MAAM,GAAGA;QACd,MAAKC,IAAI,GAAGA;QACZ,MAAKA,IAAI,CAACC,MAAM;;;iBAVCL;IAgBnBM,OAAAA,MAqBC,GArBDA,SAAAA,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B;;QACzF,IAAI,OAAOD,YAAY,YAAY;YACjCC,WAAWD;YACXA,UAAU;QACZ;QAEA,IAAI,OAAOC,aAAa,YAAY;YAClCD,UAAUA,WAAW,CAAC;YACtB,OAAOE,8BAAS,CAACC,SAAS,CAACL,MAAM,CAACM,IAAI,CAAC,IAAI,EAAEL,MAAMC,SAAS,SAACK;gBAC3DJ,SAASI;gBACT,IAAI,MAAKT,IAAI,EAAE;oBACb,MAAKA,IAAI,CAACU,OAAO;oBACjB,MAAKV,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIW,QAAQ,SAACC,SAASC;YAC3B,MAAKX,MAAM,CAACC,MAAMC,SAA2B,SAACK,KAAaK;gBACzDL,MAAMI,OAAOJ,OAAOG,QAAQE;YAC9B;QACF;IACF;IAEAC,OAAAA,UAgBC,GAhBDA,SAAAA,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB;QAC9E,IAAI,CAAC,IAAI,CAACP,KAAK,IAAI,CAAC,IAAI,CAACC,MAAM,EAAE;YAC/BM,SAAS,IAAIa,MAAM;YACnB;QACF;QAEA,yCAAyC;QACzC,IAAI,CAACnB,MAAM,CAACoB,mBAAmB,CAAC,IAAI,CAACrB,KAAK,EAAE,SAACW,KAAKW;YAChD,IAAIX,KAAK,OAAOJ,SAASI;YACzB,IAAI,CAACW,QAAQ,OAAOf,SAAS,IAAIa,MAAM;YAEvC,IAAMG,MAAMD,OAAOE,IAAI,CAACC,WAAE,CAACC,iBAAiB,CAACR;YAC7CS,IAAAA,cAAE,EAACJ,KAAK;gBAAC;gBAAS;gBAAS;aAAS,EAAE,SAACK;gBACrCA,WAAWrB,SAASqB,YAAYC,IAAAA,kCAAa,EAACX,UAAUX;YAC1D;QACF;IACF;IAEAuB,OAAAA,OAQC,GARDA,SAAAA;QACEtB,8BAAS,CAACC,SAAS,CAACqB,OAAO,CAACpB,IAAI,CAAC,IAAI;QACrC,IAAI,CAACV,KAAK,GAAG;QACb,IAAI,CAACC,MAAM,GAAG;QACd,IAAI,IAAI,CAACC,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACU,OAAO;YACjB,IAAI,CAACV,IAAI,GAAG;QACd;IACF;WAjEmBJ;EAA0BU,8BAAS"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/FileEntry.ts"],"sourcesContent":["/**\n * FileEntry for 7z archives\n *\n * Wraps a lazy stream - decompression happens when the stream is read.\n * API consistent with zip-iterator and tar-iterator.\n */\n\nimport once from 'call-once-fn';\nimport { type FileAttributes, FileEntry, type Lock, type NoParamCallback, waitForAccess } from 'extract-base-iterator';\nimport fs from 'fs';\nimport oo from 'on-one';\nimport type { ExtractOptions } from './types.ts';\n\nexport default class SevenZipFileEntry extends FileEntry {\n  private lock: Lock;\n  private stream: NodeJS.ReadableStream;\n\n  /**\n   * Whether this entry's folder supports streaming decompression.\n   */\n  readonly _canStream: boolean;\n\n  constructor(attributes: FileAttributes, stream: NodeJS.ReadableStream, lock: Lock, canStream: boolean) {\n    super(attributes);\n    this.stream = stream;\n    this.lock = lock;\n    this.lock.retain();\n    this._canStream = canStream;\n  }\n\n  create(dest: string, callback: NoParamCallback): void;\n  create(dest: string, options: ExtractOptions, callback: NoParamCallback): void;\n  create(dest: string, options?: ExtractOptions): Promise<boolean>;\n  create(dest: string, options?: ExtractOptions | NoParamCallback, callback?: NoParamCallback): void | Promise<boolean> {\n    callback = typeof options === 'function' ? options : callback;\n    options = typeof options === 'function' ? {} : ((options || {}) as ExtractOptions);\n\n    if (typeof callback === 'function') {\n      return FileEntry.prototype.create.call(this, dest, options, (err?: Error) => {\n        callback(err);\n        if (this.lock) {\n          this.lock.release();\n          this.lock = null;\n        }\n      });\n    }\n    return new Promise((resolve, reject) =>\n      this.create(dest, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      })\n    );\n  }\n\n  _writeFile(fullPath: string, _options: ExtractOptions, callback: NoParamCallback): void {\n    if (!this.stream) {\n      callback(new Error('7z FileEntry missing stream. Check for calling create multiple times'));\n      return;\n    }\n\n    const stream = this.stream;\n    this.stream = null; // Prevent reuse\n\n    // Use once since errors can come from either stream\n    const cb = once((err?: Error) => {\n      err ? callback(err) : waitForAccess(fullPath, callback);\n    });\n\n    try {\n      const writeStream = fs.createWriteStream(fullPath);\n\n      // Listen for errors on source stream (errors don't propagate through pipe)\n      stream.on('error', (streamErr: Error) => {\n        // Destroy the write stream on source error.\n        // On Node 0.8, destroy() emits 'close' before 'error'. Since on-one is listening\n        // for ['error', 'close', 'finish'], it catches 'close' first, calls our callback,\n        // and removes ALL listeners - including the 'error' listener. The subsequent EBADF\n        // error then fires with no handler, causing an uncaught exception.\n        // Adding a no-op error handler ensures there's always a listener for any error.\n        const ws = writeStream as fs.WriteStream & { destroy?: () => void };\n        writeStream.on('error', () => {});\n        if (typeof ws.destroy === 'function') ws.destroy();\n        cb(streamErr);\n      });\n\n      // Pipe and listen for write stream completion/errors\n      stream.pipe(writeStream);\n      oo(writeStream, ['error', 'close', 'finish'], cb);\n    } catch (pipeErr) {\n      cb(pipeErr);\n    }\n  }\n\n  destroy() {\n    FileEntry.prototype.destroy.call(this);\n    if (this.stream) {\n      // Use destroy() to prevent decompression (our stream has custom destroy that sets destroyed flag)\n      // Fallback to resume() for older Node versions without destroy()\n      const s = this.stream as NodeJS.ReadableStream & { destroy?: () => void };\n      if (typeof s.destroy === 'function') {\n        s.destroy();\n      }\n      this.stream = null;\n    }\n    if (this.lock) {\n      this.lock.release();\n      this.lock = null;\n    }\n  }\n}\n"],"names":["SevenZipFileEntry","attributes","stream","lock","canStream","retain","_canStream","create","dest","options","callback","FileEntry","prototype","call","err","release","Promise","resolve","reject","done","_writeFile","fullPath","_options","Error","cb","once","waitForAccess","writeStream","fs","createWriteStream","on","streamErr","ws","destroy","pipe","oo","pipeErr","s"],"mappings":"AAAA;;;;;CAKC;;;;;;;eAQoBA;;;iEANJ;mCAC8E;yDAChF;4DACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,IAAA,AAAMA,kCAAN;;cAAMA;aAAAA,kBASPC,UAA0B,EAAEC,MAA6B,EAAEC,IAAU,EAAEC,SAAkB;gCATlFJ;;gBAUjB,kBAViBA;YAUXC;;QACN,MAAKC,MAAM,GAAGA;QACd,MAAKC,IAAI,GAAGA;QACZ,MAAKA,IAAI,CAACE,MAAM;QAChB,MAAKC,UAAU,GAAGF;;;iBAdDJ;IAoBnBO,OAAAA,MAkBC,GAlBDA,SAAAA,OAAOC,IAAY,EAAEC,OAA0C,EAAEC,QAA0B;;QACzFA,WAAW,OAAOD,YAAY,aAAaA,UAAUC;QACrDD,UAAU,OAAOA,YAAY,aAAa,CAAC,IAAMA,WAAW,CAAC;QAE7D,IAAI,OAAOC,aAAa,YAAY;YAClC,OAAOC,8BAAS,CAACC,SAAS,CAACL,MAAM,CAACM,IAAI,CAAC,IAAI,EAAEL,MAAMC,SAAS,SAACK;gBAC3DJ,SAASI;gBACT,IAAI,MAAKX,IAAI,EAAE;oBACb,MAAKA,IAAI,CAACY,OAAO;oBACjB,MAAKZ,IAAI,GAAG;gBACd;YACF;QACF;QACA,OAAO,IAAIa,QAAQ,SAACC,SAASC;mBAC3B,MAAKX,MAAM,CAACC,MAAMC,SAAS,SAACK,KAAaK;gBACvCL,MAAMI,OAAOJ,OAAOG,QAAQE;YAC9B;;IAEJ;IAEAC,OAAAA,UAqCC,GArCDA,SAAAA,WAAWC,QAAgB,EAAEC,QAAwB,EAAEZ,QAAyB;QAC9E,IAAI,CAAC,IAAI,CAACR,MAAM,EAAE;YAChBQ,SAAS,IAAIa,MAAM;YACnB;QACF;QAEA,IAAMrB,SAAS,IAAI,CAACA,MAAM;QAC1B,IAAI,CAACA,MAAM,GAAG,MAAM,gBAAgB;QAEpC,oDAAoD;QACpD,IAAMsB,KAAKC,IAAAA,mBAAI,EAAC,SAACX;YACfA,MAAMJ,SAASI,OAAOY,IAAAA,kCAAa,EAACL,UAAUX;QAChD;QAEA,IAAI;YACF,IAAMiB,cAAcC,WAAE,CAACC,iBAAiB,CAACR;YAEzC,2EAA2E;YAC3EnB,OAAO4B,EAAE,CAAC,SAAS,SAACC;gBAClB,4CAA4C;gBAC5C,iFAAiF;gBACjF,kFAAkF;gBAClF,mFAAmF;gBACnF,mEAAmE;gBACnE,gFAAgF;gBAChF,IAAMC,KAAKL;gBACXA,YAAYG,EAAE,CAAC,SAAS,YAAO;gBAC/B,IAAI,OAAOE,GAAGC,OAAO,KAAK,YAAYD,GAAGC,OAAO;gBAChDT,GAAGO;YACL;YAEA,qDAAqD;YACrD7B,OAAOgC,IAAI,CAACP;YACZQ,IAAAA,cAAE,EAACR,aAAa;gBAAC;gBAAS;gBAAS;aAAS,EAAEH;QAChD,EAAE,OAAOY,SAAS;YAChBZ,GAAGY;QACL;IACF;IAEAH,OAAAA,OAeC,GAfDA,SAAAA;QACEtB,8BAAS,CAACC,SAAS,CAACqB,OAAO,CAACpB,IAAI,CAAC,IAAI;QACrC,IAAI,IAAI,CAACX,MAAM,EAAE;YACf,kGAAkG;YAClG,iEAAiE;YACjE,IAAMmC,IAAI,IAAI,CAACnC,MAAM;YACrB,IAAI,OAAOmC,EAAEJ,OAAO,KAAK,YAAY;gBACnCI,EAAEJ,OAAO;YACX;YACA,IAAI,CAAC/B,MAAM,GAAG;QAChB;QACA,IAAI,IAAI,CAACC,IAAI,EAAE;YACb,IAAI,CAACA,IAAI,CAACY,OAAO;YACjB,IAAI,CAACZ,IAAI,GAAG;QACd;IACF;WA9FmBH;EAA0BW,8BAAS"}

package/dist/cjs/SevenZipIterator.d.cts

@@ -1,8 +1,31 @@
 import BaseIterator, { Lock } from 'extract-base-iterator';
-import type { Entry, ExtractOptions, SevenZipFileIterator } from './types.js';
+import { type SevenZipEntry } from './sevenz/SevenZipParser.js';
+import type { Entry, ExtractOptions } from './types.js';
 export default class SevenZipIterator extends BaseIterator<Entry> {
     lock: Lock | null;
-    iterator: SevenZipFileIterator;
+    /** @internal - Do not use directly */
+    _iterator: unknown;
     constructor(source: string | NodeJS.ReadableStream, options?: ExtractOptions);
     end(err?: Error): void;
+    /**
+     * Check if streaming extraction is available for any folder in this archive.
+     * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy
+     * that can decompress incrementally without buffering the entire input.
+     *
+     * @returns true if at least one folder supports streaming
+     */
+    canStream(): boolean;
+    /**
+     * Get entries sorted for optimal streaming extraction.
+     *
+     * Entries are sorted by:
+     * 1. Folder index (process one folder at a time)
+     * 2. Stream index within folder (for solid block streaming)
+     *
+     * This ordering allows multi-file solid folders to stream with
+     * O(largest file) memory instead of O(folder size).
+     *
+     * @returns Array of entries in streaming order
+     */
+    getStreamingOrder(): SevenZipEntry[];
 }

package/dist/cjs/SevenZipIterator.d.ts

@@ -1,8 +1,31 @@
 import BaseIterator, { Lock } from 'extract-base-iterator';
-import type { Entry, ExtractOptions, SevenZipFileIterator } from './types.js';
+import { type SevenZipEntry } from './sevenz/SevenZipParser.js';
+import type { Entry, ExtractOptions } from './types.js';
 export default class SevenZipIterator extends BaseIterator<Entry> {
     lock: Lock | null;
-    iterator: SevenZipFileIterator;
+    /** @internal - Do not use directly */
+    _iterator: unknown;
     constructor(source: string | NodeJS.ReadableStream, options?: ExtractOptions);
     end(err?: Error): void;
+    /**
+     * Check if streaming extraction is available for any folder in this archive.
+     * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy
+     * that can decompress incrementally without buffering the entire input.
+     *
+     * @returns true if at least one folder supports streaming
+     */
+    canStream(): boolean;
+    /**
+     * Get entries sorted for optimal streaming extraction.
+     *
+     * Entries are sorted by:
+     * 1. Folder index (process one folder at a time)
+     * 2. Stream index within folder (for solid block streaming)
+     *
+     * This ordering allows multi-file solid folders to stream with
+     * O(largest file) memory instead of O(folder size).
+     *
+     * @returns Array of entries in streaming order
+     */
+    getStreamingOrder(): SevenZipEntry[];
 }

package/dist/cjs/SevenZipIterator.js

@@ -189,7 +189,7 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
                 });
             });
         } else {
-            // Stream input - use hybrid memory/temp-file approach
+            // Stream input - write to temp file for random access
             // Register cleanup for source stream
             var stream = source;
             _this.lock.registerCleanup(function() {
@@ -199,30 +199,23 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
             var tempPath = _path.default.join((0, _compatts.tmpdir)(), '7z-iterator', (0, _shorthash.default)(process.cwd()), (0, _tempsuffix.default)('tmp.7z'));
             queue.defer(function(cb) {
                 (0, _streamToSourcets.default)(source, {
-                    memoryThreshold: options.memoryThreshold,
                     tempPath: tempPath
                 }, function(err, result) {
                     if (_this.done || cancelled) return;
                     if (err) return cb(err);
                     if (!result) return cb(new Error('No result from streamToSource'));
                     archiveSource = result.source;
-                    if (result.fd !== undefined) {
-                        var fd = result.fd;
-                        // Register cleanup for file descriptor
-                        _this.lock.registerCleanup(function() {
-                            _fs.default.closeSync(fd);
-                        });
-                    }
-                    if (result.tempPath) {
-                        var tp = result.tempPath;
-                        // Register cleanup for temp file
-                        _this.lock.registerCleanup(function() {
-                            try {
-                                (0, _fsremovecompat.rmSync)(tp);
-                            } catch (_e) {
-                            /* ignore */ }
-                        });
-                    }
+                    // Register cleanup for file descriptor
+                    _this.lock.registerCleanup(function() {
+                        _fs.default.closeSync(result.fd);
+                    });
+                    // Register cleanup for temp file
+                    _this.lock.registerCleanup(function() {
+                        try {
+                            (0, _fsremovecompat.rmSync)(result.tempPath);
+                        } catch (_e) {
+                        /* ignore */ }
+                    });
                     cb();
                 });
             });
@@ -234,7 +227,7 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
             try {
                 var parser = new _SevenZipParserts.SevenZipParser(archiveSource);
                 parser.parse();
-                _this.iterator = new EntryIterator(parser);
+                _this._iterator = new EntryIterator(parser);
                 cb();
             } catch (parseErr) {
                 cb(parseErr);
@@ -257,7 +250,61 @@ var SevenZipIterator = /*#__PURE__*/ function(BaseIterator) {
             lock.release();
         }
         // Don't call base end here - Lock.__destroy() handles it
-        this.iterator = null;
+        this._iterator = null;
+    };
+    /**
+   * Check if streaming extraction is available for any folder in this archive.
+   * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy
+   * that can decompress incrementally without buffering the entire input.
+   *
+   * @returns true if at least one folder supports streaming
+   */ _proto.canStream = function canStream() {
+        if (!this._iterator) return false;
+        var parser = this._iterator.getParser();
+        if (!parser) return false;
+        var entries = parser.getEntries();
+        var checkedFolders = {};
+        for(var i = 0; i < entries.length; i++){
+            var folderIndex = entries[i]._folderIndex;
+            if (folderIndex >= 0 && checkedFolders[folderIndex] === undefined) {
+                checkedFolders[folderIndex] = parser.canStreamFolder(folderIndex);
+                if (checkedFolders[folderIndex]) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    };
+    /**
+   * Get entries sorted for optimal streaming extraction.
+   *
+   * Entries are sorted by:
+   * 1. Folder index (process one folder at a time)
+   * 2. Stream index within folder (for solid block streaming)
+   *
+   * This ordering allows multi-file solid folders to stream with
+   * O(largest file) memory instead of O(folder size).
+   *
+   * @returns Array of entries in streaming order
+   */ _proto.getStreamingOrder = function getStreamingOrder() {
+        if (!this._iterator) return [];
+        var parser = this._iterator.getParser();
+        if (!parser) return [];
+        var entries = parser.getEntries();
+        // Create a copy and sort for streaming order
+        var sorted = [];
+        for(var i = 0; i < entries.length; i++){
+            sorted.push(entries[i]);
+        }
+        sorted.sort(function(a, b) {
+            // First by folder index
+            if (a._folderIndex !== b._folderIndex) {
+                return a._folderIndex - b._folderIndex;
+            }
+            // Then by stream index within folder
+            return a._streamIndexInFolder - b._streamIndexInFolder;
+        });
+        return sorted;
     };
     return SevenZipIterator;
 }(_extractbaseiterator.default);

package/dist/cjs/SevenZipIterator.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/SevenZipIterator.ts"],"sourcesContent":["import BaseIterator, { Lock } from 'extract-base-iterator';\nimport fs from 'fs';\nimport { rmSync } from 'fs-remove-compat';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport shortHash from 'short-hash';\nimport tempSuffix from 'temp-suffix';\nimport { tmpdir } from './compat.ts';\nimport streamToSource, { type SourceResult } from './lib/streamToSource.ts';\nimport nextEntry from './nextEntry.ts';\nimport { setPassword } from './sevenz/codecs/index.ts';\nimport { type ArchiveSource, FileSource, type SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\n\nimport type { Entry, ExtractOptions, SevenZipFileIterator } from './types.ts';\n\n/**\n * Iterator wrapper around SevenZipParser entries\n */\nclass EntryIterator implements SevenZipFileIterator {\n  private parser: SevenZipParser;\n  private entries: SevenZipEntry[];\n  private index = 0;\n\n  constructor(parser: SevenZipParser) {\n    this.parser = parser;\n    this.entries = parser.getEntries();\n  }\n\n  next(): SevenZipEntry | null {\n    if (this.index >= this.entries.length) {\n      return null;\n    }\n    return this.entries[this.index++];\n  }\n\n  getParser(): SevenZipParser {\n    return this.parser;\n  }\n}\n\nexport default class SevenZipIterator extends BaseIterator<Entry> {\n  lock: Lock | null;\n  iterator: SevenZipFileIterator;\n\n  constructor(source: string | NodeJS.ReadableStream, options: ExtractOptions = {}) {\n    super(options);\n    this.lock = new Lock();\n    this.lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n    const queue = new Queue(1);\n    let cancelled = false;\n    let archiveSource: ArchiveSource | null = null;\n    const setup = (): void => {\n      cancelled = true;\n    };\n    this.processing.push(setup);\n\n    // Set password (or clear if not provided)\n    setPassword(options.password || null);\n\n    if (typeof source === 'string') {\n      // File path input - use FileSource directly\n      queue.defer((cb: (err?: Error) => void) => {\n        fs.stat(source, (statErr, stats) => {\n          if (this.done || cancelled) return;\n          if (statErr) return cb(statErr);\n\n          fs.open(source, 'r', (err, fd) => {\n            if (this.done || cancelled) return;\n            if (err) return cb(err);\n\n            archiveSource = new FileSource(fd, stats.size);\n            // Register cleanup for file descriptor\n            this.lock.registerCleanup(() => {\n              fs.closeSync(fd);\n            });\n            cb();\n          });\n        });\n      });\n    } else {\n      // Stream input - use hybrid memory/temp-file approach\n      // Register cleanup for source stream\n      const stream = source as NodeJS.ReadableStream;\n      this.lock.registerCleanup(() => {\n        const s = stream as NodeJS.ReadableStream & { destroy?: () => void };\n        if (typeof s.destroy === 'function') s.destroy();\n      });\n\n      const tempPath = path.join(tmpdir(), '7z-iterator', shortHash(process.cwd()), tempSuffix('tmp.7z'));\n      queue.defer((cb: (err?: Error) => void) => {\n        streamToSource(\n          source,\n          {\n            memoryThreshold: options.memoryThreshold,\n            tempPath: tempPath,\n          },\n          (err?: Error, result?: SourceResult) => {\n            if (this.done || cancelled) return;\n            if (err) return cb(err);\n            if (!result) return cb(new Error('No result from streamToSource'));\n\n            archiveSource = result.source;\n            if (result.fd !== undefined) {\n              const fd = result.fd;\n              // Register cleanup for file descriptor\n              this.lock.registerCleanup(() => {\n                fs.closeSync(fd);\n              });\n            }\n            if (result.tempPath) {\n              const tp = result.tempPath;\n              // Register cleanup for temp file\n              this.lock.registerCleanup(() => {\n                try {\n                  rmSync(tp);\n                } catch (_e) {\n                  /* ignore */\n                }\n              });\n            }\n            cb();\n          }\n        );\n      });\n    }\n\n    // Parse and build iterator\n    queue.defer((cb: (err?: Error) => void) => {\n      if (this.done || cancelled) return;\n      if (!archiveSource) return cb(new Error('No archive source'));\n\n      try {\n        const parser = new SevenZipParser(archiveSource);\n        parser.parse();\n        this.iterator = new EntryIterator(parser);\n        cb();\n      } catch (parseErr) {\n        cb(parseErr as Error);\n      }\n    });\n\n    // start processing\n    queue.await((err?: Error) => {\n      this.processing.remove(setup);\n      if (this.done || cancelled) return;\n      err ? this.end(err) : this.push(nextEntry);\n    });\n  }\n\n  end(err?: Error) {\n    if (this.lock) {\n      const lock = this.lock;\n      this.lock = null; // Clear before release to prevent re-entrancy\n      lock.err = err;\n      lock.release();\n    }\n    // Don't call base end here - Lock.__destroy() handles it\n    this.iterator = null;\n  }\n}\n"],"names":["SevenZipIterator","EntryIterator","parser","index","entries","getEntries","next","length","getParser","source","options","lock","Lock","onDestroy","err","BaseIterator","prototype","end","call","queue","Queue","cancelled","archiveSource","setup","processing","push","setPassword","password","defer","cb","fs","stat","statErr","stats","done","open","fd","FileSource","size","registerCleanup","closeSync","stream","s","destroy","tempPath","path","join","tmpdir","shortHash","process","cwd","tempSuffix","streamToSource","memoryThreshold","result","Error","undefined","tp","rmSync","_e","SevenZipParser","parse","iterator","parseErr","await","remove","nextEntry","release"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/SevenZipIterator.ts"],"sourcesContent":["import BaseIterator, { Lock } from 'extract-base-iterator';\nimport fs from 'fs';\nimport { rmSync } from 'fs-remove-compat';\nimport path from 'path';\nimport Queue from 'queue-cb';\nimport shortHash from 'short-hash';\nimport tempSuffix from 'temp-suffix';\nimport { tmpdir } from './compat.ts';\nimport streamToSource, { type SourceResult } from './lib/streamToSource.ts';\nimport nextEntry from './nextEntry.ts';\nimport { setPassword } from './sevenz/codecs/index.ts';\nimport { type ArchiveSource, FileSource, type SevenZipEntry, SevenZipParser } from './sevenz/SevenZipParser.ts';\n\nimport type { Entry, ExtractOptions } from './types.ts';\n\n/**\n * Internal iterator interface for SevenZipParser entries\n * @internal\n */\ninterface SevenZipFileIterator {\n  next(): SevenZipEntry | null;\n  getParser(): SevenZipParser;\n}\n\n/**\n * Iterator wrapper around SevenZipParser entries\n */\nclass EntryIterator implements SevenZipFileIterator {\n  private parser: SevenZipParser;\n  private entries: SevenZipEntry[];\n  private index = 0;\n\n  constructor(parser: SevenZipParser) {\n    this.parser = parser;\n    this.entries = parser.getEntries();\n  }\n\n  next(): SevenZipEntry | null {\n    if (this.index >= this.entries.length) {\n      return null;\n    }\n    return this.entries[this.index++];\n  }\n\n  getParser(): SevenZipParser {\n    return this.parser;\n  }\n}\n\nexport default class SevenZipIterator extends BaseIterator<Entry> {\n  lock: Lock | null;\n  /** @internal - Do not use directly */\n  _iterator: unknown;\n\n  constructor(source: string | NodeJS.ReadableStream, options: ExtractOptions = {}) {\n    super(options);\n    this.lock = new Lock();\n    this.lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n    const queue = new Queue(1);\n    let cancelled = false;\n    let archiveSource: ArchiveSource | null = null;\n    const setup = (): void => {\n      cancelled = true;\n    };\n    this.processing.push(setup);\n\n    // Set password (or clear if not provided)\n    setPassword(options.password || null);\n\n    if (typeof source === 'string') {\n      // File path input - use FileSource directly\n      queue.defer((cb: (err?: Error) => void) => {\n        fs.stat(source, (statErr, stats) => {\n          if (this.done || cancelled) return;\n          if (statErr) return cb(statErr);\n\n          fs.open(source, 'r', (err, fd) => {\n            if (this.done || cancelled) return;\n            if (err) return cb(err);\n\n            archiveSource = new FileSource(fd, stats.size);\n            // Register cleanup for file descriptor\n            this.lock.registerCleanup(() => {\n              fs.closeSync(fd);\n            });\n            cb();\n          });\n        });\n      });\n    } else {\n      // Stream input - write to temp file for random access\n      // Register cleanup for source stream\n      const stream = source as NodeJS.ReadableStream;\n      this.lock.registerCleanup(() => {\n        const s = stream as NodeJS.ReadableStream & { destroy?: () => void };\n        if (typeof s.destroy === 'function') s.destroy();\n      });\n\n      const tempPath = path.join(tmpdir(), '7z-iterator', shortHash(process.cwd()), tempSuffix('tmp.7z'));\n      queue.defer((cb: (err?: Error) => void) => {\n        streamToSource(source, { tempPath }, (err?: Error, result?: SourceResult) => {\n          if (this.done || cancelled) return;\n          if (err) return cb(err);\n          if (!result) return cb(new Error('No result from streamToSource'));\n\n          archiveSource = result.source;\n\n          // Register cleanup for file descriptor\n          this.lock.registerCleanup(() => {\n            fs.closeSync(result.fd);\n          });\n\n          // Register cleanup for temp file\n          this.lock.registerCleanup(() => {\n            try {\n              rmSync(result.tempPath);\n            } catch (_e) {\n              /* ignore */\n            }\n          });\n\n          cb();\n        });\n      });\n    }\n\n    // Parse and build iterator\n    queue.defer((cb: (err?: Error) => void) => {\n      if (this.done || cancelled) return;\n      if (!archiveSource) return cb(new Error('No archive source'));\n\n      try {\n        const parser = new SevenZipParser(archiveSource);\n        parser.parse();\n        this._iterator = new EntryIterator(parser);\n        cb();\n      } catch (parseErr) {\n        cb(parseErr as Error);\n      }\n    });\n\n    // start processing\n    queue.await((err?: Error) => {\n      this.processing.remove(setup);\n      if (this.done || cancelled) return;\n      err ? this.end(err) : this.push(nextEntry);\n    });\n  }\n\n  end(err?: Error) {\n    if (this.lock) {\n      const lock = this.lock;\n      this.lock = null; // Clear before release to prevent re-entrancy\n      lock.err = err;\n      lock.release();\n    }\n    // Don't call base end here - Lock.__destroy() handles it\n    this._iterator = null;\n  }\n\n  /**\n   * Check if streaming extraction is available for any folder in this archive.\n   * Streaming is possible when folders use codecs like BZip2, Deflate, or Copy\n   * that can decompress incrementally without buffering the entire input.\n   *\n   * @returns true if at least one folder supports streaming\n   */\n  canStream(): boolean {\n    if (!this._iterator) return false;\n    const parser = (this._iterator as SevenZipFileIterator).getParser();\n    if (!parser) return false;\n\n    const entries = parser.getEntries();\n    const checkedFolders: { [key: number]: boolean } = {};\n\n    for (let i = 0; i < entries.length; i++) {\n      const folderIndex = entries[i]._folderIndex;\n      if (folderIndex >= 0 && checkedFolders[folderIndex] === undefined) {\n        checkedFolders[folderIndex] = parser.canStreamFolder(folderIndex);\n        if (checkedFolders[folderIndex]) {\n          return true;\n        }\n      }\n    }\n\n    return false;\n  }\n\n  /**\n   * Get entries sorted for optimal streaming extraction.\n   *\n   * Entries are sorted by:\n   * 1. Folder index (process one folder at a time)\n   * 2. Stream index within folder (for solid block streaming)\n   *\n   * This ordering allows multi-file solid folders to stream with\n   * O(largest file) memory instead of O(folder size).\n   *\n   * @returns Array of entries in streaming order\n   */\n  getStreamingOrder(): SevenZipEntry[] {\n    if (!this._iterator) return [];\n    const parser = (this._iterator as SevenZipFileIterator).getParser();\n    if (!parser) return [];\n\n    const entries = parser.getEntries();\n\n    // Create a copy and sort for streaming order\n    const sorted: SevenZipEntry[] = [];\n    for (let i = 0; i < entries.length; i++) {\n      sorted.push(entries[i]);\n    }\n\n    sorted.sort((a, b) => {\n      // First by folder index\n      if (a._folderIndex !== b._folderIndex) {\n        return a._folderIndex - b._folderIndex;\n      }\n      // Then by stream index within folder\n      return a._streamIndexInFolder - b._streamIndexInFolder;\n    });\n\n    return sorted;\n  }\n}\n"],"names":["SevenZipIterator","EntryIterator","parser","index","entries","getEntries","next","length","getParser","source","options","lock","Lock","onDestroy","err","BaseIterator","prototype","end","call","queue","Queue","cancelled","archiveSource","setup","processing","push","setPassword","password","defer","cb","fs","stat","statErr","stats","done","open","fd","FileSource","size","registerCleanup","closeSync","stream","s","destroy","tempPath","path","join","tmpdir","shortHash","process","cwd","tempSuffix","streamToSource","result","Error","rmSync","_e","SevenZipParser","parse","_iterator","parseErr","await","remove","nextEntry","release","canStream","checkedFolders","i","folderIndex","_folderIndex","undefined","canStreamFolder","getStreamingOrder","sorted","sort","a","b","_streamIndexInFolder"],"mappings":"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"}

package/dist/cjs/compat.js

@@ -17,14 +17,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
-/**
- * os.tmpdir wrapper for Node.js 0.8+
- * - Uses native os.tmpdir on Node 0.10+
- * - Falls back to os-shim on Node 0.8
- */ var hasTmpdir = typeof _os.default.tmpdir === 'function';
 function tmpdir() {
-    if (hasTmpdir) return _os.default.tmpdir();
-    var osShim = require('os-shim');
-    return osShim.tmpdir();
+    return typeof _os.default.tmpdir === 'function' ? _os.default.tmpdir() : require('os-shim').tmpdir();
 }
 /* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/compat.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/compat.ts"],"sourcesContent":["/**\n * Compatibility Layer for Node.js 0.8+\n * Local to this package - contains only needed functions.\n */\nimport os from 'os';\n\n/**\n * os.tmpdir wrapper for Node.js 0.8+\n * - Uses native os.tmpdir on Node 0.10+\n * - Falls back to os-shim on Node 0.8\n */\nconst hasTmpdir = typeof os.tmpdir === 'function';\nexport function tmpdir(): string {\n  if (hasTmpdir) return os.tmpdir();\n  const osShim = require('os-shim');\n  return osShim.tmpdir();\n}\n"],"names":["tmpdir","hasTmpdir","os","osShim","require"],"mappings":"AAAA;;;CAGC;;;;+BASeA;;;eAAAA;;;yDARD;;;;;;AAEf;;;;CAIC,GACD,IAAMC,YAAY,OAAOC,WAAE,CAACF,MAAM,KAAK;AAChC,SAASA;IACd,IAAIC,WAAW,OAAOC,WAAE,CAACF,MAAM;IAC/B,IAAMG,SAASC,QAAQ;IACvB,OAAOD,OAAOH,MAAM;AACtB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/compat.ts"],"sourcesContent":["/**\n * Compatibility Layer for Node.js 0.8+\n * Local to this package - contains only needed functions.\n */\nimport os from 'os';\n\nexport function tmpdir(): string {\n  return typeof os.tmpdir === 'function' ? os.tmpdir() : require('os-shim').tmpdir();\n}\n"],"names":["tmpdir","os","require"],"mappings":"AAAA;;;CAGC;;;;+BAGeA;;;eAAAA;;;yDAFD;;;;;;AAER,SAASA;IACd,OAAO,OAAOC,WAAE,CAACD,MAAM,KAAK,aAAaC,WAAE,CAACD,MAAM,KAAKE,QAAQ,WAAWF,MAAM;AAClF"}

package/dist/cjs/index.d.cts

@@ -1,4 +1,2 @@
 export { default } from './SevenZipIterator.js';
-export type { ArchiveSource, SevenZipEntry } from './sevenz/index.js';
-export { SevenZipParser } from './sevenz/index.js';
 export * from './types.js';

package/dist/cjs/index.d.ts

@@ -1,4 +1,2 @@
 export { default } from './SevenZipIterator.js';
-export type { ArchiveSource, SevenZipEntry } from './sevenz/index.js';
-export { SevenZipParser } from './sevenz/index.js';
 export * from './types.js';

package/dist/cjs/index.js

@@ -2,22 +2,13 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get SevenZipParser () {
-        return _indexts.SevenZipParser;
-    },
-    get default () {
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
         return _SevenZipIteratorts.default;
     }
 });
 var _SevenZipIteratorts = /*#__PURE__*/ _interop_require_default(require("./SevenZipIterator.js"));
-var _indexts = require("./sevenz/index.js");
 _export_star(require("./types.js"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/index.ts"],"sourcesContent":["export { default } from './SevenZipIterator.ts';\nexport type { ArchiveSource, SevenZipEntry } from './sevenz/index.ts';\nexport { SevenZipParser } from './sevenz/index.ts';\nexport * from './types.ts';\n"],"names":["SevenZipParser","default"],"mappings":";;;;;;;;;;;QAESA;eAAAA,uBAAc;;QAFdC;eAAAA,2BAAO;;;yEAAQ;uBAEO;qBACjB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/7z-iterator/src/index.ts"],"sourcesContent":["export { default } from './SevenZipIterator.ts';\nexport * from './types.ts';\n"],"names":["default"],"mappings":";;;;+BAASA;;;eAAAA,2BAAO;;;yEAAQ;qBACV"}

package/dist/cjs/lib/streamToSource.d.cts

@@ -1,20 +1,17 @@
-import { BufferSource, FileSource } from '../sevenz/SevenZipParser.js';
+import { FileSource } from '../sevenz/SevenZipParser.js';
 export interface StreamToSourceOptions {
-    memoryThreshold?: number;
-    tempPath?: string;
+    tempPath: string;
 }
 export interface SourceResult {
-    source: BufferSource | FileSource;
-    fd?: number;
-    tempPath?: string;
+    source: FileSource;
+    fd: number;
+    tempPath: string;
 }
 export type Callback = (error?: Error, result?: SourceResult) => void;
 /**
- * Convert a stream to an ArchiveSource (BufferSource for small files, FileSource for large)
+ * Convert a stream to a FileSource by writing to temp file
  *
- * Algorithm:
- * 1. Buffer stream data in memory up to memoryThreshold
- * 2. If threshold exceeded, write all buffered data to temp file and continue streaming
- * 3. When done, return BufferSource for memory buffer or FileSource for temp file
+ * 7z format requires random access for header parsing, so temp file is necessary for streams.
+ * Writes directly to temp file for predictable O(1) memory usage during stream consumption.
  */
 export default function streamToSource(stream: NodeJS.ReadableStream, options: StreamToSourceOptions, callback: Callback): void;

package/dist/cjs/lib/streamToSource.d.ts

@@ -1,20 +1,17 @@
-import { BufferSource, FileSource } from '../sevenz/SevenZipParser.js';
+import { FileSource } from '../sevenz/SevenZipParser.js';
 export interface StreamToSourceOptions {
-    memoryThreshold?: number;
-    tempPath?: string;
+    tempPath: string;
 }
 export interface SourceResult {
-    source: BufferSource | FileSource;
-    fd?: number;
-    tempPath?: string;
+    source: FileSource;
+    fd: number;
+    tempPath: string;
 }
 export type Callback = (error?: Error, result?: SourceResult) => void;
 /**
- * Convert a stream to an ArchiveSource (BufferSource for small files, FileSource for large)
+ * Convert a stream to a FileSource by writing to temp file
  *
- * Algorithm:
- * 1. Buffer stream data in memory up to memoryThreshold
- * 2. If threshold exceeded, write all buffered data to temp file and continue streaming
- * 3. When done, return BufferSource for memory buffer or FileSource for temp file
+ * 7z format requires random access for header parsing, so temp file is necessary for streams.
+ * Writes directly to temp file for predictable O(1) memory usage during stream consumption.
  */
 export default function streamToSource(stream: NodeJS.ReadableStream, options: StreamToSourceOptions, callback: Callback): void;