roxify 1.9.7 → 1.10.0

package/dist/utils/native.js

@@ -72,7 +72,15 @@ function getNativeModule() {
         for (const triple of triples) {
             const name = `roxify_native-${triple}.node`;
             const libName = `libroxify_native-${triple}.node`;
-            candidates.push(resolve(moduleDir, '..', name), resolve(moduleDir, '..', libName), resolve(root, name), resolve(root, libName), resolve(root, 'node_modules', 'roxify', name), resolve(root, 'node_modules', 'roxify', libName), resolve(moduleDir, '..', '..', name), resolve(moduleDir, '..', '..', libName));
+            candidates.push(
+            // dist/ sibling (npm-installed package)
+            resolve(moduleDir, '..', name), resolve(moduleDir, '..', libName), 
+            // package root
+            resolve(root, name), resolve(root, libName), 
+            // node_modules/roxify/
+            resolve(root, 'node_modules', 'roxify', name), resolve(root, 'node_modules', 'roxify', libName), 
+            // two levels up (global npm install)
+            resolve(moduleDir, '..', '..', name), resolve(moduleDir, '..', '..', libName));
         }
         // --- 2. Build output candidates (local dev) ---
         for (const triple of triples) {

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

@@ -1,35 +1,18 @@
 import { execSync, spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
 let moduleDir;
 if (typeof __dirname !== 'undefined') {
     moduleDir = __dirname;
 }
 else {
-    try {
-        moduleDir = dirname(fileURLToPath(import.meta.url));
-    }
-    catch {
-        moduleDir = process.cwd();
-    }
+    moduleDir = process.cwd();
 }
 function findRustBinary() {
     const binNames = process.platform === 'win32'
         ? ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe']
         : ['roxify_native', 'roxify-cli', 'roxify_cli'];
-    const baseDir = moduleDir;
-    for (const name of binNames) {
-        const sameDirPath = join(baseDir, name);
-        if (existsSync(sameDirPath))
-            return sameDirPath;
-        const parentPath = join(baseDir, '..', name);
-        if (existsSync(parentPath))
-            return parentPath;
-        const parentDistPath = join(baseDir, '..', 'dist', name);
-        if (existsSync(parentDistPath))
-            return parentDistPath;
-    }
+    const baseDir = typeof moduleDir !== 'undefined' ? moduleDir : process.cwd();
     if (process.pkg) {
         const snapshotPaths = [
             join(baseDir, '..', '..', 'target', 'release'),
@@ -39,8 +22,9 @@ function findRustBinary() {
         for (const basePath of snapshotPaths) {
             for (const name of binNames) {
                 const binPath = join(basePath, name);
-                if (existsSync(binPath))
+                if (existsSync(binPath)) {
                     return binPath;
+                }
             }
         }
         try {
@@ -51,35 +35,40 @@ function findRustBinary() {
                     join(execDir, 'tools', 'roxify'),
                     join(execDir, '..', 'tools', 'roxify', 'dist'),
                     join(execDir, '..', 'tools', 'roxify'),
+                    join(execDir, 'tools', 'roxify', 'roxify_native.exe'),
                 ];
                 for (const c of execCandidates) {
                     for (const name of binNames) {
-                        const p = join(c, name);
-                        if (existsSync(p))
+                        const p = c.endsWith(name) ? c : join(c, name);
+                        if (existsSync(p)) {
                             return p;
+                        }
                     }
                 }
             }
         }
-        catch { }
+        catch (e) { }
     }
     try {
         let paths = [];
         if (process.platform === 'win32') {
             try {
-                const out = execSync('where rox', { encoding: 'utf-8', timeout: 5000 }).trim();
+                const out = execSync('where rox', { encoding: 'utf-8' }).trim();
                 if (out)
-                    paths = out.split(/\r?\n/).map((s) => s.trim()).filter(Boolean);
+                    paths = out
+                        .split(/\r?\n/)
+                        .map((s) => s.trim())
+                        .filter(Boolean);
             }
-            catch { }
+            catch (e) { }
         }
         else {
             try {
-                const out = execSync('which rox', { encoding: 'utf-8', timeout: 5000 }).trim();
+                const out = execSync('which rox', { encoding: 'utf-8' }).trim();
                 if (out)
                     paths = [out.trim()];
             }
-            catch { }
+            catch (e) { }
         }
         for (const p of paths) {
             try {
@@ -89,33 +78,44 @@ function findRustBinary() {
                     join(d, 'dist'),
                     join(d, '..', 'dist'),
                     join(d, '..'),
-                    join(d, 'node_modules', 'roxify', 'dist'),
                 ];
                 for (const c of candidates) {
                     for (const name of binNames) {
                         const candidate = join(c, name);
-                        if (existsSync(candidate))
+                        if (existsSync(candidate)) {
                             return candidate;
+                        }
                     }
                 }
             }
-            catch { }
+            catch (e) { }
         }
     }
-    catch { }
+    catch (e) { }
     for (const name of binNames) {
+        const local = join(baseDir, name);
+        if (existsSync(local)) {
+            return local;
+        }
+        const parentLocal = join(baseDir, '..', name);
+        if (existsSync(parentLocal)) {
+            return parentLocal;
+        }
         const parentParentLocal = join(baseDir, '..', '..', name);
-        if (existsSync(parentParentLocal))
+        if (existsSync(parentParentLocal)) {
             return parentParentLocal;
+        }
         const nodeModulesPath = join(baseDir, '..', '..', '..', '..', name);
-        if (existsSync(nodeModulesPath))
+        if (existsSync(nodeModulesPath)) {
             return nodeModulesPath;
+        }
     }
     const targetRelease = join(baseDir, '..', '..', 'target', 'release');
     for (const name of binNames) {
         const targetPath = join(targetRelease, name);
-        if (existsSync(targetPath))
+        if (existsSync(targetPath)) {
             return targetPath;
+        }
     }
     return null;
 }

package/native/reconstitution.rs

@@ -349,7 +349,7 @@ pub fn crop_and_reconstitute(png_data: &[u8]) -> Result<Vec<u8>, String> {
             // Filtre : la zone encodée NN a des blocs monochromes → intra très bas
             // Zone de fond aléatoire → intra ≈ lw × n_scan × 0.99 >> 0
             // Seuil : lw/8 × n_scan pour permettre ≈ lw/8 pixels parasites
-            let intra_threshold = ((lw as u32 / 4 + 2) * n_scan).max(n_scan * 3);
+            let intra_threshold = ((lw as u32 / 2 + 3) * n_scan).max(n_scan * 3);
 
             if intra_final > intra_threshold {
                 continue;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.9.7",
+  "version": "1.10.0",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",
@@ -27,6 +27,9 @@
     "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",
     "scripts/postinstall.cjs",
     "native",
     "Cargo.toml",
@@ -96,7 +99,7 @@
     "lightweight"
   ],
   "author": "",
-  "license": "MIT",
+  "license": "SEE LICENSE IN LICENSE",
   "devDependencies": {
     "@types/node": "^22.0.0",
     "pkg": "^5.8.1",