neozipkit 0.7.2 → 1.0.2

package/src/node/ZipDecompressNode.ts

@@ -14,8 +14,9 @@
 //
 
 const pako = require('pako');
-import { ZstdManager } from '../core/ZstdManager';
 import ZipkitNode from './ZipkitNode';
+import { ZstdNode } from './ZstdNode';
+import { repairLegacyWasmZstdPlaintext } from './LegacyZstd';
 import { Logger } from '../core/components/Logger';
 import ZipEntry from '../core/ZipEntry';
 import Errors from '../core/constants/Errors';
@@ -125,6 +126,18 @@ export class ZipDecompressNode {
     return await this.extractToBufferInternal(fileHandle, entry, options);
   }
 
+  /**
+   * Read the raw compressed payload for an entry (no decrypt / decompress).
+   */
+  async readCompressedPayload(entry: ZipEntry): Promise<Buffer> {
+    const fileHandle = (this.zipkitNode as any).getFileHandle();
+    const chunks: Buffer[] = [];
+    for await (const chunk of this.readCompressedDataStream(fileHandle, entry)) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  }
+
   /**
    * Test entry integrity without extracting to disk
    * Validates CRC-32 or SHA-256 hash without writing decompressed data
@@ -228,19 +241,15 @@ export class ZipDecompressNode {
         entry.aesVersion > 0 || entry.cmpMethod === CMP_METHOD.AES_ENCRYPT || entry.neoCryptoAlgorithm > 0;
 
       if (isEncrypted && isFullPayloadCrypto) {
-        // WinZip AES or NeoEncrypt: read full payload, decrypt in one shot (HMAC must be verified first)
+        // WinZip AES / NeoEncrypt: stream decrypt (HMAC verified at end of ciphertext)
         const dataStream = this.readCompressedDataStream(fileHandle, entry);
-        const chunks: Buffer[] = [];
-        for await (const chunk of dataStream) {
-          chunks.push(chunk);
-        }
-        const fullPayload = Buffer.concat(chunks);
-        const decrypted = AesCrypto.decryptBuffer(entry, fullPayload, (this.zipkitNode as any).password);
-
-        // Wrap decrypted data as a single-item generator for the decompression pipeline
+        const decrypted = AesCrypto.decryptStream(
+          (this.zipkitNode as any).password,
+          entry.compressedSize,
+          dataStream
+        );
         const skipHash = entry.aesVersion === 2 ? true : options?.skipHashCheck;
-        async function* singleChunk() { yield decrypted; }
-        await this.unCompressToFile(singleChunk(), entry, writeStream, {
+        await this.unCompressToFile(decrypted, entry, writeStream, {
           skipHashCheck: skipHash,
           onProgress: options?.onProgress,
           outputPath
@@ -297,16 +306,13 @@ export class ZipDecompressNode {
 
       if (isEncrypted && isFullPayloadCrypto) {
         const dataStream = this.readCompressedDataStream(fileHandle, entry);
-        const chunks: Buffer[] = [];
-        for await (const chunk of dataStream) {
-          chunks.push(chunk);
-        }
-        const fullPayload = Buffer.concat(chunks);
-        const decrypted = AesCrypto.decryptBuffer(entry, fullPayload, (this.zipkitNode as any).password);
-
+        const decrypted = AesCrypto.decryptStream(
+          (this.zipkitNode as any).password,
+          entry.compressedSize,
+          dataStream
+        );
         const skipHash = entry.aesVersion === 2 ? true : options?.skipHashCheck;
-        async function* singleChunk() { yield decrypted; }
-        return await this.unCompressToBuffer(singleChunk(), entry, {
+        return await this.unCompressToBuffer(decrypted, entry, {
           skipHashCheck: skipHash,
           onProgress: options?.onProgress
         });
@@ -357,16 +363,13 @@ export class ZipDecompressNode {
 
       if (isEncrypted && isFullPayloadCrypto) {
         const dataStream = this.readCompressedDataStream(fileHandle, entry);
-        const chunks: Buffer[] = [];
-        for await (const chunk of dataStream) {
-          chunks.push(chunk);
-        }
-        const fullPayload = Buffer.concat(chunks);
-        const decrypted = AesCrypto.decryptBuffer(entry, fullPayload, (this.zipkitNode as any).password);
-
+        const decrypted = AesCrypto.decryptStream(
+          (this.zipkitNode as any).password,
+          entry.compressedSize,
+          dataStream
+        );
         const skipHash = entry.aesVersion === 2 ? true : options?.skipHashCheck;
-        async function* singleChunk() { yield decrypted; }
-        return await this.unCompressToTest(singleChunk(), entry, {
+        return await this.unCompressToTest(decrypted, entry, {
           skipHashCheck: skipHash,
           onProgress: options?.onProgress
         });
@@ -662,8 +665,8 @@ export class ZipDecompressNode {
       // Use pako streaming inflate - maintains state across chunks
       yield* this.inflateStream(compressedStream);
     } else if (method === CMP_METHOD.ZSTD) {
-      // Use ZSTD streaming decompression - note: ZSTD requires full buffer
-      yield* this.zstdDecompressStream(compressedStream);
+      // Native Node zstd; bound output to entry size (repairs legacy WASM +18 padding)
+      yield* this.zstdDecompressStream(compressedStream, entry?.uncompressedSize ?? 0);
     } else {
       throw new Error(`Unsupported compression method: ${method}`);
     }
@@ -707,36 +710,32 @@ export class ZipDecompressNode {
   }
 
   /**
-   * Streaming ZSTD decompression
+   * Streaming ZSTD decompression via Node zlib (native).
+   * When maxOut > 0, truncates output (legacy WASM emitted +18 zero bytes).
    */
   private async *zstdDecompressStream(
-    compressedStream: AsyncGenerator<Buffer>
+    compressedStream: AsyncGenerator<Buffer>,
+    maxOut: number = 0
   ): AsyncGenerator<Buffer> {
-    // ZSTD is guaranteed to be initialized via factory method
-    
-    // Collect all compressed chunks first (ZSTD needs complete data)
-    const compressedChunks: Buffer[] = [];
-    for await (const chunk of compressedStream) {
-      compressedChunks.push(chunk);
-    }
-    
-    const compressedData = Buffer.concat(compressedChunks);
-    
     try {
-      // Use global ZstdManager for decompression
-      const decompressed = await ZstdManager.decompress(compressedData);
-      const decompressedBuffer = Buffer.from(decompressed);
-      
-      // Yield decompressed data in chunks using ZipkitServer's bufferSize
-      const chunkSize = this.zipkitNode.getBufferSize();
-      let offset = 0;
-      while (offset < decompressedBuffer.length) {
-        const end = Math.min(offset + chunkSize, decompressedBuffer.length);
-        yield decompressedBuffer.slice(offset, end);
-        offset = end;
+      let remaining = maxOut > 0 ? maxOut : Number.POSITIVE_INFINITY;
+      for await (const chunk of ZstdNode.decompressStream(compressedStream)) {
+        if (remaining <= 0) {
+          break;
+        }
+        if (chunk.length <= remaining) {
+          remaining -= chunk.length;
+          yield chunk;
+        } else {
+          yield chunk.subarray(0, remaining);
+          remaining = 0;
+          break;
+        }
       }
     } catch (error) {
-      throw new Error(`ZSTD streaming decompression failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `ZSTD streaming decompression failed: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
 
@@ -750,20 +749,35 @@ export class ZipDecompressNode {
   }
 
   /**
-   * Zstd decompress method (now async with ZstdManager)
-   * Internal method only
+   * Zstd decompress via Node zlib (native), repairing legacy WASM +18 padding when present.
    */
-  private async zstdDecompressSync(data: Buffer): Promise<Buffer> {
+  private async zstdDecompressSync(data: Buffer, entry?: ZipEntry): Promise<Buffer> {
     this.log(`zstdDecompressSync() called with ${data.length} bytes`);
-    
+
     try {
-      // Use global ZstdManager for decompression
-      const decompressed = await ZstdManager.decompress(data);
-      this.log(`ZSTD decompression successful: ${data.length} bytes -> ${decompressed.length} bytes`);
-      return Buffer.from(decompressed);
+      let decompressed = await ZstdNode.decompress(data);
+      if (entry && entry.uncompressedSize > 0) {
+        const { repaired, wasLegacy } = repairLegacyWasmZstdPlaintext(
+          decompressed,
+          entry.uncompressedSize,
+          entry.crc
+        );
+        if (wasLegacy) {
+          this.log(
+            `Legacy WASM zstd padding repaired: ${decompressed.length} -> ${repaired.length} bytes`
+          );
+        }
+        decompressed = repaired;
+      }
+      this.log(
+        `ZSTD decompression successful: ${data.length} bytes -> ${decompressed.length} bytes`
+      );
+      return decompressed;
     } catch (error) {
       this.log(`ZSTD decompression failed: ${error}`);
-      throw new Error(`ZSTD decompression failed: ${error instanceof Error ? error.message : String(error)}`);
+      throw new Error(
+        `ZSTD decompression failed: ${error instanceof Error ? error.message : String(error)}`
+      );
     }
   }
 
@@ -794,7 +808,7 @@ export class ZipDecompressNode {
     } else if (method === CMP_METHOD.DEFLATED) {
       outBuf = this.inflate(compressedData);
     } else if (method === CMP_METHOD.ZSTD) {
-      outBuf = await this.zstdDecompressSync(compressedData);
+      outBuf = await this.zstdDecompressSync(compressedData, entry);
     } else {
       throw new Error(`Unsupported compression method: ${method}`);
     }

package/src/node/ZipkitNode.ts

@@ -19,6 +19,11 @@ import {
   ENCRYPT_HDR_SIZE
 } from '../core/constants/Headers';
 import { NEO_CRYPTO_ALGORITHM_AES256_V1 } from '../core/encryption/NeoCrypto';
+import { AesCrypto } from '../core/encryption/AesCrypto';
+import {
+  detectLegacyWasmZstd,
+  type LegacyZstdDetectResult,
+} from './LegacyZstd';
 import * as fs from 'fs';
 import * as path from 'path';
 import { minimatch } from 'minimatch';
@@ -345,6 +350,75 @@ export default class ZipkitNode extends Zipkit {
     };
   }
 
+  /**
+   * Scan the loaded archive (or `archivePath`) for entries compressed with the
+   * legacy NeoZipKit WASM zstd codec (`@oneidentity/zstd-js`).
+   *
+   * Encrypted entries are skipped unless you only need a header check after
+   * decrypting externally — this API inspects raw stored payloads.
+   */
+  async detectLegacyZstdEntries(
+    archivePath?: string,
+    options?: { verify?: boolean }
+  ): Promise<Array<{ entry: ZipEntry; detection: LegacyZstdDetectResult }>> {
+    if (archivePath && !this.filePath) {
+      await this.loadZipFile(archivePath);
+    }
+    if (!this.filePath) {
+      throw new Error('Archive not loaded. Call loadZipFile() first or provide archivePath parameter.');
+    }
+
+    const verify = options?.verify !== false;
+    const results: Array<{ entry: ZipEntry; detection: LegacyZstdDetectResult }> = [];
+    const entries = this.getDirectory();
+
+    for (const entry of entries) {
+      if (entry.isDirectory) {
+        continue;
+      }
+      const method =
+        entry.cmpMethod === CMP_METHOD.AES_ENCRYPT && entry.realCmpMethod >= 0
+          ? entry.realCmpMethod
+          : entry.cmpMethod;
+      if (method !== CMP_METHOD.ZSTD) {
+        continue;
+      }
+      if (entry.isEncrypted || (entry.bitFlags & GP_FLAG.ENCRYPTED)) {
+        results.push({
+          entry,
+          detection: {
+            isLegacyWasm: false,
+            confidence: 'none',
+            frameContentSize: null,
+            expectedUncompressedSize: entry.uncompressedSize,
+            paddingBytes: 18,
+            reason: 'Encrypted zstd entry — decrypt before detecting legacy WASM frames',
+          },
+        });
+        continue;
+      }
+
+      const compressed = await this.getZipDecompressNode().readCompressedPayload(entry);
+
+      if (!verify) {
+        const detection = await detectLegacyWasmZstd(compressed, entry.uncompressedSize, {
+          verify: false,
+          crc: entry.crc,
+        });
+        results.push({ entry, detection });
+        continue;
+      }
+
+      const detection = await detectLegacyWasmZstd(compressed, entry.uncompressedSize, {
+        verify: true,
+        crc: entry.crc,
+      });
+      results.push({ entry, detection });
+    }
+
+    return results;
+  }
+
   /**
    * Test entry integrity without extracting to disk
    * Validates CRC-32 or SHA-256 hash without writing decompressed data
@@ -578,8 +652,12 @@ export default class ZipkitNode extends Zipkit {
     // For AES encryption, pre-configure the entry so the initial local header
     // includes the 0x9901 extra field and method 99. The actual compression
     // method is preserved in realCmpMethod for the AES extra field.
-    const isAesRequested = options?.password && options?.encryptionMethod === 'aes256';
-    const isNeoRequested = options?.password && options?.encryptionMethod === 'neo-aes256';
+    // Default password encryption is WinZip AES-256 (matches compressData).
+    const encMethod = options?.password
+      ? (options.encryptionMethod || 'aes256')
+      : undefined;
+    const isAesRequested = encMethod === 'aes256';
+    const isNeoRequested = encMethod === 'neo-aes256';
     if (isAesRequested) {
       entry.cmpMethod = CMP_METHOD.AES_ENCRYPT;
       entry.aesVersion = 1;
@@ -615,55 +693,87 @@ export default class ZipkitNode extends Zipkit {
       });
     });
 
-    // Step 3: Compress file and write data
+    // Step 3: Compress file and write data (chunked when large).
+    // ZipCrypto still uses the buffer path (legacy header needs CRC up front).
+    // AES / NeoEncrypt use AesEncryptor so ciphertext is written in chunks.
     const bufferSize = options?.bufferSize || this.getBufferSize();
-    const useZstd = options?.useZstd !== false;
-    // Never use the chunked/streaming path when encrypting: the streaming path writes
-    // compressed data to the writer via onOutputBuffer BEFORE encryption can be applied.
-    // Encryption requires the full compressed buffer to create the 12-byte header and
-    // encrypt all data in one pass, so we must use the buffer path (compressFile).
-    const shouldUseChunked = !useZstd && !options?.password && entry.uncompressedSize && entry.uncompressedSize > bufferSize;
-
-    if (shouldUseChunked) {
-      // Use streaming compression for large files
-      // Data is written directly via onOutputBuffer callback
-      const onOutputBuffer = async (data: Buffer) => {
-        await new Promise<void>((resolve, reject) => {
-          writer.outputStream.write(data, (error) => {
-            if (error) {
-              reject(error);
-            } else {
-              writer.currentPosition += data.length;
-              if (callbacks?.onProgress) {
-                callbacks.onProgress(entry, data.length);
-              }
-              resolve();
-            }
-          });
-        });
-      };
-
-      // compressFileStream will set entry.compressedSize and entry.crc
-      await this.compressFileStream(filePath, entry, options, onOutputBuffer);
-    } else {
-      // Use regular buffer compression for small files
-      // compressFile will set entry.compressedSize and entry.crc
-      const compressedData = await this.compressFile(filePath, entry, options);
-      
-      // Write compressed data to file
+    const useZipCrypto = encMethod === 'zipcrypto';
+    const shouldUseChunked =
+      !!entry.uncompressedSize &&
+      entry.uncompressedSize > bufferSize &&
+      !useZipCrypto;
+
+    const writeChunk = async (data: Buffer): Promise<void> => {
+      if (data.length === 0) {
+        return;
+      }
       await new Promise<void>((resolve, reject) => {
-        writer.outputStream.write(compressedData, (error) => {
+        writer.outputStream.write(data, (error) => {
           if (error) {
             reject(error);
           } else {
-            writer.currentPosition += compressedData.length;
+            writer.currentPosition += data.length;
             if (callbacks?.onProgress) {
-              callbacks.onProgress(entry, compressedData.length);
+              callbacks.onProgress(entry, data.length);
             }
             resolve();
           }
         });
       });
+    };
+
+    if (shouldUseChunked) {
+      const useAesStream = isAesRequested || isNeoRequested;
+      const encryptor = useAesStream
+        ? AesCrypto.createEncryptor(options!.password!)
+        : null;
+      let streamedBytes = 0;
+
+      if (encryptor) {
+        const hdr = encryptor.header();
+        await writeChunk(hdr);
+        streamedBytes += hdr.length;
+        entry.isEncrypted = true;
+        entry.bitFlags |= GP_FLAG.ENCRYPTED;
+      }
+
+      // Compress without applying buffer encrypt — we stream-encrypt below.
+      const streamOptions: CompressOptions = encryptor
+        ? { ...options, password: undefined, encryptionMethod: undefined }
+        : { ...options };
+
+      const onOutputBuffer = async (data: Buffer) => {
+        const out = encryptor ? encryptor.update(data) : data;
+        await writeChunk(out);
+        streamedBytes += out.length;
+      };
+
+      await this.compressFileStream(filePath, entry, streamOptions, onOutputBuffer);
+
+      if (encryptor) {
+        const auth = encryptor.finish();
+        await writeChunk(auth);
+        streamedBytes += auth.length;
+        entry.compressedSize = streamedBytes;
+        entry.isEncrypted = true;
+        entry.bitFlags |= GP_FLAG.ENCRYPTED;
+        // compressFileStream overwrites cmpMethod with the real codec — restore AES/Neo metadata
+        if (isAesRequested) {
+          entry.realCmpMethod = realCmpMethod;
+          entry.cmpMethod = CMP_METHOD.AES_ENCRYPT;
+          entry.aesVersion = 1;
+          entry.aesStrength = 3;
+        } else if (isNeoRequested) {
+          entry.cmpMethod = realCmpMethod;
+          entry.neoCryptoPayloadVersion = 1;
+          entry.neoCryptoAlgorithm = NEO_CRYPTO_ALGORITHM_AES256_V1;
+          entry.neoCryptoFlags = 0;
+        }
+      }
+    } else {
+      // Small files / ZipCrypto: buffer compression (may encrypt inside compressFile)
+      const compressedData = await this.compressFile(filePath, entry, options);
+      await writeChunk(compressedData);
     }
 
     // Step 4: Patch local header in-place with final compressed size, CRC, and flags

package/src/node/ZstdNode.ts

@@ -0,0 +1,155 @@
+/**
+ * ZstdNode - Native Node.js Zstandard via zlib (streaming / chunked)
+ *
+ * This is the only zstd backend in NeoZipKit. There is no WASM codec.
+ * Requires Node.js with `zlib.createZstdCompress` (Node >= 22.15 or >= 23.8).
+ * Browser builds alias this module to a stub that throws.
+ */
+
+import * as zlib from 'zlib';
+import { Readable } from 'stream';
+import { promisify } from 'util';
+
+const zstdCompressAsync = promisify(zlib.zstdCompress);
+const zstdDecompressAsync = promisify(zlib.zstdDecompress);
+
+export function isNativeZstdAvailable(): boolean {
+  return (
+    typeof zlib.createZstdCompress === 'function' &&
+    typeof zlib.createZstdDecompress === 'function' &&
+    typeof zlib.zstdCompress === 'function' &&
+    typeof zlib.zstdDecompress === 'function'
+  );
+}
+
+function assertNativeZstd(): void {
+  if (!isNativeZstdAvailable()) {
+    throw new Error(
+      'Native zstd requires Node.js with zlib ZSTD support ' +
+        '(Node.js >= 22.15 or >= 23.8).'
+    );
+  }
+}
+
+/** Map NeoZipKit level 1–9 to a zstd compression level (1–19). */
+export function mapCompressionLevel(level: number): number {
+  return Math.min(Math.max(1, Math.floor(level * 2.1)), 19);
+}
+
+function compressOptions(level: number): zlib.ZstdOptions {
+  return {
+    params: {
+      [zlib.constants.ZSTD_c_compressionLevel]: mapCompressionLevel(level),
+    },
+  };
+}
+
+export function createCompressTransform(level: number = 6): zlib.ZstdCompress {
+  assertNativeZstd();
+  return zlib.createZstdCompress(compressOptions(level));
+}
+
+export function createDecompressTransform(): zlib.ZstdDecompress {
+  assertNativeZstd();
+  return zlib.createZstdDecompress();
+}
+
+export async function compress(data: Buffer, level: number = 6): Promise<Buffer> {
+  assertNativeZstd();
+  const result = await zstdCompressAsync(data, compressOptions(level));
+  return Buffer.from(result);
+}
+
+export async function decompress(data: Buffer): Promise<Buffer> {
+  assertNativeZstd();
+  const result = await zstdDecompressAsync(data);
+  return Buffer.from(result);
+}
+
+export function compressSync(data: Buffer, level: number = 6): Buffer {
+  assertNativeZstd();
+  return zlib.zstdCompressSync(data, compressOptions(level));
+}
+
+export function decompressSync(data: Buffer): Buffer {
+  assertNativeZstd();
+  return zlib.zstdDecompressSync(data);
+}
+
+/**
+ * Stream-compress plaintext from a chunked reader (primary path for all sizes).
+ */
+export async function compressChunks(
+  readChunk: (position: number, size: number) => Buffer,
+  totalSize: number,
+  chunkSize: number,
+  level: number,
+  onPlainChunk?: (chunk: Buffer) => void,
+  onCompressedChunk?: (chunk: Buffer) => void | Promise<void>
+): Promise<number> {
+  async function* plainChunks(): AsyncGenerator<Buffer> {
+    let position = 0;
+    while (position < totalSize) {
+      const size = Math.min(chunkSize, totalSize - position);
+      const chunk = readChunk(position, size);
+      onPlainChunk?.(chunk);
+      position += chunk.length;
+      yield chunk;
+    }
+  }
+
+  const transform = createCompressTransform(level);
+  const readable = Readable.from(plainChunks());
+  readable.pipe(transform);
+
+  let compressedSize = 0;
+  try {
+    for await (const out of transform) {
+      const buf = Buffer.isBuffer(out) ? out : Buffer.from(out as Uint8Array);
+      compressedSize += buf.length;
+      if (onCompressedChunk) {
+        await onCompressedChunk(buf);
+      }
+    }
+  } finally {
+    readable.destroy();
+    transform.destroy();
+  }
+
+  return compressedSize;
+}
+
+/**
+ * Decompress an async iterable of compressed chunks, yielding plaintext buffers.
+ */
+export async function* decompressStream(
+  compressedStream: AsyncIterable<Buffer>
+): AsyncGenerator<Buffer> {
+  const transform = createDecompressTransform();
+  const readable = Readable.from(compressedStream);
+  readable.pipe(transform);
+
+  try {
+    for await (const chunk of transform) {
+      yield Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk as Uint8Array);
+    }
+  } finally {
+    readable.destroy();
+    transform.destroy();
+  }
+}
+
+export const ZstdNode = {
+  isNativeZstdAvailable,
+  mapCompressionLevel,
+  createCompressTransform,
+  createDecompressTransform,
+  compress,
+  decompress,
+  compressSync,
+  decompressSync,
+  compressChunks,
+  decompressStream,
+};
+
+export default ZstdNode;

package/src/node/index.ts

@@ -21,6 +21,16 @@ export default ZipkitNodeDefault;
 export type { ZipFileWriter } from './ZipkitNode';
 export { ZipCompressNode } from './ZipCompressNode';
 export { ZipDecompressNode } from './ZipDecompressNode';
+export { ZstdNode, isNativeZstdAvailable } from './ZstdNode';
+export {
+  LegacyZstd,
+  LEGACY_WASM_ZSTD_PADDING,
+  parseZstdFrameContentSize,
+  looksLikeLegacyWasmZstd,
+  detectLegacyWasmZstd,
+  repairLegacyWasmZstdPlaintext,
+} from './LegacyZstd';
+export type { LegacyZstdDetectResult, LegacyZstdConfidence, DetectLegacyZstdOptions } from './LegacyZstd';
 
 // Efficient ZIP copying using ZipEntry directly
 export { ZipCopyNode } from './ZipCopyNode';

package/dist/core/ZstdManager.d.ts

@@ -1,56 +0,0 @@
-/**
- * ZstdManager - Global Zstd Codec Manager
- *
- * This manager ensures safe usage of the Zstd WASM module across multiple instances.
- *
- * ## Why This Is Necessary
- *
- * The `@oneidentity/zstd-js` library uses a shared WASM module internally.
- * While `ZstdInit()` returns different object references, they all share the same
- * `ZstdSimple` implementation and WASM memory/heap.
- *
- * This means concurrent or improperly managed sequential operations can cause
- * memory corruption because they're all operating on the same underlying WASM state.
- *
- * ## How It Works
- *
- * 1. Single initialization: WASM module is initialized once globally
- * 2. Operation queuing: All compress/decompress operations are queued
- * 3. Sequential execution: JavaScript's single-threaded nature ensures safe execution
- * 4. Automatic initialization: Lazy initialization on first use
- *
- * ## Usage
- *
- * ```typescript
- * import { ZstdManager } from './ZstdManager';
- *
- * // Compress
- * const compressed = await ZstdManager.compress(data, level);
- *
- * // Decompress
- * const decompressed = await ZstdManager.decompress(compressedData);
- * ```
- */
-/**
- * Global Zstd Manager
- * Use this for all Zstd compression/decompression operations
- */
-export declare const ZstdManager: {
-    /**
-     * Compress data using Zstd
-     * Operations are automatically queued to prevent interference
-     */
-    compress: (data: Uint8Array, level?: number) => Promise<Uint8Array<ArrayBufferLike>>;
-    /**
-     * Decompress data using Zstd
-     * Operations are automatically queued to prevent interference
-     */
-    decompress: (data: Uint8Array | Buffer) => Promise<Uint8Array<ArrayBufferLike>>;
-    /**
-     * Reset the manager (for testing)
-     * @internal
-     */
-    reset: () => void;
-};
-export default ZstdManager;
-//# sourceMappingURL=ZstdManager.d.ts.map

package/dist/core/ZstdManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ZstdManager.d.ts","sourceRoot":"","sources":["../../src/core/ZstdManager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAyGH;;;GAGG;AACH,eAAO,MAAM,WAAW;IACtB;;;OAGG;qBACc,UAAU,UAAU,MAAM;IAG3C;;;OAGG;uBACgB,UAAU,GAAG,MAAM;IAGtC;;;OAGG;;CAEJ,CAAC;AAEF,eAAe,WAAW,CAAC"}