roxify 1.12.11 → 1.13.1

package/dist/utils/encoder.js

@@ -467,40 +467,29 @@ export async function encodeBinaryToPng(input, opts = {}) {
                 console.log(`[DEBUG] Width=${width}, Height=${height}, Pixels=${width * height}`);
                 console.log(`[DEBUG] outputFormat=${opts.outputFormat}, useManualPng=${useManualPng}`);
             }
+            const totalDataBytes = logicalWidth * logicalHeight * 3;
+            const markerEndPos = totalDataBytes - MARKER_END.length * 3;
+            const fullData = Buffer.alloc(totalDataBytes);
+            const flatData = Buffer.concat(dataWithMarkers);
+            flatData.copy(fullData, 0, 0, Math.min(flatData.length, markerEndPos));
+            let mOff = markerEndPos;
+            for (let i = 0; i < MARKER_END.length; i++) {
+                fullData[mOff++] = MARKER_END[i].r;
+                fullData[mOff++] = MARKER_END[i].g;
+                fullData[mOff++] = MARKER_END[i].b;
+            }
             let raw;
             let stride = 0;
             if (useManualPng) {
                 stride = width * 3 + 1;
                 raw = Buffer.alloc(height * stride);
-                const flatData = Buffer.concat(dataWithMarkers);
-                const markerEndBytes = Buffer.alloc(MARKER_END.length * 3);
-                for (let i = 0; i < MARKER_END.length; i++) {
-                    markerEndBytes[i * 3] = MARKER_END[i].r;
-                    markerEndBytes[i * 3 + 1] = MARKER_END[i].g;
-                    markerEndBytes[i * 3 + 2] = MARKER_END[i].b;
-                }
-                const totalDataBytes = logicalWidth * logicalHeight * 3;
-                const fullData = Buffer.alloc(totalDataBytes);
-                const markerEndPos = totalDataBytes - MARKER_END.length * 3;
-                flatData.copy(fullData, 0, 0, Math.min(flatData.length, markerEndPos));
-                markerEndBytes.copy(fullData, markerEndPos);
                 for (let row = 0; row < height; row++) {
                     raw[row * stride] = 0;
                     fullData.copy(raw, row * stride + 1, row * width * 3, (row + 1) * width * 3);
                 }
             }
             else {
-                raw = Buffer.alloc(width * height * 3);
-                const flatData = Buffer.concat(dataWithMarkers);
-                flatData.copy(raw, 0, 0, Math.min(flatData.length, raw.length));
-                const markerEndBytes = Buffer.alloc(MARKER_END.length * 3);
-                for (let i = 0; i < MARKER_END.length; i++) {
-                    markerEndBytes[i * 3] = MARKER_END[i].r;
-                    markerEndBytes[i * 3 + 1] = MARKER_END[i].g;
-                    markerEndBytes[i * 3 + 2] = MARKER_END[i].b;
-                }
-                const markerEndPos = raw.length - MARKER_END.length * 3;
-                markerEndBytes.copy(raw, markerEndPos);
+                raw = fullData;
             }
             if (opts.onProgress)
                 opts.onProgress({ phase: 'png_gen', loaded: 0, total: height });

package/dist/utils/optimization.js

@@ -112,6 +112,7 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
             const row = raw.slice(rowStart, rowStart + rowBytes);
             let bestSum = Infinity;
             let bestFiltered = null;
+            let chosenFilter = 0;
             for (let f = 0; f <= 4; f++) {
                 const filtered = Buffer.alloc(rowBytes);
                 let sum = 0;
@@ -145,33 +146,10 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                 if (sum < bestSum) {
                     bestSum = sum;
                     bestFiltered = filtered;
-                }
-            }
-            const rowBuf = Buffer.alloc(1 + rowBytes);
-            let chosenFilter = 0;
-            for (let f = 0; f <= 4; f++) {
-                const filtered = Buffer.alloc(rowBytes);
-                for (let i = 0; i < rowBytes; i++) {
-                    const val = row[i];
-                    const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
-                    const up = prevRow ? prevRow[i] : 0;
-                    const upLeft = prevRow && i - bytesPerPixel >= 0 ? prevRow[i - bytesPerPixel] : 0;
-                    if (f === 0)
-                        filtered[i] = val;
-                    else if (f === 1)
-                        filtered[i] = (val - left + 256) & 0xff;
-                    else if (f === 2)
-                        filtered[i] = (val - up + 256) & 0xff;
-                    else if (f === 3)
-                        filtered[i] = (val - Math.floor((left + up) / 2) + 256) & 0xff;
-                    else
-                        filtered[i] = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
-                }
-                if (filtered.equals(bestFiltered)) {
                     chosenFilter = f;
-                    break;
                 }
             }
+            const rowBuf = Buffer.alloc(1 + rowBytes);
             rowBuf[0] = chosenFilter;
             bestFiltered.copy(rowBuf, 1);
             outRows.push(rowBuf);

package/dist/utils/rust-cli-wrapper.d.ts

@@ -2,3 +2,6 @@ declare function findRustBinary(): string | null;
 export { findRustBinary };
 export declare function isRustBinaryAvailable(): boolean;
 export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor', name?: string): Promise<void>;
+export declare function decodeWithRustCLI(inputPath: string, outputPath: string, passphrase?: string, files?: string[], dict?: string): Promise<void>;
+export declare function listWithRustCLI(inputPath: string): Promise<string>;
+export declare function havepassphraseWithRustCLI(inputPath: string): Promise<string>;

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

@@ -1,5 +1,5 @@
 import { execSync, spawn } from 'child_process';
-import { existsSync } from 'fs';
+import { accessSync, constants, existsSync } from 'fs';
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 let moduleDir;
@@ -14,6 +14,19 @@ else {
         moduleDir = process.cwd();
     }
 }
+function canExecute(p) {
+    if (!existsSync(p))
+        return false;
+    if (process.platform === 'win32')
+        return true;
+    try {
+        accessSync(p, constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function findRustBinary() {
     const platformBins = {
         win32: ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe'],
@@ -24,13 +37,13 @@ function findRustBinary() {
     const baseDir = moduleDir;
     for (const name of binNames) {
         const sameDirPath = join(baseDir, name);
-        if (existsSync(sameDirPath))
+        if (canExecute(sameDirPath))
             return sameDirPath;
         const parentPath = join(baseDir, '..', name);
-        if (existsSync(parentPath))
+        if (canExecute(parentPath))
             return parentPath;
         const parentDistPath = join(baseDir, '..', 'dist', name);
-        if (existsSync(parentDistPath))
+        if (canExecute(parentDistPath))
             return parentDistPath;
     }
     if (process.pkg) {
@@ -42,7 +55,7 @@ function findRustBinary() {
         for (const basePath of snapshotPaths) {
             for (const name of binNames) {
                 const binPath = join(basePath, name);
-                if (existsSync(binPath))
+                if (canExecute(binPath))
                     return binPath;
             }
         }
@@ -58,7 +71,7 @@ function findRustBinary() {
                 for (const c of execCandidates) {
                     for (const name of binNames) {
                         const p = join(c, name);
-                        if (existsSync(p))
+                        if (canExecute(p))
                             return p;
                     }
                 }
@@ -97,7 +110,7 @@ function findRustBinary() {
                 for (const c of candidates) {
                     for (const name of binNames) {
                         const candidate = join(c, name);
-                        if (existsSync(candidate))
+                        if (canExecute(candidate))
                             return candidate;
                     }
                 }
@@ -108,16 +121,16 @@ function findRustBinary() {
     catch { }
     for (const name of binNames) {
         const parentParentLocal = join(baseDir, '..', '..', name);
-        if (existsSync(parentParentLocal))
+        if (canExecute(parentParentLocal))
             return parentParentLocal;
         const nodeModulesPath = join(baseDir, '..', '..', '..', '..', name);
-        if (existsSync(nodeModulesPath))
+        if (canExecute(nodeModulesPath))
             return nodeModulesPath;
     }
     const targetRelease = join(baseDir, '..', '..', 'target', 'release');
     for (const name of binNames) {
         const targetPath = join(targetRelease, name);
-        if (existsSync(targetPath))
+        if (canExecute(targetPath))
             return targetPath;
     }
     return null;
@@ -128,52 +141,32 @@ export function isRustBinaryAvailable() {
 }
 import { chmodSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
 import { tmpdir } from 'os';
-export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name) {
+function extractToTemp(pathToRead) {
+    const buf = readFileSync(pathToRead);
+    const tmp = mkdtempSync(join(tmpdir(), 'roxify-'));
+    const dest = join(tmp, pathToRead.replace(/.*[\\/]/, ''));
+    writeFileSync(dest, buf);
+    try {
+        chmodSync(dest, 0o755);
+    }
+    catch (e) { }
+    return dest;
+}
+function spawnRustCLI(args, options) {
     const cliPath = findRustBinary();
-    if (!cliPath) {
+    if (!cliPath)
         throw new Error('Rust CLI binary not found');
-    }
-    function extractToTemp(pathToRead) {
-        const buf = readFileSync(pathToRead);
-        const tmp = mkdtempSync(join(tmpdir(), 'roxify-'));
-        const dest = join(tmp, pathToRead.replace(/.*[\\/]/, ''));
-        writeFileSync(dest, buf);
-        try {
-            chmodSync(dest, 0o755);
-        }
-        catch (e) { }
-        return dest;
-    }
     return new Promise((resolve, reject) => {
-        const args = ['encode', '--level', String(compressionLevel)];
-        let supportsName = false;
-        if (name) {
-            try {
-                const helpOut = execSync(`"${cliPath}" --help`, {
-                    encoding: 'utf8',
-                    timeout: 2000,
-                });
-                if (helpOut && helpOut.includes('--name'))
-                    supportsName = true;
-            }
-            catch (e) {
-                supportsName = false;
-            }
-            if (supportsName) {
-                args.push('--name', name);
-            }
-        }
-        if (passphrase) {
-            args.push('--passphrase', passphrase);
-            args.push('--encrypt', encryptType);
-        }
-        args.push(inputPath, outputPath);
         let triedExtract = false;
         let tempExe;
+        let stdout = '';
         const runSpawn = (exePath) => {
             let proc;
+            const stdio = options?.collectStdout
+                ? ['pipe', 'pipe', 'inherit']
+                : 'inherit';
             try {
-                proc = spawn(exePath, args, { stdio: 'inherit' });
+                proc = spawn(exePath, args, { stdio });
             }
             catch (err) {
                 if (!triedExtract) {
@@ -188,6 +181,9 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 return reject(err);
             }
+            if (options?.collectStdout && proc.stdout) {
+                proc.stdout.on('data', (chunk) => { stdout += chunk.toString(); });
+            }
             proc.on('error', (err) => {
                 if (!triedExtract) {
                     triedExtract = true;
@@ -201,21 +197,55 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
                 }
                 reject(err);
             });
-            proc.on('close', (code) => {
+            proc.on('close', (code, signal) => {
                 if (tempExe) {
                     try {
                         unlinkSync(tempExe);
                     }
                     catch (e) { }
                 }
-                if (code === 0) {
-                    resolve();
-                }
-                else {
-                    reject(new Error(`Rust encoder exited with status ${code}`));
-                }
+                if (code === 0 || (code === null && signal === null))
+                    resolve(stdout);
+                else
+                    reject(new Error(`Rust CLI exited with status ${code ?? signal}`));
             });
         };
         runSpawn(cliPath);
     });
 }
+export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes', name) {
+    const cliPath = findRustBinary();
+    if (!cliPath)
+        throw new Error('Rust CLI binary not found');
+    const args = ['encode', '--level', String(compressionLevel)];
+    if (name) {
+        try {
+            const helpOut = execSync(`"${cliPath}" --help`, { encoding: 'utf8', timeout: 2000 });
+            if (helpOut && helpOut.includes('--name'))
+                args.push('--name', name);
+        }
+        catch (e) { }
+    }
+    if (passphrase) {
+        args.push('--passphrase', passphrase);
+        args.push('--encrypt', encryptType);
+    }
+    args.push(inputPath, outputPath);
+    await spawnRustCLI(args);
+}
+export async function decodeWithRustCLI(inputPath, outputPath, passphrase, files, dict) {
+    const args = ['decompress', inputPath, outputPath];
+    if (passphrase)
+        args.push('--passphrase', passphrase);
+    if (files && files.length > 0)
+        args.push('--files', JSON.stringify(files));
+    if (dict)
+        args.push('--dict', dict);
+    await spawnRustCLI(args);
+}
+export async function listWithRustCLI(inputPath) {
+    return spawnRustCLI(['list', inputPath], { collectStdout: true });
+}
+export async function havepassphraseWithRustCLI(inputPath) {
+    return spawnRustCLI(['havepassphrase', inputPath], { collectStdout: true });
+}

package/dist/utils/zstd.js

@@ -45,7 +45,7 @@ export async function compressStream(stream, level = 19, onProgress, dict) {
     };
 }
 export async function parallelZstdCompress(payload, level = 19, onProgress, dict) {
-    const chunkSize = 8 * 1024 * 1024;
+    const chunkSize = 32 * 1024 * 1024;
     // For small payloads (< chunkSize), concatenate and compress as single frame
     // to avoid multi-chunk overhead (16+ bytes header per chunk boundary).
     let flat = null;

package/native/bwt.rs

@@ -1,56 +1,56 @@
-use anyhow::Result;
-use libsais::bwt::Bwt;
-use libsais::typestate::OwnedBuffer;
-use libsais::BwtConstruction;
-use rayon::prelude::*;
-
-pub struct BwtResult {
-    pub transformed: Vec<u8>,
-    pub primary_index: u32,
-}
-
-pub fn bwt_encode(data: &[u8]) -> Result<BwtResult> {
-    let n = data.len();
-    if n == 0 {
-        return Ok(BwtResult { transformed: Vec::new(), primary_index: 0 });
-    }
-
-    let bwt_result = BwtConstruction::for_text(data)
-        .with_owned_temporary_array_buffer32()
-        .single_threaded()
-        .run()
-        .map_err(|e| anyhow::anyhow!("libsais BWT: {:?}", e))?;
-
-    let primary_index = bwt_result.primary_index() as u32;
-    let transformed = bwt_result.bwt().to_vec();
-
-    Ok(BwtResult { transformed, primary_index })
-}
-
-pub fn bwt_decode(bwt_data: &[u8], primary_index: u32) -> Result<Vec<u8>> {
-    if bwt_data.is_empty() {
-        return Ok(Vec::new());
-    }
-
-    let bwt_obj: Bwt<'static, u8, OwnedBuffer> =
-        unsafe { Bwt::from_parts(bwt_data.to_vec(), primary_index as usize) };
-
-    let text = bwt_obj
-        .unbwt()
-        .with_owned_temporary_array_buffer32()
-        .single_threaded()
-        .run()
-        .map_err(|e| anyhow::anyhow!("libsais UnBWT: {:?}", e))?;
-
-    Ok(text.as_slice().to_vec())
-}
-
-pub fn bwt_encode_streaming(block_size: usize, data: &[u8]) -> Result<Vec<(BwtResult, usize)>> {
-    data.par_chunks(block_size)
-        .enumerate()
-        .map(|(i, chunk)| {
-            let result = bwt_encode(chunk)?;
-            Ok((result, i * block_size))
-        })
-        .collect()
-}
+use anyhow::Result;
+use libsais::bwt::Bwt;
+use libsais::typestate::OwnedBuffer;
+use libsais::BwtConstruction;
+use rayon::prelude::*;
+
+pub struct BwtResult {
+    pub transformed: Vec<u8>,
+    pub primary_index: u32,
+}
+
+pub fn bwt_encode(data: &[u8]) -> Result<BwtResult> {
+    let n = data.len();
+    if n == 0 {
+        return Ok(BwtResult { transformed: Vec::new(), primary_index: 0 });
+    }
+
+    let bwt_result = BwtConstruction::for_text(data)
+        .with_owned_temporary_array_buffer32()
+        .single_threaded()
+        .run()
+        .map_err(|e| anyhow::anyhow!("libsais BWT: {:?}", e))?;
+
+    let primary_index = bwt_result.primary_index() as u32;
+    let transformed = bwt_result.bwt().to_vec();
+
+    Ok(BwtResult { transformed, primary_index })
+}
+
+pub fn bwt_decode(bwt_data: &[u8], primary_index: u32) -> Result<Vec<u8>> {
+    if bwt_data.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let bwt_obj: Bwt<'static, u8, OwnedBuffer> =
+        unsafe { Bwt::from_parts(bwt_data.to_vec(), primary_index as usize) };
+
+    let text = bwt_obj
+        .unbwt()
+        .with_owned_temporary_array_buffer32()
+        .single_threaded()
+        .run()
+        .map_err(|e| anyhow::anyhow!("libsais UnBWT: {:?}", e))?;
+
+    Ok(text.as_slice().to_vec())
+}
+
+pub fn bwt_encode_streaming(block_size: usize, data: &[u8]) -> Result<Vec<(BwtResult, usize)>> {
+    data.par_chunks(block_size)
+        .enumerate()
+        .map(|(i, chunk)| {
+            let result = bwt_encode(chunk)?;
+            Ok((result, i * block_size))
+        })
+        .collect()
+}