roxify 1.13.1 → 1.13.2

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxify_native"
-version = "1.13.1"
+version = "1.13.2"
 edition = "2021"
 publish = false
 
@@ -52,25 +52,15 @@ rand = "0.8"
 sha2 = "0.10"
 mimalloc = "0.1"
 
-wgpu = { version = "0.19", optional = true }
 memmap2 = "0.9"
 bytemuck = { version = "1.14", features = ["derive"] }
-# tokio is optional now; enable via the 'async' feature
 tokio = { version = "1", features = ["sync", "rt"], optional = true }
 parking_lot = "0.12"
-pollster = { version = "0.3", optional = true }
 libsais = { version = "0.2.0", default-features = false }
 
 [features]
-# default is intentionally empty so the crate compiles fast for local checks.
-# Enable 'gpu' to pull in the WGPU and pollster dependencies (heavy).
-# Enable 'async' to include tokio runtime (optional).
-# Example: `cargo build -p roxify_native --features gpu`
 default = []
-
-gpu = ["wgpu", "pollster"]
 async = ["tokio"]
-full = ["gpu", "async"]
 
 [profile.release]
 opt-level = 3

package/README.md

@@ -57,151 +57,27 @@ The core compression and image-processing logic is written in Rust and exposed t
 
 ## Benchmarks
 
-All measurements were taken on Linux x64 (Intel i7-6700K @ 4.0 GHz, 32 GB RAM) with Node.js v20. Every tool uses its **maximum compression** setting: zip -9, gzip -9, 7z LZMA2 -mx=9, and Roxify Zstd level 19. Roxify produces a valid PNG or WAV file rather than a raw archive.
-
-### BWT-ANS Native Compression (Rust, via N-API)
-
-Direct API calls through the native module (BWT → MTF → RLE0 → rANS, 1 MB blocks):
-
-| Dataset | Original | Compressed | Ratio | Encode | Decode | Enc Throughput | Dec Throughput |
-| ------- | -------- | ---------- | ----- | ------ | ------ | -------------- | -------------- |
-| Repetitive text 45 KB | 45 KB | 207 B | 0.5% | < 1 ms | < 1 ms | — | — |
-| Rust source 6 KB | 6 KB | 2.0 KB | 33.7% | < 1 ms | < 1 ms | — | — |
-| node_modules tar 175 MB | 175.5 MB | 38.4 MB | 21.9% | 9.68 s | 5.62 s | 18.1 MB/s | 31.2 MB/s |
-| Random 100 KB | 100 KB | 101 KB | 101.5% | < 1 ms | < 1 ms | — | — |
-| Zeros 100 KB | 100 KB | 51 B | 0.1% | < 1 ms | < 1 ms | — | — |
-
-> BWT-ANS achieves **21.9% on real-world node_modules** (175 MB), with **18 MB/s encode** and **31 MB/s decode** throughput. 100% lossless roundtrip verified on all datasets.
-
-### Compression Ratio (Maximum Compression for All Tools)
-
-| Dataset     | Original | zip -9          | gzip -9         | 7z LZMA2 -9     | Roxify PNG          | Roxify WAV          |
-| ----------- | -------- | --------------- | --------------- | --------------- | ------------------- | ------------------- |
-| Text 1 MB   | 1.00 MB  | 219 KB (21.4%)  | 219 KB (21.4%)  | 187 KB (18.3%)  | **188 KB (18.3%)**  | **187 KB (18.3%)**  |
-| JSON 1 MB   | 1.00 MB  | 263 KB (25.7%)  | 263 KB (25.7%)  | 225 KB (22.0%)  | **220 KB (21.5%)**  | **219 KB (21.4%)**  |
-| Binary 1 MB | 1.00 MB  | 1.00 MB (100%)  | 1.00 MB (100%)  | 1.00 MB (100%)  | 1.00 MB (100%)      | 1.00 MB (100%)      |
-| Mixed 5 MB  | 5.00 MB  | 2.45 MB (49.0%) | 2.45 MB (49.1%) | 2.33 MB (46.6%) | 2.38 MB (47.6%)     | 2.38 MB (47.6%)     |
-| Text 10 MB  | 10.00 MB | 2.13 MB (21.3%) | 2.13 MB (21.3%) | 1.71 MB (17.1%) | **1.71 MB (17.1%)** | **1.70 MB (17.0%)** |
-| Mixed 10 MB | 10.00 MB | 4.90 MB (49.0%) | 4.90 MB (49.0%) | 4.65 MB (46.5%) | 4.73 MB (47.3%)     | 4.73 MB (47.3%)     |
-
-> **Roxify matches 7z LZMA2 ultra-compression on text** (18.3% for both at 1 MB) and **beats LZMA2 on JSON** (21.4% vs 22.0%). On mixed data, Roxify is within 1 percentage point of LZMA2 while producing a shareable PNG/WAV instead of an archive.
-
-### Encode and Decode Speed (CLI)
-
-| Dataset    | Tool           | Encode     | Decode     | Enc Throughput | Dec Throughput |
-| ---------- | -------------- | ---------- | ---------- | -------------- | -------------- |
-| Text 1 MB  | zip -9         | 112 ms     | 36 ms      | 8.9 MB/s       | 27.6 MB/s      |
-|            | gzip -9        | 146 ms     | 38 ms      | 6.9 MB/s       | 26.0 MB/s      |
-|            | 7z LZMA -9     | 303 ms     | 21 ms      | 3.3 MB/s       | 46.6 MB/s      |
-|            | **Roxify PNG** | **859 ms** | **577 ms** | **1.2 MB/s**   | **1.7 MB/s**   |
-|            | **Roxify WAV** | **794 ms** | **480 ms** | **1.3 MB/s**   | **2.1 MB/s**   |
-| JSON 1 MB  | zip -9         | 79 ms      | 20 ms      | 12.7 MB/s      | 50.5 MB/s      |
-|            | 7z LZMA -9     | 197 ms     | 26 ms      | 5.1 MB/s       | 37.9 MB/s      |
-|            | **Roxify PNG** | **1.14 s** | **755 ms** | **0.9 MB/s**   | **1.3 MB/s**   |
-|            | **Roxify WAV** | **1.49 s** | **518 ms** | **0.7 MB/s**   | **1.9 MB/s**   |
-| Text 10 MB | zip -9         | 1.21 s     | 70 ms      | 8.2 MB/s       | 143.8 MB/s     |
-|            | 7z LZMA -9     | 5.05 s     | 99 ms      | 2.0 MB/s       | 100.8 MB/s     |
-|            | **Roxify PNG** | **9.05 s** | **4.53 s** | **1.1 MB/s**   | **2.2 MB/s**   |
-|            | **Roxify WAV** | **9.22 s** | **2.59 s** | **1.1 MB/s**   | **3.9 MB/s**   |
-
-> Roxify CLI includes Node.js startup overhead (~400 ms). In the JS API (below), the same operations are significantly faster. WAV decode is consistently faster than PNG decode due to simpler container parsing.
-
-### JavaScript API Throughput
-
-Direct API calls (no CLI startup overhead):
-
-| Size   | Container | Encode | Decode  | Enc Throughput | Dec Throughput | Output    | Ratio  | Integrity |
-| ------ | --------- | ------ | ------- | -------------- | -------------- | --------- | ------ | --------- |
-| 1 KB   | PNG       | 9 ms   | 12 ms   | 0.1 MB/s       | 0.1 MB/s       | 1.14 KB   | 114.3% | ✓         |
-| 10 KB  | PNG       | 18 ms  | 34 ms   | 0.5 MB/s       | 0.3 MB/s       | 10.32 KB  | 103.2% | ✓         |
-| 100 KB | PNG       | 52 ms  | 109 ms  | 1.9 MB/s       | 0.9 MB/s       | 100.52 KB | 100.5% | ✓         |
-| 500 KB | PNG       | 339 ms | 541 ms  | 1.4 MB/s       | 0.9 MB/s       | 502.64 KB | 100.5% | ✓         |
-| 1 MB   | PNG       | 875 ms | 1.24 s  | 1.1 MB/s       | 0.8 MB/s       | 1.00 MB   | 100.3% | ✓         |
-| 5 MB   | PNG       | 3.39 s | 4.12 s  | 1.5 MB/s       | 1.2 MB/s       | 5.01 MB   | 100.2% | ✓         |
-| 10 MB  | PNG       | 6.84 s | 12.28 s | 1.5 MB/s       | 0.8 MB/s       | 10.01 MB  | 100.1% | ✓         |
-| 1 KB   | WAV       | 2 ms   | 2 ms    | 0.6 MB/s       | 0.6 MB/s       | 1.08 KB   | 107.5% | ✓         |
-| 10 KB  | WAV       | 4 ms   | 5 ms    | 2.3 MB/s       | 1.8 MB/s       | 10.08 KB  | 100.8% | ✓         |
-| 100 KB | WAV       | 39 ms  | 28 ms   | 2.5 MB/s       | 3.5 MB/s       | 100.08 KB | 100.1% | ✓         |
-| 500 KB | WAV       | 172 ms | 190 ms  | 2.8 MB/s       | 2.6 MB/s       | 500.09 KB | 100.0% | ✓         |
-| 1 MB   | WAV       | 452 ms | 276 ms  | 2.2 MB/s       | 3.6 MB/s       | 1.00 MB   | 100.0% | ✓         |
-| 5 MB   | WAV       | 2.70 s | 1.65 s  | 1.8 MB/s       | 3.0 MB/s       | 5.00 MB   | 100.0% | ✓         |
-| 10 MB  | WAV       | 4.81 s | 2.56 s  | 2.1 MB/s       | 3.9 MB/s       | 10.00 MB  | 100.0% | ✓         |
-
-> WAV container is **2–4× faster** than PNG for decoding at large sizes, and produces slightly smaller output thanks to simpler framing.
-
-### Reed-Solomon ECC Throughput
-
-| Size   | Encode | Decode | Enc Throughput | Dec Throughput | Overhead |
-| ------ | ------ | ------ | -------------- | -------------- | -------- |
-| 1 KB   | 6 ms   | 4 ms   | 0.2 MB/s       | 0.2 MB/s       | 125.7%   |
-| 10 KB  | 7 ms   | 6 ms   | 1.3 MB/s       | 1.5 MB/s       | 119.6%   |
-| 100 KB | 49 ms  | 45 ms  | 2.0 MB/s       | 2.1 MB/s       | 118.8%   |
-| 1 MB   | 483 ms | 377 ms | 2.1 MB/s       | 2.7 MB/s       | 118.6%   |
-
-### Lossy-Resilient Encoding
-
-#### Robust Image (QR-code-style, block size 4×4)
-
-| Data Size | Encode Time | Output (PNG) |
-| --------- | ----------- | ------------ |
-| 32 B      | 32 ms       | 122 KB       |
-| 128 B     | 39 ms       | 122 KB       |
-| 512 B     | 76 ms       | 316 KB       |
-| 1 KB      | 139 ms      | 508 KB       |
-| 2 KB      | 251 ms      | 986 KB       |
-
-#### Robust Audio (MFSK 8-channel, medium ECC)
-
-| Data Size | Encode | Decode | Output (WAV) | Integrity |
-| --------- | ------ | ------ | ------------ | --------- |
-| 10 B      | 33 ms  | 44 ms  | 1.35 MB      | ✓         |
-| 32 B      | 19 ms  | 31 ms  | 1.35 MB      | ✓         |
-| 64 B      | 22 ms  | 24 ms  | 1.35 MB      | ✓         |
-| 128 B     | 21 ms  | 28 ms  | 1.35 MB      | ✓         |
-| 256 B     | 40 ms  | 45 ms  | 2.59 MB      | ✓         |
-
-### Data Integrity Verification
-
-All encode/decode roundtrips produce bit-exact output, verified by SHA-256:
-
-| Test Case               | PNG | WAV |
-| ----------------------- | --- | --- |
-| Empty buffer (0 B)      | ✓   | ✓   |
-| Single byte (1 B)       | ✓   | ✓   |
-| All byte values (256 B) | ✓   | ✓   |
-| 1 KB text               | ✓   | ✓   |
-| 100 KB random           | ✓   | ✓   |
-| 1 MB random             | ✓   | ✓   |
-| 5 MB random             | ✓   | ✓   |
-
-**14 / 14 integrity tests passed** across both containers.
-
-### Key Observations
-
-- **Roxify matches LZMA2 ultra-compression** on text data (18.3%) and **outperforms it on JSON** (21.4% vs 22.0%), while producing a standard PNG or WAV file instead of an archive.
-- **WAV container decode is 2–4× faster** than PNG decode at large sizes (3.9 MB/s vs 0.8 MB/s for 10 MB).
-- **WAV encode for 1 KB data completes in 2 ms** — well under the sub-second target.
-- **Lossy-resilient audio** encode/decode completes in under 50 ms for data up to 256 bytes, with full integrity.
-- **100% data integrity** across all sizes and containers — every byte is recovered exactly.
-- The CLI overhead (~400 ms Node.js startup) is amortized on larger inputs. For programmatic use, the JS API eliminates this entirely.
-- On incompressible (random) data, all tools converge to ~100% as expected. No compression algorithm can shrink truly random data.
-
-### Methodology
-
-Benchmarks were generated using `test/benchmark-detailed.cjs`. Datasets consist of procedurally generated text, JSON, and random binary data. Each tool was invoked with its maximum compression setting:
-
-| Tool     | Command / Setting           |
-| -------- | --------------------------- |
-| zip      | `zip -r -q -9`              |
-| tar/gzip | `tar -cf - \| gzip -9`      |
-| 7z       | `7z a -mx=9` (LZMA2 ultra)  |
-| Roxify   | Zstd level 19, compact mode |
-
-To reproduce:
+All measurements taken on Linux x64 (Intel i7-6700K @ 4.0 GHz, 32 GB RAM). Roxify uses its native Rust CLI (`roxify_native`) with streaming Zstd L3 + multi-threaded + LDM + window_log(30). ZIP uses `zip -r -q -9` (maximum compression).
 
-```bash
-node test/benchmark-detailed.cjs
-```
+### Real-world directory encoding: Roxify vs ZIP
+
+| Dataset | Original | ZIP -9 | Roxify PNG | ZIP time | Roxify time | Speedup |
+| --- | --- | --- | --- | --- | --- | --- |
+| Test A (19 638 files, 177 MB) | 177 MB | 87.7 MB (49.6%) | 54.9 MB (31.0%) | 17.6 s | 1.2 s | 14.7x |
+| Test B (3 936 files, 1.4 GB) | 1.4 GB | 513 MB (36.7%) | 409 MB (29.2%) | 1 min 46 s | 6.7 s | 15.9x |
+
+### Decompression
+
+| Dataset | unzip | Roxify decode | Speedup |
+| --- | --- | --- | --- |
+| Test A (177 MB) | 2.4 s | 1.8 s | 1.3x |
+| Test B (1.4 GB) | 8.4 s | 2.2 s | 3.8x |
+
+Roxify produces a valid PNG image instead of a ZIP archive. On these real-world datasets it compresses 20-37% smaller than ZIP -9 while encoding 15x faster, thanks to multi-threaded Zstd with long-distance matching.
+
+### Data integrity
+
+100% lossless roundtrip verified by byte-exact diff on all datasets. Start and end markers verified in every output PNG.
 
 ---
 

package/dist/cli.js

@@ -20,7 +20,7 @@ async function loadJsEngine() {
         VFSIndexEntry: undefined,
     };
 }
-const VERSION = '1.13.1';
+const VERSION = '1.13.2';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
 export * from './utils/robust-audio.js';
 export * from './utils/robust-image.js';
-export { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+export { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/index.js

@@ -12,7 +12,7 @@ export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
 export * from './utils/robust-audio.js';
 export * from './utils/robust-image.js';
-export { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+export { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/native/bench_hybrid.rs

@@ -8,7 +8,7 @@ mod pool;
 mod hybrid;
 
 fn bench_roundtrip(name: &str, data: &[u8]) {
-    let compressor = hybrid::HybridCompressor::new(false, 4);
+    let compressor = hybrid::HybridCompressor::new();
 
     let start = Instant::now();
     let (compressed, stats) = compressor.compress(data).unwrap();

package/native/hybrid.rs

@@ -28,7 +28,7 @@ pub struct HybridCompressor {
 }
 
 impl HybridCompressor {
-    pub fn new(_enable_gpu: bool, _pool_size: usize) -> Self {
+    pub fn new() -> Self {
         HybridCompressor {
             block_size: BLOCK_SIZE,
         }
@@ -36,7 +36,6 @@ impl HybridCompressor {
 
     pub fn compress(&self, data: &[u8]) -> Result<(Vec<u8>, CompressionStats)> {
         let original_size = data.len() as u64;
-
         let blocks: Vec<&[u8]> = data.chunks(self.block_size).collect();
         let blocks_count = blocks.len();
 
@@ -136,13 +135,11 @@ impl HybridCompressor {
     }
 }
 
-fn compress_block(block: &[u8]) -> Result<Vec<u8>> {
+fn compress_block_with_entropy(block: &[u8], entropy: f32) -> Result<Vec<u8>> {
     if block.is_empty() {
         return Ok(vec![BLOCK_FLAG_STORE]);
     }
 
-    let entropy = analyze_entropy(block);
-
     if entropy >= ENTROPY_THRESHOLD_STORE {
         let mut result = Vec::with_capacity(1 + block.len());
         result.push(BLOCK_FLAG_STORE);
@@ -165,6 +162,19 @@ fn compress_block(block: &[u8]) -> Result<Vec<u8>> {
         return Ok(result);
     }
 
+    try_bwt_or_zstd(block)
+}
+
+fn compress_block(block: &[u8]) -> Result<Vec<u8>> {
+    if block.is_empty() {
+        return Ok(vec![BLOCK_FLAG_STORE]);
+    }
+
+    let entropy = analyze_entropy(block);
+    compress_block_with_entropy(block, entropy)
+}
+
+fn try_bwt_or_zstd(block: &[u8]) -> Result<Vec<u8>> {
     let bwt = bwt_encode(block)?;
     let mtf_data = mtf_encode(&bwt.transformed);
     let rle_data = rle0_encode(&mtf_data);
@@ -277,11 +287,11 @@ fn decompress_block_v1(block: &[u8]) -> Result<Vec<u8>> {
 }
 
 pub fn compress_high_performance(data: &[u8]) -> Result<(Vec<u8>, CompressionStats)> {
-    let compressor = HybridCompressor::new(false, 0);
+    let compressor = HybridCompressor::new();
     compressor.compress(data)
 }
 
 pub fn decompress_high_performance(data: &[u8]) -> Result<Vec<u8>> {
-    let compressor = HybridCompressor::new(false, 0);
+    let compressor = HybridCompressor::new();
     compressor.decompress(data)
 }

package/native/lib.rs

@@ -6,8 +6,6 @@ use napi_derive::napi;
 static GLOBAL: mimalloc::MiMalloc = mimalloc::MiMalloc;
 
 mod core;
-#[cfg(feature = "gpu")]
-mod gpu;
 mod rans;
 mod rans_byte;
 mod bwt;
@@ -27,15 +25,6 @@ mod archive;
 mod streaming;
 
 pub use core::*;
-#[cfg(feature = "gpu")]
-pub use gpu::*;
-#[cfg(not(feature = "gpu"))]
-mod gpu {
-        pub fn gpu_available() -> bool {
-        false
-    }
-}
-
 pub use rans::*;
 pub use bwt::*;
 pub use context_mixing::*;
@@ -57,12 +46,6 @@ pub struct CompressionReport {
     pub blocks_count: u32,
 }
 
-#[napi(object)]
-pub struct GpuStatus {
-    pub available: bool,
-    pub adapter_info: Option<String>,
-}
-
 #[cfg(not(test))]
 #[napi]
 pub fn scan_pixels(buffer: Buffer, channels: u32, marker_bytes: Option<Buffer>) -> Result<ScanResult> {
@@ -122,15 +105,6 @@ pub fn native_zstd_decompress_with_dict(buffer: Buffer, dict: Buffer) -> Result<
     core::zstd_decompress_bytes(&buffer, Some(dict_slice)).map_err(|e| Error::from_reason(e))
 }
 
-#[cfg(not(test))]
-#[napi]
-pub fn check_gpu_status() -> GpuStatus {
-    GpuStatus {
-        available: gpu::gpu_available(),
-        adapter_info: None,
-    }
-}
-
 #[cfg(not(test))]
 #[napi]
 pub fn bwt_transform(buffer: Buffer) -> Result<Vec<u8>> {

package/native/main.rs

@@ -17,6 +17,7 @@ mod archive;
 mod streaming;
 mod streaming_decode;
 mod streaming_encode;
+mod progress;
 
 use crate::encoder::ImageFormat;
 use std::path::PathBuf;
@@ -157,13 +158,16 @@ fn main() -> anyhow::Result<()> {
                 .or_else(|| input.file_name().and_then(|n| n.to_str()));
 
             if is_dir && dict.is_none() {
-                streaming_encode::encode_dir_to_png_encrypted(
+                streaming_encode::encode_dir_to_png_encrypted_with_progress(
                     &input,
                     &output,
                     level,
                     file_name,
                     passphrase.as_deref(),
                     Some(&encrypt),
+                    Some(Box::new(|current, total, step| {
+                        eprintln!("PROGRESS:{}:{}:{}", current, total, step);
+                    })),
                 )?;
                 println!("(TAR archive, rXFL chunk embedded)");
                 return Ok(());
@@ -187,6 +191,7 @@ fn main() -> anyhow::Result<()> {
             };
 
             let use_streaming = payload.len() > 64 * 1024 * 1024;
+            eprintln!("PROGRESS:50:100:encoding");
 
             if use_streaming {
                 streaming::encode_to_png_file(
@@ -227,6 +232,7 @@ fn main() -> anyhow::Result<()> {
             }
 
             if file_list_json.is_some() {
+                eprintln!("PROGRESS:100:100:done");
                 if is_dir {
                     println!("(TAR archive, rXFL chunk embedded)");
                 } else {
@@ -339,8 +345,10 @@ fn main() -> anyhow::Result<()> {
 
             if is_png_file && files.is_none() && dict.is_none() && file_size > 100_000_000 {
                 let out_dir = output.clone().unwrap_or_else(|| PathBuf::from("out.raw"));
+                eprintln!("PROGRESS:5:100:decoding");
                 match streaming_decode::streaming_decode_to_dir_encrypted(&input, &out_dir, passphrase.as_deref()) {
                     Ok(written) => {
+                        eprintln!("PROGRESS:100:100:done");
                         println!("Unpacked {} files (TAR)", written.len());
                         return Ok(());
                     }
@@ -351,6 +359,7 @@ fn main() -> anyhow::Result<()> {
             }
 
             let buf = read_all(&input)?;
+            eprintln!("PROGRESS:20:100:decompressing");
             let dict_bytes: Option<Vec<u8>> = match dict {
                 Some(path) => Some(read_all(&path)?),
                 None => None,
@@ -413,6 +422,7 @@ fn main() -> anyhow::Result<()> {
                 let files_slice = file_list.as_ref().map(|v| v.as_slice());
 
                                 let written = packer::unpack_stream_to_dir(&mut reader, &out_dir, files_slice).map_err(|e| anyhow::anyhow!(e))?;
+                eprintln!("PROGRESS:100:100:done");
                 println!("Unpacked {} files", written.len());
             } else {
                                                 let is_png = buf.len() >= 8 && &buf[0..8] == &[137, 80, 78, 71, 13, 10, 26, 10];
@@ -511,6 +521,7 @@ fn main() -> anyhow::Result<()> {
                 } else {
                     write_all(&dest, &out_bytes)?;
                 }
+                eprintln!("PROGRESS:100:100:done");
             }
         }
         Commands::Crc32 { input } => {

package/native/progress.rs

@@ -1,43 +1,142 @@
 use parking_lot::Mutex;
 use std::sync::Arc;
+use std::time::Instant;
 
-pub struct ProgressBar {
+#[derive(Clone, Debug)]
+pub struct ProgressSnapshot {
+    pub current: u64,
+    pub total: u64,
+    pub percentage: f64,
+    pub elapsed_ms: u64,
+    pub eta_ms: Option<u64>,
+    pub speed_bytes_per_sec: f64,
+    pub step: String,
+}
+
+struct ProgressInner {
     total: u64,
-    current: Arc<Mutex<u64>>,
-    message: Arc<Mutex<String>>,
+    current: u64,
+    step: String,
+    start: Instant,
+}
+
+pub struct ProgressBar {
+    inner: Arc<Mutex<ProgressInner>>,
+    callback: Arc<Mutex<Option<Box<dyn Fn(ProgressSnapshot) + Send>>>>,
 }
 
 impl ProgressBar {
     pub fn new(total: u64) -> Self {
         Self {
-            total,
-            current: Arc::new(Mutex::new(0)),
-            message: Arc::new(Mutex::new(String::new())),
+            inner: Arc::new(Mutex::new(ProgressInner {
+                total,
+                current: 0,
+                step: String::new(),
+                start: Instant::now(),
+            })),
+            callback: Arc::new(Mutex::new(None)),
+        }
+    }
+
+    pub fn with_callback<F: Fn(ProgressSnapshot) + Send + 'static>(total: u64, cb: F) -> Self {
+        Self {
+            inner: Arc::new(Mutex::new(ProgressInner {
+                total,
+                current: 0,
+                step: String::new(),
+                start: Instant::now(),
+            })),
+            callback: Arc::new(Mutex::new(Some(Box::new(cb)))),
         }
     }
 
     pub fn inc(&self, delta: u64) {
-        let mut current = self.current.lock();
-        *current += delta;
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.current += delta;
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
     }
 
     pub fn set(&self, value: u64) {
-        let mut current = self.current.lock();
-        *current = value;
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.current = value;
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
     }
 
-    pub fn set_message(&self, msg: String) {
-        let mut message = self.message.lock();
-        *message = msg;
+    pub fn set_step(&self, step: &str) {
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.step = step.to_string();
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
     }
 
-    pub fn get_progress(&self) -> (u64, u64) {
-        let current = *self.current.lock();
-        (current, self.total)
+    pub fn snapshot(&self) -> ProgressSnapshot {
+        let inner = self.inner.lock();
+        self.snapshot_inner(&inner)
+    }
+
+    fn snapshot_inner(&self, inner: &ProgressInner) -> ProgressSnapshot {
+        let elapsed = inner.start.elapsed();
+        let elapsed_ms = elapsed.as_millis() as u64;
+        let percentage = if inner.total > 0 {
+            (inner.current as f64 / inner.total as f64) * 100.0
+        } else {
+            0.0
+        };
+
+        let elapsed_secs = elapsed.as_secs_f64();
+        let speed = if elapsed_secs > 0.01 {
+            inner.current as f64 / elapsed_secs
+        } else {
+            0.0
+        };
+
+        let eta_ms = if speed > 0.0 && inner.current > 0 && inner.current < inner.total {
+            let remaining = inner.total - inner.current;
+            Some((remaining as f64 / speed * 1000.0) as u64)
+        } else {
+            None
+        };
+
+        ProgressSnapshot {
+            current: inner.current,
+            total: inner.total,
+            percentage,
+            elapsed_ms,
+            eta_ms,
+            speed_bytes_per_sec: speed,
+            step: inner.step.clone(),
+        }
+    }
+
+    fn emit(&self, snapshot: ProgressSnapshot) {
+        if let Some(ref cb) = *self.callback.lock() {
+            cb(snapshot);
+        }
     }
 
     pub fn finish(&self) {
-        let mut current = self.current.lock();
-        *current = self.total;
+        let snapshot = {
+            let mut inner = self.inner.lock();
+            inner.current = inner.total;
+            self.snapshot_inner(&inner)
+        };
+        self.emit(snapshot);
+    }
+
+    pub fn get_progress(&self) -> (u64, u64) {
+        let inner = self.inner.lock();
+        (inner.current, inner.total)
+    }
+
+    pub fn set_message(&self, msg: String) {
+        self.set_step(&msg);
     }
 }

package/native/streaming_encode.rs

@@ -11,6 +11,8 @@ const MARKER_END: [(u8, u8, u8); 3] = [(0, 0, 255), (0, 255, 0), (255, 0, 0)];
 const MARKER_ZSTD: (u8, u8, u8) = (0, 255, 0);
 const MAGIC: &[u8] = b"ROX1";
 
+pub type ProgressCallback = Box<dyn Fn(u64, u64, &str) + Send>;
+
 pub fn encode_dir_to_png(
     dir_path: &Path,
     output_path: &Path,
@@ -27,10 +29,27 @@ pub fn encode_dir_to_png_encrypted(
     name: Option<&str>,
     passphrase: Option<&str>,
     encrypt_type: Option<&str>,
+) -> anyhow::Result<()> {
+    encode_dir_to_png_encrypted_with_progress(dir_path, output_path, compression_level, name, passphrase, encrypt_type, None)
+}
+
+pub fn encode_dir_to_png_encrypted_with_progress(
+    dir_path: &Path,
+    output_path: &Path,
+    compression_level: i32,
+    name: Option<&str>,
+    passphrase: Option<&str>,
+    encrypt_type: Option<&str>,
+    progress: Option<ProgressCallback>,
 ) -> anyhow::Result<()> {
     let tmp_zst = output_path.with_extension("tmp.zst");
 
-    let file_list = compress_dir_to_zst(dir_path, &tmp_zst, compression_level)?;
+    let file_list = compress_dir_to_zst(dir_path, &tmp_zst, compression_level, &progress)?;
+
+    if let Some(ref cb) = progress {
+        cb(90, 100, "writing_png");
+    }
+
     let file_list_json = serde_json::to_string(&file_list)?;
 
     let result = write_png_from_zst(
@@ -38,6 +57,11 @@ pub fn encode_dir_to_png_encrypted(
         passphrase, encrypt_type,
     );
     let _ = std::fs::remove_file(&tmp_zst);
+
+    if let Some(ref cb) = progress {
+        cb(100, 100, "done");
+    }
+
     result
 }
 
@@ -45,6 +69,7 @@ fn compress_dir_to_zst(
     dir_path: &Path,
     zst_path: &Path,
     compression_level: i32,
+    progress: &Option<ProgressCallback>,
 ) -> anyhow::Result<Vec<serde_json::Value>> {
     let base = dir_path;
 
@@ -55,6 +80,8 @@ fn compress_dir_to_zst(
         .filter(|e| e.file_type().is_file())
         .collect();
 
+    let total_files = entries.len() as u64;
+
     let zst_file = File::create(zst_path)?;
     let buf_writer = BufWriter::with_capacity(16 * 1024 * 1024, zst_file);
 
@@ -74,7 +101,7 @@ fn compress_dir_to_zst(
     let mut file_list = Vec::new();
     {
         let mut tar_builder = Builder::new(&mut encoder);
-        for entry in &entries {
+        for (idx, entry) in entries.iter().enumerate() {
             let full = entry.path();
             let rel = full.strip_prefix(base).unwrap_or(full);
             let rel_str = rel.to_string_lossy().replace('\\', "/");
@@ -103,6 +130,11 @@ fn compress_dir_to_zst(
                 .map_err(|e| anyhow::anyhow!("tar append {}: {}", rel_str, e))?;
 
             file_list.push(serde_json::json!({"name": rel_str, "size": size}));
+
+            if let Some(ref cb) = progress {
+                let pct = ((idx as u64 + 1) * 85 / total_files.max(1)).min(85);
+                cb(pct, 100, "compressing");
+            }
         }
         tar_builder.finish().map_err(|e| anyhow::anyhow!("tar finish: {}", e))?;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.13.1",
+  "version": "1.13.2",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",

package/native/gpu.rs

@@ -1,116 +0,0 @@
-use anyhow::{anyhow, Result};
-use parking_lot::RwLock;
-use std::sync::Arc;
-use wgpu::*;
-use wgpu::util::DeviceExt;
-
-pub struct GpuDevice {
-    device: Device,
-    queue: Queue,
-    supported: bool,
-    adapter_info: String,
-}
-
-pub struct GpuContext {
-    inner: Arc<RwLock<Option<GpuDevice>>>,
-}
-
-impl GpuContext {
-    pub async fn new() -> Self {
-        let instance = Instance::new(InstanceDescriptor {
-            backends: Backends::all(),
-            ..Default::default()
-        });
-
-        let adapter = instance.request_adapter(&RequestAdapterOptions {
-            power_preference: PowerPreference::HighPerformance,
-            compatible_surface: None,
-            force_fallback_adapter: false,
-        }).await;
-
-        let device_info = if let Some(adapter) = adapter {
-            match adapter.request_device(&DeviceDescriptor {
-                label: Some("roxify-compute"),
-                required_features: Features::empty(),
-                required_limits: Limits::default(),
-            }, None).await {
-                Ok((device, queue)) => {
-                    let info = adapter.get_info();
-                    Some(GpuDevice {
-                        device,
-                        queue,
-                        supported: true,
-                        adapter_info: format!("{:?}", info.driver),
-                    })
-                }
-                Err(_) => None,
-            }
-        } else {
-            None
-        };
-
-        GpuContext {
-            inner: Arc::new(RwLock::new(device_info)),
-        }
-    }
-
-    pub fn is_available(&self) -> bool {
-        self.inner.read().is_some()
-    }
-
-    pub fn get_adapter_info(&self) -> Option<String> {
-        self.inner.read().as_ref().map(|d| d.adapter_info.clone())
-    }
-
-    pub async fn create_compute_pipeline(
-        &self,
-        shader_src: &str,
-        entry_point: &str,
-    ) -> Result<ComputePipeline> {
-        let gpu = self.inner.read();
-        let gpu = gpu.as_ref().ok_or_else(|| anyhow!("No GPU device available"))?;
-
-        let shader_module = gpu.device.create_shader_module(ShaderModuleDescriptor {
-            label: Some("compute-shader"),
-            source: ShaderSource::Wgsl(std::borrow::Cow::Borrowed(shader_src)),
-        });
-
-        let pipeline_layout = gpu.device.create_pipeline_layout(&PipelineLayoutDescriptor {
-            label: Some("compute-layout"),
-            bind_group_layouts: &[],
-            push_constant_ranges: &[],
-        });
-
-        Ok(gpu.device.create_compute_pipeline(&ComputePipelineDescriptor {
-            label: Some("compute-pipeline"),
-            layout: Some(&pipeline_layout),
-            module: &shader_module,
-            entry_point,
-        }))
-    }
-
-    pub fn create_buffer_init(&self, data: &[u8], usage: BufferUsages) -> Result<Buffer> {
-        let gpu = self.inner.read();
-        let gpu = gpu.as_ref().ok_or_else(|| anyhow!("No GPU device available"))?;
-
-        Ok(gpu.device.create_buffer_init(&util::BufferInitDescriptor {
-            label: None,
-            contents: data,
-            usage,
-        }))
-    }
-}
-
-pub fn gpu_available() -> bool {
-    pollster::block_on(async {
-        let instance = Instance::new(InstanceDescriptor {
-            backends: Backends::all(),
-            ..Default::default()
-        });
-        instance.request_adapter(&RequestAdapterOptions {
-            power_preference: PowerPreference::HighPerformance,
-            compatible_surface: None,
-            force_fallback_adapter: false,
-        }).await.is_some()
-    })
-}