@push.rocks/smartarchive 4.2.3 → 5.0.0

package/dist_ts/bzip2/index.d.ts

@@ -1,2 +1,5 @@
 import * as plugins from '../plugins.js';
-export declare function unbzip2Stream(): plugins.smartstream.SmartDuplex<any, void>;
+/**
+ * Creates a streaming BZIP2 decompression transform
+ */
+export declare function unbzip2Stream(): plugins.smartstream.SmartDuplex<Buffer, Buffer>;

package/dist_ts/bzip2/index.js

@@ -1,42 +1,42 @@
 import * as plugins from '../plugins.js';
+import { Bzip2Error, BZIP2_ERROR_CODES } from '../errors.js';
 import { Bzip2 } from './bzip2.js';
 import { bitIterator } from './bititerator.js';
+/**
+ * Creates a streaming BZIP2 decompression transform
+ */
 export function unbzip2Stream() {
     const bzip2Instance = new Bzip2();
-    var bufferQueue = [];
-    var hasBytes = 0;
-    var blockSize = 0;
-    var broken = false;
-    var done = false;
-    var bitReader = null;
-    var streamCRC = null;
+    const bufferQueue = [];
+    let hasBytes = 0;
+    let blockSize = 0;
+    let broken = false;
+    let bitReader = null;
+    let streamCRC = null;
     function decompressBlock() {
         if (!blockSize) {
             blockSize = bzip2Instance.header(bitReader);
             streamCRC = 0;
+            return undefined;
         }
-        else {
-            var bufsize = 100000 * blockSize;
-            var buf = new Int32Array(bufsize);
-            var chunk = [];
-            var f = function (b) {
-                chunk.push(b);
-            };
-            streamCRC = bzip2Instance.decompress(bitReader, f, buf, bufsize, streamCRC);
-            if (streamCRC === null) {
-                // reset for next bzip2 header
-                blockSize = 0;
-                return;
-            }
-            else {
-                return Buffer.from(chunk);
-            }
+        const bufsize = 100000 * blockSize;
+        const buf = new Int32Array(bufsize);
+        const chunk = [];
+        const outputFunc = (b) => {
+            chunk.push(b);
+        };
+        streamCRC = bzip2Instance.decompress(bitReader, outputFunc, buf, bufsize, streamCRC);
+        if (streamCRC === null) {
+            // Reset for next bzip2 header
+            blockSize = 0;
+            return undefined;
         }
+        return Buffer.from(chunk);
     }
-    var outlength = 0;
+    let outlength = 0;
     const decompressAndPush = async () => {
         if (broken)
-            return;
+            return undefined;
         try {
             const resultChunk = decompressBlock();
             if (resultChunk) {
@@ -45,18 +45,18 @@ export function unbzip2Stream() {
             return resultChunk;
         }
         catch (e) {
-            console.error(e);
             broken = true;
+            if (e instanceof Error) {
+                throw new Bzip2Error(`Decompression failed: ${e.message}`, BZIP2_ERROR_CODES.INVALID_BLOCK_DATA);
+            }
+            throw e;
         }
     };
-    let counter = 0;
     return new plugins.smartstream.SmartDuplex({
         objectMode: true,
         name: 'bzip2',
-        debug: false,
         highWaterMark: 1,
         writeFunction: async function (data, streamTools) {
-            // console.log(`got chunk ${counter++}`)
             bufferQueue.push(data);
             hasBytes += data.length;
             if (bitReader === null) {
@@ -64,19 +64,17 @@ export function unbzip2Stream() {
                     return bufferQueue.shift();
                 });
             }
-            while (!broken &&
-                hasBytes - bitReader.bytesRead + 1 >= (25000 + 100000 * blockSize || 4)) {
-                //console.error('decompressing with', hasBytes - bitReader.bytesRead + 1, 'bytes in buffer');
+            const threshold = 25000 + 100000 * blockSize || 4;
+            while (!broken && hasBytes - bitReader.bytesRead + 1 >= threshold) {
                 const result = await decompressAndPush();
                 if (!result) {
                     continue;
                 }
-                // console.log(result.toString());
                 await streamTools.push(result);
             }
+            return null;
         },
         finalFunction: async function (streamTools) {
-            //console.error(x,'last compressing with', hasBytes, 'bytes in buffer');
             while (!broken && bitReader && hasBytes > bitReader.bytesRead) {
                 const result = await decompressAndPush();
                 if (!result) {
@@ -84,11 +82,11 @@ export function unbzip2Stream() {
                 }
                 await streamTools.push(result);
             }
-            if (!broken) {
-                if (streamCRC !== null)
-                    this.emit('error', new Error('input stream ended prematurely'));
+            if (!broken && streamCRC !== null) {
+                this.emit('error', new Bzip2Error('Input stream ended prematurely', BZIP2_ERROR_CODES.PREMATURE_END));
             }
+            return null;
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.archiveanalyzer.d.ts

@@ -1,15 +1,35 @@
 import type { SmartArchive } from './classes.smartarchive.js';
 import * as plugins from './plugins.js';
+/**
+ * Type for decompression streams
+ */
+export type TDecompressionStream = plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract;
+/**
+ * Result of archive analysis
+ */
 export interface IAnalyzedResult {
-    fileType: plugins.fileType.FileTypeResult;
+    fileType: plugins.fileType.FileTypeResult | undefined;
     isArchive: boolean;
-    resultStream: plugins.smartstream.SmartDuplex;
-    decompressionStream: plugins.stream.Transform | plugins.stream.Duplex | plugins.tarStream.Extract;
+    resultStream: plugins.smartstream.SmartDuplex<Buffer, Buffer>;
+    decompressionStream: TDecompressionStream;
 }
+/**
+ * Analyzes archive streams to detect format and provide decompression
+ */
 export declare class ArchiveAnalyzer {
-    smartArchiveRef: SmartArchive;
+    private smartArchiveRef;
     constructor(smartArchiveRefArg: SmartArchive);
+    /**
+     * Check if a MIME type represents an archive format
+     */
     private mimeTypeIsArchive;
+    /**
+     * Get the appropriate decompression stream for a MIME type
+     */
     private getDecompressionStream;
-    getAnalyzedStream(): plugins.smartstream.SmartDuplex<Buffer<ArrayBufferLike>, IAnalyzedResult>;
+    /**
+     * Create an analyzed stream that detects archive type and provides decompression
+     * Emits a single IAnalyzedResult object
+     */
+    getAnalyzedStream(): plugins.smartstream.SmartDuplex<Buffer, IAnalyzedResult>;
 }

package/dist_ts/classes.archiveanalyzer.js

@@ -1,9 +1,17 @@
 import * as plugins from './plugins.js';
+/**
+ * Analyzes archive streams to detect format and provide decompression
+ */
 export class ArchiveAnalyzer {
     constructor(smartArchiveRefArg) {
         this.smartArchiveRef = smartArchiveRefArg;
     }
+    /**
+     * Check if a MIME type represents an archive format
+     */
     async mimeTypeIsArchive(mimeType) {
+        if (!mimeType)
+            return false;
         const archiveMimeTypes = new Set([
             'application/zip',
             'application/x-rar-compressed',
@@ -11,10 +19,12 @@ export class ArchiveAnalyzer {
             'application/gzip',
             'application/x-7z-compressed',
             'application/x-bzip2',
-            // Add other archive mime types here
         ]);
         return archiveMimeTypes.has(mimeType);
     }
+    /**
+     * Get the appropriate decompression stream for a MIME type
+     */
     async getDecompressionStream(mimeTypeArg) {
         switch (mimeTypeArg) {
             case 'application/gzip':
@@ -22,14 +32,18 @@ export class ArchiveAnalyzer {
             case 'application/zip':
                 return this.smartArchiveRef.zipTools.getDecompressionStream();
             case 'application/x-bzip2':
-                return await this.smartArchiveRef.bzip2Tools.getDecompressionStream(); // replace with your own bzip2 decompression stream
+                return this.smartArchiveRef.bzip2Tools.getDecompressionStream();
             case 'application/x-tar':
-                return this.smartArchiveRef.tarTools.getDecompressionStream(); // replace with your own tar decompression stream
+                return this.smartArchiveRef.tarTools.getDecompressionStream();
             default:
                 // Handle unsupported formats or no decompression needed
                 return plugins.smartstream.createPassThrough();
         }
     }
+    /**
+     * Create an analyzed stream that detects archive type and provides decompression
+     * Emits a single IAnalyzedResult object
+     */
     getAnalyzedStream() {
         let firstRun = true;
         const resultStream = plugins.smartstream.createPassThrough();
@@ -40,9 +54,6 @@ export class ArchiveAnalyzer {
                     firstRun = false;
                     const fileType = await plugins.fileType.fileTypeFromBuffer(chunkArg);
                     const decompressionStream = await this.getDecompressionStream(fileType?.mime);
-                    /**
-                     * analyzed stream emits once with this object
-                     */
                     const result = {
                         fileType,
                         isArchive: await this.mimeTypeIsArchive(fileType?.mime),
@@ -54,7 +65,7 @@ export class ArchiveAnalyzer {
                 await resultStream.backpressuredPush(chunkArg);
                 return null;
             },
-            finalFunction: async (tools) => {
+            finalFunction: async () => {
                 resultStream.push(null);
                 return null;
             },
@@ -62,4 +73,4 @@ export class ArchiveAnalyzer {
         return analyzerstream;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5hcmNoaXZlYW5hbHl6ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9jbGFzc2VzLmFyY2hpdmVhbmFseXplci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssT0FBTyxNQUFNLGNBQWMsQ0FBQztBQW9CeEM7O0dBRUc7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUcxQixZQUFZLGtCQUFnQztRQUMxQyxJQUFJLENBQUMsZUFBZSxHQUFHLGtCQUFrQixDQUFDO0lBQzVDLENBQUM7SUFFRDs7T0FFRztJQUNLLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxRQUE0QjtRQUMxRCxJQUFJLENBQUMsUUFBUTtZQUFFLE9BQU8sS0FBSyxDQUFDO1FBRTVCLE1BQU0sZ0JBQWdCLEdBQWdCLElBQUksR0FBRyxDQUFDO1lBQzVDLGlCQUFpQjtZQUNqQiw4QkFBOEI7WUFDOUIsbUJBQW1CO1lBQ25CLGtCQUFrQjtZQUNsQiw2QkFBNkI7WUFDN0IscUJBQXFCO1NBQ3RCLENBQUMsQ0FBQztRQUVILE9BQU8sZ0JBQWdCLENBQUMsR0FBRyxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3hDLENBQUM7SUFFRDs7T0FFRztJQUNLLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxXQUEyQjtRQUM5RCxRQUFRLFdBQVcsRUFBRSxDQUFDO1lBQ3BCLEtBQUssa0JBQWtCO2dCQUNyQixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUFDLHNCQUFzQixFQUFFLENBQUM7WUFDakUsS0FBSyxpQkFBaUI7Z0JBQ3BCLE9BQU8sSUFBSSxDQUFDLGVBQWUsQ0FBQyxRQUFRLENBQUMsc0JBQXNCLEVBQUUsQ0FBQztZQUNoRSxLQUFLLHFCQUFxQjtnQkFDeEIsT0FBTyxJQUFJLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQyxzQkFBc0IsRUFBRSxDQUFDO1lBQ2xFLEtBQUssbUJBQW1CO2dCQUN0QixPQUFPLElBQUksQ0FBQyxlQUFlLENBQUMsUUFBUSxDQUFDLHNCQUFzQixFQUFFLENBQUM7WUFDaEU7Z0JBQ0Usd0RBQXdEO2dCQUN4RCxPQUFPLE9BQU8sQ0FBQyxXQUFXLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztRQUNuRCxDQUFDO0lBQ0gsQ0FBQztJQUVEOzs7T0FHRztJQUNJLGlCQUFpQjtRQUN0QixJQUFJLFFBQVEsR0FBRyxJQUFJLENBQUM7UUFDcEIsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLFdBQVcsQ0FBQyxpQkFBaUIsRUFBRSxDQUFDO1FBRTdELE1BQU0sY0FBYyxHQUFHLElBQUksT0FBTyxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQTBCO1lBQ2xGLGtCQUFrQixFQUFFLElBQUk7WUFDeEIsYUFBYSxFQUFFLEtBQUssRUFBRSxRQUFnQixFQUFFLFdBQVcsRUFBRSxFQUFFO2dCQUNyRCxJQUFJLFFBQVEsRUFBRSxDQUFDO29CQUNiLFFBQVEsR0FBRyxLQUFLLENBQUM7b0JBQ2pCLE1BQU0sUUFBUSxHQUFHLE1BQU0sT0FBTyxDQUFDLFFBQVEsQ0FBQyxrQkFBa0IsQ0FBQyxRQUFRLENBQUMsQ0FBQztvQkFDckUsTUFBTSxtQkFBbUIsR0FBRyxNQUFNLElBQUksQ0FBQyxzQkFBc0IsQ0FBQyxRQUFRLEVBQUUsSUFBc0IsQ0FBQyxDQUFDO29CQUVoRyxNQUFNLE1BQU0sR0FBb0I7d0JBQzlCLFFBQVE7d0JBQ1IsU0FBUyxFQUFFLE1BQU0sSUFBSSxDQUFDLGlCQUFpQixDQUFDLFFBQVEsRUFBRSxJQUFJLENBQUM7d0JBQ3ZELFlBQVk7d0JBQ1osbUJBQW1CO3FCQUNwQixDQUFDO29CQUNGLE1BQU0sV0FBVyxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztnQkFDakMsQ0FBQztnQkFDRCxNQUFNLFlBQVksQ0FBQyxpQkFBaUIsQ0FBQyxRQUFRLENBQUMsQ0FBQztnQkFDL0MsT0FBTyxJQUFJLENBQUM7WUFDZCxDQUFDO1lBQ0QsYUFBYSxFQUFFLEtBQUssSUFBSSxFQUFFO2dCQUN4QixZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO2dCQUN4QixPQUFPLElBQUksQ0FBQztZQUNkLENBQUM7U0FDRixDQUFDLENBQUM7UUFFSCxPQUFPLGNBQWMsQ0FBQztJQUN4QixDQUFDO0NBQ0YifQ==

package/dist_ts/classes.bzip2tools.d.ts

@@ -3,5 +3,5 @@ import * as plugins from './plugins.js';
 export declare class Bzip2Tools {
     smartArchiveRef: SmartArchive;
     constructor(smartArchiveRefArg: SmartArchive);
-    getDecompressionStream(): plugins.smartstream.SmartDuplex<any, void>;
+    getDecompressionStream(): plugins.smartstream.SmartDuplex<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
 }

package/dist_ts/classes.gziptools.d.ts

@@ -1,16 +1,49 @@
 import * as plugins from './plugins.js';
-export declare class CompressGunzipTransform extends plugins.stream.Transform {
-    constructor();
+import type { TCompressionLevel } from './interfaces.js';
+/**
+ * Transform stream for GZIP compression using fflate
+ */
+export declare class GzipCompressionTransform extends plugins.stream.Transform {
+    private gzip;
+    constructor(level?: TCompressionLevel);
     _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
+    _flush(callback: plugins.stream.TransformCallback): void;
 }
-export declare class DecompressGunzipTransform extends plugins.stream.Transform {
+/**
+ * Transform stream for GZIP decompression using fflate
+ */
+export declare class GzipDecompressionTransform extends plugins.stream.Transform {
     private gunzip;
     constructor();
     _transform(chunk: Buffer, encoding: BufferEncoding, callback: plugins.stream.TransformCallback): void;
     _flush(callback: plugins.stream.TransformCallback): void;
 }
+/**
+ * GZIP compression and decompression utilities
+ */
 export declare class GzipTools {
-    constructor();
-    getCompressionStream(): CompressGunzipTransform;
-    getDecompressionStream(): DecompressGunzipTransform;
+    /**
+     * Get a streaming compression transform
+     */
+    getCompressionStream(level?: TCompressionLevel): plugins.stream.Transform;
+    /**
+     * Get a streaming decompression transform
+     */
+    getDecompressionStream(): plugins.stream.Transform;
+    /**
+     * Compress data synchronously
+     */
+    compressSync(data: Buffer, level?: TCompressionLevel): Buffer;
+    /**
+     * Decompress data synchronously
+     */
+    decompressSync(data: Buffer): Buffer;
+    /**
+     * Compress data asynchronously
+     */
+    compress(data: Buffer, level?: TCompressionLevel): Promise<Buffer>;
+    /**
+     * Decompress data asynchronously
+     */
+    decompress(data: Buffer): Promise<Buffer>;
 }

package/dist_ts/classes.gziptools.js

@@ -1,39 +1,53 @@
 import * as plugins from './plugins.js';
-// This class wraps fflate's gunzip in a Node.js Transform stream
-export class CompressGunzipTransform extends plugins.stream.Transform {
-    constructor() {
+/**
+ * Transform stream for GZIP compression using fflate
+ */
+export class GzipCompressionTransform extends plugins.stream.Transform {
+    constructor(level = 6) {
         super();
-    }
-    _transform(chunk, encoding, callback) {
-        plugins.fflate.gunzip(chunk, (err, decompressed) => {
-            if (err) {
-                callback(err);
-            }
-            else {
-                this.push(decompressed);
-                callback();
+        // Create a streaming Gzip compressor
+        this.gzip = new plugins.fflate.Gzip({ level }, (chunk, final) => {
+            this.push(Buffer.from(chunk));
+            if (final) {
+                this.push(null);
             }
         });
     }
+    _transform(chunk, encoding, callback) {
+        try {
+            this.gzip.push(chunk, false);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
+    _flush(callback) {
+        try {
+            this.gzip.push(new Uint8Array(0), true);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    }
 }
-// DecompressGunzipTransform class that extends the Node.js Transform stream to
-// create a stream that decompresses GZip-compressed data using fflate's gunzip function
-export class DecompressGunzipTransform extends plugins.stream.Transform {
+/**
+ * Transform stream for GZIP decompression using fflate
+ */
+export class GzipDecompressionTransform extends plugins.stream.Transform {
     constructor() {
         super();
         // Create a streaming Gunzip decompressor
         this.gunzip = new plugins.fflate.Gunzip((chunk, final) => {
-            // Push decompressed chunks to the output stream
             this.push(Buffer.from(chunk));
             if (final) {
-                // Signal end of stream when decompression is complete
                 this.push(null);
             }
         });
     }
     _transform(chunk, encoding, callback) {
         try {
-            // Feed chunks to the gunzip stream
             this.gunzip.push(chunk, false);
             callback();
         }
@@ -43,7 +57,6 @@ export class DecompressGunzipTransform extends plugins.stream.Transform {
     }
     _flush(callback) {
         try {
-            // Signal end of input to gunzip
             this.gunzip.push(new Uint8Array(0), true);
             callback();
         }
@@ -52,13 +65,61 @@ export class DecompressGunzipTransform extends plugins.stream.Transform {
         }
     }
 }
+/**
+ * GZIP compression and decompression utilities
+ */
 export class GzipTools {
-    constructor() { }
-    getCompressionStream() {
-        return new CompressGunzipTransform();
+    /**
+     * Get a streaming compression transform
+     */
+    getCompressionStream(level) {
+        return new GzipCompressionTransform(level);
     }
+    /**
+     * Get a streaming decompression transform
+     */
     getDecompressionStream() {
-        return new DecompressGunzipTransform();
+        return new GzipDecompressionTransform();
+    }
+    /**
+     * Compress data synchronously
+     */
+    compressSync(data, level) {
+        const options = level !== undefined ? { level } : undefined;
+        return Buffer.from(plugins.fflate.gzipSync(data, options));
+    }
+    /**
+     * Decompress data synchronously
+     */
+    decompressSync(data) {
+        return Buffer.from(plugins.fflate.gunzipSync(data));
+    }
+    /**
+     * Compress data asynchronously
+     */
+    async compress(data, level) {
+        return new Promise((resolve, reject) => {
+            const options = level !== undefined ? { level } : undefined;
+            plugins.fflate.gzip(data, options, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(Buffer.from(result));
+            });
+        });
+    }
+    /**
+     * Decompress data asynchronously
+     */
+    async decompress(data) {
+        return new Promise((resolve, reject) => {
+            plugins.fflate.gunzip(data, (err, result) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(Buffer.from(result));
+            });
+        });
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.smartarchive.d.ts

@@ -1,32 +1,117 @@
 import * as plugins from './plugins.js';
+import type { IArchiveCreationOptions, IArchiveEntry, IArchiveExtractionOptions, IArchiveEntryInfo, IArchiveInfo } from './interfaces.js';
 import { Bzip2Tools } from './classes.bzip2tools.js';
 import { GzipTools } from './classes.gziptools.js';
 import { TarTools } from './classes.tartools.js';
 import { ZipTools } from './classes.ziptools.js';
 import { ArchiveAnalyzer } from './classes.archiveanalyzer.js';
+/**
+ * Main class for archive manipulation
+ * Supports TAR, ZIP, GZIP, and BZIP2 formats
+ */
 export declare class SmartArchive {
-    static fromArchiveUrl(urlArg: string): Promise<SmartArchive>;
-    static fromArchiveFile(filePathArg: string): Promise<SmartArchive>;
-    static fromArchiveStream(streamArg: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform): Promise<SmartArchive>;
+    /**
+     * Create SmartArchive from a URL
+     */
+    static fromUrl(urlArg: string): Promise<SmartArchive>;
+    /**
+     * Create SmartArchive from a local file path
+     */
+    static fromFile(filePathArg: string): Promise<SmartArchive>;
+    /**
+     * Create SmartArchive from a readable stream
+     */
+    static fromStream(streamArg: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform): Promise<SmartArchive>;
+    /**
+     * Create SmartArchive from an in-memory buffer
+     */
+    static fromBuffer(buffer: Buffer): Promise<SmartArchive>;
+    /**
+     * Create a new archive from a directory
+     */
+    static fromDirectory(directoryPath: string, options: IArchiveCreationOptions): Promise<SmartArchive>;
+    /**
+     * Create a new archive from an array of entries
+     */
+    static fromFiles(files: IArchiveEntry[], options: IArchiveCreationOptions): Promise<SmartArchive>;
+    /**
+     * Start building an archive incrementally using a builder pattern
+     */
+    static create(options: IArchiveCreationOptions): SmartArchive;
+    /**
+     * Helper to convert a stream to buffer
+     */
+    private static streamToBuffer;
     tarTools: TarTools;
     zipTools: ZipTools;
     gzipTools: GzipTools;
     bzip2Tools: Bzip2Tools;
     archiveAnalyzer: ArchiveAnalyzer;
-    sourceUrl: string;
-    sourceFilePath: string;
-    sourceStream: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform;
-    archiveName: string;
-    singleFileMode: boolean;
-    addedDirectories: string[];
-    addedFiles: (plugins.smartfile.SmartFile | plugins.smartfile.StreamFile)[];
-    addedUrls: string[];
+    sourceUrl?: string;
+    sourceFilePath?: string;
+    sourceStream?: plugins.stream.Readable | plugins.stream.Duplex | plugins.stream.Transform;
+    private archiveBuffer?;
+    private creationOptions?;
+    private pendingEntries?;
     constructor();
     /**
-     * gets the original archive stream
+     * Add a file to the archive (builder pattern)
+     */
+    addFile(archivePath: string, content: string | Buffer): this;
+    /**
+     * Add a SmartFile to the archive (builder pattern)
+     */
+    addSmartFile(file: plugins.smartfile.SmartFile, archivePath?: string): this;
+    /**
+     * Add a StreamFile to the archive (builder pattern)
+     */
+    addStreamFile(file: plugins.smartfile.StreamFile, archivePath?: string): this;
+    /**
+     * Build the archive from pending entries
+     */
+    build(): Promise<SmartArchive>;
+    /**
+     * Get the original archive stream
+     */
+    toStream(): Promise<plugins.stream.Readable>;
+    /**
+     * Get archive as a Buffer
+     */
+    toBuffer(): Promise<Buffer>;
+    /**
+     * Write archive to a file
+     */
+    toFile(filePath: string): Promise<void>;
+    /**
+     * Extract archive to filesystem
+     */
+    extractToDirectory(targetDir: string, options?: Partial<IArchiveExtractionOptions>): Promise<void>;
+    /**
+     * Extract archive to a stream of StreamFile objects
+     */
+    extractToStream(): Promise<plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>>;
+    /**
+     * Extract archive to an array of SmartFile objects (in-memory)
+     */
+    extractToSmartFiles(): Promise<plugins.smartfile.SmartFile[]>;
+    /**
+     * Extract a single file from the archive by path
+     */
+    extractFile(filePath: string): Promise<plugins.smartfile.SmartFile | null>;
+    /**
+     * Analyze the archive and return metadata
+     */
+    analyze(): Promise<IArchiveInfo>;
+    /**
+     * List all entries in the archive without extracting
+     */
+    listEntries(): Promise<IArchiveEntryInfo[]>;
+    /**
+     * Check if a specific file exists in the archive
+     */
+    hasFile(filePath: string): Promise<boolean>;
+    /**
+     * Helper to read first chunk from stream
      */
-    getArchiveStream(): Promise<plugins.stream.Readable>;
-    exportToTarGzStream(): Promise<void>;
-    exportToFs(targetDir: string, fileNameArg?: string): Promise<void>;
-    exportToStreamOfStreamFiles(): Promise<plugins.smartstream.StreamIntake<plugins.smartfile.StreamFile>>;
+    private readFirstChunk;
 }