roxify 1.13.0 → 1.13.2

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxify_native"
-version = "1.13.0"
+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

@@ -2,11 +2,25 @@
 import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from 'fs';
 import { open } from 'fs/promises';
 import { basename, dirname, join, resolve } from 'path';
-import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
-import { packPathsGenerator, unpackBuffer } from './pack.js';
 import * as cliProgress from './stub-progress.js';
-import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.12.0';
+import { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+async function loadJsEngine() {
+    const indexMod = await import('./index.js');
+    const packMod = await import('./pack.js');
+    return {
+        decodePngToBinary: indexMod.decodePngToBinary,
+        encodeBinaryToPng: indexMod.encodeBinaryToPng,
+        hasPassphraseInPng: indexMod.hasPassphraseInPng,
+        listFilesInPng: indexMod.listFilesInPng,
+        DataFormatError: indexMod.DataFormatError,
+        IncorrectPassphraseError: indexMod.IncorrectPassphraseError,
+        PassphraseRequiredError: indexMod.PassphraseRequiredError,
+        packPathsGenerator: packMod.packPathsGenerator,
+        unpackBuffer: packMod.unpackBuffer,
+        VFSIndexEntry: undefined,
+    };
+}
+const VERSION = '1.13.2';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -280,8 +294,9 @@ async function encodeCommand(args) {
                 return false;
             }
         });
-        if (anyDir) {
-            const { index } = await packPathsGenerator(inputPaths, undefined, () => { });
+        if (anyDir && !isRustBinaryAvailable()) {
+            const js = await loadJsEngine();
+            const { index } = await js.packPathsGenerator(inputPaths, undefined, () => { });
             if (!index || index.length === 0) {
                 console.log(' ');
                 console.error('Error: No files found in specified input paths.');
@@ -357,6 +372,7 @@ async function encodeCommand(args) {
         }
     }
     try {
+        const js = await loadJsEngine();
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
@@ -428,7 +444,7 @@ async function encodeCommand(args) {
         };
         if (inputPaths.length > 1) {
             currentEncodeStep = 'Reading files';
-            const { index, stream, totalSize } = await packPathsGenerator(inputPaths, undefined, onProgress);
+            const { index, stream, totalSize } = await js.packPathsGenerator(inputPaths, undefined, onProgress);
             if (!index || index.length === 0) {
                 console.log(' ');
                 console.error('Error: No files found in specified input paths.');
@@ -448,7 +464,7 @@ async function encodeCommand(args) {
             const st = statSync(resolvedInput);
             if (st.isDirectory()) {
                 currentEncodeStep = 'Reading files';
-                const { index, stream, totalSize } = await packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
+                const { index, stream, totalSize } = await js.packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
                 if (!index || index.length === 0) {
                     console.log(' ');
                     console.error(`Error: No files found in ${resolvedInput}`);
@@ -535,7 +551,7 @@ async function encodeCommand(args) {
         else {
             inputBuffer = inputData;
         }
-        const output = await encodeBinaryToPng(inputBuffer, options);
+        const output = await js.encodeBinaryToPng(inputBuffer, options);
         const encodeTime = Date.now() - startEncode;
         clearInterval(encodeHeartbeat);
         if (barStarted) {
@@ -574,7 +590,38 @@ async function decodeCommand(args) {
         process.exit(1);
     }
     const resolvedInput = resolve(inputPath);
-    const resolvedOutput = parsed.output || outputPath || 'decoded.bin';
+    const resolvedOutput = parsed.output || outputPath || '.';
+    if (isRustBinaryAvailable() && !parsed.forceTs && !parsed.lossyResilient) {
+        try {
+            console.log(' ');
+            console.log('Decoding... (Using native Rust decoder)\n');
+            const startTime = Date.now();
+            const decodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
+            let barValue = 0;
+            decodeBar.start(100, 0, { step: 'Decoding', elapsed: '0' });
+            const progressInterval = setInterval(() => {
+                barValue = Math.min(barValue + 2, 99);
+                decodeBar.update(barValue, {
+                    step: 'Decoding',
+                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
+                });
+            }, 300);
+            await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, parsed.dict);
+            clearInterval(progressInterval);
+            const decodeTime = Date.now() - startTime;
+            decodeBar.update(100, { step: 'done', elapsed: String(Math.floor(decodeTime / 1000)) });
+            decodeBar.stop();
+            console.log(`\nSuccess!`);
+            console.log(`  Time: ${decodeTime}ms`);
+            console.log(`  Output: ${resolve(resolvedOutput)}`);
+            console.log(' ');
+            return;
+        }
+        catch (err) {
+            console.warn('\nRust decoder failed, falling back to TypeScript decoder...');
+            console.warn(`Reason: ${err.message}\n`);
+        }
+    }
     try {
         const options = {};
         if (parsed.passphrase) {
@@ -645,7 +692,8 @@ async function decodeCommand(args) {
             }
         };
         const inputBuffer = await readLargeFile(resolvedInput);
-        const result = await decodePngToBinary(inputBuffer, options);
+        const js = await loadJsEngine();
+        const result = await js.decodePngToBinary(inputBuffer, options);
         const decodeTime = Date.now() - startDecode;
         clearInterval(heartbeat);
         if (barStarted) {
@@ -684,7 +732,7 @@ async function decodeCommand(args) {
             console.log(`Time: ${decodeTime}ms`);
         }
         else if (result.buf) {
-            const unpacked = unpackBuffer(result.buf);
+            const unpacked = js.unpackBuffer(result.buf);
             if (unpacked) {
                 const baseDir = parsed.output || outputPath || '.';
                 for (const file of unpacked.files) {
@@ -720,17 +768,17 @@ async function decodeCommand(args) {
         console.log(' ');
     }
     catch (err) {
-        if (err instanceof PassphraseRequiredError ||
+        if ((err.message && err.message.includes('passphrase required')) ||
             (err.message && err.message.includes('passphrase') && !parsed.passphrase)) {
             console.log(' ');
             console.error('File appears to be encrypted. Provide a passphrase with -p');
         }
-        else if (err instanceof IncorrectPassphraseError ||
+        else if ((err.message && err.message.includes('Incorrect passphrase')) ||
             (err.message && err.message.includes('Incorrect passphrase'))) {
             console.log(' ');
             console.error('Incorrect passphrase');
         }
-        else if (err instanceof DataFormatError ||
+        else if ((err.message && err.message.includes('data format error')) ||
             (err.message &&
                 (err.message.includes('decompression failed') ||
                     err.message.includes('missing ROX1') ||
@@ -761,40 +809,25 @@ async function listCommand(args) {
     const resolvedInput = resolve(inputPath);
     if (isRustBinaryAvailable()) {
         try {
-            const { findRustBinary } = await import('./utils/rust-cli-wrapper.js');
-            const cliPath = findRustBinary();
-            if (cliPath) {
-                const { execSync } = await import('child_process');
-                try {
-                    const help = execSync(`"${cliPath}" --help`, { encoding: 'utf-8' });
-                    if (!help.includes('list')) {
-                        throw new Error('native CLI does not support list');
-                    }
-                    const output = execSync(`"${cliPath}" list "${resolvedInput}"`, {
-                        encoding: 'utf-8',
-                        stdio: ['pipe', 'pipe', 'inherit'],
-                        timeout: 30000,
-                    });
-                    const fileList = JSON.parse(output.trim());
-                    console.log(`Files in ${resolvedInput}:`);
-                    for (const file of fileList) {
-                        if (typeof file === 'string') {
-                            console.log(`  ${file}`);
-                        }
-                        else {
-                            console.log(`  ${file.name} (${file.size} bytes)`);
-                        }
-                    }
-                    return;
+            const output = await listWithRustCLI(resolvedInput);
+            const fileList = JSON.parse(output.trim());
+            console.log(`Files in ${resolvedInput}:`);
+            for (const file of fileList) {
+                if (typeof file === 'string') {
+                    console.log(`  ${file}`);
+                }
+                else {
+                    console.log(`  ${file.name} (${file.size} bytes)`);
                 }
-                catch (e) { }
             }
+            return;
         }
-        catch (err) { }
+        catch (e) { }
     }
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const fileList = await listFilesInPng(inputBuffer, {
+        const js = await loadJsEngine();
+        const fileList = await js.listFilesInPng(inputBuffer, {
             includeSizes: parsed.sizes !== false,
         });
         if (fileList) {
@@ -831,9 +864,18 @@ async function havePassphraseCommand(args) {
         process.exit(1);
     }
     const resolvedInput = resolve(inputPath);
+    if (isRustBinaryAvailable()) {
+        try {
+            const output = await havepassphraseWithRustCLI(resolvedInput);
+            console.log(output.trim());
+            return;
+        }
+        catch (e) { }
+    }
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const has = await hasPassphraseInPng(inputBuffer);
+        const js = await loadJsEngine();
+        const has = await js.hasPassphraseInPng(inputBuffer);
         console.log(has ? 'Passphrase detected.' : 'No passphrase detected.');
     }
     catch (err) {

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 { encodeWithRustCLI, isRustBinaryAvailable } 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 { encodeWithRustCLI, isRustBinaryAvailable } 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/utils/rust-cli-wrapper.d.ts

@@ -2,3 +2,6 @@ declare function findRustBinary(): string | null;
 export { findRustBinary };
 export declare function isRustBinaryAvailable(): boolean;
 export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor', name?: string): Promise<void>;
+export declare function decodeWithRustCLI(inputPath: string, outputPath: string, passphrase?: string, files?: string[], dict?: string): Promise<void>;
+export declare function listWithRustCLI(inputPath: string): Promise<string>;
+export declare function havepassphraseWithRustCLI(inputPath: string): Promise<string>;

package/dist/utils/rust-cli-wrapper.js

@@ -1,5 +1,5 @@
 import { execSync, spawn } from 'child_process';
-import { existsSync } from 'fs';
+import { accessSync, constants, existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 let moduleDir;
@@ -14,6 +14,19 @@ else {
         moduleDir = process.cwd();
     }
 }
+function canExecute(p) {
+    if (!existsSync(p))
+        return false;
+    if (process.platform === 'win32')
+        return true;
+    try {
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function findRustBinary() {
     const platformBins = {
         win32: ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe'],
@@ -24,13 +37,13 @@ function findRustBinary() {
     const baseDir = moduleDir;
     for (const name of binNames) {
         const sameDirPath = join(baseDir, name);
-        if (existsSync(sameDirPath))
+        if (canExecute(sameDirPath))
             return sameDirPath;
         const parentPath = join(baseDir, '..', name);
-        if (existsSync(parentPath))
+        if (canExecute(parentPath))
             return parentPath;
         const parentDistPath = join(baseDir, '..', 'dist', name);
-        if (existsSync(parentDistPath))
+        if (canExecute(parentDistPath))
             return parentDistPath;
     }
     if (process.pkg) {
@@ -42,7 +55,7 @@ function findRustBinary() {
         for (const basePath of snapshotPaths) {
             for (const name of binNames) {
                 const binPath = join(basePath, name);
-                if (existsSync(binPath))
+                if (canExecute(binPath))
                     return binPath;
             }
         }
@@ -58,7 +71,7 @@ function findRustBinary() {
                 for (const c of execCandidates) {
                     for (const name of binNames) {
                         const p = join(c, name);
-                        if (existsSync(p))
+                        if (canExecute(p))
                             return p;
                     }
                 }
@@ -97,7 +110,7 @@ function findRustBinary() {
                 for (const c of candidates) {
                     for (const name of binNames) {
                         const candidate = join(c, name);
-                        if (existsSync(candidate))
+                        if (canExecute(candidate))
                             return candidate;
                     }
                 }
@@ -108,16 +121,16 @@ function findRustBinary() {
     catch { }
     for (const name of binNames) {
         const parentParentLocal = join(baseDir, '..', '..', name);
-        if (existsSync(parentParentLocal))
+        if (canExecute(parentParentLocal))
             return parentParentLocal;
         const nodeModulesPath = join(baseDir, '..', '..', '..', '..', name);
-        if (existsSync(nodeModulesPath))
+        if (canExecute(nodeModulesPath))
             return nodeModulesPath;
     }
     const targetRelease = join(baseDir, '..', '..', 'target', 'release');
     for (const name of binNames) {
         const targetPath = join(targetRelease, name);
-        if (existsSync(targetPath))
+        if (canExecute(targetPath))
             return targetPath;
     }
     return null;
@@ -128,52 +141,32 @@ export function isRustBinaryAvailable() {
 }
 import { chmodSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
 import { tmpdir } from 'os';
-export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name) {
+function extractToTemp(pathToRead) {
+    const buf = readFileSync(pathToRead);
+    const tmp = mkdtempSync(join(tmpdir(), 'roxify-'));
+    const dest = join(tmp, pathToRead.replace(/.*[\\/]/, ''));
+    writeFileSync(dest, buf);
+    try {
+        chmodSync(dest, 0o755);
+    }
+    catch (e) { }
+    return dest;
+}
+function spawnRustCLI(args, options) {
     const cliPath = findRustBinary();
-    if (!cliPath) {
+    if (!cliPath)
         throw new Error('Rust CLI binary not found');
-    }
-    function extractToTemp(pathToRead) {
-        const buf = readFileSync(pathToRead);
-        const tmp = mkdtempSync(join(tmpdir(), 'roxify-'));
-        const dest = join(tmp, pathToRead.replace(/.*[\\/]/, ''));
-        writeFileSync(dest, buf);
-        try {
-            chmodSync(dest, 0o755);
-        }
-        catch (e) { }
-        return dest;
-    }
     return new Promise((resolve, reject) => {
-        const args = ['encode', '--level', String(compressionLevel)];
-        let supportsName = false;
-        if (name) {
-            try {
-                const helpOut = execSync(`"${cliPath}" --help`, {
-                    encoding: 'utf8',
-                    timeout: 2000,
-                });
-                if (helpOut && helpOut.includes('--name'))
-                    supportsName = true;
-            }
-            catch (e) {
-                supportsName = false;
-            }
-            if (supportsName) {
-                args.push('--name', name);
-            }
-        }
-        if (passphrase) {
-            args.push('--passphrase', passphrase);
-            args.push('--encrypt', encryptType);
-        }
-        args.push(inputPath, outputPath);
         let triedExtract = false;
         let tempExe;
+        let stdout = '';
         const runSpawn = (exePath) => {
             let proc;
+            const stdio = options?.collectStdout
+                ? ['pipe', 'pipe', 'inherit']
+                : 'inherit';
             try {
-                proc = spawn(exePath, args, { stdio: 'inherit' });
+                proc = spawn(exePath, args, { stdio });
             }
             catch (err) {
                 if (!triedExtract) {
@@ -188,6 +181,9 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 return reject(err);
             }
+            if (options?.collectStdout && proc.stdout) {
+                proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            }
             proc.on('error', (err) => {
                 if (!triedExtract) {
                     triedExtract = true;
@@ -201,21 +197,55 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 reject(err);
             });
-            proc.on('close', (code) => {
+            proc.on('close', (code, signal) => {
                 if (tempExe) {
                     try {
                         unlinkSync(tempExe);
                     }
                     catch (e) { }
                 }
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Rust encoder exited with status ${code}`));
-                }
+                if (code === 0 || (code === null && signal === null))
+                    resolve(stdout);
+                else
+                    reject(new Error(`Rust CLI exited with status ${code ?? signal}`));
             });
         };
         runSpawn(cliPath);
     });
 }
+export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name) {
+    const cliPath = findRustBinary();
+    if (!cliPath)
+        throw new Error('Rust CLI binary not found');
+    const args = ['encode', '--level', String(compressionLevel)];
+    if (name) {
+        try {
+            const helpOut = execSync(`"${cliPath}" --help`, { encoding: 'utf8', timeout: 2000 });
+            if (helpOut && helpOut.includes('--name'))
+                args.push('--name', name);
+        }
+        catch (e) { }
+    }
+    if (passphrase) {
+        args.push('--passphrase', passphrase);
+        args.push('--encrypt', encryptType);
+    }
+    args.push(inputPath, outputPath);
+    await spawnRustCLI(args);
+}
+export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, dict) {
+    const args = ['decompress', inputPath, outputPath];
+    if (passphrase)
+        args.push('--passphrase', passphrase);
+    if (files && files.length > 0)
+        args.push('--files', JSON.stringify(files));
+    if (dict)
+        args.push('--dict', dict);
+    await spawnRustCLI(args);
+}
+export async function listWithRustCLI(inputPath) {
+    return spawnRustCLI(['list', inputPath], { collectStdout: true });
+}
+export async function havepassphraseWithRustCLI(inputPath) {
+    return spawnRustCLI(['havepassphrase', inputPath], { collectStdout: true });
+}

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.0",
+  "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()
-    })
-}