roxify 1.13.7 → 1.13.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.13.7",
+  "version": "1.13.9",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",
@@ -10,34 +10,17 @@
     "roxify": "dist/cli.js"
   },
   "files": [
-    "dist",
-    "roxify_native-x86_64-unknown-linux-gnu.node",
-    "roxify_native-i686-unknown-linux-gnu.node",
-    "roxify_native-aarch64-unknown-linux-gnu.node",
-    "roxify_native-x86_64-apple-darwin.node",
-    "roxify_native-aarch64-apple-darwin.node",
-    "roxify_native-x86_64-pc-windows-msvc.node",
-    "roxify_native-i686-pc-windows-msvc.node",
-    "roxify_native-aarch64-pc-windows-msvc.node",
-    "roxify_native-x86_64-pc-windows-gnu.node",
-    "libroxify_native-x86_64-unknown-linux-gnu.node",
-    "libroxify_native-i686-unknown-linux-gnu.node",
-    "libroxify_native-aarch64-unknown-linux-gnu.node",
-    "libroxify_native-x86_64-apple-darwin.node",
-    "libroxify_native-aarch64-apple-darwin.node",
-    "dist/roxify_native.exe",
-    "dist/roxify_native",
-    "dist/roxify_native-macos-arm64",
-    "dist/roxify_native-macos-x64",
-    "dist/rox-macos-universal",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
     "scripts/postinstall.cjs",
-    "native",
-    "Cargo.toml",
+    "roxify_native-*.node",
+    "libroxify_native-*.node",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc",
+    "bundle": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --format=esm --minify && esbuild src/cli.ts --bundle --platform=node --target=node18 --outfile=dist/cli.js --format=esm --minify && tsc --emitDeclarationOnly --declaration --declarationDir dist",
     "prebuild:pkg": "node scripts/copy-cli-binary.js",
     "build:native": "cargo build --release --lib",
     "build:native:linux": "cargo build --release --lib --target x86_64-unknown-linux-gnu",
@@ -59,7 +42,7 @@
     "clean:targets": "node scripts/clean-artifacts.js",
     "release:prepare": "npm run build && npm run build:native:targets && node scripts/prepare-release.cjs",
     "release:github": "npm run release:prepare && node scripts/create-gh-release.cjs",
-    "package:prepare": "npm run build && npm run build:native:targets && node scripts/pack-npm.cjs",
+    "package:prepare": "npm run bundle && npm run build:native:targets && node scripts/pack-npm.cjs",
     "publish:npm": "npm run package:prepare && echo 'Run npm publish --access public'",
     "release:flow": "node scripts/release-flow.cjs",
     "release:flow:auto": "AUTO_PUBLISH=1 node scripts/release-flow.cjs",
@@ -103,12 +86,12 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "pkg": "^5.8.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "esbuild": "^0.18.0",
+    "pngjs": "^7.0.0"
   },
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "pngjs": "^7.0.0"
-  }
-}
+  "dependencies": {}
+}

package/scripts/postinstall.cjs

@@ -1,5 +1,5 @@
 const { execSync } = require('child_process');
-const { existsSync, copyFileSync, mkdirSync } = require('fs');
+const { existsSync, copyFileSync, mkdirSync, readdirSync, unlinkSync } = require('fs');
 const { join } = require('path');
 const { platform, arch } = require('os');
 
@@ -157,5 +157,26 @@ function ensureNativeLib() {
       }
 }
 
-ensureCliBinary();
+if (process.env.ROXIFY_ENABLE_RUST_CLI === '1') {
+      ensureCliBinary();
+}
 ensureNativeLib();
+
+// Cleanup: remove other platform .node artifacts to reduce disk usage after install
+try {
+      const triples = getTriples();
+      if (triples && triples.length) {
+            const files = readdirSync(root);
+            for (const f of files) {
+                  // match roxify_native-<triple>.node or libroxify_native-<triple>.node
+                  const m = f.match(/^(lib)?roxify_native-(.+)\.node$/);
+                  if (m) {
+                        const fileTriple = m[2];
+                        // keep if fileTriple is one of the allowed triples
+                        if (!triples.includes(fileTriple)) {
+                              try { unlinkSync(join(root, f)); console.log(`roxify: removed ${f}`); } catch (e) { }
+                        }
+                  }
+            }
+      }
+} catch (e) { }

package/Cargo.toml

@@ -1,91 +0,0 @@
-[package]
-name = "roxify_native"
-version = "1.13.6"
-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 = { 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"
-
-memmap2 = "0.9"
-bytemuck = { version = "1.14", features = ["derive"] }
-tokio = { version = "1", features = ["sync", "rt"], optional = true }
-parking_lot = "0.12"
-libsais = { version = "0.2.0", default-features = false }
-libc = "0.2"
-
-[features]
-default = []
-async = ["tokio"]
-
-[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/native/archive.rs

@@ -1,220 +0,0 @@
-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

@@ -1,151 +0,0 @@
-/// 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());
-    }
-}