roxify 1.4.0 → 1.4.1

package/dist/cli.js

@@ -211,7 +211,8 @@ async function encodeCommand(args) {
                 });
             }, 500);
             const encryptType = parsed.encrypt === 'xor' ? 'xor' : 'aes';
-            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 19, parsed.passphrase, encryptType);
+            const fileName = basename(inputPaths[0]);
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 12, parsed.passphrase, encryptType, fileName);
             clearInterval(progressInterval);
             const encodeTime = Date.now() - startTime;
             encodeBar.update(100, {
@@ -284,7 +285,7 @@ async function encodeCommand(args) {
             mode,
             name: parsed.outputName || 'archive',
             skipOptimization: false,
-            compressionLevel: 19,
+            compressionLevel: 12,
             outputFormat: 'auto',
         });
         if (parsed.verbose)

package/dist/utils/constants.d.ts

@@ -37,3 +37,20 @@ export declare const COMPRESSION_MARKERS: {
         b: number;
     }[];
 };
+export declare const FORMAT_MARKERS: {
+    png: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    webp: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    jxl: {
+        r: number;
+        g: number;
+        b: number;
+    };
+};

package/dist/utils/constants.js

@@ -21,3 +21,8 @@ export const COMPRESSION_MARKERS = {
     zstd: [{ r: 0, g: 255, b: 0 }],
     lzma: [{ r: 255, g: 255, b: 0 }],
 };
+export const FORMAT_MARKERS = {
+    png: { r: 0, g: 255, b: 255 },
+    webp: { r: 255, g: 0, b: 255 },
+    jxl: { r: 255, g: 255, b: 0 },
+};

package/dist/utils/decoder.js

@@ -1,5 +1,8 @@
+import { execFileSync } from 'child_process';
 import cliProgress from 'cli-progress';
-import { readFileSync } from 'fs';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import extract from 'png-chunks-extract';
 import sharp from 'sharp';
 import { unpackBuffer } from '../pack.js';
@@ -34,6 +37,52 @@ async function tryDecompress(payload, onProgress) {
         }
     }
 }
+function detectImageFormat(buf) {
+    if (buf.length < 12)
+        return 'unknown';
+    if (buf[0] === 0x89 &&
+        buf[1] === 0x50 &&
+        buf[2] === 0x4e &&
+        buf[3] === 0x47) {
+        return 'png';
+    }
+    if (buf[0] === 0x52 &&
+        buf[1] === 0x49 &&
+        buf[2] === 0x46 &&
+        buf[3] === 0x46 &&
+        buf[8] === 0x57 &&
+        buf[9] === 0x45 &&
+        buf[10] === 0x42 &&
+        buf[11] === 0x50) {
+        return 'webp';
+    }
+    if (buf[0] === 0xff && buf[1] === 0x0a) {
+        return 'jxl';
+    }
+    return 'unknown';
+}
+function convertToPng(buf, format) {
+    const tempDir = mkdtempSync(join(tmpdir(), 'rox-decode-'));
+    const inputPath = join(tempDir, format === 'webp' ? 'input.webp' : 'input.jxl');
+    const outputPath = join(tempDir, 'output.png');
+    try {
+        writeFileSync(inputPath, buf);
+        if (format === 'webp') {
+            execFileSync('dwebp', [inputPath, '-o', outputPath]);
+        }
+        else if (format === 'jxl') {
+            execFileSync('djxl', [inputPath, outputPath]);
+        }
+        const pngBuf = readFileSync(outputPath);
+        return pngBuf;
+    }
+    finally {
+        try {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
 export async function decodePngToBinary(input, opts = {}) {
     let pngBuf;
     if (Buffer.isBuffer(input)) {

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

@@ -1,2 +1,2 @@
 export declare function isRustBinaryAvailable(): boolean;
-export declare function encodeWithRustCLI(inputPath: string, outputPath: string, compressionLevel?: number, passphrase?: string, encryptType?: 'aes' | 'xor'): Promise<void>;
+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

@@ -56,7 +56,7 @@ function findRustBinary() {
 export function isRustBinaryAvailable() {
     return findRustBinary() !== null;
 }
-export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel = 3, passphrase, encryptType = 'aes') {
+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. Run: cargo build --release');
@@ -69,6 +69,9 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
             '--level',
             String(compressionLevel),
         ];
+        if (name) {
+            args.push('--name', name);
+        }
         if (passphrase) {
             args.push('--passphrase', passphrase);
             args.push('--encrypt', encryptType);

package/dist/utils/types.d.ts

@@ -45,4 +45,5 @@ export interface DecodeOptions {
         total?: number;
     }) => void;
     showProgress?: boolean;
+    verbose?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Encode binary data into PNG images and decode them back. CLI and programmatic API with native Rust acceleration.",
   "type": "module",
   "main": "dist/index.js",

package/README.md

@@ -1,391 +0,0 @@
-# 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](./CLI.md)** - Complete command-line usage guide
-- 📗 **[JavaScript SDK](./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';
-
-// Encode
-const input = readFileSync('input.zip');
-const png = await encodeBinaryToPng(input, {
-  mode: 'screenshot',
-  name: 'input.zip',
-});
-writeFileSync('output.png', png);
-
-// Decode
-const encoded = readFileSync('output.png');
-const result = await decodePngToBinary(encoded);
-writeFileSync(result.meta?.name || 'output.bin', result.buf);
-```
-
-### With Encryption
-
-```typescript
-// Encode with AES-256-GCM
-const png = await encodeBinaryToPng(input, {
-  mode: 'screenshot',
-  passphrase: 'my-secret-password',
-  encrypt: 'aes',
-  name: 'secret.zip',
-});
-
-// Decode with passphrase
-const result = await decodePngToBinary(encoded, {
-  passphrase: 'my-secret-password',
-});
-```
-
-### Fast Compression
-
-```typescript
-// Optimize for speed (recommended for large files)
-const png = await encodeBinaryToPng(largeBuffer, {
-  mode: 'screenshot',
-  brQuality: 0, // Fastest
-  name: 'large-file.bin',
-});
-
-// Optimize for size (recommended for small files)
-const png = await encodeBinaryToPng(smallBuffer, {
-  mode: 'compact',
-  brQuality: 11, // Best compression
-  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 algorithm ('br' = Brotli, 'none' = no compression)
-  compression?: 'br' | 'none';
-
-  // Passphrase for encryption
-  passphrase?: string;
-
-  // Original filename to embed
-  name?: string;
-
-  // Encoding mode
-  mode?: 'compact' | 'chunk' | 'pixel' | 'screenshot';
-
-  // Encryption method
-  encrypt?: 'auto' | 'aes' | 'xor' | 'none';
-
-  // Output format
-  output?: 'auto' | 'png' | 'rox';
-
-  // Include filename in metadata (default: true)
-  includeName?: boolean;
-
-  // Brotli quality 0-11 (default: 1)
-  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 for decryption
-  passphrase?: string;
-}
-```
-
-**Result:**
-
-```typescript
-interface DecodeResult {
-  // Decoded binary data
-  buf: Buffer;
-
-  // Extracted metadata
-  meta?: {
-    // Original filename
-    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, // 10-20x faster than default
-});
-```
-
-### 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, // Best compression ratio
-});
-```
-
-### 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/RoxCompressor)
-- [npm Package](https://www.npmjs.com/package/roxify)
-- [Report Issues](https://github.com/RoxasYTB/RoxCompressor/issues)