roxify 1.14.1 → 1.14.2

package/native/test_stages.rs

@@ -0,0 +1,70 @@
+mod bwt;
+mod mtf;
+mod rans_byte;
+mod context_mixing;
+mod pool;
+
+fn main() {
+    let data = b"banana";
+
+    // Test BWT
+    let bwt_result = bwt::bwt_encode(data).unwrap();
+    println!("BWT of 'banana': {:?}", String::from_utf8_lossy(&bwt_result.transformed));
+    println!("Primary index: {}", bwt_result.primary_index);
+
+    let decoded = bwt::bwt_decode(&bwt_result.transformed, bwt_result.primary_index).unwrap();
+    println!("BWT decode: {:?}", String::from_utf8_lossy(&decoded));
+    assert_eq!(&decoded, data, "BWT round-trip failed");
+    println!("BWT round-trip OK!\n");
+
+    // Test MTF
+    let mtf_enc = mtf::mtf_encode(data);
+    println!("MTF of 'banana': {:?}", mtf_enc);
+    let mtf_dec = mtf::mtf_decode(&mtf_enc);
+    assert_eq!(mtf_dec, data, "MTF round-trip failed");
+    println!("MTF round-trip OK!\n");
+
+    // Test RLE0
+    let test_rle = vec![0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 0, 7];
+    let rle_enc = mtf::rle0_encode(&test_rle);
+    println!("RLE0 of {:?}: {:?}", test_rle, rle_enc);
+    let rle_dec = mtf::rle0_decode(&rle_enc);
+    println!("RLE0 decode: {:?}", rle_dec);
+    assert_eq!(rle_dec, test_rle, "RLE0 round-trip failed");
+    println!("RLE0 round-trip OK!\n");
+
+    // Test rANS byte
+    let test_data = b"abracadabra";
+    let stats = rans_byte::SymbolStats::from_data(test_data);
+    let encoded = rans_byte::rans_encode_block(test_data, &stats);
+    println!("rANS encoded 'abracadabra': {} bytes -> {} bytes", test_data.len(), encoded.len());
+    let decoded = rans_byte::rans_decode_block(&encoded, &stats, test_data.len()).unwrap();
+    assert_eq!(&decoded, test_data, "rANS round-trip failed");
+    println!("rANS round-trip OK!\n");
+
+    // Test full pipeline on larger data
+    let big_data: Vec<u8> = "Hello World! Testing the full BWT+MTF+RLE+rANS pipeline. ".repeat(20).into_bytes();
+    let bwt_r = bwt::bwt_encode(&big_data).unwrap();
+    let mtf_r = mtf::mtf_encode(&bwt_r.transformed);
+    let rle_r = mtf::rle0_encode(&mtf_r);
+    let stats = rans_byte::SymbolStats::from_data(&rle_r);
+    let enc = rans_byte::rans_encode_block(&rle_r, &stats);
+
+    println!("Full pipeline: {} -> BWT {} -> MTF {} -> RLE {} -> rANS {}",
+        big_data.len(), bwt_r.transformed.len(), mtf_r.len(), rle_r.len(), enc.len());
+
+    let dec_rle = rans_byte::rans_decode_block(&enc, &stats, rle_r.len()).unwrap();
+    assert_eq!(dec_rle, rle_r, "rANS stage failed");
+
+    let dec_mtf = mtf::rle0_decode(&dec_rle);
+    assert_eq!(dec_mtf, mtf_r, "RLE0 stage failed");
+
+    let dec_bwt = mtf::mtf_decode(&dec_mtf);
+    assert_eq!(dec_bwt, bwt_r.transformed, "MTF stage failed");
+
+    let dec_orig = bwt::bwt_decode(&dec_bwt, bwt_r.primary_index).unwrap();
+    assert_eq!(dec_orig, big_data, "BWT stage failed");
+
+    println!("Full pipeline round-trip OK!");
+    println!("Ratio: {:.1}%", (enc.len() as f64 / big_data.len() as f64) * 100.0);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.14.1",
+  "version": "1.14.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",
@@ -12,11 +12,11 @@
   "files": [
     "dist/**/*.js",
     "dist/**/*.d.ts",
-    "dist/roxify_native*",
-    "dist/rox-macos-universal",
     "scripts/postinstall.cjs",
-    "roxify_native-*.node",
-    "libroxify_native-*.node",
+    "scripts/download-binary.cjs",
+    "native/Cargo.toml",
+    "native/**/*.rs",
+    "Cargo.toml",
     "README.md",
     "LICENSE"
   ],
@@ -96,4 +96,4 @@
     "node": ">=18.0.0"
   },
   "dependencies": {}
-}
+}

package/scripts/download-binary.cjs

@@ -0,0 +1,259 @@
+const https = require('https');
+const { createWriteStream, existsSync, mkdirSync, chmodSync, unlinkSync } = require('fs');
+const { join } = require('path');
+const { platform, arch } = require('os');
+
+const GITHUB_REPO = 'RoxasYTB/roxify';
+const DIST_DIR = join(__dirname, '..', 'dist');
+const root = join(__dirname, '..');
+
+function getPlatformBinary() {
+    const os = platform();
+    const cpu = arch();
+
+    const map = {
+        linux: { x64: 'roxify_native', arm64: 'roxify_native' },
+        win32: { x64: 'roxify_native.exe', arm64: 'roxify_native.exe' },
+        darwin: { x64: 'rox-macos-universal', arm64: 'rox-macos-universal' },
+    };
+
+    return (map[os] && map[os][cpu]) || null;
+}
+
+function getReleaseAssetName(version) {
+    const os = platform();
+    const cpu = arch();
+
+    // Map platform/arch to release asset names as uploaded by GitHub Actions
+    const map = {
+        linux: {
+            x64: `roxify_native-x86_64-unknown-linux-gnu`,
+            arm64: `roxify_native-aarch64-unknown-linux-gnu`
+        },
+        win32: {
+            x64: `roxify_native-x86_64-pc-windows-msvc.exe`,
+            arm64: `roxify_native-aarch64-pc-windows-msvc.exe`
+        },
+        darwin: {
+            x64: `rox-macos-universal`,
+            arm64: `rox-macos-universal`
+        },
+    };
+
+    return (map[os] && map[os][cpu]) || null;
+}
+
+function getNativeLibAssetName(version) {
+    const os = platform();
+    const cpu = arch();
+
+    const triples = {
+        linux: { x64: 'x86_64-unknown-linux-gnu', arm64: 'aarch64-unknown-linux-gnu' },
+        win32: { x64: 'x86_64-pc-windows-msvc', arm64: 'aarch64-pc-windows-msvc' },
+        darwin: { x64: 'x86_64-apple-darwin', arm64: 'aarch64-apple-darwin' },
+    };
+
+    const triple = triples[os] && triples[os][cpu];
+    if (!triple) return null;
+
+    return `roxify_native-${triple}.node`;
+}
+
+function downloadFile(url, dest, maxRedirects = 5) {
+    return new Promise((resolve, reject) => {
+        if (maxRedirects <= 0) {
+            reject(new Error('Too many redirects'));
+            return;
+        }
+
+        const file = createWriteStream(dest);
+        const request = https.get(url, { timeout: 60000 }, (response) => {
+            // Handle redirects
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                const location = response.headers.location;
+                if (location) {
+                    file.close();
+                    // Clean up partial file
+                    try { unlinkSync(dest); } catch { }
+                    downloadFile(location, dest, maxRedirects - 1).then(resolve).catch(reject);
+                    return;
+                }
+            }
+
+            if (response.statusCode !== 200) {
+                file.close();
+                try { unlinkSync(dest); } catch { }
+                reject(new Error(`HTTP ${response.statusCode} for ${url}`));
+                return;
+            }
+
+            let downloaded = 0;
+            response.on('data', (chunk) => {
+                downloaded += chunk.length;
+            });
+
+            response.pipe(file);
+
+            file.on('finish', () => {
+                file.close();
+                console.log(`roxify: Downloaded ${(downloaded / 1024 / 1024).toFixed(2)} MB`);
+                resolve();
+            });
+        });
+
+        request.on('error', (err) => {
+            file.close();
+            try { unlinkSync(dest); } catch { }
+            reject(err);
+        });
+
+        request.on('timeout', () => {
+            request.destroy();
+            file.close();
+            try { unlinkSync(dest); } catch { }
+            reject(new Error('Request timeout'));
+        });
+    });
+}
+
+async function getLatestReleaseVersion() {
+    const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+
+    return new Promise((resolve, reject) => {
+        https.get(url, {
+            headers: {
+                'User-Agent': 'roxify-install',
+                'Accept': 'application/vnd.github.v3+json'
+            },
+            timeout: 10000
+        }, (response) => {
+            if (response.statusCode !== 200) {
+                reject(new Error(`GitHub API HTTP ${response.statusCode}`));
+                return;
+            }
+
+            let data = '';
+            response.on('data', chunk => data += chunk);
+            response.on('end', () => {
+                try {
+                    const release = JSON.parse(data);
+                    const version = release.tag_name.replace(/^v/, '');
+                    resolve(version);
+                } catch (e) {
+                    reject(new Error('Failed to parse GitHub API response'));
+                }
+            });
+        }).on('error', reject).on('timeout', function () { this.destroy(); reject(new Error('API timeout')); });
+    });
+}
+
+async function downloadBinary() {
+    let version;
+    try {
+        version = require('../package.json').version;
+    } catch (e) {
+        version = '1.14.2';
+    }
+
+    // Try to get latest release version from GitHub
+    try {
+        const latestVersion = await getLatestReleaseVersion();
+        if (latestVersion && latestVersion !== version) {
+            console.log(`roxify: Latest release is v${latestVersion} (package is v${version})`);
+            version = latestVersion;
+        }
+    } catch (e) {
+        console.log(`roxify: Using package version v${version} (could not check latest: ${e.message})`);
+    }
+
+    const binaryName = getPlatformBinary();
+    const assetName = getReleaseAssetName(version);
+
+    if (!binaryName || !assetName) {
+        console.log(`roxify: Unsupported platform ${platform()}/${arch()}`);
+        return false;
+    }
+
+    if (!existsSync(DIST_DIR)) {
+        mkdirSync(DIST_DIR, { recursive: true });
+    }
+
+    const destPath = join(DIST_DIR, binaryName);
+
+    // Check if already exists
+    if (existsSync(destPath)) {
+        console.log(`roxify: CLI binary already exists at ${destPath}`);
+        return true;
+    }
+
+    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
+
+    console.log(`roxify: Downloading ${assetName} from GitHub...`);
+    console.log(`roxify: URL: ${url}`);
+
+    try {
+        await downloadFile(url, destPath);
+
+        if (platform() !== 'win32') {
+            try { chmodSync(destPath, 0o755); } catch { }
+        }
+
+        console.log(`roxify: CLI binary ready at ${destPath}`);
+        return true;
+    } catch (e) {
+        console.log(`roxify: Download failed: ${e.message}`);
+        // Clean up partial download
+        try { unlinkSync(destPath); } catch { }
+        return false;
+    }
+}
+
+async function downloadNativeLib() {
+    let version;
+    try {
+        version = require('../package.json').version;
+    } catch (e) {
+        version = '1.14.2';
+    }
+
+    // Try to get latest release version from GitHub
+    try {
+        const latestVersion = await getLatestReleaseVersion();
+        if (latestVersion && latestVersion !== version) {
+            version = latestVersion;
+        }
+    } catch (e) {
+        // Use package version
+    }
+
+    const assetName = getNativeLibAssetName(version);
+
+    if (!assetName) {
+        console.log(`roxify: Unsupported platform for native lib ${platform()}/${arch()}`);
+        return false;
+    }
+
+    const destPath = join(root, assetName);
+
+    // Check if already exists
+    if (existsSync(destPath)) {
+        console.log(`roxify: Native lib already exists at ${destPath}`);
+        return true;
+    }
+
+    const url = `https://github.com/${GITHUB_REPO}/releases/download/v${version}/${assetName}`;
+
+    console.log(`roxify: Downloading native lib ${assetName}...`);
+
+    try {
+        await downloadFile(url, destPath);
+        console.log(`roxify: Native lib ready at ${destPath}`);
+        return true;
+    } catch (e) {
+        console.log(`roxify: Native lib download failed: ${e.message}`);
+        try { unlinkSync(destPath); } catch { }
+        return false;
+    }
+}
+
+module.exports = { downloadBinary, downloadNativeLib, getPlatformBinary, getLatestReleaseVersion };

package/scripts/postinstall.cjs

@@ -1,11 +1,20 @@
 const { execSync } = require('child_process');
-const { existsSync, copyFileSync, mkdirSync, readdirSync, unlinkSync } = require('fs');
+const { existsSync, copyFileSync, mkdirSync, readdirSync, unlinkSync, chmodSync } = require('fs');
 const { join } = require('path');
 const { platform, arch } = require('os');
 
 const root = join(__dirname, '..');
 const distDir = join(root, 'dist');
 
+// Try to import download helper
+try {
+      var { downloadBinary, downloadNativeLib } = require('./download-binary.cjs');
+} catch (e) {
+      console.log('roxify: Download helper not available, will use local build only');
+      var downloadBinary = null;
+      var downloadNativeLib = null;
+}
+
 function hasCargo() {
       try {
             execSync('cargo --version', { stdio: 'ignore', timeout: 5000 });
@@ -18,165 +27,182 @@ function getTriples() {
       const cpu = arch();
       const map = {
             linux: { x64: ['x86_64-unknown-linux-gnu'], arm64: ['aarch64-unknown-linux-gnu'] },
-            win32: { x64: ['x86_64-pc-windows-msvc', 'x86_64-pc-windows-gnu'], arm64: ['aarch64-pc-windows-msvc'] },
+            win32: { x64: ['x86_64-pc-windows-msvc'], arm64: ['aarch64-pc-windows-msvc'] },
             darwin: { x64: ['x86_64-apple-darwin'], arm64: ['aarch64-apple-darwin'] },
       };
       return (map[os] && map[os][cpu]) || [];
 }
 
-function getLibExt() {
-      if (platform() === 'win32') return 'dll';
-      if (platform() === 'darwin') return 'dylib';
-      return 'so';
-}
-
 function getBinaryName() {
       return platform() === 'win32' ? 'roxify_native.exe' : 'roxify_native';
 }
 
-function findExistingBinary() {
-      const name = getBinaryName();
-      const triples = getTriples();
-      const candidates = [join(distDir, name), join(root, 'target', 'release', name)];
-      for (const t of triples) {
-            candidates.push(join(root, 'target', t, 'release', name));
-      }
-      for (const c of candidates) {
-            if (existsSync(c)) return c;
-      }
-      return null;
+function getMacosBinaryName() {
+      return 'rox-macos-universal';
 }
 
-function findExistingNativeLib() {
-      const triples = getTriples();
-      const ext = getLibExt();
-      const prefix = platform() === 'win32' ? '' : 'lib';
-      for (const t of triples) {
-            const specific = join(root, `roxify_native-${t}.node`);
-            if (existsSync(specific)) return { path: specific, triple: t };
-      }
-      for (const t of triples) {
-            for (const profile of ['release', 'fastdev']) {
-                  const paths = [
-                        join(root, 'target', t, profile, `${prefix}roxify_native.${ext}`),
-                        join(root, 'target', profile, `${prefix}roxify_native.${ext}`),
-                  ];
-                  for (const p of paths) {
-                        if (existsSync(p)) return { path: p, triple: t };
-                  }
-            }
-      }
-      return null;
-}
-
-function buildNative(target) {
-      if (!hasCargo()) return false;
-      const args = target ? ` --target ${target}` : '';
-      console.log(`roxify: Building native lib${args}...`);
-      try {
-            execSync(`cargo build --release --lib${args}`, { cwd: root, stdio: 'inherit', timeout: 600000 });
-            return true;
-      } catch {
-            console.log('roxify: Native lib build failed');
-            return false;
-      }
-}
-
-function buildBinary() {
+function buildBinaryLocally() {
       if (!hasCargo()) {
-            console.log('roxify: Cargo not found, skipping native build (TypeScript fallback will be used)');
+            console.log('roxify: Cargo not found, will try to download prebuilt binary');
             return false;
       }
-      console.log('roxify: Building native CLI binary...');
+      console.log('roxify: Building native CLI binary locally...');
       try {
             execSync('cargo build --release --bin roxify_native', { cwd: root, stdio: 'inherit', timeout: 600000 });
             return true;
-      } catch {
-            console.log('roxify: Native build failed, TypeScript fallback will be used');
+      } catch (e) {
+            console.log('roxify: Local build failed, will try to download prebuilt binary');
             return false;
       }
 }
 
-function ensureCliBinary() {
+async function ensureCliBinary() {
       if (!existsSync(distDir)) mkdirSync(distDir, { recursive: true });
-      const dest = join(distDir, getBinaryName());
-      if (existsSync(dest)) return;
 
-      const existing = findExistingBinary();
-      if (existing && existing !== dest) {
-            copyFileSync(existing, dest);
+      const binaryName = platform() === 'darwin' ? getMacosBinaryName() : getBinaryName();
+      const dest = join(distDir, binaryName);
+
+      if (existsSync(dest)) {
+            console.log(`roxify: CLI binary already exists at ${dest}`);
+            return true;
+      }
+
+      // Check if built locally exists
+      const localBuilt = join(root, 'target', 'release', getBinaryName());
+      if (existsSync(localBuilt)) {
+            copyFileSync(localBuilt, dest);
             if (platform() !== 'win32') {
-                  try { require('fs').chmodSync(dest, 0o755); } catch { }
+                  try { chmodSync(dest, 0o755); } catch { }
             }
-            console.log(`roxify: Copied CLI binary from ${existing}`);
-            return;
+            console.log(`roxify: CLI binary copied from local build`);
+            return true;
+      }
+
+      if (process.env.ROXIFY_SKIP_BUILD === '1') return false;
+
+      // PRIMARY: Try download from GitHub releases (fast, no compilation)
+      if (downloadBinary && !process.env.ROXIFY_FORCE_LOCAL_BUILD) {
+            console.log(`roxify: Attempting to download prebuilt binary from GitHub...`);
+            const downloaded = await downloadBinary();
+            if (downloaded) {
+                  console.log(`roxify: Successfully downloaded prebuilt binary`);
+                  return true;
+            }
+            console.log(`roxify: Download failed, will try local build...`);
       }
-      if (existing) return;
-      if (process.env.ROXIFY_SKIP_BUILD === '1') return;
 
-      if (buildBinary()) {
-            const built = join(root, 'target', 'release', getBinaryName());
-            if (existsSync(built)) {
-                  copyFileSync(built, dest);
+      // FALLBACK: Try local build (requires Cargo)
+      if (buildBinaryLocally()) {
+            if (existsSync(localBuilt)) {
+                  copyFileSync(localBuilt, dest);
                   if (platform() !== 'win32') {
-                        try { require('fs').chmodSync(dest, 0o755); } catch { }
+                        try { chmodSync(dest, 0o755); } catch { }
                   }
-                  console.log('roxify: CLI binary built and copied to dist/');
+                  console.log(`roxify: CLI binary built locally`);
+                  return true;
             }
       }
+
+      console.log('roxify: No native binary available, TypeScript fallback will be used');
+      return false;
 }
 
-function ensureNativeLib() {
+async function ensureNativeLib() {
       const triples = getTriples();
       if (!triples.length) return;
 
-      for (const t of triples) {
-            if (existsSync(join(root, `roxify_native-${t}.node`))) return;
-      }
+      const triple = triples[0];
+      const dest = join(root, `roxify_native-${triple}.node`);
+
+      if (existsSync(dest)) return;
+
+      // Check if built locally
+      const ext = platform() === 'win32' ? 'dll' : (platform() === 'darwin' ? 'dylib' : 'so');
+      const prefix = platform() === 'win32' ? '' : 'lib';
+      const localBuilt = join(root, 'target', 'release', `${prefix}roxify_native.${ext}`);
 
-      const found = findExistingNativeLib();
-      if (found) {
-            const dest = join(root, `roxify_native-${found.triple}.node`);
-            copyFileSync(found.path, dest);
-            console.log(`roxify: Copied native lib → ${dest}`);
+      if (existsSync(localBuilt)) {
+            copyFileSync(localBuilt, dest);
+            console.log(`roxify: Native lib copied from local build → ${dest}`);
             return;
       }
 
       if (process.env.ROXIFY_SKIP_BUILD === '1') return;
 
-      const triple = triples[0];
-      if (buildNative(null)) {
-            const ext = getLibExt();
-            const prefix = platform() === 'win32' ? '' : 'lib';
-            const built = join(root, 'target', 'release', `${prefix}roxify_native.${ext}`);
-            if (existsSync(built)) {
-                  const dest = join(root, `roxify_native-${triple}.node`);
-                  copyFileSync(built, dest);
-                  console.log(`roxify: Native lib built → ${dest}`);
+      // PRIMARY: Try download from GitHub releases
+      if (downloadNativeLib && !process.env.ROXIFY_FORCE_LOCAL_BUILD) {
+            console.log(`roxify: Attempting to download native lib from GitHub...`);
+            const downloaded = await downloadNativeLib();
+            if (downloaded) {
+                  console.log(`roxify: Successfully downloaded native lib`);
+                  return;
             }
+            console.log(`roxify: Native lib download failed, will try local build...`);
       }
-}
 
-if (process.env.ROXIFY_ENABLE_RUST_CLI === '1') {
-      ensureCliBinary();
+      // FALLBACK: Try build locally
+      if (hasCargo()) {
+            console.log(`roxify: Building native lib locally...`);
+            try {
+                  execSync('cargo build --release --lib', { cwd: root, stdio: 'inherit', timeout: 600000 });
+                  if (existsSync(localBuilt)) {
+                        copyFileSync(localBuilt, dest);
+                        console.log(`roxify: Native lib built locally → ${dest}`);
+                  }
+            } catch {
+                  console.log('roxify: Native lib build failed, TypeScript fallback will be used');
+            }
+      }
 }
-ensureNativeLib();
 
-// Cleanup: remove other platform .node artifacts to reduce disk usage after install
+// Always ensure CLI binary is available (download first, build as fallback)
+(async () => {
+      await ensureCliBinary();
+      await ensureNativeLib();
+
+      // Summary
+      console.log('');
+      console.log('roxify: Post-install complete');
+      console.log(`roxify: Platform: ${platform()}/${arch()}`);
+      if (!existsSync(join(distDir, platform() === 'darwin' ? getMacosBinaryName() : getBinaryName()))) {
+            console.log('roxify: WARNING: No native CLI binary available - will use TypeScript fallback');
+      }
+})();
+
+// Cleanup: remove ALL other platform .node artifacts
 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) { }
-                        }
+      const files = readdirSync(root);
+      for (const f of files) {
+            const m = f.match(/^roxify_native-(.+)\.node$/);
+            if (m) {
+                  const fileTriple = m[1];
+                  if (!triples.includes(fileTriple)) {
+                        try {
+                              unlinkSync(join(root, f));
+                              console.log(`roxify: removed unused native lib ${f}`);
+                        } catch (e) { }
                   }
             }
       }
 } catch (e) { }
+
+// Cleanup: remove ALL other platform CLI binaries from dist/
+try {
+      const os = platform();
+      const distFiles = existsSync(distDir) ? readdirSync(distDir) : [];
+      const keepName = os === 'darwin' ? getMacosBinaryName() : getBinaryName();
+
+      for (const f of distFiles) {
+            // Skip if it's the correct binary for this platform
+            if (f === keepName) continue;
+
+            // Remove any roxify_native binary
+            if (f.match(/^roxify_native/) || f === 'rox-macos-universal') {
+                  try {
+                        unlinkSync(join(distDir, f));
+                        console.log(`roxify: removed unused binary dist/${f}`);
+                  } catch (e) { }
+            }
+      }
+} catch (e) { }