roxify 1.14.1 → 1.14.2

package/Cargo.toml

@@ -0,0 +1,76 @@
+[package]
+name = "roxify_native"
+version = "1.14.0"
+edition = "2021"
+publish = false
+
+[lib]
+name = "roxify_native"
+crate-type = ["cdylib"]
+path = "native/lib.rs"
+
+[[bin]]
+name = "roxify_native"
+path = "native/main.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 = { version = "1.0", 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"
+simd-adler32 = "0.3"
+
+bytemuck = { version = "1.14", features = ["derive"] }
+parking_lot = "0.12"
+libsais = { version = "0.2.0", default-features = false }
+libc = "0.2"
+
+[features]
+default = []
+
+[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

@@ -3,7 +3,7 @@ import { readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { open } from 'fs/promises';
 import { basename, dirname, join, resolve } from 'path';
 import * as cliProgress from './stub-progress.js';
-import { encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+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');
@@ -462,6 +462,38 @@ async function encodeCommand(args) {
         else {
             const resolvedInput = resolvedInputs[0];
             const st = statSync(resolvedInput);
+            // Calculate total size for deciding whether to use Rust CLI streaming
+            const totalInputSize = st.isDirectory()
+                ? getDirectorySize(resolvedInput)
+                : st.size;
+            // Use Rust CLI for large files (> 1GB) to avoid Buffer.concat 4GB limit
+            const STREAMING_THRESHOLD = 1024 * 1024 * 1024; // 1GB
+            if (totalInputSize > STREAMING_THRESHOLD && isRustBinaryAvailable()) {
+                console.log('Using native Rust encoder (streaming for large payload)\n');
+                const encodeStart = Date.now();
+                let lastPct = 0;
+                await encodeWithRustCLI(resolvedInput, resolvedOutput, parsed.level ? Number(parsed.level) : 6, parsed.passphrase, parsed.encrypt || 'aes', parsed.outputName || (st.isDirectory() ? basename(resolvedInput) : undefined), undefined, // ramBudgetMb
+                (current, total, step) => {
+                    const pct = Math.floor((current / total) * 100);
+                    if (pct !== lastPct) {
+                        lastPct = pct;
+                        if (barStarted) {
+                            encodeBar.update(pct, { step });
+                        }
+                    }
+                });
+                const encodeTime = Date.now() - encodeStart;
+                if (barStarted) {
+                    encodeBar.update(100, { step: 'done', elapsed: String(Math.floor(encodeTime / 1000)) });
+                    encodeBar.stop();
+                }
+                console.log(`\nSuccess!`);
+                console.log(`  Input:  ${(totalInputSize / 1024 / 1024).toFixed(2)} MB`);
+                console.log(`  Time:   ${encodeTime}ms`);
+                console.log(`  Saved:  ${resolvedOutput}`);
+                console.log(' ');
+                return;
+            }
             if (st.isDirectory()) {
                 currentEncodeStep = 'Reading files';
                 const { index, stream, totalSize } = await js.packPathsGenerator([resolvedInput], dirname(resolvedInput), onProgress);
@@ -591,33 +623,24 @@ async function decodeCommand(args) {
     }
     const resolvedInput = resolve(inputPath);
     const resolvedOutput = parsed.output || outputPath || '.';
+    if (!isRustBinaryAvailable()) {
+        console.error('Error: Rust decoder binary not found');
+        process.exit(1);
+    }
     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);
         decodeBar.start(100, 0, { step: 'Decoding', elapsed: '0' });
-        const js = await loadJsEngine();
-        const result = await js.decodePngToBinary(readFileSync(resolvedInput));
-        if (result.files && result.files.length > 0) {
-            const outputDir = resolve(resolvedOutput);
-            for (const file of result.files) {
-                const dest = join(outputDir, file.path);
-                const parent = dirname(dest);
-                try {
-                    await import('fs/promises').then(({ mkdir }) => mkdir(parent, { recursive: true }));
-                }
-                catch { }
-                writeFileSync(dest, file.buf);
-            }
-        }
-        else if (result.buf) {
-            const outputFile = resolvedOutput === '.' ? join(process.cwd(), result.meta?.name || basename(resolvedInput).replace(/\.[^.]+$/, '')) : resolvedOutput;
-            writeFileSync(outputFile, result.buf);
-        }
-        else {
-            throw new Error('Decoded result is empty');
-        }
+        await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, parsed.dict, parsed.ramBudgetMb, (current, total, step) => {
+            const pct = total > 0 ? Math.floor((current / total) * 100) : 0;
+            const elapsed = Math.floor((Date.now() - startTime) / 1000);
+            decodeBar.update(Math.min(pct, 99), {
+                step: step || 'Decoding',
+                elapsed: String(elapsed),
+            });
+        });
         const decodeTime = Date.now() - startTime;
         decodeBar.update(100, { step: 'done', elapsed: String(Math.floor(decodeTime / 1000)) });
         decodeBar.stop();

package/native/archive.rs

@@ -0,0 +1,220 @@
+use std::io::Cursor;
+use std::path::Path;
+use rayon::prelude::*;
+use tar::{Archive, Builder, Header};
+use walkdir::WalkDir;
+
+pub struct TarPackResult {
+    pub data: Vec<u8>,
+    pub file_list: Vec<(String, u64)>,
+}
+
+pub fn tar_pack_directory_with_list(dir_path: &Path) -> Result<TarPackResult, String> {
+    let base = dir_path;
+
+    let entries: Vec<_> = WalkDir::new(dir_path)
+        .follow_links(false)
+        .into_iter()
+        .filter_map(|e| e.ok())
+        .filter(|e| e.file_type().is_file())
+        .collect();
+
+    let file_data: Vec<(String, Vec<u8>)> = entries
+        .par_iter()
+        .filter_map(|entry| {
+            let full = entry.path();
+            let rel = full.strip_prefix(base).unwrap_or(full);
+            let rel_str = rel.to_string_lossy().replace('\\', "/");
+            match std::fs::read(full) {
+                Ok(data) => Some((rel_str, data)),
+                Err(_) => None,
+            }
+        })
+        .collect();
+
+    let file_list: Vec<(String, u64)> = file_data.iter()
+        .map(|(name, data)| (name.clone(), data.len() as u64))
+        .collect();
+
+    let total_estimate: usize = file_data.iter().map(|(n, d)| 512 + d.len() + 512 + n.len()).sum();
+    let mut buf = Vec::with_capacity(total_estimate + 1024);
+    {
+        let mut builder = Builder::new(&mut buf);
+        for (rel_str, data) in &file_data {
+            let mut header = Header::new_gnu();
+            header.set_size(data.len() as u64);
+            header.set_mode(0o644);
+            header.set_cksum();
+            builder
+                .append_data(&mut header, rel_str, &data[..])
+                .map_err(|e| format!("tar append {}: {}", rel_str, e))?;
+        }
+        builder.finish().map_err(|e| format!("tar finish: {}", e))?;
+    }
+    Ok(TarPackResult { data: buf, file_list })
+}
+
+pub fn tar_pack_directory(dir_path: &Path) -> Result<Vec<u8>, String> {
+    tar_pack_directory_with_list(dir_path).map(|r| r.data)
+}
+
+pub fn tar_file_list_fast(tar_data: &[u8]) -> Vec<(String, u64)> {
+    let mut list = Vec::new();
+    let mut pos = 0;
+    while pos + 512 <= tar_data.len() {
+        let header = &tar_data[pos..pos + 512];
+        if header.iter().all(|&b| b == 0) {
+            break;
+        }
+        let name_end = header[..100].iter().position(|&b| b == 0).unwrap_or(100);
+        let name = String::from_utf8_lossy(&header[..name_end]).to_string();
+        let size_str = String::from_utf8_lossy(&header[124..136]);
+        let size = u64::from_str_radix(size_str.trim().trim_matches('\0'), 8).unwrap_or(0);
+        if !name.is_empty() {
+            list.push((name, size));
+        }
+        let data_blocks = (size as usize + 511) / 512;
+        pos += 512 + data_blocks * 512;
+    }
+    list
+}
+
+pub fn tar_unpack(tar_data: &[u8], output_dir: &Path) -> Result<Vec<String>, String> {
+    let mut archive = Archive::new(Cursor::new(tar_data));
+    let mut entries_data: Vec<(std::path::PathBuf, Vec<u8>)> = Vec::new();
+
+    let entries = archive.entries().map_err(|e| format!("tar entries: {}", e))?;
+    for entry in entries {
+        let mut entry = entry.map_err(|e| format!("tar entry: {}", e))?;
+        let path = entry.path().map_err(|e| format!("tar entry path: {}", e))?.to_path_buf();
+
+        let mut safe = std::path::PathBuf::new();
+        for comp in path.components() {
+            if let std::path::Component::Normal(osstr) = comp {
+                safe.push(osstr);
+            }
+        }
+        if safe.as_os_str().is_empty() {
+            continue;
+        }
+
+        let mut data = Vec::with_capacity(entry.size() as usize);
+        std::io::Read::read_to_end(&mut entry, &mut data)
+            .map_err(|e| format!("tar read {:?}: {}", safe, e))?;
+        entries_data.push((safe, data));
+    }
+
+    let dirs: std::collections::HashSet<_> = entries_data.iter()
+        .filter_map(|(p, _)| {
+            let dest = output_dir.join(p);
+            dest.parent().map(|d| d.to_path_buf())
+        })
+        .collect();
+    for dir in &dirs {
+        std::fs::create_dir_all(dir).map_err(|e| format!("mkdir {:?}: {}", dir, e))?;
+    }
+
+    let written: Vec<String> = entries_data.par_iter()
+        .filter_map(|(safe, data)| {
+            let dest = output_dir.join(safe);
+            match std::fs::write(&dest, data) {
+                Ok(_) => Some(safe.to_string_lossy().to_string()),
+                Err(_) => None,
+            }
+        })
+        .collect();
+
+    Ok(written)
+}
+
+pub fn is_tar(data: &[u8]) -> bool {
+    if data.len() < 263 {
+        return false;
+    }
+    &data[257..262] == b"ustar"
+}
+
+pub fn tar_file_list(tar_data: &[u8]) -> Result<Vec<(String, u64)>, String> {
+    let mut archive = Archive::new(Cursor::new(tar_data));
+    let mut list = Vec::new();
+    let entries = archive.entries().map_err(|e| format!("tar entries: {}", e))?;
+    for entry in entries {
+        let entry = entry.map_err(|e| format!("tar entry: {}", e))?;
+        let path = entry
+            .path()
+            .map_err(|e| format!("tar path: {}", e))?
+            .to_string_lossy()
+            .to_string();
+        let size = entry.size();
+        list.push((path, size));
+    }
+    Ok(list)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_tar_roundtrip() {
+        let tmp = std::env::temp_dir().join("rox_tar_test");
+        let _ = fs::remove_dir_all(&tmp);
+        fs::create_dir_all(tmp.join("sub")).unwrap();
+        fs::write(tmp.join("hello.txt"), b"Hello TAR").unwrap();
+        fs::write(tmp.join("sub/nested.txt"), b"Nested!").unwrap();
+
+        let tar_data = tar_pack_directory(&tmp).unwrap();
+        assert!(is_tar(&tar_data));
+
+        let list = tar_file_list(&tar_data).unwrap();
+        assert_eq!(list.len(), 2);
+
+        let out = std::env::temp_dir().join("rox_tar_test_out");
+        let _ = fs::remove_dir_all(&out);
+        fs::create_dir_all(&out).unwrap();
+
+        let written = tar_unpack(&tar_data, &out).unwrap();
+        assert_eq!(written.len(), 2);
+        assert_eq!(fs::read_to_string(out.join("hello.txt")).unwrap(), "Hello TAR");
+        assert_eq!(fs::read_to_string(out.join("sub/nested.txt")).unwrap(), "Nested!");
+
+        let _ = fs::remove_dir_all(&tmp);
+        let _ = fs::remove_dir_all(&out);
+    }
+
+    #[test]
+    fn test_tar_zstd_roundtrip() {
+        use std::io::Write;
+
+        let tmp = std::env::temp_dir().join("rox_tar_zstd_test");
+        let _ = fs::remove_dir_all(&tmp);
+        fs::create_dir_all(tmp.join("a/b")).unwrap();
+        fs::write(tmp.join("root.txt"), b"root file content").unwrap();
+        fs::write(tmp.join("a/mid.txt"), b"mid level").unwrap();
+        fs::write(tmp.join("a/b/deep.txt"), b"deep nested file").unwrap();
+
+        let tar_data = tar_pack_directory(&tmp).unwrap();
+        assert!(is_tar(&tar_data));
+
+        let mut encoder = zstd::stream::Encoder::new(Vec::new(), 3).unwrap();
+        encoder.write_all(&tar_data).unwrap();
+        let compressed = encoder.finish().unwrap();
+
+        let decompressed = crate::core::zstd_decompress_bytes(&compressed, None).unwrap();
+        assert!(is_tar(&decompressed));
+
+        let out = std::env::temp_dir().join("rox_tar_zstd_test_out");
+        let _ = fs::remove_dir_all(&out);
+        fs::create_dir_all(&out).unwrap();
+
+        let written = tar_unpack(&decompressed, &out).unwrap();
+        assert_eq!(written.len(), 3);
+        assert_eq!(fs::read_to_string(out.join("root.txt")).unwrap(), "root file content");
+        assert_eq!(fs::read_to_string(out.join("a/mid.txt")).unwrap(), "mid level");
+        assert_eq!(fs::read_to_string(out.join("a/b/deep.txt")).unwrap(), "deep nested file");
+
+        let _ = fs::remove_dir_all(&tmp);
+        let _ = fs::remove_dir_all(&out);
+    }
+}

package/native/audio.rs

@@ -0,0 +1,151 @@
+/// WAV container for binary data.
+///
+/// Encodes raw bytes as 8-bit unsigned PCM mono samples (44100 Hz).
+/// Header is exactly 44 bytes. Total overhead: 44 bytes.
+///
+/// Compared to PNG (stored deflate): PNG overhead grows with data size
+/// (zlib framing, filter bytes, chunk CRCs). WAV overhead is constant.
+
+const WAV_HEADER_SIZE: usize = 44;
+const SAMPLE_RATE: u32 = 44100;
+const BITS_PER_SAMPLE: u16 = 8;
+const NUM_CHANNELS: u16 = 1;
+
+/// Pack raw bytes into a WAV file (8-bit PCM, mono, 44100 Hz).
+/// The bytes are stored directly as unsigned PCM samples.
+/// Returns the complete WAV file as a Vec<u8>.
+pub fn bytes_to_wav(data: &[u8]) -> Vec<u8> {
+    let data_size = data.len() as u32;
+    let file_size = WAV_HEADER_SIZE as u32 - 8 + data_size; // RIFF chunk size
+
+    let byte_rate = SAMPLE_RATE * NUM_CHANNELS as u32 * (BITS_PER_SAMPLE as u32 / 8);
+    let block_align = NUM_CHANNELS * (BITS_PER_SAMPLE / 8);
+
+    let mut wav = Vec::with_capacity(WAV_HEADER_SIZE + data.len());
+
+    // RIFF header
+    wav.extend_from_slice(b"RIFF");
+    wav.extend_from_slice(&file_size.to_le_bytes());
+    wav.extend_from_slice(b"WAVE");
+
+    // fmt sub-chunk
+    wav.extend_from_slice(b"fmt ");
+    wav.extend_from_slice(&16u32.to_le_bytes()); // sub-chunk size (PCM = 16)
+    wav.extend_from_slice(&1u16.to_le_bytes());  // audio format (1 = PCM)
+    wav.extend_from_slice(&NUM_CHANNELS.to_le_bytes());
+    wav.extend_from_slice(&SAMPLE_RATE.to_le_bytes());
+    wav.extend_from_slice(&byte_rate.to_le_bytes());
+    wav.extend_from_slice(&block_align.to_le_bytes());
+    wav.extend_from_slice(&BITS_PER_SAMPLE.to_le_bytes());
+
+    // data sub-chunk
+    wav.extend_from_slice(b"data");
+    wav.extend_from_slice(&data_size.to_le_bytes());
+    wav.extend_from_slice(data);
+
+    wav
+}
+
+/// Extract raw bytes from a WAV file.
+/// Returns the PCM data (the original bytes) or an error.
+pub fn wav_to_bytes(wav: &[u8]) -> Result<Vec<u8>, String> {
+    if wav.len() < WAV_HEADER_SIZE {
+        return Err("WAV data too short".to_string());
+    }
+
+    // Validate RIFF header
+    if &wav[0..4] != b"RIFF" {
+        return Err("Not a RIFF file".to_string());
+    }
+    if &wav[8..12] != b"WAVE" {
+        return Err("Not a WAVE file".to_string());
+    }
+
+    // Find the "data" sub-chunk (skip fmt and any other chunks)
+    let mut offset = 12; // past "RIFF" + size + "WAVE"
+    loop {
+        if offset + 8 > wav.len() {
+            return Err("data chunk not found".to_string());
+        }
+        let chunk_id = &wav[offset..offset + 4];
+        let chunk_size = u32::from_le_bytes([
+            wav[offset + 4],
+            wav[offset + 5],
+            wav[offset + 6],
+            wav[offset + 7],
+        ]) as usize;
+
+        if chunk_id == b"data" {
+            let data_start = offset + 8;
+            let data_end = data_start + chunk_size;
+            if data_end > wav.len() {
+                // Allow truncation: return what we have
+                return Ok(wav[data_start..].to_vec());
+            }
+            return Ok(wav[data_start..data_end].to_vec());
+        }
+
+        // Skip this chunk (+ padding byte if odd size)
+        offset += 8 + chunk_size;
+        if chunk_size % 2 != 0 {
+            offset += 1; // RIFF chunks are word-aligned
+        }
+    }
+}
+
+/// Check if a buffer starts with a RIFF/WAVE header.
+pub fn is_wav(buf: &[u8]) -> bool {
+    buf.len() >= 12 && &buf[0..4] == b"RIFF" && &buf[8..12] == b"WAVE"
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_wav_roundtrip() {
+        let data = b"Hello, World! This is roxify audio container test data.";
+        let wav = bytes_to_wav(data);
+
+        // Check header
+        assert_eq!(&wav[0..4], b"RIFF");
+        assert_eq!(&wav[8..12], b"WAVE");
+        assert_eq!(wav.len(), 44 + data.len());
+
+        // Roundtrip
+        let recovered = wav_to_bytes(&wav).expect("decode should succeed");
+        assert_eq!(recovered, data);
+    }
+
+    #[test]
+    fn test_wav_empty() {
+        let data: &[u8] = b"";
+        let wav = bytes_to_wav(data);
+        assert_eq!(wav.len(), 44);
+        let recovered = wav_to_bytes(&wav).expect("decode empty");
+        assert!(recovered.is_empty());
+    }
+
+    #[test]
+    fn test_wav_large() {
+        let data = vec![0xAB_u8; 1024 * 1024]; // 1 MB
+        let wav = bytes_to_wav(&data);
+        assert_eq!(wav.len(), 44 + 1024 * 1024);
+        let recovered = wav_to_bytes(&wav).expect("decode large");
+        assert_eq!(recovered, data);
+    }
+
+    #[test]
+    fn test_is_wav() {
+        let wav = bytes_to_wav(b"test");
+        assert!(is_wav(&wav));
+        assert!(!is_wav(b"not a wav"));
+        assert!(!is_wav(b"RIFF1234XXXX")); // RIFF but not WAVE
+    }
+
+    #[test]
+    fn test_invalid_wav() {
+        assert!(wav_to_bytes(b"short").is_err());
+        assert!(wav_to_bytes(b"NOT a RIFF file!").is_err());
+    }
+}

package/native/bench_hybrid.rs

@@ -0,0 +1,145 @@
+use std::time::Instant;
+
+mod rans_byte;
+mod bwt;
+mod mtf;
+mod context_mixing;
+mod pool;
+mod hybrid;
+
+fn bench_roundtrip(name: &str, data: &[u8]) {
+    let compressor = hybrid::HybridCompressor::new();
+
+    let start = Instant::now();
+    let (compressed, stats) = compressor.compress(data).unwrap();
+    let compress_time = start.elapsed();
+
+    let start = Instant::now();
+    let decompressed = compressor.decompress(&compressed).unwrap();
+    let decompress_time = start.elapsed();
+
+    let ratio = (compressed.len() as f64) / (data.len() as f64) * 100.0;
+    let compress_mbps = (data.len() as f64 / 1_048_576.0) / compress_time.as_secs_f64();
+    let decompress_mbps = (data.len() as f64 / 1_048_576.0) / decompress_time.as_secs_f64();
+
+    assert_eq!(decompressed, data, "ROUND-TRIP FAILED for {}", name);
+
+    println!("=== {} ===", name);
+    println!("  Input:       {} bytes", data.len());
+    println!("  Compressed:  {} bytes ({:.1}%)", compressed.len(), ratio);
+    println!("  Reduction:   {:.1}%", 100.0 - ratio);
+    println!("  Compress:    {:.1} ms ({:.1} MB/s)", compress_time.as_secs_f64() * 1000.0, compress_mbps);
+    println!("  Decompress:  {:.1} ms ({:.1} MB/s)", decompress_time.as_secs_f64() * 1000.0, decompress_mbps);
+    println!("  Entropy:     {:.2} bits/byte", stats.entropy_bits);
+    println!();
+}
+
+fn bench_zstd(name: &str, data: &[u8], level: i32) {
+    let start = Instant::now();
+    let compressed = zstd::encode_all(std::io::Cursor::new(data), level).unwrap();
+    let compress_time = start.elapsed();
+
+    let start = Instant::now();
+    let decompressed = zstd::decode_all(std::io::Cursor::new(&compressed)).unwrap();
+    let decompress_time = start.elapsed();
+
+    let ratio = (compressed.len() as f64) / (data.len() as f64) * 100.0;
+    let compress_mbps = (data.len() as f64 / 1_048_576.0) / compress_time.as_secs_f64();
+    let decompress_mbps = (data.len() as f64 / 1_048_576.0) / decompress_time.as_secs_f64();
+
+    assert_eq!(decompressed, data);
+
+    println!("=== Zstd L{} ({}) ===", level, name);
+    println!("  Compressed:  {} bytes ({:.1}%)", compressed.len(), ratio);
+    println!("  Reduction:   {:.1}%", 100.0 - ratio);
+    println!("  Compress:    {:.1} ms ({:.1} MB/s)", compress_time.as_secs_f64() * 1000.0, compress_mbps);
+    println!("  Decompress:  {:.1} ms ({:.1} MB/s)", decompress_time.as_secs_f64() * 1000.0, decompress_mbps);
+    println!();
+}
+
+fn main() {
+    println!("╔══════════════════════════════════════════════════════════╗");
+    println!("║     ROXIFY BWT-ANS COMPRESSION BENCHMARK               ║");
+    println!("╚══════════════════════════════════════════════════════════╝\n");
+
+    let text_1k: Vec<u8> = "Hello World! This is a test of the roxify compression engine. ".repeat(16).into_bytes();
+    bench_roundtrip("Text 1KB", &text_1k);
+    bench_zstd("Text 1KB", &text_1k, 3);
+    bench_zstd("Text 1KB", &text_1k, 19);
+
+    let text_100k: Vec<u8> = "The quick brown fox jumps over the lazy dog. Pack my box with five dozen liquor jugs. ".repeat(1200).into_bytes();
+    bench_roundtrip("Text 100KB", &text_100k);
+    bench_zstd("Text 100KB", &text_100k, 3);
+    bench_zstd("Text 100KB", &text_100k, 19);
+
+    let text_1m: Vec<u8> = {
+        let mut data = Vec::with_capacity(1_048_576);
+        let phrases = [
+            b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".as_slice(),
+            b"Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. ".as_slice(),
+            b"Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris. ".as_slice(),
+            b"Duis aute irure dolor in reprehenderit in voluptate velit esse. ".as_slice(),
+            b"Excepteur sint occaecat cupidatat non proident, sunt in culpa. ".as_slice(),
+        ];
+        let mut i = 0;
+        while data.len() < 1_048_576 {
+            data.extend_from_slice(phrases[i % phrases.len()]);
+            i += 1;
+        }
+        data.truncate(1_048_576);
+        data
+    };
+    bench_roundtrip("Text 1MB", &text_1m);
+    bench_zstd("Text 1MB", &text_1m, 3);
+    bench_zstd("Text 1MB", &text_1m, 19);
+
+    let json_data: Vec<u8> = {
+        let mut data = String::with_capacity(512_000);
+        data.push('[');
+        for i in 0..5000 {
+            if i > 0 { data.push(','); }
+            data.push_str(&format!(
+                r#"{{"id":{},"name":"user_{}","email":"user{}@example.com","active":{},"score":{:.2},"tags":["tag1","tag2","tag3"]}}"#,
+                i, i, i, i % 2 == 0, (i as f64) * 1.337
+            ));
+        }
+        data.push(']');
+        data.into_bytes()
+    };
+    bench_roundtrip("JSON 500KB", &json_data);
+    bench_zstd("JSON 500KB", &json_data, 3);
+    bench_zstd("JSON 500KB", &json_data, 19);
+
+    let random_data: Vec<u8> = {
+        let mut data = vec![0u8; 100_000];
+        let mut state = 12345u64;
+        for b in data.iter_mut() {
+            state = state.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407);
+            *b = (state >> 33) as u8;
+        }
+        data
+    };
+    bench_roundtrip("Random 100KB", &random_data);
+    bench_zstd("Random 100KB", &random_data, 3);
+
+    let binary_data: Vec<u8> = {
+        let mut data = Vec::with_capacity(256_000);
+        for i in 0..256_000u32 {
+            match i % 7 {
+                0 => data.push(0),
+                1 => data.push(0xFF),
+                2 => data.push((i & 0xFF) as u8),
+                3 => data.push(((i >> 8) & 0xFF) as u8),
+                4 => data.push(b'A' + (i % 26) as u8),
+                5 => data.push(0x20),
+                _ => data.push((i.wrapping_mul(37) & 0xFF) as u8),
+            }
+        }
+        data
+    };
+    bench_roundtrip("Binary 256KB", &binary_data);
+    bench_zstd("Binary 256KB", &binary_data, 3);
+    bench_zstd("Binary 256KB", &binary_data, 19);
+
+    println!("All round-trip tests PASSED!");
+}