roxify 1.5.11 → 1.6.1

package/README.md

@@ -0,0 +1,377 @@
+# RoxCompressor Transform
+
+> Encode binary data into PNG images and decode them back. Fast, efficient, with optional encryption and native Rust acceleration.
+
+[![npm version](https://img.shields.io/npm/v/roxify.svg)](https://www.npmjs.com/package/roxify)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+## Features
+
+- ⚡ **Blazing Fast**: Native Rust acceleration via N-API — **1GB/s** throughput on modern hardware
+- 🚀 **Optimized Compression**: Multi-threaded Zstd compression (level 19) with parallel processing
+- 🔒 **Secure**: AES-256-GCM encryption support with PBKDF2 key derivation
+- 🎨 **Multiple modes**: Compact, chunk, pixel, and screenshot modes
+- 📦 **CLI & API**: Use as command-line tool or JavaScript library
+- 🔄 **Lossless**: Perfect roundtrip encoding/decoding
+- 📖 **Full TSDoc**: Complete TypeScript documentation
+- 🦀 **Rust Powered**: Optional native module for extreme performance (falls back to pure JS)
+
+## Real-world benchmarks 🔧
+
+**Highlights**
+
+- Practical benchmarks on large codebase datasets showing significant compression and high throughput while handling many small files efficiently.
+
+**Results**
+
+| Dataset  |   Files | Original | Compressed |     Ratio |   Time | Throughput | Notes                                       |
+| -------- | ------: | -------: | ---------: | --------: | -----: | ---------: | ------------------------------------------- |
+| 4,000 MB | 731,340 |  3.93 GB |  111.42 MB |  **2.8%** | 26.9 s | 149.4 MB/s | gzip: 2.26 GB (57.5%); 7z: 1.87 GB (47.6%)  |
+| 1,000 MB | 141,522 |  1.03 GB |     205 MB | **19.4%** | ~6.2 s |  ≈170 MB/s | shows benefits for many-small-file datasets |
+
+### Methodology
+
+- Compression: multithreaded Zstd (level 19) and Brotli (configurable).
+- Setup: parallel I/O and multithreaded compression on modern SSD-backed systems.
+- Measurements: wall-clock time; throughput = original size / time; comparisons against gzip and 7z with typical defaults.
+- Reproducibility: full benchmark details, commands and raw data are available in `docs/BENCHMARK_FINAL_REPORT.md`.
+
+These results demonstrate Roxify's strength for packaging large codebases and many-small-file archives where speed and a good compression/throughput trade-off matter.
+
+## Documentation
+
+- 📘 **[CLI Documentation](./docs/CLI.md)** - Complete command-line usage guide
+- 📗 **[JavaScript SDK](./docs/JAVASCRIPT_SDK.md)** - Programmatic API reference with examples
+- 📙 **[Quick Start](#quick-start)** - Get started in 2 minutes
+
+## Installation
+
+### As CLI tool (npx)
+
+No installation needed! Use directly with npx:
+
+```bash
+  npx rox encode input.zip output.png
+  npx rox decode output.png original.zip
+```
+
+### As library
+
+```bash
+npm install roxify
+```
+
+## CLI Usage
+
+### Quick Start
+
+```bash
+# Encode a file
+  npx rox encode document.pdf document.png
+
+# Decode it back
+  npx rox decode document.png document.pdf
+
+# With encryption
+  npx rox encode secret.zip secret.png -p mypassword
+  npx rox decode secret.png secret.zip -p mypassword
+```
+
+### CLI Commands
+
+#### `encode` - Encode file to PNG
+
+```bash
+  npx rox encode <input> [output] [options]
+```
+
+**Options:**
+
+- `-p, --passphrase <pass>` - Encrypt with passphrase (AES-256-GCM)
+- `-m, --mode <mode>` - Encoding mode: `compact|chunk|pixel|screenshot` (default: `screenshot`)
+- `-q, --quality <0-11>` - Brotli compression quality (default: `1`)
+  - `0` = fastest, largest
+  - `11` = slowest, smallest
+- `-e, --encrypt <type>` - Encryption: `auto|aes|xor|none` (default: `aes` if passphrase)
+- `--no-compress` - Disable compression
+- `-o, --output <path>` - Output file path
+
+**Examples:**
+
+```bash
+# Basic encoding
+  npx rox encode data.bin output.png
+
+# Fast compression for large files
+  npx rox encode large-video.mp4 output.png -q 0
+
+# High compression for small files
+  npx rox encode config.json output.png -q 11
+
+# With encryption
+  npx rox encode secret.pdf secure.png -p "my secure password"
+
+# Compact mode (smallest PNG)
+  npx rox encode data.bin tiny.png -m compact
+
+# Screenshot mode (recommended, looks like a real image)
+  npx rox encode archive.tar.gz screenshot.png -m screenshot
+```
+
+#### `decode` - Decode PNG to file
+
+```bash
+  npx rox decode <input> [output] [options]
+```
+
+**Options:**
+
+- `-p, --passphrase <pass>` - Decryption passphrase
+- `-o, --output <path>` - Output file path (auto-detected from metadata if not provided)
+
+**Examples:**
+
+```bash
+# Basic decoding
+  npx rox decode encoded.png output.bin
+
+# Auto-detect filename from metadata
+  npx rox decode encoded.png
+
+# With decryption
+  npx rox decode encrypted.png output.pdf -p "my secure password"
+```
+
+## JavaScript API
+
+### Basic Usage
+
+```typescript
+import { encodeBinaryToPng, decodePngToBinary } from 'roxify';
+import { readFileSync, writeFileSync } from 'fs';
+
+const input = readFileSync('input.zip');
+const png = await encodeBinaryToPng(input, {
+  mode: 'screenshot',
+  name: 'input.zip',
+});
+writeFileSync('output.png', png);
+
+const encoded = readFileSync('output.png');
+const result = await decodePngToBinary(encoded);
+writeFileSync(result.meta?.name || 'output.bin', result.buf);
+```
+
+### With Encryption
+
+```typescript
+const png = await encodeBinaryToPng(input, {
+  mode: 'screenshot',
+  passphrase: 'my-secret-password',
+  encrypt: 'aes',
+  name: 'secret.zip',
+});
+
+const result = await decodePngToBinary(encoded, {
+  passphrase: 'my-secret-password',
+});
+```
+
+### Fast Compression
+
+```typescript
+const png = await encodeBinaryToPng(largeBuffer, {
+  mode: 'screenshot',
+  brQuality: 0,
+  name: 'large-file.bin',
+});
+
+const png = await encodeBinaryToPng(smallBuffer, {
+  mode: 'compact',
+  brQuality: 11,
+  name: 'config.json',
+});
+```
+
+### Encoding Modes
+
+#### `screenshot` (Recommended)
+
+Encodes data as RGB pixel values, optimized for screenshot-like appearance. Best balance of size and compatibility.
+
+```typescript
+const png = await encodeBinaryToPng(data, { mode: 'screenshot' });
+```
+
+#### `compact` (Smallest)
+
+Minimal 1x1 PNG with data in custom chunk. Fastest and smallest.
+
+```typescript
+const png = await encodeBinaryToPng(data, { mode: 'compact' });
+```
+
+#### `pixel`
+
+Encodes data as RGB pixel values without screenshot optimization.
+
+```typescript
+const png = await encodeBinaryToPng(data, { mode: 'pixel' });
+```
+
+#### `chunk`
+
+Standard PNG with data in custom rXDT chunk.
+
+```typescript
+const png = await encodeBinaryToPng(data, { mode: 'chunk' });
+```
+
+## API Reference
+
+### `encodeBinaryToPng(input, options)`
+
+Encodes binary data into a PNG image.
+
+**Parameters:**
+
+- `input: Buffer` - The binary data to encode
+- `options?: EncodeOptions` - Encoding options
+
+**Returns:** `Promise<Buffer>` - The encoded PNG
+
+**Options:**
+
+```typescript
+interface EncodeOptions {
+  compression?: 'br' | 'none';
+
+  passphrase?: string;
+
+  name?: string;
+
+  mode?: 'compact' | 'chunk' | 'pixel' | 'screenshot';
+
+  encrypt?: 'auto' | 'aes' | 'xor' | 'none';
+
+  output?: 'auto' | 'png' | 'rox';
+
+  includeName?: boolean;
+
+  brQuality?: number;
+}
+```
+
+### `decodePngToBinary(pngBuf, options)`
+
+Decodes a PNG image back to binary data.
+
+**Parameters:**
+
+- `pngBuf: Buffer` - The PNG image to decode
+- `options?: DecodeOptions` - Decoding options
+
+**Returns:** `Promise<DecodeResult>` - The decoded data and metadata
+
+**Options:**
+
+```typescript
+interface DecodeOptions {
+  passphrase?: string;
+}
+```
+
+**Result:**
+
+```typescript
+interface DecodeResult {
+  buf: Buffer;
+
+  meta?: {
+    name?: string;
+  };
+}
+```
+
+## Performance Tips
+
+### For Large Files (>10 MB)
+
+```bash
+# Use quality 0 for fastest encoding
+npx rox encode large.bin output.png -q 0
+```
+
+```typescript
+const png = await encodeBinaryToPng(largeFile, {
+  mode: 'screenshot',
+  brQuality: 0,
+});
+```
+
+### For Small Files (<1 MB)
+
+```bash
+# Use quality 11 for best compression
+npx rox encode small.json output.png -q 11 -m compact
+```
+
+```typescript
+const png = await encodeBinaryToPng(smallFile, {
+  mode: 'compact',
+  brQuality: 11,
+});
+```
+
+### Benchmark Results
+
+File: 3.8 MB binary
+
+- **Quality 0**: ~500-800ms, output ~1.2 MB
+- **Quality 1** (default): ~1-2s, output ~800 KB
+- **Quality 5**: ~8-12s, output ~750 KB
+- **Quality 11**: ~20-30s, output ~720 KB
+
+## Error Handling
+
+```typescript
+try {
+  const result = await decodePngToBinary(encoded, {
+    passphrase: 'wrong-password',
+  });
+} catch (err) {
+  if (err.message.includes('Incorrect passphrase')) {
+    console.error('Wrong password!');
+  } else if (err.message.includes('Invalid ROX format')) {
+    console.error('Not a valid RoxCompressor PNG');
+  } else {
+    console.error('Decode failed:', err.message);
+  }
+}
+```
+
+## Security
+
+- **AES-256-GCM**: Authenticated encryption with 100,000 PBKDF2 iterations
+- **XOR cipher**: Simple obfuscation (not cryptographically secure)
+- **No encryption**: Data is compressed but not encrypted
+
+⚠️ **Warning**: Use strong passphrases for sensitive data. The `xor` encryption mode is not secure and should only be used for obfuscation.
+
+## License
+
+MIT © RoxCompressor
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR on GitHub.
+
+## Links
+
+- [GitHub Repository](https://github.com/RoxasYTB/roxify)
+- [npm Package](https://www.npmjs.com/package/roxify)
+- [Report Issues](https://github.com/RoxasYTB/roxify/issues)
+
+## CI / Multi-platform builds
+
+This project runs continuous integration on Linux, Windows and macOS via GitHub Actions. Native modules are built on each platform and attached to the workflow (and release) as artifacts. On releases we also publish platform artifacts to GitHub Releases. For npm publishing, set the `NPM_TOKEN` secret in your repository settings to allow automated publishes on release.

package/dist/_esmodule_test.d.ts

@@ -0,0 +1 @@
+export declare const TEST_EMIT = 42;

package/dist/_esmodule_test.js

@@ -0,0 +1 @@
+export const TEST_EMIT = 42;

package/dist/cli.js

@@ -1,12 +1,32 @@
 #!/usr/bin/env node
-import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, } from 'fs';
 import { open } from 'fs/promises';
 import { basename, dirname, join, resolve } from 'path';
 import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
 import { packPathsGenerator, unpackBuffer } from './pack.js';
 import * as cliProgress from './stub-progress.js';
 import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.4.0';
+const VERSION = '1.6.1';
+function getDirectorySize(dirPath) {
+    let totalSize = 0;
+    try {
+        const entries = readdirSync(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                totalSize += getDirectorySize(fullPath);
+            }
+            else if (entry.isFile()) {
+                try {
+                    totalSize += statSync(fullPath).size;
+                }
+                catch (e) { }
+            }
+        }
+    }
+    catch (e) { }
+    return totalSize;
+}
 async function readLargeFile(filePath) {
     const st = statSync(filePath);
     if (st.size <= 2 * 1024 * 1024 * 1024) {
@@ -177,7 +197,6 @@ async function encodeCommand(args) {
         safeCwd = process.cwd();
     }
     catch (e) {
-        // ENOENT: fallback sur racine
         safeCwd = '/';
     }
     const resolvedInputs = inputPaths.map((p) => resolve(safeCwd, p));
@@ -195,7 +214,6 @@ async function encodeCommand(args) {
     catch (e) {
         resolvedOutput = join('/', parsed.output || outputPath || outputName);
     }
-    // Check for empty directories *before* attempting native Rust encoder.
     try {
         const anyDir = inputPaths.some((p) => {
             try {
@@ -214,10 +232,15 @@ async function encodeCommand(args) {
             }
         }
     }
+    catch (e) { }
+    let anyInputDir = false;
+    try {
+        anyInputDir = resolvedInputs.some((p) => statSync(p).isDirectory());
+    }
     catch (e) {
-        // ignore errors from the quick pre-check and proceed to try Rust encoding
+        anyInputDir = false;
     }
-    if (isRustBinaryAvailable() && !parsed.forceTs) {
+    if (isRustBinaryAvailable() && !parsed.forceTs && !anyInputDir) {
         try {
             console.log(`Encoding to ${resolvedOutput} (Using native Rust encoder)\n`);
             const startTime = Date.now();
@@ -246,11 +269,7 @@ async function encodeCommand(args) {
             let inputSize = 0;
             if (inputPaths.length === 1 &&
                 fstatSync(resolvedInputs[0]).isDirectory()) {
-                const { execSync } = await import('child_process');
-                const sizeOutput = execSync(`du -sb "${resolvedInputs[0]}"`, {
-                    encoding: 'utf-8',
-                });
-                inputSize = parseInt(sizeOutput.split(/\s+/)[0]);
+                inputSize = getDirectorySize(resolvedInputs[0]);
             }
             else {
                 inputSize = fstatSync(resolvedInputs[0]).size;
@@ -656,6 +675,39 @@ async function listCommand(args) {
         process.exit(1);
     }
     const resolvedInput = resolve(inputPath);
+    if (isRustBinaryAvailable()) {
+        try {
+            const { findRustBinary } = await import('./utils/rust-cli-wrapper.js');
+            const cliPath = findRustBinary();
+            if (cliPath) {
+                const { execSync } = await import('child_process');
+                try {
+                    const help = execSync(`"${cliPath}" --help`, { encoding: 'utf-8' });
+                    if (!help.includes('list')) {
+                        throw new Error('native CLI does not support list');
+                    }
+                    const output = execSync(`"${cliPath}" list "${resolvedInput}"`, {
+                        encoding: 'utf-8',
+                        stdio: ['pipe', 'pipe', 'inherit'],
+                        timeout: 30000,
+                    });
+                    const fileList = JSON.parse(output.trim());
+                    console.log(`Files in ${resolvedInput}:`);
+                    for (const file of fileList) {
+                        if (typeof file === 'string') {
+                            console.log(`  ${file}`);
+                        }
+                        else {
+                            console.log(`  ${file.name} (${file.size} bytes)`);
+                        }
+                    }
+                    return;
+                }
+                catch (e) { }
+            }
+        }
+        catch (err) { }
+    }
     try {
         const inputBuffer = readFileSync(resolvedInput);
         const fileList = await listFilesInPng(inputBuffer, {

package/dist/index.d.ts

@@ -5,9 +5,10 @@ export * from './utils/encoder.js';
 export * from './utils/errors.js';
 export * from './utils/helpers.js';
 export * from './utils/inspection.js';
+export { native } from './utils/native.js';
 export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
+export { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
-export { decodeMinPng, encodeMinPng } from './minpng.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/index.js

@@ -5,9 +5,10 @@ export * from './utils/encoder.js';
 export * from './utils/errors.js';
 export * from './utils/helpers.js';
 export * from './utils/inspection.js';
+export { native } from './utils/native.js';
 export * from './utils/optimization.js';
 export * from './utils/reconstitution.js';
+export { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
-export { decodeMinPng, encodeMinPng } from './minpng.js';
 export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/utils/decoder.js

@@ -697,7 +697,6 @@ export async function decodePngToBinary(input, opts = {}) {
                         throw new IncorrectPassphraseError(`Incorrect passphrase (screenshot mode, zstd failed: ` +
                             errMsg +
                             ')');
-                    // Fallback: try reconstituting the image and re-extracting the pixels
                     try {
                         if (process.env.ROX_DEBUG)
                             console.log('DEBUG: decompress failed, attempting cropAndReconstitute fallback');
@@ -706,7 +705,6 @@ export async function decodePngToBinary(input, opts = {}) {
                         let logicalData2 = Buffer.from(raw2.pixels);
                         let logicalWidth2 = raw2.width;
                         let logicalHeight2 = raw2.height;
-                        // find startIdx2 (linear)
                         let startIdx2 = -1;
                         const totalPixels2 = (logicalData2.length / 3) | 0;
                         for (let i2 = 0; i2 <= totalPixels2 - MARKER_START.length; i2++) {
@@ -725,7 +723,6 @@ export async function decodePngToBinary(input, opts = {}) {
                             }
                         }
                         if (startIdx2 === -1) {
-                            // try 2D scan
                             let found2D2 = false;
                             for (let y = 0; y < logicalHeight2 && !found2D2; y++) {
                                 for (let x = 0; x <= logicalWidth2 - MARKER_START.length && !found2D2; x++) {
@@ -740,7 +737,6 @@ export async function decodePngToBinary(input, opts = {}) {
                                         }
                                     }
                                     if (match) {
-                                        // compute rectangle
                                         let endX = x + MARKER_START.length - 1;
                                         let endY = y;
                                         for (let scanY = y; scanY < logicalHeight2; scanY++) {
@@ -800,7 +796,6 @@ export async function decodePngToBinary(input, opts = {}) {
                             if (!found2D2)
                                 throw new DataFormatError('Screenshot fallback failed: START not found');
                         }
-                        // compute endStartPixel2
                         const curTotalPixels2 = (logicalData2.length / 3) | 0;
                         const lastLineStart2 = (logicalHeight2 - 1) * logicalWidth2;
                         const endMarkerStartCol2 = logicalWidth2 - MARKER_END.length;
@@ -843,7 +838,6 @@ export async function decodePngToBinary(input, opts = {}) {
                             pixelBytes2[dstOffset + 1] = logicalData2[srcOffset + 1];
                             pixelBytes2[dstOffset + 2] = logicalData2[srcOffset + 2];
                         }
-                        // try decompressing fallback payload
                         const foundPX = pixelBytes2.indexOf(PIXEL_MAGIC);
                         if (process.env.ROX_DEBUG)
                             console.log('DEBUG: PIXEL_MAGIC index in fallback:', foundPX);
@@ -891,7 +885,6 @@ export async function decodePngToBinary(input, opts = {}) {
                         throw new DataFormatError('Screenshot mode zstd decompression failed: ' + errMsg);
                     }
                     catch (e2) {
-                        // If fallback fails, rethrow original error
                         throw new DataFormatError(`Screenshot mode zstd decompression failed: ` + errMsg);
                     }
                 }

package/dist/utils/encoder.d.ts

@@ -17,7 +17,6 @@ import { EncodeOptions } from './types.js';
  *   outputFormat: 'png',
  * });
  *
- * // write to disk using fs.writeFileSync('out.png', png)
- * ```
+ *  * ```
  */
 export declare function encodeBinaryToPng(input: Buffer | Buffer[], opts?: EncodeOptions): Promise<Buffer>;

package/dist/utils/encoder.js

@@ -24,8 +24,7 @@ import { parallelZstdCompress } from './zstd.js';
  *   outputFormat: 'png',
  * });
  *
- * // write to disk using fs.writeFileSync('out.png', png)
- * ```
+ *  * ```
  */
 export async function encodeBinaryToPng(input, opts = {}) {
     let progressBar = null;
@@ -149,6 +148,48 @@ export async function encodeBinaryToPng(input, opts = {}) {
     const payloadTotalLen = payload.reduce((a, b) => a + b.length, 0);
     if (opts.onProgress)
         opts.onProgress({ phase: 'meta_prep_done', loaded: payloadTotalLen });
+    if (typeof native.nativeEncodePngWithNameAndFilelist === 'function' &&
+        opts.includeFileList &&
+        opts.fileList) {
+        const fileName = opts.name || undefined;
+        let sizeMap = null;
+        if (!Array.isArray(input)) {
+            try {
+                const unpack = unpackBuffer(input);
+                if (unpack) {
+                    sizeMap = {};
+                    for (const ef of unpack.files)
+                        sizeMap[ef.path] = ef.buf.length;
+                }
+            }
+            catch (e) { }
+        }
+        const normalized = opts.fileList.map((f) => {
+            if (typeof f === 'string')
+                return { name: f, size: sizeMap && sizeMap[f] ? sizeMap[f] : 0 };
+            if (f && typeof f === 'object') {
+                if (f.name)
+                    return { name: f.name, size: f.size ?? 0 };
+                if (f.path)
+                    return { name: f.path, size: f.size ?? 0 };
+            }
+            return { name: String(f), size: 0 };
+        });
+        const fileListJson = JSON.stringify(normalized);
+        const flatPayload = Buffer.concat(payload);
+        if (opts.passphrase && opts.encrypt && opts.encrypt !== 'auto') {
+            const result = native.nativeEncodePngWithEncryptionNameAndFilelist(flatPayload, compressionLevel, opts.passphrase, opts.encrypt, fileName, fileListJson);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            return Buffer.from(result);
+        }
+        else {
+            const result = native.nativeEncodePngWithNameAndFilelist(flatPayload, compressionLevel, fileName, fileListJson);
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            return Buffer.from(result);
+        }
+    }
     const metaParts = [];
     const includeName = opts.includeName === undefined ? true : !!opts.includeName;
     if (includeName && opts.name) {

package/dist/utils/inspection.js

@@ -23,6 +23,46 @@ import { cropAndReconstitute } from './reconstitution.js';
 export async function listFilesInPng(pngBuf, opts = {}) {
     try {
         const chunks = native.extractPngChunks(pngBuf);
+        const fileListChunk = chunks.find((c) => c.name === 'rXFL');
+        if (fileListChunk) {
+            const data = Buffer.from(fileListChunk.data);
+            const parsedFiles = JSON.parse(data.toString('utf8'));
+            if (parsedFiles.length > 0 &&
+                typeof parsedFiles[0] === 'object' &&
+                (parsedFiles[0].name || parsedFiles[0].path)) {
+                const objs = parsedFiles.map((p) => ({
+                    name: p.name ?? p.path,
+                    size: typeof p.size === 'number' ? p.size : 0,
+                }));
+                return objs.sort((a, b) => a.name.localeCompare(b.name));
+            }
+            const files = parsedFiles;
+            return files.sort();
+        }
+        const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);
+        if (metaChunk) {
+            const dataBuf = Buffer.from(metaChunk.data);
+            const markerIdx = dataBuf.indexOf(Buffer.from('rXFL'));
+            if (markerIdx !== -1 && markerIdx + 8 <= dataBuf.length) {
+                const jsonLen = dataBuf.readUInt32BE(markerIdx + 4);
+                const jsonStart = markerIdx + 8;
+                const jsonEnd = jsonStart + jsonLen;
+                if (jsonEnd <= dataBuf.length) {
+                    const parsedFiles = JSON.parse(dataBuf.slice(jsonStart, jsonEnd).toString('utf8'));
+                    if (parsedFiles.length > 0 &&
+                        typeof parsedFiles[0] === 'object' &&
+                        (parsedFiles[0].name || parsedFiles[0].path)) {
+                        const objs = parsedFiles.map((p) => ({
+                            name: p.name ?? p.path,
+                            size: typeof p.size === 'number' ? p.size : 0,
+                        }));
+                        return objs.sort((a, b) => a.name.localeCompare(b.name));
+                    }
+                    const files = parsedFiles;
+                    return files.sort();
+                }
+            }
+        }
         const ihdr = chunks.find((c) => c.name === 'IHDR');
         const idatChunks = chunks.filter((c) => c.name === 'IDAT');
         if (ihdr && idatChunks.length > 0) {
@@ -101,23 +141,7 @@ export async function listFilesInPng(pngBuf, opts = {}) {
                                 return;
                             }
                             const names = parsedFiles;
-                            if (opts.includeSizes) {
-                                getFileSizesFromPng(pngBuf)
-                                    .then((sizes) => {
-                                    if (sizes) {
-                                        resolve(names
-                                            .map((f) => ({ name: f, size: sizes[f] ?? 0 }))
-                                            .sort((a, b) => a.name.localeCompare(b.name)));
-                                    }
-                                    else {
-                                        resolve(names.sort());
-                                    }
-                                })
-                                    .catch(() => resolve(names.sort()));
-                            }
-                            else {
-                                resolve(names.sort());
-                            }
+                            resolve(names.sort());
                         }
                         catch (e) {
                             resolved = true;
@@ -202,14 +226,6 @@ export async function listFilesInPng(pngBuf, opts = {}) {
                                             return objs.sort((a, b) => a.name.localeCompare(b.name));
                                         }
                                         const files = parsedFiles;
-                                        if (opts.includeSizes) {
-                                            const sizes = await getFileSizesFromPng(pngBuf);
-                                            if (sizes) {
-                                                return files
-                                                    .map((f) => ({ name: f, size: sizes[f] ?? 0 }))
-                                                    .sort((a, b) => a.name.localeCompare(b.name));
-                                            }
-                                        }
                                         return files.sort();
                                     }
                                 }
@@ -272,14 +288,6 @@ export async function listFilesInPng(pngBuf, opts = {}) {
                                             return objs.sort((a, b) => a.name.localeCompare(b.name));
                                         }
                                         const files = parsedFiles;
-                                        if (opts.includeSizes) {
-                                            const sizes = await getFileSizesFromPng(reconstructed);
-                                            if (sizes) {
-                                                return files
-                                                    .map((f) => ({ name: f, size: sizes[f] ?? 0 }))
-                                                    .sort((a, b) => a.name.localeCompare(b.name));
-                                            }
-                                        }
                                         return files.sort();
                                     }
                                 }
@@ -360,14 +368,6 @@ export async function listFilesInPng(pngBuf, opts = {}) {
                 return objs.sort((a, b) => a.name.localeCompare(b.name));
             }
             const files = parsedFiles;
-            if (opts.includeSizes) {
-                const sizes = await getFileSizesFromPng(pngBuf);
-                if (sizes) {
-                    return files
-                        .map((f) => ({ name: f, size: sizes[f] ?? 0 }))
-                        .sort((a, b) => a.name.localeCompare(b.name));
-                }
-            }
             return files.sort();
         }
         const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);

package/dist/utils/native.js

@@ -1,35 +1,21 @@
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { arch, platform } from 'os';
-import { dirname, join, resolve } from 'path';
-import { fileURLToPath } from 'url';
+import { join, resolve } from 'path';
 function getNativeModule() {
     let moduleDir;
     let nativeRequire;
     if (typeof __dirname !== 'undefined') {
-        // Mode CJS - variables globales disponibles
         moduleDir = __dirname;
-        // @ts-ignore
         nativeRequire = require;
     }
     else {
-        // Try ESM import.meta.url first (may throw in CJS/bundled contexts), otherwise fallback to CWD
+        moduleDir = process.cwd();
         try {
-            // @ts-ignore - import.meta.url exists in proper ESM contexts
-            const __filename = fileURLToPath(import.meta.url);
-            moduleDir = dirname(__filename);
-            nativeRequire = createRequire(import.meta.url);
+            nativeRequire = require;
         }
         catch {
-            // Fallback (bundled CJS without __dirname): use current working directory
-            moduleDir = process.cwd();
-            try {
-                // @ts-ignore
-                nativeRequire = require;
-            }
-            catch {
-                nativeRequire = createRequire(process.cwd());
-            }
+            nativeRequire = createRequire(process.cwd() + '/package.json');
         }
     }
     function getNativePath() {
@@ -53,10 +39,12 @@ function getNativeModule() {
         if (!target || !ext) {
             throw new Error(`Unsupported platform: ${currentPlatform}`);
         }
-        const prebuiltPath = join(moduleDir, '../../libroxify_native.node');
-        const bundlePath = join(moduleDir, '../libroxify_native.node');
-        // compute repo root by walking up from moduleDir (fallback to process.cwd())
-        // @ts-ignore
+        const prebuiltPath = join(moduleDir, '../../roxify_native.node');
+        const prebuiltLibPath = join(moduleDir, '../../libroxify_native.node');
+        const bundlePath = join(moduleDir, '../roxify_native.node');
+        const bundleLibPath = join(moduleDir, '../libroxify_native.node');
+        const bundlePathWithTarget = join(moduleDir, `../roxify_native-${target}.node`);
+        const bundleLibPathWithTarget = join(moduleDir, `../libroxify_native-${target}.node`);
         console.debug('[native] moduleDir', moduleDir);
         let root = moduleDir && moduleDir !== '.' ? moduleDir : process.cwd();
         while (root.length > 1 &&
@@ -67,48 +55,54 @@ function getNativeModule() {
                 break;
             root = parent;
         }
-        const localTargetRelease = resolve(root, `target/release/libroxify_native${ext === 'node' ? '.node' : `-${target}.${ext}`}`);
-        const localReleaseGeneric = resolve(root, 'target/release/libroxify_native.so');
-        const nodeModulesBase = resolve(root, 'node_modules/roxify');
-        const nodeModulesTarget = resolve(nodeModulesBase, `libroxify_native-${target}.${ext}`);
-        const nodeModulesGeneric = resolve(nodeModulesBase, ext === 'node' ? 'libroxify_native.node' : `libroxify_native.${ext}`);
-        const bundleTarget = resolve(moduleDir, `../libroxify_native-${target}.${ext}`);
-        const bundleGeneric = resolve(moduleDir, bundlePath);
-        const candidates = [
-            localTargetRelease,
-            localReleaseGeneric,
-            nodeModulesTarget,
-            nodeModulesGeneric,
-            bundleTarget,
-            bundleGeneric,
-            prebuiltPath,
-        ];
-        // use built-in fs.existsSync (static import to work in ESM and CJS)
+        const bundleNode = resolve(moduleDir, '../roxify_native.node');
+        const bundleLibNode = resolve(moduleDir, '../libroxify_native.node');
+        const bundleNodeWithTarget = resolve(moduleDir, `../roxify_native-${target}.node`);
+        const bundleLibNodeWithTarget = resolve(moduleDir, `../libroxify_native-${target}.node`);
+        const repoNode = resolve(root, 'roxify_native.node');
+        const repoLibNode = resolve(root, 'libroxify_native.node');
+        const repoNodeWithTarget = resolve(root, `roxify_native-${target}.node`);
+        const repoLibNodeWithTarget = resolve(root, `libroxify_native-${target}.node`);
+        const targetNode = resolve(root, 'target/release/roxify_native.node');
+        const targetSo = resolve(root, 'target/release/roxify_native.so');
+        const targetLibSo = resolve(root, 'target/release/libroxify_native.so');
+        const nodeModulesNode = resolve(root, 'node_modules/roxify/roxify_native.node');
+        const nodeModulesNodeWithTarget = resolve(root, `node_modules/roxify/roxify_native-${target}.node`);
+        const prebuiltNode = resolve(moduleDir, '../../roxify_native.node');
+        const prebuiltLibNode = resolve(moduleDir, '../../libroxify_native.node');
+        const prebuiltNodeWithTarget = resolve(moduleDir, `../../roxify_native-${target}.node`);
+        const prebuiltLibNodeWithTarget = resolve(moduleDir, `../../libroxify_native-${target}.node`);
+        // Support multiple possible OS triples (e.g. windows-gnu and windows-msvc)
+        const targets = targetAlt ? [target, targetAlt] : [target];
+        const candidates = [];
+        for (const t of targets) {
+            const bundleNodeWithT = resolve(moduleDir, `../roxify_native-${t}.node`);
+            const bundleLibNodeWithT = resolve(moduleDir, `../libroxify_native-${t}.node`);
+            const repoNodeWithT = resolve(root, `roxify_native-${t}.node`);
+            const repoLibNodeWithT = resolve(root, `libroxify_native-${t}.node`);
+            const nodeModulesNodeWithT = resolve(root, `node_modules/roxify/roxify_native-${t}.node`);
+            const prebuiltNodeWithT = resolve(moduleDir, `../../roxify_native-${t}.node`);
+            const prebuiltLibNodeWithT = resolve(moduleDir, `../../libroxify_native-${t}.node`);
+            candidates.push(bundleLibNodeWithT, bundleNodeWithT, repoLibNodeWithT, repoNodeWithT, nodeModulesNodeWithT, prebuiltLibNodeWithT, prebuiltNodeWithT);
+        }
+        candidates.push(bundleLibNode, bundleNode, repoLibNode, repoNode, targetNode, targetLibSo, targetSo, nodeModulesNode, prebuiltLibNode, prebuiltNode);
         for (const c of candidates) {
             try {
                 if (!existsSync(c))
                     continue;
-                // If it's a .so (native build) but Node expects .node extension, create a .node symlink
                 if (c.endsWith('.so')) {
                     const nodeAlias = c.replace(/\.so$/, '.node');
                     try {
                         if (!existsSync(nodeAlias)) {
-                            // copy the .so to a .node so Node treats it as a native addon
-                            // @ts-ignore
                             require('fs').copyFileSync(c, nodeAlias);
                         }
-                        // debug
-                        // @ts-ignore
                         console.debug('[native] using node alias', nodeAlias);
                         return nodeAlias;
                     }
                     catch (e) {
-                        // fallback to original .so (might fail to load via require)
                         return c;
                     }
                 }
-                // debug
-                // @ts-ignore
                 console.debug('[native] using path', c);
                 return c;
             }

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

@@ -1,2 +1,4 @@
+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>;

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

@@ -1,21 +1,11 @@
-import { spawn } from 'child_process';
+import { execSync, spawn } from 'child_process';
 import { existsSync } from 'fs';
 import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
 let moduleDir;
-try {
-    // CJS bundlers may provide __dirname; prefer it when available
-    if (typeof __dirname !== 'undefined') {
-        // @ts-ignore
-        moduleDir = __dirname;
-    }
-    else {
-        // @ts-ignore - import.meta.url exists in ESM
-        const __filename = fileURLToPath(import.meta.url);
-        moduleDir = dirname(__filename);
-    }
+if (typeof __dirname !== 'undefined') {
+    moduleDir = __dirname;
 }
-catch {
+else {
     moduleDir = process.cwd();
 }
 function findRustBinary() {
@@ -23,7 +13,85 @@ function findRustBinary() {
         ? ['roxify_native.exe', 'roxify-cli.exe', 'roxify_cli.exe']
         : ['roxify_native', 'roxify-cli', 'roxify_cli'];
     const baseDir = typeof moduleDir !== 'undefined' ? moduleDir : process.cwd();
-    // Check immediate locations (for packaged CLI)
+    if (process.pkg) {
+        const snapshotPaths = [
+            join(baseDir, '..', '..', 'target', 'release'),
+            join(baseDir, '..', 'target', 'release'),
+            join(baseDir, 'target', 'release'),
+        ];
+        for (const basePath of snapshotPaths) {
+            for (const name of binNames) {
+                const binPath = join(basePath, name);
+                if (existsSync(binPath)) {
+                    return binPath;
+                }
+            }
+        }
+        try {
+            const execDir = require('path').dirname(process.execPath || '');
+            if (execDir) {
+                const execCandidates = [
+                    join(execDir, 'tools', 'roxify', 'dist'),
+                    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 = c.endsWith(name) ? c : join(c, name);
+                        if (existsSync(p)) {
+                            return p;
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) { }
+    }
+    try {
+        let paths = [];
+        if (process.platform === 'win32') {
+            try {
+                const out = execSync('where rox', { encoding: 'utf-8' }).trim();
+                if (out)
+                    paths = out
+                        .split(/\r?\n/)
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+            }
+            catch (e) { }
+        }
+        else {
+            try {
+                const out = execSync('which rox', { encoding: 'utf-8' }).trim();
+                if (out)
+                    paths = [out.trim()];
+            }
+            catch (e) { }
+        }
+        for (const p of paths) {
+            try {
+                const d = dirname(p);
+                const candidates = [
+                    d,
+                    join(d, 'dist'),
+                    join(d, '..', 'dist'),
+                    join(d, '..'),
+                ];
+                for (const c of candidates) {
+                    for (const name of binNames) {
+                        const candidate = join(c, name);
+                        if (existsSync(candidate)) {
+                            return candidate;
+                        }
+                    }
+                }
+            }
+            catch (e) { }
+        }
+    }
+    catch (e) { }
     for (const name of binNames) {
         const local = join(baseDir, name);
         if (existsSync(local)) {
@@ -33,8 +101,15 @@ function findRustBinary() {
         if (existsSync(parentLocal)) {
             return parentLocal;
         }
+        const parentParentLocal = join(baseDir, '..', '..', name);
+        if (existsSync(parentParentLocal)) {
+            return parentParentLocal;
+        }
+        const nodeModulesPath = join(baseDir, '..', '..', '..', '..', name);
+        if (existsSync(nodeModulesPath)) {
+            return nodeModulesPath;
+        }
     }
-    // Check target/release (for development)
     const targetRelease = join(baseDir, '..', '..', 'target', 'release');
     for (const name of binNames) {
         const targetPath = join(targetRelease, name);
@@ -44,33 +119,100 @@ function findRustBinary() {
     }
     return null;
 }
+export { findRustBinary };
 export function isRustBinaryAvailable() {
     return findRustBinary() !== null;
 }
+import { chmodSync, mkdtempSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
+import { tmpdir } from 'os';
 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');
     }
+    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) {
-            args.push('--name', 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);
-        const proc = spawn(cliPath, args, { stdio: 'inherit' });
-        proc.on('error', (err) => reject(err));
-        proc.on('close', (code) => {
-            if (code === 0) {
-                resolve();
+        let triedExtract = false;
+        let tempExe;
+        const runSpawn = (exePath) => {
+            let proc;
+            try {
+                proc = spawn(exePath, args, { stdio: 'inherit' });
             }
-            else {
-                reject(new Error(`Rust encoder exited with status ${code}`));
+            catch (err) {
+                if (!triedExtract) {
+                    triedExtract = true;
+                    try {
+                        tempExe = extractToTemp(cliPath);
+                    }
+                    catch (ex) {
+                        return reject(ex);
+                    }
+                    return runSpawn(tempExe);
+                }
+                return reject(err);
             }
-        });
+            proc.on('error', (err) => {
+                if (!triedExtract) {
+                    triedExtract = true;
+                    try {
+                        tempExe = extractToTemp(cliPath);
+                    }
+                    catch (ex) {
+                        return reject(ex);
+                    }
+                    return runSpawn(tempExe);
+                }
+                reject(err);
+            });
+            proc.on('close', (code) => {
+                if (tempExe) {
+                    try {
+                        unlinkSync(tempExe);
+                    }
+                    catch (e) { }
+                }
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Rust encoder exited with status ${code}`));
+                }
+            });
+        };
+        runSpawn(cliPath);
     });
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "roxify",
-  "version": "1.5.11",
-  "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
+  "version": "1.6.1",
   "type": "module",
+  "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -11,33 +11,63 @@
   },
   "files": [
     "dist",
+    "roxify_native.node",
     "libroxify_native.node",
-    "libroxify_native-*.so",
-    "libroxify_native-*.dylib",
-    "libroxify_native-*.dll",
-    "libroxify_native-x86_64-pc-windows-gnu.node",
-    "libroxify_native-x86_64-pc-windows-msvc.node",
+    "roxify_native-x86_64-pc-windows-gnu.node",
+    "roxify_native-x86_64-pc-windows-msvc.node",
+    "roxify_native-x86_64-unknown-linux-gnu.node",
+    "libroxify_native-x86_64-unknown-linux-gnu.node",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc",
+    "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 && cp target/x86_64-unknown-linux-gnu/release/libroxify_native.so libroxify_native-x86_64-unknown-linux-gnu.so",
-    "build:native:macos-x64": "cargo build --release --lib --target x86_64-apple-darwin && cp target/x86_64-apple-darwin/release/libroxify_native.dylib libroxify_native-x86_64-apple-darwin.dylib",
-    "build:native:macos-arm": "cargo build --release --lib --target aarch64-apple-darwin && cp target/aarch64-apple-darwin/release/libroxify_native.dylib libroxify_native-aarch64-apple-darwin.dylib",
-    "build:native:windows": "cargo build --release --lib --target x86_64-pc-windows-msvc && cp target/x86_64-pc-windows-msvc/release/roxify_native.dll libroxify_native-x86_64-pc-windows-msvc.dll",
+    "build:native:linux": "cargo build --release --lib --target x86_64-unknown-linux-gnu",
+    "build:native:macos-x64": "cargo build --release --lib --target x86_64-apple-darwin",
+    "build:native:macos-arm": "cargo build --release --lib --target aarch64-apple-darwin",
+    "build:native:windows": "cargo build --release --lib --target x86_64-pc-windows-msvc",
     "build:cli": "cargo build --release --bin roxify_native && cp target/release/roxify_native dist/roxify-cli",
+    "build:cli:windows": "cargo build --release --bin roxify_native --target x86_64-pc-windows-gnu && node scripts/copy-cli-binary.js",
     "build:all": "npm run build:native && npm run build && npm run build:cli",
     "build:cross": "node scripts/build-all-platforms.js && npm run build && npm run build:cli",
+    "build:native:fast": "cargo build -p roxify_native --release --lib --no-default-features",
+    "build:native:quick-release": "FAST_RELEASE=1 cargo build --profile fastdev -p roxify_native --lib --no-default-features",
+    "build:native:super-fast": "USE_SYSTEM_ZSTD=1 FAST_RELEASE=1 cargo build --profile fastdev -p roxify_native --lib --no-default-features -j 1",
+    "build:native:low-cpu": "LOW_CPU=1 USE_SYSTEM_ZSTD=1 FAST_RELEASE=1 MAX_JOBS=1 node scripts/build-native-targets.cjs",
+    "build:native:targets": "node scripts/build-native-targets.cjs",
+    "build:native:targets:fast": "FAST_RELEASE=1 node scripts/build-native-targets.cjs",
+    "build:pkg": "npm run build && npx pkg . --target node18-win-x64 --output dist/rox.exe --compress Brotli --public",
     "postbuild:native": "node scripts/copy-native.js",
-    "prepublishOnly": "npm run build:cross",
-    "test": "npm run build && node test/run-all-tests.js",
+    "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",
+    "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",
+    "publish": "node scripts/publish.cjs",
+    "prepublishOnly": "npm run build && npm run build:native && npm run postbuild:native && npm run clean:targets",
+    "test": "npm run build && node ./test/run-all-tests.cjs",
+    "test:integration": "node scripts/run-integration-tests.cjs",
     "cli": "node dist/cli.js"
   },
+  "pkg": {
+    "targets": [
+      "node18-win-x64"
+    ],
+    "outputPath": "dist",
+    "scripts": [
+      "dist/**/*.js"
+    ],
+    "assets": [
+      "dist/roxify_native.exe"
+    ]
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/yourusername/roxify.git"
+    "url": "https://github.com/RoxasYTB/roxify.git"
   },
   "keywords": [
     "steganography",
@@ -53,9 +83,9 @@
   ],
   "author": "",
   "license": "MIT",
-  "dependencies": {},
   "devDependencies": {
     "@types/node": "^22.0.0",
+    "pkg": "^5.8.1",
     "typescript": "^5.6.0"
   },
   "engines": {