roxify 1.13.7 → 1.13.8

package/Cargo.toml

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

package/dist/cli.js

@@ -20,7 +20,7 @@ async function loadJsEngine() {
         VFSIndexEntry: undefined,
     };
 }
-const VERSION = '1.13.6';
+const VERSION = '1.13.8';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {

package/dist/utils/decoder.d.ts

@@ -1,7 +1,42 @@
 import { DecodeOptions, DecodeResult } from './types.js';
 /**
  * Decode a ROX PNG or buffer into the original binary payload or files list.
- * This function uses the Rust native implementation exclusively.
+ * This function extracts pixels, parses the payload header, handles encryption/decryption,
+ * decompresses with zstd, and returns the decoded buffer - all in memory.
+ *
+ * @example
+ * ```js
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { decodePngToBinary } from 'roxify';
+ *
+ * // Decode a PNG file
+ * const png = readFileSync('config.png');
+ * const result = await decodePngToBinary(png);
+ *
+ * console.log(result.buf.toString()); // Original content
+ * console.log(result.meta?.name);     // Original filename (e.g., "config.json")
+ *
+ * // Save with original filename
+ * writeFileSync(result.meta?.name || 'output.bin', result.buf);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Decode from file path
+ * const result = await decodePngToBinary('config.png');
+ * writeFileSync('output.bin', result.buf);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Handle multi-file archives
+ * const result = await decodePngToBinary(png);
+ * if (result.files) {
+ *   for (const file of result.files) {
+ *     writeFileSync(file.path, file.buf);
+ *   }
+ * }
+ * ```
  *
  * @param input - Buffer or path to a PNG file.
  * @param opts - Optional decode options.

package/dist/utils/decoder.js

@@ -1,15 +1,123 @@
 import { readFileSync } from 'fs';
 import { native } from './native.js';
 import { unpackBuffer } from '../pack.js';
+const PXL1_MAGIC = Buffer.from([0x50, 0x58, 0x4c, 0x31]); // "PXL1"
+/**
+ * Find PXL1 magic in pixel buffer
+ */
+function findPxl1Offset(pixels) {
+    for (let i = 0; i <= pixels.length - 4; i++) {
+        if (pixels[i] === 0x50 && pixels[i + 1] === 0x58 &&
+            pixels[i + 2] === 0x4c && pixels[i + 3] === 0x31) {
+            return i;
+        }
+    }
+    return -1;
+}
+/**
+ * Parse payload header and extract compressed data from pixels
+ */
+function extractPayloadFromPixels(pixels) {
+    const pos = findPxl1Offset(pixels);
+    if (pos < 0) {
+        throw new Error('PXL1 magic not found in pixels');
+    }
+    let offset = pos + 4; // Skip "PXL1"
+    // Read version (1 byte)
+    if (offset >= pixels.length) {
+        throw new Error('Truncated header: missing version');
+    }
+    const version = pixels[offset];
+    offset += 1;
+    // Read name length (1 byte)
+    if (offset >= pixels.length) {
+        throw new Error('Truncated header: missing name length');
+    }
+    const nameLen = pixels[offset];
+    offset += 1;
+    // Read name if present
+    let name;
+    if (nameLen > 0) {
+        if (offset + nameLen > pixels.length) {
+            throw new Error('Truncated header: name exceeds buffer');
+        }
+        name = pixels.subarray(offset, offset + nameLen).toString('utf8');
+        offset += nameLen;
+    }
+    // Read payload length
+    if (version === 1) {
+        if (offset + 4 > pixels.length) {
+            throw new Error('Truncated header: missing payload length (V1)');
+        }
+        const payloadLen = pixels.readUInt32BE(offset);
+        offset += 4;
+        if (offset + payloadLen > pixels.length) {
+            throw new Error('Truncated payload data');
+        }
+        const payload = pixels.subarray(offset, offset + payloadLen);
+        return { payload, name };
+    }
+    else if (version === 2) {
+        if (offset + 8 > pixels.length) {
+            throw new Error('Truncated header: missing payload length (V2)');
+        }
+        const payloadLen = Number(pixels.readBigUInt64BE(offset));
+        offset += 8;
+        if (offset + payloadLen > pixels.length) {
+            throw new Error('Truncated payload data');
+        }
+        const payload = pixels.subarray(offset, offset + payloadLen);
+        return { payload, name };
+    }
+    else {
+        throw new Error(`Unsupported header version: ${version}`);
+    }
+}
 /**
  * Decode a ROX PNG or buffer into the original binary payload or files list.
- * This function uses the Rust native implementation exclusively.
+ * This function extracts pixels, parses the payload header, handles encryption/decryption,
+ * decompresses with zstd, and returns the decoded buffer - all in memory.
+ *
+ * @example
+ * ```js
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { decodePngToBinary } from 'roxify';
+ *
+ * // Decode a PNG file
+ * const png = readFileSync('config.png');
+ * const result = await decodePngToBinary(png);
+ *
+ * console.log(result.buf.toString()); // Original content
+ * console.log(result.meta?.name);     // Original filename (e.g., "config.json")
+ *
+ * // Save with original filename
+ * writeFileSync(result.meta?.name || 'output.bin', result.buf);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Decode from file path
+ * const result = await decodePngToBinary('config.png');
+ * writeFileSync('output.bin', result.buf);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Handle multi-file archives
+ * const result = await decodePngToBinary(png);
+ * if (result.files) {
+ *   for (const file of result.files) {
+ *     writeFileSync(file.path, file.buf);
+ *   }
+ * }
+ * ```
  *
  * @param input - Buffer or path to a PNG file.
  * @param opts - Optional decode options.
  * @returns A Promise resolving to DecodeResult ({ buf, meta } or { files }).
  */
 export async function decodePngToBinary(input, opts = {}) {
+    // Get PNG buffer
     let pngBuf;
     if (Buffer.isBuffer(input)) {
         pngBuf = input;
@@ -17,51 +125,49 @@ export async function decodePngToBinary(input, opts = {}) {
     else {
         pngBuf = readFileSync(input);
     }
-    // --- Native decoder: let Rust handle extraction/decompression/decryption ---
-    const payload = Buffer.from(native.extractPayloadFromPng(pngBuf));
+    // Decode PNG to RGB pixels
+    const rgbResult = native.pngToRgb(pngBuf);
+    const pixels = Buffer.from(rgbResult.pixels);
+    // Extract payload from pixels
+    const { payload, name } = extractPayloadFromPixels(pixels);
     if (payload.length === 0) {
-        throw new Error('No payload found in PNG');
+        throw new Error('Empty payload extracted');
     }
-    // Extract name from payload header (version byte, name length, name)
-    let name;
-    let dataOffset = 0;
-    if (payload.length > 2) {
-        const version = payload[0];
-        const nameLen = payload[1];
-        dataOffset = 2;
-        if (nameLen > 0 && payload.length >= 2 + nameLen + 8) {
-            name = payload.subarray(2, 2 + nameLen).toString('utf8');
-            dataOffset = 2 + nameLen;
-        }
-        // Read payload length (8 bytes, big-endian, after name)
-        const payloadLen = Number(payload.readBigUInt64BE(dataOffset));
-        dataOffset += 8;
-        // The actual compressed/encrypted data starts at dataOffset
-        let compressedData = payload.subarray(dataOffset, dataOffset + payloadLen);
-        // Try to decompress with zstd if needed
-        let decompressed;
-        try {
-            decompressed = Buffer.from(native.nativeZstdDecompress(compressedData));
-        }
-        catch {
-            // If decompression fails, use raw data
-            decompressed = compressedData;
-        }
-        // Check for ROX1 magic
-        if (decompressed.length >= 4 && decompressed.subarray(0, 4).toString() === 'ROX1') {
-            decompressed = decompressed.subarray(4);
-        }
-        // Try to unpack as multi-file archive
-        try {
-            const unpacked = unpackBuffer(decompressed);
-            if (unpacked && unpacked.files && unpacked.files.length > 0) {
-                return { files: unpacked.files, meta: { name } };
-            }
-        }
-        catch {
-            // Fall through to raw buffer return
+    // Handle encryption flag (first byte)
+    // 0x00 = none, 0x01 = XOR, 0x02 = AES, 0x03 = AES-CTR
+    let data;
+    if (payload[0] !== 0x00) {
+        // Encrypted payload - not supported in current decoder
+        // The native encoder handles encryption, but decoder needs native decrypt support
+        throw new Error('Encrypted payload requires passphrase (not yet implemented in decoder)');
+    }
+    else {
+        // Non-encrypted: skip the flag byte
+        data = payload.subarray(1);
+    }
+    // Decompress with zstd
+    let decompressed;
+    try {
+        decompressed = Buffer.from(native.nativeZstdDecompress(data));
+    }
+    catch (e) {
+        // If decompression fails, try using raw data (might be uncompressed)
+        decompressed = data;
+    }
+    // Remove ROX1 prefix if present
+    if (decompressed.length >= 4 && decompressed.subarray(0, 4).toString() === 'ROX1') {
+        decompressed = decompressed.subarray(4);
+    }
+    // Try to unpack as multi-file archive
+    try {
+        const unpacked = unpackBuffer(decompressed);
+        if (unpacked && unpacked.files && unpacked.files.length > 0) {
+            // Return files directly as PackedFile[]
+            return { files: unpacked.files, meta: { name } };
         }
-        return { buf: decompressed, meta: { name } };
     }
-    return { buf: payload, meta: { name } };
+    catch {
+        // Not a multi-file archive, return as single buffer
+    }
+    return { buf: decompressed, meta: { name } };
 }

package/dist/utils/encoder.d.ts

@@ -1,7 +1,36 @@
 import { EncodeOptions } from './types.js';
 /**
  * Encode a buffer or array of buffers into a PNG image (ROX format).
- * This function uses the Rust native implementation exclusively.
+ * This function uses the native Rust encoder directly.
+ *
+ * @example
+ * ```js
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { encodeBinaryToPng } from 'roxify';
+ *
+ * // Encode a file with a custom filename
+ * const input = readFileSync('config.json');
+ * const png = await encodeBinaryToPng(input, { name: 'config.json' });
+ * writeFileSync('config.png', png);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Encode without filename
+ * const input = Buffer.from('Hello World');
+ * const png = await encodeBinaryToPng(input);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Encode with encryption (AES)
+ * const input = readFileSync('secret.txt');
+ * const png = await encodeBinaryToPng(input, {
+ *   name: 'secret.txt',
+ *   passphrase: 'my-secret-key',
+ *   encrypt: 'aes'
+ * });
+ * ```
  *
  * @param input - The buffer or array of buffers to encode.
  * @param opts - Optional encoding options.

package/dist/utils/encoder.js

@@ -1,31 +1,44 @@
 import { native } from './native.js';
-function normalizeNativeFileList(fileList) {
-    if (!fileList)
-        return '[]';
-    return JSON.stringify(fileList.map((entry) => {
-        if (typeof entry === 'string') {
-            return { name: entry, size: 0 };
-        }
-        if (entry && typeof entry === 'object') {
-            if (entry.name)
-                return { name: entry.name, size: entry.size ?? 0 };
-            if (entry.path)
-                return { name: entry.path, size: entry.size ?? 0 };
-        }
-        return { name: String(entry), size: 0 };
-    }));
-}
 /**
  * Encode a buffer or array of buffers into a PNG image (ROX format).
- * This function uses the Rust native implementation exclusively.
+ * This function uses the native Rust encoder directly.
+ *
+ * @example
+ * ```js
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { encodeBinaryToPng } from 'roxify';
+ *
+ * // Encode a file with a custom filename
+ * const input = readFileSync('config.json');
+ * const png = await encodeBinaryToPng(input, { name: 'config.json' });
+ * writeFileSync('config.png', png);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Encode without filename
+ * const input = Buffer.from('Hello World');
+ * const png = await encodeBinaryToPng(input);
+ * ```
+ *
+ * @example
+ * ```js
+ * // Encode with encryption (AES)
+ * const input = readFileSync('secret.txt');
+ * const png = await encodeBinaryToPng(input, {
+ *   name: 'secret.txt',
+ *   passphrase: 'my-secret-key',
+ *   encrypt: 'aes'
+ * });
+ * ```
  *
  * @param input - The buffer or array of buffers to encode.
  * @param opts - Optional encoding options.
  * @returns A Promise that resolves to a PNG Buffer containing the encoded data.
  */
 export async function encodeBinaryToPng(input, opts = {}) {
-    const compressionLevel = opts.compressionLevel ?? 19;
     const inputBuf = Array.isArray(input) ? Buffer.concat(input) : input;
+    const compressionLevel = opts.compressionLevel ?? 3;
     const fileName = opts.name || undefined;
     const fileListJson = opts.includeFileList && opts.fileList
         ? normalizeNativeFileList(opts.fileList)
@@ -54,3 +67,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
         }
     }
 }
+function normalizeNativeFileList(fileList) {
+    return JSON.stringify(fileList);
+}

package/package.json

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