neozipkit 0.1.1 → 0.3.0

package/src/browser/{ZipKitBrowser.ts → ZipkitBrowser.ts}

@@ -1,39 +1,41 @@
 // ======================================
-//	ZipKitBrowser.ts
+//	ZipkitBrowser.ts
 //  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
 // ======================================
 
-import ZipKit, { CompressOptions, CreateZipOptions } from '../shared/ZipKit';
-import ZipEntry from '../shared/ZipEntry';
-import Errors from '../shared/constants/Errors';
-import * as Headers from '../shared/constants/Headers';
-import { TOKENIZED_METADATA, TIMESTAMP_SUBMITTED, TIMESTAMP_METADATA } from '../shared/constants/Headers';
-import { sha256 } from '../shared/components/ZipCrypto';
-import { crc32 } from '../shared/components/Util';
-import { DATATYPE, getTypeOf } from '../shared/components/Util';
-import type { FileData } from '../shared/types';
-
-// Re-export everything from ZipKit
-export * from '../shared/ZipKit';
+import Zipkit, { CompressOptions, CreateZipOptions } from '../core';
+import ZipEntry from '../core/ZipEntry';
+import { ZipCompress } from '../core/ZipCompress';
+import Errors from '../core/constants/Errors';
+import * as Headers from '../core/constants/Headers';
+import { TOKENIZED_METADATA, TIMESTAMP_SUBMITTED, TIMESTAMP_METADATA } from '../core/constants/Headers';
+import { sha256, crc32 } from '../core/encryption/ZipCrypto';
+import { DATATYPE, getTypeOf } from '../core/components/Util';
+import type { FileData } from '../types';
+import HashCalculator from '../core/components/HashCalculator';
+
+// Re-export everything from Zipkit
+export * from '../core';
 export { ZipEntry, Errors, Headers, sha256, getTypeOf };
 
 // ======================================
-//	ZipKitBrowser
+//	ZipkitBrowser
 // ======================================
 
-export default class ZipKitBrowser extends ZipKit {
+export default class ZipkitBrowser extends Zipkit {
   constructor() {
     super();      // Call the parent constructor
 
-    // console.log('ZipKit.support.isNode: ', ZipKit.support.isNode);
-    // console.log('ZipKit.support.buffer: ', ZipKit.support.buffer);
-    // console.log('ZipKit.support.blob: ', ZipKit.support.blob);
-    // console.log('ZipKit.support.streams: ', ZipKit.support.streams);
-    // console.log('ZipKit.support.fileReader: ', ZipKit.support.fileReader);
+    // console.log('Zipkit.support.isNode: ', Zipkit.support.isNode);
+    // console.log('Zipkit.support.buffer: ', Zipkit.support.buffer);
+    // console.log('Zipkit.support.blob: ', Zipkit.support.blob);
+    // console.log('Zipkit.support.streams: ', Zipkit.support.streams);
+    // console.log('Zipkit.support.fileReader: ', Zipkit.support.fileReader);
   }
 
   // --------------------------------------
   // Load a ZIP file from a Blob and return the ZipEntry array
+  // Always uses loadZip() to ensure proper initialization
 
   async loadZipBlob(data: Blob): Promise<ZipEntry[] | null> {
     if (getTypeOf(data) !== DATATYPE.BLOB) {
@@ -41,30 +43,34 @@ export default class ZipKitBrowser extends ZipKit {
     }
 
     return new Promise((resolve, reject) => {
-      const _readEntries = (data: Buffer): ZipEntry[] | null => {
-        try { 
-          super.loadZip(data);
-          return super.getDirectory();
-        } catch (error) {
-          reject(error);
-          return null;
-        }
-      };
-
       const reader = new window.FileReader();
       reader.readAsArrayBuffer(data);
 
-      reader.onload = function(this: FileReader, e: ProgressEvent<FileReader>) {
-        if (!this.result) {
+      reader.onload = (e: ProgressEvent<FileReader>) => {
+        if (!reader.result) {
           reject(new Error('Failed to read file'));
           return;
         }
-        const _inBuf = Buffer.from(this.result as ArrayBuffer);
-        resolve(_readEntries(_inBuf));
+        
+        try {
+          // Convert ArrayBuffer to Buffer
+          const buffer = Buffer.from(reader.result as ArrayBuffer);
+          
+          // Always use loadZip() which:
+          // 1. Resets ZIP data
+          // 2. Stores buffer in this.inBuffer
+          // 3. Loads EOCD and parses central directory
+          // 4. Stores entries in this.zipEntries
+          // 5. Returns the entries
+          const entries = super.loadZip(buffer);
+          resolve(entries);
+        } catch (error) {
+          reject(error);
+        }
       };
 
-      reader.onerror = function(this: FileReader, e: ProgressEvent<FileReader>) {
-        reject(this.error || new Error('Failed to read file'));
+      reader.onerror = () => {
+        reject(reader.error || new Error('Failed to read file'));
       };
     });
   }
@@ -104,7 +110,8 @@ export default class ZipKitBrowser extends ZipKit {
 
     return new Promise(async (resolve, reject) => {
       const _compressData = async (entry: ZipEntry, data: Buffer, options?: CompressOptions): Promise<Buffer> => {
-        return await super.compressData(entry, data, options);
+        // Use Zipkit wrapper method
+        return await this.compressData(entry, data, options);
       };
 
       const reader = new window.FileReader();
@@ -135,7 +142,7 @@ export default class ZipKitBrowser extends ZipKit {
 
   async extractBlob(entry: ZipEntry, skipHashCheck?: boolean): Promise<Blob | null> {
     try {
-      const _outBuf = await super.extract(entry, skipHashCheck);
+      const _outBuf = await this.extract(entry, skipHashCheck);
       if (!_outBuf) return null;
       
       // Convert Buffer to Uint8Array for Blob compatibility
@@ -170,7 +177,7 @@ export default class ZipKitBrowser extends ZipKit {
           entry.isUpdated = true;
           // Don't continue here - let it fall through to special handling below
         } else {
-          const inData = super.copyEntry(entry);
+          const inData = await super.copyEntry(entry);
           entry.localHdrOffset = offset;
           offset += inData.length;
           buffers.push(inData);
@@ -186,6 +193,19 @@ export default class ZipKitBrowser extends ZipKit {
 
       const fileBuffer = await entry.fileData.arrayBuffer();
       
+      // Special handling for already-compressed entries - use existing compressed data
+      if (entry.cmpData && entry.compressedSize && entry.crc) {
+        // Entry is already compressed, use the existing compressed data
+        const localHdr = entry.createLocalHdr();
+        entry.localHdrOffset = offset;
+        offset += localHdr.length + entry.cmpData.length;
+        
+        buffers.push(localHdr);
+        buffers.push(entry.cmpData);
+        _onEntryDone(entry, 'Written (pre-compressed)');
+        continue;
+      }
+      
       // Special handling for token metadata files - store uncompressed with CRC-32
       if (entry.filename === TOKENIZED_METADATA || entry.filename === TIMESTAMP_SUBMITTED || entry.filename === TIMESTAMP_METADATA) {
         // For token metadata, use STORED compression (no compression)
@@ -211,7 +231,7 @@ export default class ZipKitBrowser extends ZipKit {
         _onEntryDone(entry, 'Stored (metadata)');
       } else {
         // Normal file processing with compression
-        const cmpData = await super.compressData(entry, Buffer.from(fileBuffer), cmpOptions);
+        const cmpData = await this.compressData(entry, Buffer.from(fileBuffer), cmpOptions);
         const localHdr = entry.createLocalHdr();
 
         entry.localHdrOffset = offset;
@@ -238,5 +258,48 @@ export default class ZipKitBrowser extends ZipKit {
     // Convert Buffer to Uint8Array for Blob compatibility
     const uint8Array = new Uint8Array(combinedBuffer);
     return new Blob([uint8Array], { type: 'application/zip' });
-  } 
+  }
+
+  /**
+   * Checks if a filename is a blockchain metadata file that should be excluded from Merkle Root calculation
+   * @param filename - The filename to check
+   * @returns boolean - True if the file is a metadata file
+   */
+  private isMetadataFile(filename: string): boolean {
+    return filename === TIMESTAMP_SUBMITTED ||
+           filename === TIMESTAMP_METADATA ||
+           filename === TOKENIZED_METADATA;
+  }
+
+  // --------------------------------------
+  // Helper method: Add a file to the ZIP with compression
+  // Simplifies the common workflow of creating entry + compressing
+
+  async addFile(file: FileData, options?: CompressOptions): Promise<ZipEntry> {
+    // Create entry
+    const entry = this.createZipFileEntry(file);
+    
+    // Compress the file
+    // In browser, File objects implement both FileData and Blob interfaces
+    // We need to convert FileData to Blob for compressDataBlob
+    const fileBlob = file as unknown as Blob;
+    const compressedData = await this.compressDataBlob(entry, fileBlob, options);
+    entry.cmpData = compressedData;
+    
+    return entry;
+  }
+
+  // --------------------------------------
+  // Verify a ZIP entry by attempting to extract it
+  // Returns true if the entry is valid, false otherwise
+
+  async verifyEntry(entry: ZipEntry, skipHashCheck?: boolean): Promise<boolean> {
+    try {
+      const blob = await this.extractBlob(entry, skipHashCheck);
+      return blob !== null;
+    } catch (error) {
+      console.error(`Verification failed for ${entry.filename}:`, error);
+      return false;
+    }
+  }
 }

package/src/browser/index.esm.ts

@@ -0,0 +1,37 @@
+// =============================================================================
+// NeoZipkit - Browser ES Module Entry Point
+// =============================================================================
+// This is a clean ES module entry point for browser bundles
+// All exports are named exports for better tree-shaking support
+
+// Buffer polyfill for browser
+import { Buffer } from 'buffer';
+if (typeof globalThis !== 'undefined') {
+  (globalThis as any).Buffer = Buffer;
+}
+
+// Core exports
+export * from '../core';
+
+// Browser-specific class
+export { default as ZipkitBrowser } from './ZipkitBrowser';
+
+// Re-export ZipEntry as named export for convenience
+export { default as ZipEntry } from '../core/ZipEntry';
+
+// Re-export commonly used types and constants
+export type { CompressOptions, CreateZipOptions } from '../core/ZipCompress';
+export type { FileData, TokenMetadata } from '../types';
+export * from '../core/constants/Headers';
+export * from '../core/constants/Errors';
+
+// Blockchain exports for browser (if needed)
+export * from '../blockchain/browser';
+export { createTokenVerifier } from '../blockchain/browser';
+
+// Platform utilities
+export const PlatformUtils = {
+  isBrowser: typeof window !== 'undefined' && typeof document !== 'undefined',
+  isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
+};
+

package/src/browser/index.ts

@@ -0,0 +1,25 @@
+// =============================================================================
+// NeoZipkit - Browser-Only Package Exports  
+// =============================================================================
+
+// Core shared exports (re-exported from core module)
+export * from '../core';
+import Zipkit from '../core';
+export default Zipkit;
+
+// Browser-only exports
+export { default as ZipkitBrowser } from './ZipkitBrowser';
+export { TokenMetadata } from '../types';
+
+// Blockchain exports for browser
+export * from '../blockchain/browser';
+export { createTokenVerifier } from '../blockchain/browser';
+
+// Platform-specific conditional exports
+export const PlatformUtils = {
+  // Browser detection
+  isBrowser: typeof window !== 'undefined' && typeof document !== 'undefined',
+  // Node.js detection  
+  isNode: typeof process !== 'undefined' && process.versions && process.versions.node,
+};
+

package/src/core/ZipCompress.ts

@@ -0,0 +1,398 @@
+// ======================================
+//	ZipkitCompress.ts - Compression Module
+//  Copyright (c) 2025 NeoWare, Inc. All rights reserved.
+// ======================================
+//
+// LOGGING INSTRUCTIONS:
+// ---------------------
+// To enable/disable logging, set loggingEnabled to true/false in the class:
+//   private static loggingEnabled: boolean = true;  // Enable logging
+//   private static loggingEnabled: boolean = false; // Disable logging
+//
+// Logging respects the global Logger level (debug, info, warn, error, silent).
+// Logger level is automatically set to 'debug' when loggingEnabled is true.
+//
+
+const pako = require('pako');
+import { ZstdInit, ZstdSimple } from '@oneidentity/zstd-js';
+import Zipkit from './Zipkit';
+import { Logger } from './components/Logger';
+import ZipEntry from './ZipEntry';
+import Errors from './constants/Errors';
+import { CMP_METHOD, GP_FLAG, ENCRYPT_HDR_SIZE } from './constants/Headers';
+import { HashCalculator } from './components/HashCalculator';
+import { ZipCrypto } from './encryption/ZipCrypto';
+
+// We'll initialize zstd when needed
+let zstdCodec: { ZstdSimple: typeof ZstdSimple } | null = null;
+
+// Async initialization function for zstd
+async function initZstd(): Promise<{ ZstdSimple: typeof ZstdSimple }> {
+  if (!zstdCodec) {
+    zstdCodec = await ZstdInit();
+  }
+  return zstdCodec;
+}
+
+/**
+ * Options for compressing files in a ZIP archive
+ */
+export interface CompressOptions {
+  level?: number;             // Compression level (1-9, 0=store)
+  password?: string | null;   // Password for encryption
+  useSHA256?: boolean;        // Whether to calculate SHA256 hash default is false
+  useZstd?: boolean;          // Whether to use Zstandard compression default is true
+  bufferSize?: number;        // Override default buffer size
+}
+
+/**
+ * Callbacks for ZIP file creation process
+ * Buffer-based only - no file I/O operations
+ */
+export interface CreateZipOptions {
+  onError?: (error: Error) => void;              // Called when an error occurs
+  onEntryDone?: (entry: ZipEntry, status: string) => void;  // Called when entry processing completes
+  onOutputBuffer?: (data: Buffer) => Promise<void>;       // Called to write output data
+}
+
+/**
+ * Compression handler for ZIP files
+ * Supports Deflate, Zstandard, and Store methods
+ */
+export class ZipCompress {
+  private zipkit: Zipkit;
+  private debug: boolean;
+
+  // Class-level logging control - set to true to enable logging
+  private static loggingEnabled: boolean = false;
+
+  /**
+   * Internal logging method - only logs if class logging is enabled
+   */
+  private log(...args: any[]): void {
+    if (ZipCompress.loggingEnabled) {
+      Logger.debug(`[ZipCompress]`, ...args);
+    }
+  }
+
+  /**
+   * Creates a new ZipCompress instance
+   * @param zipkit - Zipkit instance to use for ZIP operations
+   */
+  constructor(zipkit: Zipkit) {
+    this.zipkit = zipkit;
+    // Debug disabled by default (controlled by class-level logging)
+    this.debug = false;
+    // If logging is enabled, ensure Logger level is set to debug
+    if (ZipCompress.loggingEnabled) {
+      Logger.setLevel('debug');
+    }
+    this.log(`ZipCompress initialized`);
+  }
+
+  /**
+   * Compresses data for a ZIP entry (Buffer-based only)
+   * @param entry - ZIP entry to compress
+   * @param data - Buffer containing data to compress
+   * @param options - Compression options
+   * @param onOutputBuffer - Optional callback for streaming output
+   * @returns Buffer containing compressed data
+   */
+  async compressData(entry: ZipEntry, data: Buffer, options?: CompressOptions, onOutputBuffer?: (data: Buffer) => Promise<void>): Promise<Buffer> {
+    this.log(`compressData() called for entry: ${entry.filename}`);
+    
+    // Set uncompressed size if not already set
+    if (!entry.uncompressedSize || entry.uncompressedSize === 0) {
+      entry.uncompressedSize = data.length;
+    }
+    const totalSize = data.length;
+    const bufferSize = options?.bufferSize || this.zipkit.getBufferSize(); // Use Zipkit's bufferSize
+    
+    this.log(`Compressing ${totalSize} bytes for entry: ${entry.filename}`);
+    this.log(`Compression options:`, { level: options?.level, useZstd: options?.useZstd, bufferSize });
+    
+    // Determine compression method
+    let compressionMethod: number;
+    
+    if (options?.level === 0) {
+      compressionMethod = CMP_METHOD.STORED;
+      this.log(`Using STORED method (no compression)`);
+    } else if (options?.useZstd) {
+      // ZSTD fallback to STORED if file too small
+      if (totalSize < 100) {
+        compressionMethod = CMP_METHOD.STORED;
+        this.log(`ZSTD fallback to STORED (file too small: ${totalSize} bytes)`);
+      } else {
+        compressionMethod = CMP_METHOD.ZSTD;
+        this.log(`Using ZSTD method (zstd compression)`);
+      }
+    } else {
+      compressionMethod = CMP_METHOD.DEFLATED;
+      this.log(`Using DEFLATED method (default compression)`);
+    }
+    
+    entry.cmpMethod = compressionMethod;
+    
+    // Initialize hash calculator
+    const needsHashCalculation = (!entry.crc || entry.crc === 0) || (options?.useSHA256 && !entry.sha256);
+    const hashCalculator = needsHashCalculation ? new HashCalculator({ useSHA256: options?.useSHA256 && !entry.sha256 || false }) : null;
+    
+    // Calculate hashes if needed
+    if (hashCalculator) {
+      hashCalculator.update(data);
+      if (!entry.crc || entry.crc === 0) {
+        entry.crc = hashCalculator.finalizeCRC32();
+      }
+      if (options?.useSHA256 && !entry.sha256) {
+        entry.sha256 = hashCalculator.finalizeSHA256();
+      }
+      this.log(`Final hashes: CRC32=0x${entry.crc.toString(16).padStart(8, '0')}, SHA256=${entry.sha256 || 'N/A'}`);
+    }
+    
+    // Encrypt if password provided
+    if (options?.password) {
+      this.log(`Encrypting compressed data for entry: ${entry.filename}`);
+      (entry as any).gpFlag = ((entry as any).gpFlag || 0) | GP_FLAG.ENCRYPTED;
+      (entry as any).isEncrypted = true;
+    }
+    
+    // Compress data based on method
+    let compressedData: Buffer;
+    const methodName = compressionMethod === CMP_METHOD.ZSTD ? 'ZSTD' : compressionMethod === CMP_METHOD.DEFLATED ? 'DEFLATED' : 'STORED';
+    
+    if (compressionMethod === CMP_METHOD.STORED) {
+      compressedData = data;
+    } else {
+      this.log(`Processing sequence for ${methodName}: [HASH] -> [COMPRESS] -> [OUTPUT]`);
+      this.log(`Compressing: method=${methodName}, input=${totalSize} bytes, buffer size=${bufferSize} bytes`);
+      this.log(`Calculating hashes: CRC32=${!entry.crc || entry.crc === 0}, SHA256=${options?.useSHA256}`);
+      
+      if (compressionMethod === CMP_METHOD.ZSTD) {
+        compressedData = await this.zstdCompress(data, options, bufferSize, entry, onOutputBuffer);
+      } else {
+        compressedData = await this.deflateCompress(data, options, bufferSize, entry, onOutputBuffer);
+      }
+    }
+    
+    // Encrypt compressed data if password provided
+    if (options?.password) {
+      compressedData = this.encryptCompressedData(entry, compressedData, options.password);
+    }
+    
+    entry.compressedSize = compressedData.length;
+    
+    return compressedData;
+  }
+
+  /**
+   * Compress data using deflate algorithm with chunked processing
+   * @param data - Data to compress (Buffer or chunked reader)
+   * @param options - Compression options
+   * @param bufferSize - Buffer size for chunked processing
+   * @param entry - ZIP entry being compressed
+   * @param onOutputBuffer - Optional callback for streaming output
+   * @returns Buffer containing compressed data
+   */
+  async deflateCompress(
+    data: Buffer | { totalSize: number, onReadChunk: (position: number, size: number) => Buffer, onOutChunk: (chunk: Buffer) => void },
+    options?: CompressOptions,
+    bufferSize?: number,
+    entry?: ZipEntry,
+    onOutputBuffer?: (data: Buffer) => Promise<void>
+  ): Promise<Buffer> {
+    this.log(`deflateCompress() called - entry: ${entry?.filename ?? 'unknown'}, bufferSize: ${bufferSize}, level: ${options?.level ?? 6}`);
+    
+    const effectiveBufferSize = bufferSize || this.zipkit.getBufferSize();
+    const level = options?.level ?? 6;
+    
+    // Handle chunked reader
+    if (typeof data === 'object' && 'totalSize' in data && 'onReadChunk' in data) {
+      // Chunked reader mode - not implemented in simplified version
+      throw new Error('Chunked reader mode not supported in ZipCompress');
+    }
+    
+    // For small data, use synchronous deflate
+    if (data.length <= effectiveBufferSize) {
+      return this.deflate(data, options);
+    }
+    
+    // For large data, use chunked deflate
+    const deflator = new pako.Deflate({ level, raw: true });
+    const compressedChunks: Buffer[] = [];
+    let totalProcessed = 0;
+    let totalCompressedSize = 0;
+    
+    try {
+      // Process data in chunks
+      for (let offset = 0; offset < data.length; offset += effectiveBufferSize) {
+        const chunk = data.slice(offset, offset + effectiveBufferSize);
+        const isLast = offset + effectiveBufferSize >= data.length;
+        
+        deflator.push(chunk, isLast);
+        
+        // Collect compressed chunks
+        if (deflator.result && deflator.result.length > 0) {
+          const compressedChunk = Buffer.from(deflator.result);
+          compressedChunks.push(compressedChunk);
+          totalCompressedSize += compressedChunk.length;
+          
+          // Stream output if callback provided
+          if (onOutputBuffer) {
+            await onOutputBuffer(compressedChunk);
+          }
+        }
+        
+        totalProcessed += chunk.length;
+      }
+      
+      // Calculate compression ratio
+      const ratio = totalProcessed > 0 ? Math.round((totalCompressedSize / totalProcessed) * 100) : 0;
+      this.log(`Final hashes: CRC32=0x${entry?.crc?.toString(16).padStart(8, '0')}, SHA256=${entry?.sha256 || 'N/A'}`);
+      this.log(`Deflate compression complete: ${totalCompressedSize} bytes from ${totalProcessed} bytes (ratio=${ratio}%)`);
+      
+      return Buffer.concat(compressedChunks);
+    } catch (e) {
+      throw new Error(`Deflate compression failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+
+  /**
+   * Compress data using deflate algorithm (synchronous, small buffers only)
+   * @param inbuf - Buffer containing data to compress
+   * @param options - Compression options
+   * @returns Buffer containing compressed data
+   */
+  deflate(inbuf: Buffer, options?: CompressOptions): Buffer {
+    this.log(`deflate() called with buffer size: ${inbuf.length}, level: ${options?.level ?? 6}`);
+    const level = options?.level ?? 6;
+    const result = pako.deflateRaw(inbuf, { level });
+    const ratio = inbuf.length > 0 ? Math.round((result.length / inbuf.length) * 100) : 0;
+    this.log(`Deflate compression complete: ${result.length} bytes from ${inbuf.length} bytes (ratio=${ratio}%)`);
+    return Buffer.from(result.buffer, result.byteOffset, result.byteLength);
+  }
+
+  /**
+   * Compress data using Zstandard (zstd) algorithm
+   * @param input - Input data to compress (Buffer or chunked reader)
+   * @param options - Compression options
+   * @param bufferSize - Buffer size for chunked processing
+   * @param entry - ZIP entry being compressed
+   * @param onOutputBuffer - Optional callback for streaming output
+   * @returns Buffer containing compressed data
+   */
+  async zstdCompress(
+    input: Buffer | { totalSize: number, readChunk: (position: number, size: number) => Buffer },
+    options?: CompressOptions,
+    bufferSize?: number,
+    entry?: ZipEntry,
+    onOutputBuffer?: (data: Buffer) => Promise<void>
+  ): Promise<Buffer> {
+    this.log(`zstdCompress() called - entry: ${entry?.filename ?? 'unknown'}, bufferSize: ${bufferSize}, level: ${options?.level ?? 6}`);
+    
+    const effectiveBufferSize = bufferSize || this.zipkit.getBufferSize();
+    const level = options?.level ?? 6;
+    
+    // Handle chunked reader
+    if (typeof input === 'object' && 'totalSize' in input && 'readChunk' in input) {
+      // Chunked reader mode - not implemented in simplified version
+      throw new Error('Chunked reader mode not supported in ZipCompress');
+    }
+    
+    // Lazy ZSTD initialization
+    const zstdCodec = await initZstd();
+    
+    // Validate input
+    if (!input || input.length === 0) {
+      throw new Error('ZSTD compression: empty input buffer');
+    }
+    
+    // Convert Buffer to Uint8Array for WASM module (same fix as decompression)
+    const inputArray = new Uint8Array(input.buffer, input.byteOffset, input.byteLength);
+    
+    // For small data, compress in one go
+    if (input.length <= effectiveBufferSize) {
+      const compressed = zstdCodec.ZstdSimple.compress(inputArray, level);
+      const compressedBuffer = Buffer.from(compressed);
+      
+      if (onOutputBuffer) {
+        await onOutputBuffer(compressedBuffer);
+      }
+      
+      return compressedBuffer;
+    }
+    
+    // For large data, compress in chunks (ZSTD supports streaming)
+    // Note: ZSTD streaming compression is more complex, so for now we compress the whole buffer
+    // This could be optimized in the future for true streaming
+    const compressed = zstdCodec.ZstdSimple.compress(inputArray, level);
+    const compressedBuffer = Buffer.from(compressed);
+    
+    if (onOutputBuffer) {
+      await onOutputBuffer(compressedBuffer);
+    }
+    
+    return compressedBuffer;
+  }
+
+  /**
+   * Encrypt compressed data using PKZIP encryption
+   * @param entry - ZIP entry to encrypt
+   * @param compressedData - Compressed data to encrypt
+   * @param password - Password for encryption
+   * @returns Buffer containing encrypted data (includes 12-byte header)
+   */
+  encryptCompressedData(entry: ZipEntry, compressedData: Buffer, password: string): Buffer {
+    this.log(`encryptCompressedData() called for entry: ${entry.filename}, compressed size: ${compressedData.length}`);
+    
+    const zipCrypto = new ZipCrypto();
+    const encryptedData = zipCrypto.encryptBuffer(entry, compressedData, password);
+    
+    this.log(`Encryption complete: ${compressedData.length} bytes compressed -> ${encryptedData.length} bytes encrypted (includes ${ENCRYPT_HDR_SIZE}-byte header)`);
+    
+    return encryptedData;
+  }
+
+  /**
+   * Compress file data in memory and return ZIP entry information as Buffer
+   * @param entry - ZIP entry to compress
+   * @param fileData - File data buffer to compress
+   * @param cmpOptions - Compression options
+   * @returns Buffer containing local header + compressed data
+   */
+  async compressFileBuffer(
+    entry: ZipEntry,
+    fileData: Buffer,
+    cmpOptions?: CompressOptions
+  ): Promise<Buffer> {
+    this.log(`compressFileBuffer() called for entry: ${entry.filename}, size: ${fileData.length}`);
+    
+    // Set uncompressed size
+    entry.uncompressedSize = fileData.length;
+    
+    // Initialize hash calculator
+    const hashCalculator = new HashCalculator({ useSHA256: cmpOptions?.useSHA256 || false });
+    hashCalculator.update(fileData);
+    
+    // Set hashes
+    entry.crc = hashCalculator.finalizeCRC32();
+    if (cmpOptions?.useSHA256) {
+      entry.sha256 = hashCalculator.finalizeSHA256();
+      this.log(`SHA-256 calculated: ${entry.sha256}`);
+    }
+    
+    // Compress data
+    const compressedData = await this.compressData(entry, fileData, cmpOptions);
+    
+    // Encrypt if password provided
+    if (cmpOptions?.password) {
+      this.log(`Encrypting compressed data for entry: ${entry.filename}`);
+      (entry as any).gpFlag = ((entry as any).gpFlag || 0) | GP_FLAG.ENCRYPTED;
+      (entry as any).isEncrypted = true;
+      const zipCrypto = new ZipCrypto();
+      const encryptedData = zipCrypto.encryptBuffer(entry, compressedData, cmpOptions.password);
+      return encryptedData;
+    }
+    
+    return compressedData;
+  }
+}