roxify 1.12.6 → 1.12.8

package/Cargo.toml

@@ -0,0 +1,98 @@
+[package]
+name = "roxify_native"
+version = "1.12.8"
+edition = "2021"
+publish = false
+
+[lib]
+name = "roxify_native"
+crate-type = ["cdylib"]
+path = "native/lib.rs"
+
+[[bin]]
+name = "roxify_native"
+path = "native/main.rs"
+
+[[bin]]
+name = "bench_hybrid"
+path = "native/bench_hybrid.rs"
+
+[[bin]]
+name = "test_stages"
+path = "native/test_stages.rs"
+
+[[bin]]
+name = "test_small_bwt"
+path = "native/test_small_bwt.rs"
+
+[dev-dependencies]
+
+[dependencies]
+napi = "2"
+napi-derive = "2"
+rayon = "1.7"
+zstd = { version = "0.11", features = ["zstdmt"] }
+crc32fast = "1.3"
+num_cpus = "1.16"
+clap = { version = "4", features = ["derive"] }
+serde_json = "1.0"
+anyhow = "1.0"
+png = "0.18.0"
+image = { version = "0.25", default-features = false, features = ["png"] }
+# indicatif removed from default deps to reduce heavy build graph
+walkdir = "2.5.0"
+tar = "0.4"
+aes-gcm = "0.10"
+aes = "0.8"
+ctr = "0.9"
+cipher = { version = "0.4", features = ["std"] }
+hmac = "0.12"
+pbkdf2 = "0.12"
+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
+lto = "fat"
+codegen-units = 1
+strip = true
+panic = "abort"
+
+[profile.release-size]
+inherits = "release"
+opt-level = "z"
+lto = true
+strip = true
+
+[profile.fastdev]
+# Fast development profile for minimal user CPU and fast compilation.
+# Lower optimization and high codegen units to parallelize compilation work,
+# enable incremental to speed up subsequent incremental builds.
+inherits = "release"
+opt-level = 1
+lto = false
+codegen-units = 16
+debug = false
+incremental = true
+panic = "abort"

package/dist/cli.js

@@ -5,8 +5,8 @@ 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 { decodeWithRustCLI, encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.12.3';
+import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
+const VERSION = '1.12.0';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -51,54 +51,54 @@ async function readLargeFile(filePath) {
     return Buffer.concat(chunks);
 }
 function showHelp() {
-    console.log(`
-ROX CLI — Encode/decode binary in PNG or WAV
-
-Usage:
-  npx rox <command> [options]
-
-Commands:
-  encode <input>... [output]   Encode one or more files/directories
-  decode <input> [output]      Decode PNG/WAV to original file
-  list <input>                 List files in a Rox archive
-  havepassphrase <input>       Check whether the archive requires a passphrase
-
-Options:
-  --image                   Use PNG container (default)
-  --sound                   Use WAV audio container (smaller overhead, faster)
-  --bwt-ans                 Use BWT-ANS compression instead of Zstd
-  -p, --passphrase <pass>   Use passphrase (AES-256-GCM)
-  -m, --mode <mode>         Mode: screenshot (default)
-  -e, --encrypt <type>      auto|aes|xor|none
-  --no-compress             Disable compression
-  --dict <file>             Use zstd dictionary when compressing
-  --force-ts                Force TypeScript encoder (slower but supports encryption)
-  -o, --output <path>       Output file path
-  -s, --sizes               Show file sizes in 'list' output (default)
-  --no-sizes                Disable file size reporting in 'list'
-  --files <list>            Extract only specified files (comma-separated)
-  --view-reconst            Export the reconstituted PNG for debugging
-  --debug                   Export debug images (doubled.png, reconstructed.png)
-  -v, --verbose             Show detailed errors
-
-Lossy-Resilient Encoding:
-  --lossy-resilient         Enable lossy-resilient mode (survives JPEG/MP3)
-  --ecc-level <level>       ECC redundancy: low|medium|quartile|high (default: medium)
-  --block-size <n>          Robust image block size: 2-8 pixels (default: 4)
-
-  When --lossy-resilient is active, data is encoded with Reed-Solomon ECC
-  and rendered as a QR-code-style grid (image) or MFSK tones (audio).
-  Use --sound or --image to choose the container format.
-
-Examples:
-  npx rox encode secret.pdf                      Encode to PNG
-  npx rox encode secret.pdf --sound               Encode to WAV
-  npx rox encode secret.pdf --lossy-resilient     Lossy-resilient PNG
-  npx rox encode secret.pdf --lossy-resilient --sound --ecc-level high
-  npx rox decode secret.pdf.png                   Decode back
-  npx rox decode secret.pdf.wav                   Decode WAV back
-
-Run "npx rox help" for this message.
+    console.log(`
+ROX CLI — Encode/decode binary in PNG or WAV
+
+Usage:
+  npx rox <command> [options]
+
+Commands:
+  encode <input>... [output]   Encode one or more files/directories
+  decode <input> [output]      Decode PNG/WAV to original file
+  list <input>                 List files in a Rox archive
+  havepassphrase <input>       Check whether the archive requires a passphrase
+
+Options:
+  --image                   Use PNG container (default)
+  --sound                   Use WAV audio container (smaller overhead, faster)
+  --bwt-ans                 Use BWT-ANS compression instead of Zstd
+  -p, --passphrase <pass>   Use passphrase (AES-256-GCM)
+  -m, --mode <mode>         Mode: screenshot (default)
+  -e, --encrypt <type>      auto|aes|xor|none
+  --no-compress             Disable compression
+  --dict <file>             Use zstd dictionary when compressing
+  --force-ts                Force TypeScript encoder (slower but supports encryption)
+  -o, --output <path>       Output file path
+  -s, --sizes               Show file sizes in 'list' output (default)
+  --no-sizes                Disable file size reporting in 'list'
+  --files <list>            Extract only specified files (comma-separated)
+  --view-reconst            Export the reconstituted PNG for debugging
+  --debug                   Export debug images (doubled.png, reconstructed.png)
+  -v, --verbose             Show detailed errors
+
+Lossy-Resilient Encoding:
+  --lossy-resilient         Enable lossy-resilient mode (survives JPEG/MP3)
+  --ecc-level <level>       ECC redundancy: low|medium|quartile|high (default: medium)
+  --block-size <n>          Robust image block size: 2-8 pixels (default: 4)
+
+  When --lossy-resilient is active, data is encoded with Reed-Solomon ECC
+  and rendered as a QR-code-style grid (image) or MFSK tones (audio).
+  Use --sound or --image to choose the container format.
+
+Examples:
+  npx rox encode secret.pdf                      Encode to PNG
+  npx rox encode secret.pdf --sound               Encode to WAV
+  npx rox encode secret.pdf --lossy-resilient     Lossy-resilient PNG
+  npx rox encode secret.pdf --lossy-resilient --sound --ecc-level high
+  npx rox decode secret.pdf.png                   Decode back
+  npx rox decode secret.pdf.wav                   Decode WAV back
+
+Run "npx rox help" for this message.
 `);
 }
 function parseArgs(args) {
@@ -303,35 +303,22 @@ async function encodeCommand(args) {
             const startTime = Date.now();
             const encodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
             let barValue = 0;
-            encodeBar.start(100, 0, { step: 'Starting', elapsed: '0' });
-            const onProgress = (pct) => {
-                barValue = Math.max(barValue, pct);
+            encodeBar.start(100, 0, { step: 'Encoding', elapsed: '0' });
+            const progressInterval = setInterval(() => {
+                barValue = Math.min(barValue + 1, 99);
                 const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                let step = 'Encoding';
-                if (pct < 30)
-                    step = 'Packing files';
-                else if (pct < 80)
-                    step = 'Compressing';
-                else if (pct < 100)
-                    step = 'Writing PNG';
-                else
-                    step = 'Done';
-                encodeBar.update(Math.min(barValue, 99), { step, elapsed: String(elapsed) });
-            };
-            const smoothInterval = setInterval(() => {
-                if (barValue < 99) {
-                    barValue = Math.min(barValue + 1, 99);
-                    const elapsed = Math.floor((Date.now() - startTime) / 1000);
-                    encodeBar.update(barValue, { step: barValue < 30 ? 'Packing files' : barValue < 80 ? 'Compressing' : 'Writing PNG', elapsed: String(elapsed) });
-                }
-            }, 2000);
+                encodeBar.update(barValue, {
+                    step: 'Encoding',
+                    elapsed: String(elapsed),
+                });
+            }, 500);
             const encryptType = parsed.encrypt === 'xor' ? 'xor' : 'aes';
             const fileName = basename(inputPaths[0]);
-            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 0, parsed.passphrase, encryptType, fileName, onProgress);
-            clearInterval(smoothInterval);
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 19, parsed.passphrase, encryptType, fileName);
+            clearInterval(progressInterval);
             const encodeTime = Date.now() - startTime;
             encodeBar.update(100, {
-                step: 'Done',
+                step: 'done',
                 elapsed: String(Math.floor(encodeTime / 1000)),
             });
             encodeBar.stop();
@@ -373,18 +360,28 @@ async function encodeCommand(args) {
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
+        let barStarted = false;
         const startEncode = Date.now();
         let currentEncodeStep = 'Starting';
         let displayedPct = 0;
         let targetPct = 0;
         const TICK_MS = 100;
         const PCT_STEP = 1;
-        encodeBar.start(100, 0, { step: currentEncodeStep, elapsed: '0' });
         const encodeHeartbeat = setInterval(() => {
             const elapsed = Date.now() - startEncode;
+            if (!barStarted) {
+                encodeBar.start(100, Math.floor(displayedPct), {
+                    step: currentEncodeStep,
+                    elapsed: '0',
+                });
+                barStarted = true;
+            }
             if (displayedPct < targetPct) {
                 displayedPct = Math.min(displayedPct + PCT_STEP, targetPct);
             }
+            else if (displayedPct < 99) {
+                displayedPct = Math.min(displayedPct + PCT_STEP, 99);
+            }
             encodeBar.update(Math.floor(displayedPct), {
                 step: currentEncodeStep,
                 elapsed: String(Math.floor(elapsed / 1000)),
@@ -395,7 +392,7 @@ async function encodeCommand(args) {
             mode,
             name: parsed.outputName || 'archive',
             skipOptimization: false,
-            compressionLevel: 0,
+            compressionLevel: 6,
             outputFormat: 'auto',
             container: containerMode,
         });
@@ -541,11 +538,13 @@ async function encodeCommand(args) {
         const output = await encodeBinaryToPng(inputBuffer, options);
         const encodeTime = Date.now() - startEncode;
         clearInterval(encodeHeartbeat);
-        encodeBar.update(100, {
-            step: 'Done',
-            elapsed: String(Math.floor(encodeTime / 1000)),
-        });
-        encodeBar.stop();
+        if (barStarted) {
+            encodeBar.update(100, {
+                step: 'done',
+                elapsed: String(Math.floor(encodeTime / 1000)),
+            });
+            encodeBar.stop();
+        }
         writeFileSync(resolvedOutput, output);
         const outputSize = (output.length / 1024 / 1024).toFixed(2);
         const inputSize = (inputSizeVal / 1024 / 1024).toFixed(2);
@@ -576,42 +575,6 @@ async function decodeCommand(args) {
     }
     const resolvedInput = resolve(inputPath);
     const resolvedOutput = parsed.output || outputPath || 'decoded.bin';
-    const inputFileSize = statSync(resolvedInput).size;
-    if (isRustBinaryAvailable() && !parsed.dict && inputFileSize > 10 * 1024 * 1024) {
-        try {
-            console.log(' ');
-            console.log(`Decoding... (Using native Rust decoder)\n`);
-            const decodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
-            const startDecode = Date.now();
-            let barValue = 0;
-            decodeBar.start(100, 0, { step: 'Reading PNG', elapsed: '0' });
-            const onProgress = (pct) => {
-                barValue = Math.max(barValue, pct);
-                const elapsed = Math.floor((Date.now() - startDecode) / 1000);
-                let step = 'Reading PNG';
-                if (pct >= 10 && pct < 60)
-                    step = 'Decompressing';
-                else if (pct >= 60 && pct < 100)
-                    step = 'Extracting files';
-                else if (pct >= 100)
-                    step = 'Done';
-                decodeBar.update(Math.min(barValue, 99), { step, elapsed: String(elapsed) });
-            };
-            await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, onProgress);
-            const decodeTime = Date.now() - startDecode;
-            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) {
@@ -638,19 +601,28 @@ async function decodeCommand(args) {
         const decodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
+        let barStarted = false;
         const startDecode = Date.now();
         let currentPct = 0;
         let targetPct = 0;
-        let currentStep = 'Reading PNG';
-        decodeBar.start(100, 0, { step: currentStep, elapsed: '0' });
+        let currentStep = 'Decoding';
         const heartbeat = setInterval(() => {
             if (currentPct < targetPct) {
                 currentPct = Math.min(currentPct + 2, targetPct);
             }
-            decodeBar.update(Math.floor(currentPct), {
-                step: currentStep,
-                elapsed: String(Math.floor((Date.now() - startDecode) / 1000)),
-            });
+            if (!barStarted && targetPct > 0) {
+                decodeBar.start(100, Math.floor(currentPct), {
+                    step: currentStep,
+                    elapsed: String(Math.floor((Date.now() - startDecode) / 1000)),
+                });
+                barStarted = true;
+            }
+            else if (barStarted) {
+                decodeBar.update(Math.floor(currentPct), {
+                    step: currentStep,
+                    elapsed: String(Math.floor((Date.now() - startDecode) / 1000)),
+                });
+            }
         }, 100);
         options.onProgress = (info) => {
             if (info.phase === 'decompress_start') {
@@ -661,7 +633,7 @@ async function decodeCommand(args) {
                 info.loaded &&
                 info.total) {
                 targetPct = 50 + Math.floor((info.loaded / info.total) * 40);
-                currentStep = 'Decompressing';
+                currentStep = `Decompressing (${info.loaded}/${info.total})`;
             }
             else if (info.phase === 'decompress_done') {
                 targetPct = 90;
@@ -676,12 +648,14 @@ async function decodeCommand(args) {
         const result = await decodePngToBinary(inputBuffer, options);
         const decodeTime = Date.now() - startDecode;
         clearInterval(heartbeat);
-        currentPct = 100;
-        decodeBar.update(100, {
-            step: 'Done',
-            elapsed: String(Math.floor(decodeTime / 1000)),
-        });
-        decodeBar.stop();
+        if (barStarted) {
+            currentPct = 100;
+            decodeBar.update(100, {
+                step: 'done',
+                elapsed: String(Math.floor(decodeTime / 1000)),
+            });
+            decodeBar.stop();
+        }
         if (result.files) {
             const baseDir = parsed.output || outputPath || '.';
             const totalBytes = result.files.reduce((s, f) => s + f.buf.length, 0);

package/dist/stub-progress.d.ts

@@ -1,14 +1,9 @@
-import cliProgress from 'cli-progress';
 export declare class SingleBar {
-    private bar;
-    constructor(opts?: any, preset?: any);
-    start(total: number, startValue: number, payload?: any): void;
-    update(value: number, payload?: any): void;
-    stop(): void;
+    constructor(...args: any[]);
+    start(...args: any[]): void;
+    update(...args: any[]): void;
+    stop(...args: any[]): void;
 }
 export declare const Presets: {
-    legacy: cliProgress.Preset;
-    rect: cliProgress.Preset;
-    shades_classic: cliProgress.Preset;
-    shades_grey: cliProgress.Preset;
+    shades_classic: {};
 };

package/dist/stub-progress.js

@@ -1,22 +1,9 @@
-import cliProgress from 'cli-progress';
 export class SingleBar {
-    constructor(opts, preset) {
-        this.bar = new cliProgress.SingleBar({
-            ...opts,
-            hideCursor: true,
-            forceRedraw: true,
-            barCompleteChar: '\u2588',
-            barIncompleteChar: '\u2591',
-        }, preset || cliProgress.Presets.shades_classic);
-    }
-    start(total, startValue, payload) {
-        this.bar.start(total, startValue, payload);
-    }
-    update(value, payload) {
-        this.bar.update(value, payload);
-    }
-    stop() {
-        this.bar.stop();
-    }
+    constructor(...args) { }
+    start(...args) { }
+    update(...args) { }
+    stop(...args) { }
 }
-export const Presets = cliProgress.Presets;
+export const Presets = {
+    shades_classic: {},
+};

package/dist/utils/encoder.js

@@ -59,7 +59,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
             };
         }
     }
-    const compressionLevel = opts.compressionLevel ?? 3;
+    const compressionLevel = opts.compressionLevel ?? 19;
     // ─── Lossy-resilient encoding fast path ────────────────────────────────────
     // When lossyResilient is true, use QR-code-style block encoding with
     // Reed-Solomon FEC. This produces output that survives lossy compression.

package/dist/utils/rust-cli-wrapper.d.ts

@@ -1,7 +1,4 @@
 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, onProgress?: (pct: number) => void): Promise<void>;
-export declare function decodeWithRustCLI(inputPath: string, outputPath: string, passphrase?: string, files?: string[], onProgress?: (pct: number) => void): Promise<{
-    usedRust: boolean;
-}>;
+export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor', name?: string): Promise<void>;

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

@@ -128,7 +128,7 @@ 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, onProgress) {
+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');
@@ -145,7 +145,7 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         return dest;
     }
     return new Promise((resolve, reject) => {
-        const args = ['encode', '--level', String(compressionLevel), '--progress'];
+        const args = ['encode', '--level', String(compressionLevel)];
         let supportsName = false;
         if (name) {
             try {
@@ -173,9 +173,7 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         const runSpawn = (exePath) => {
             let proc;
             try {
-                proc = spawn(exePath, args, {
-                    stdio: ['inherit', 'inherit', 'pipe'],
-                });
+                proc = spawn(exePath, args, { stdio: 'inherit' });
             }
             catch (err) {
                 if (!triedExtract) {
@@ -190,20 +188,6 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 return reject(err);
             }
-            if (proc.stderr && onProgress) {
-                let stderrBuf = '';
-                proc.stderr.on('data', (chunk) => {
-                    stderrBuf += chunk.toString();
-                    const lines = stderrBuf.split('\n');
-                    stderrBuf = lines.pop() || '';
-                    for (const line of lines) {
-                        const match = line.match(/PROGRESS:(\d+)/);
-                        if (match) {
-                            onProgress(parseInt(match[1], 10));
-                        }
-                    }
-                });
-            }
             proc.on('error', (err) => {
                 if (!triedExtract) {
                     triedExtract = true;
@@ -235,53 +219,3 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         runSpawn(cliPath);
     });
 }
-export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, onProgress) {
-    const cliPath = findRustBinary();
-    if (!cliPath) {
-        throw new Error('Rust CLI binary not found');
-    }
-    return new Promise((resolve, reject) => {
-        const args = ['decompress', '--progress'];
-        if (passphrase) {
-            args.push('--passphrase', passphrase);
-        }
-        if (files && files.length > 0) {
-            args.push('--files', JSON.stringify(files));
-        }
-        args.push(inputPath, outputPath);
-        const proc = spawn(cliPath, args, {
-            stdio: ['inherit', 'pipe', 'pipe'],
-        });
-        let stdout = '';
-        if (proc.stdout) {
-            proc.stdout.on('data', (chunk) => {
-                const text = chunk.toString();
-                stdout += text;
-                process.stdout.write(text);
-            });
-        }
-        if (proc.stderr && onProgress) {
-            let stderrBuf = '';
-            proc.stderr.on('data', (chunk) => {
-                stderrBuf += chunk.toString();
-                const lines = stderrBuf.split('\n');
-                stderrBuf = lines.pop() || '';
-                for (const line of lines) {
-                    const match = line.match(/PROGRESS:(\d+)/);
-                    if (match) {
-                        onProgress(parseInt(match[1], 10));
-                    }
-                }
-            });
-        }
-        proc.on('error', (err) => reject(err));
-        proc.on('close', (code) => {
-            if (code === 0) {
-                resolve({ usedRust: true });
-            }
-            else {
-                reject(new Error(`Rust decoder exited with status ${code}`));
-            }
-        });
-    });
-}