roxify 1.8.0 → 1.8.2

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "roxify_native"
-version = "1.8.0"
+version = "1.8.2"
 edition = "2021"
 publish = false
 

package/native/archive.rs

@@ -157,7 +157,7 @@ mod tests {
         encoder.write_all(&tar_data).unwrap();
         let compressed = encoder.finish().unwrap();
 
-        let decompressed = zstd::stream::decode_all(std::io::Cursor::new(&compressed)).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");

package/native/core.rs

@@ -206,15 +206,19 @@ pub fn zstd_compress_bytes(buf: &[u8], level: i32, dict: Option<&[u8]>) -> std::
 
 pub fn zstd_decompress_bytes(buf: &[u8], dict: Option<&[u8]>) -> std::result::Result<Vec<u8>, String> {
     use std::io::Read;
+    let mut out = Vec::new();
     if let Some(d) = dict {
         let mut decoder = zstd::stream::Decoder::with_dictionary(std::io::Cursor::new(buf), d)
             .map_err(|e| format!("zstd decoder init error: {}", e))?;
-        let mut out = Vec::new();
+        decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max error: {}", e))?;
         decoder.read_to_end(&mut out).map_err(|e| format!("zstd decompress error: {}", e))?;
-        Ok(out)
     } else {
-        zstd::stream::decode_all(buf).map_err(|e| format!("zstd decompress error: {}", e))
+        let mut decoder = zstd::stream::Decoder::new(std::io::Cursor::new(buf))
+            .map_err(|e| format!("zstd decoder init error: {}", e))?;
+        decoder.window_log_max(31).map_err(|e| format!("zstd window_log_max error: {}", e))?;
+        decoder.read_to_end(&mut out).map_err(|e| format!("zstd decompress error: {}", e))?;
     }
+    Ok(out)
 }
 
 

package/native/main.rs

@@ -338,7 +338,8 @@ fn main() -> anyhow::Result<()> {
                                                 let mut reader: Box<dyn std::io::Read> = if normalized.starts_with(b"ROX1") {
                     Box::new(Cursor::new(normalized[4..].to_vec()))
                 } else {
-                    let dec = zstd::stream::Decoder::new(Cursor::new(normalized)).map_err(|e| anyhow::anyhow!("zstd decoder init: {}", e))?;
+                    let mut dec = zstd::stream::Decoder::new(Cursor::new(normalized)).map_err(|e| anyhow::anyhow!("zstd decoder init: {}", e))?;
+                    dec.window_log_max(31).map_err(|e| anyhow::anyhow!("zstd window_log_max: {}", e))?;
                     Box::new(dec)
                 };
 

package/native/packer.rs

@@ -376,6 +376,7 @@ mod stream_tests {
         let compressed = encoder.finish().map_err(|e| anyhow::anyhow!(e))?;
 
         let mut dec = zstd::stream::Decoder::new(std::io::Cursor::new(compressed.clone())).map_err(|e| anyhow::anyhow!(e))?;
+        dec.window_log_max(31).map_err(|e| anyhow::anyhow!(e))?;
 
                 let mut all = Vec::new();
         dec.read_to_end(&mut all).map_err(|e| anyhow::anyhow!(e))?;
@@ -383,6 +384,7 @@ mod stream_tests {
         assert_eq!(&all[..], &parts[..]);
 
                 let mut dec2 = zstd::stream::Decoder::new(std::io::Cursor::new(compressed)).map_err(|e| anyhow::anyhow!(e))?;
+        dec2.window_log_max(31).map_err(|e| anyhow::anyhow!(e))?;
 
                 let ms = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis();
         let tmpdir = std::env::temp_dir().join(format!("rox_unpack_test_{}", ms));
@@ -424,6 +426,7 @@ mod stream_tests {
         assert_eq!(first, 0x00u8);
         let compressed = payload[1..].to_vec();
         let mut dec = zstd::stream::Decoder::new(std::io::Cursor::new(compressed)).map_err(|e| anyhow::anyhow!(e))?;
+        dec.window_log_max(31).map_err(|e| anyhow::anyhow!(e))?;
 
                 let ms = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_millis();
         let tmpdir = std::env::temp_dir().join(format!("rox_unpack_png_test_{}", ms));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.8.0",
+  "version": "1.8.2",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",

package/scripts/postinstall.cjs

@@ -6,96 +6,96 @@ const root = join(__dirname, '..');
 const distDir = join(root, 'dist');
 
 function hasCargo() {
-  try {
-    execSync('cargo --version', { stdio: 'ignore', timeout: 5000 });
-    return true;
-  } catch { return false; }
+      try {
+            execSync('cargo --version', { stdio: 'ignore', timeout: 5000 });
+            return true;
+      } catch { return false; }
 }
 
 function getBinaryName() {
-  return process.platform === 'win32' ? 'roxify_native.exe' : 'roxify_native';
+      return process.platform === 'win32' ? 'roxify_native.exe' : 'roxify_native';
 }
 
 function findExistingBinary() {
-  const name = getBinaryName();
-  const candidates = [
-    join(distDir, name),
-    join(root, 'target', 'release', name),
-  ];
+      const name = getBinaryName();
+      const candidates = [
+            join(distDir, name),
+            join(root, 'target', 'release', name),
+      ];
 
-  if (process.platform === 'win32') {
-    candidates.push(join(root, 'target', 'x86_64-pc-windows-gnu', 'release', name));
-    candidates.push(join(root, 'target', 'x86_64-pc-windows-msvc', 'release', name));
-  } else if (process.platform === 'linux') {
-    candidates.push(join(root, 'target', 'x86_64-unknown-linux-gnu', 'release', name));
-  } else if (process.platform === 'darwin') {
-    candidates.push(join(root, 'target', 'x86_64-apple-darwin', 'release', name));
-    candidates.push(join(root, 'target', 'aarch64-apple-darwin', 'release', name));
-  }
+      if (process.platform === 'win32') {
+            candidates.push(join(root, 'target', 'x86_64-pc-windows-gnu', 'release', name));
+            candidates.push(join(root, 'target', 'x86_64-pc-windows-msvc', 'release', name));
+      } else if (process.platform === 'linux') {
+            candidates.push(join(root, 'target', 'x86_64-unknown-linux-gnu', 'release', name));
+      } else if (process.platform === 'darwin') {
+            candidates.push(join(root, 'target', 'x86_64-apple-darwin', 'release', name));
+            candidates.push(join(root, 'target', 'aarch64-apple-darwin', 'release', name));
+      }
 
-  for (const c of candidates) {
-    if (existsSync(c)) return c;
-  }
-  return null;
+      for (const c of candidates) {
+            if (existsSync(c)) return c;
+      }
+      return null;
 }
 
 function buildBinary() {
-  if (!hasCargo()) {
-    console.log('roxify: Cargo not found, skipping native binary build (TypeScript fallback will be used)');
-    return false;
-  }
+      if (!hasCargo()) {
+            console.log('roxify: Cargo not found, skipping native binary build (TypeScript fallback will be used)');
+            return false;
+      }
 
-  console.log('roxify: Building native CLI binary with Cargo...');
-  try {
-    execSync('cargo build --release --bin roxify_native', {
-      cwd: root,
-      stdio: 'inherit',
-      timeout: 600000,
-    });
-    return true;
-  } catch (e) {
-    console.log('roxify: Native build failed, TypeScript fallback will be used');
-    return false;
-  }
+      console.log('roxify: Building native CLI binary with Cargo...');
+      try {
+            execSync('cargo build --release --bin roxify_native', {
+                  cwd: root,
+                  stdio: 'inherit',
+                  timeout: 600000,
+            });
+            return true;
+      } catch (e) {
+            console.log('roxify: Native build failed, TypeScript fallback will be used');
+            return false;
+      }
 }
 
 function run() {
-  if (!existsSync(distDir)) {
-    mkdirSync(distDir, { recursive: true });
-  }
+      if (!existsSync(distDir)) {
+            mkdirSync(distDir, { recursive: true });
+      }
 
-  const dest = join(distDir, getBinaryName());
-  if (existsSync(dest)) {
-    return;
-  }
+      const dest = join(distDir, getBinaryName());
+      if (existsSync(dest)) {
+            return;
+      }
 
-  const existing = findExistingBinary();
-  if (existing && existing !== dest) {
-    copyFileSync(existing, dest);
-    if (process.platform !== 'win32') {
-      try { require('fs').chmodSync(dest, 0o755); } catch {}
-    }
-    console.log(`roxify: Copied native binary from ${existing}`);
-    return;
-  }
+      const existing = findExistingBinary();
+      if (existing && existing !== dest) {
+            copyFileSync(existing, dest);
+            if (process.platform !== 'win32') {
+                  try { require('fs').chmodSync(dest, 0o755); } catch { }
+            }
+            console.log(`roxify: Copied native binary from ${existing}`);
+            return;
+      }
 
-  if (existing) return;
+      if (existing) return;
 
-  if (process.env.ROXIFY_SKIP_BUILD === '1') {
-    console.log('roxify: ROXIFY_SKIP_BUILD=1, skipping native build');
-    return;
-  }
+      if (process.env.ROXIFY_SKIP_BUILD === '1') {
+            console.log('roxify: ROXIFY_SKIP_BUILD=1, skipping native build');
+            return;
+      }
 
-  if (buildBinary()) {
-    const built = join(root, 'target', 'release', getBinaryName());
-    if (existsSync(built)) {
-      copyFileSync(built, dest);
-      if (process.platform !== 'win32') {
-        try { require('fs').chmodSync(dest, 0o755); } catch {}
+      if (buildBinary()) {
+            const built = join(root, 'target', 'release', getBinaryName());
+            if (existsSync(built)) {
+                  copyFileSync(built, dest);
+                  if (process.platform !== 'win32') {
+                        try { require('fs').chmodSync(dest, 0o755); } catch { }
+                  }
+                  console.log('roxify: Native binary built and copied to dist/');
+            }
       }
-      console.log('roxify: Native binary built and copied to dist/');
-    }
-  }
 }
 
 run();