roxify 1.13.7 → 1.13.9

package/dist/cli.js

@@ -20,7 +20,7 @@ async function loadJsEngine() {
         VFSIndexEntry: undefined,
     };
 }
-const VERSION = '1.13.6';
+const VERSION = '1.13.9';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -315,13 +315,6 @@ async function encodeCommand(args) {
         }
     }
     catch (e) { }
-    let anyInputDir = false;
-    try {
-        anyInputDir = resolvedInputs.some((p) => statSync(p).isDirectory());
-    }
-    catch (e) {
-        anyInputDir = false;
-    }
     if (isRustBinaryAvailable() && !parsed.forceTs && containerMode !== 'sound' && parsed.compression !== 'bwt-ans') {
         try {
             console.log(`Encoding to ${resolvedOutput} (Using native Rust encoder)\n`);

package/dist/stub-progress.d.ts

@@ -1,8 +1,8 @@
 export declare class SingleBar {
-    constructor(...args: any[]);
-    start(...args: any[]): void;
-    update(...args: any[]): void;
-    stop(...args: any[]): void;
+    constructor(..._args: any[]);
+    start(..._args: any[]): void;
+    update(..._args: any[]): void;
+    stop(..._args: any[]): void;
 }
 export declare const Presets: {
     shades_classic: {};

package/dist/stub-progress.js

@@ -1,8 +1,8 @@
 export class SingleBar {
-    constructor(...args) { }
-    start(...args) { }
-    update(...args) { }
-    stop(...args) { }
+    constructor(..._args) { }
+    start(..._args) { }
+    update(..._args) { }
+    stop(..._args) { }
 }
 export const Presets = {
     shades_classic: {},

package/dist/utils/decoder.d.ts

@@ -1,10 +1,54 @@
 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.
  * @returns A Promise resolving to DecodeResult ({ buf, meta } or { files }).
  */
-export declare function decodePngToBinary(input: Buffer | string, opts?: DecodeOptions): Promise<DecodeResult>;
+export declare function decodePngToBinary(input: Buffer | string, _opts?: DecodeOptions): Promise<DecodeResult>;
+/**
+ * Detect and reverse simple pixel-stretching where each logical pixel
+ * is repeated in an Fx×Fy block. Returns { width, height, data } or null.
+ */
+export declare function unstretchImage(pixels: Buffer, width: number, height: number): {
+    width: number;
+    height: number;
+    data: Buffer<ArrayBuffer>;
+} | null;

package/dist/utils/decoder.js

@@ -1,15 +1,122 @@
 import { readFileSync } from 'fs';
 import { native } from './native.js';
 import { unpackBuffer } from '../pack.js';
+/**
+ * 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 = {}) {
+export async function decodePngToBinary(input, _opts = {}) {
+    // Get PNG buffer
     let pngBuf;
     if (Buffer.isBuffer(input)) {
         pngBuf = input;
@@ -17,51 +124,154 @@ 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));
+    let name;
+    try {
+        const rgbResult = native.pngToRgb(pngBuf);
+        const pixels = Buffer.from(rgbResult.pixels);
+        ({ name } = extractPayloadFromPixels(pixels));
+    }
+    catch { }
     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;
+    // 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 } };
         }
-        // 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 {
+        // Not a multi-file archive, return as single buffer
+    }
+    return { buf: decompressed, meta: { name } };
+}
+/**
+ * Detect and reverse simple pixel-stretching where each logical pixel
+ * is repeated in an Fx×Fy block. Returns { width, height, data } or null.
+ */
+export function unstretchImage(pixels, width, height) {
+    if (!Buffer.isBuffer(pixels))
+        return null;
+    if (pixels.length !== width * height * 3)
+        return null;
+    try {
+        let allWhite = true;
+        for (let i = 0; i < pixels.length; i += 3) {
+            if (!(pixels[i] === 255 && pixels[i + 1] === 255 && pixels[i + 2] === 255)) {
+                allWhite = false;
+                break;
+            }
         }
-        catch {
-            // If decompression fails, use raw data
-            decompressed = compressedData;
+        if (allWhite)
+            return null;
+        let minX = width, minY = height, maxX = -1, maxY = -1;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = (y * width + x) * 3;
+                if (!(pixels[idx] === 255 && pixels[idx + 1] === 255 && pixels[idx + 2] === 255)) {
+                    if (x < minX)
+                        minX = x;
+                    if (y < minY)
+                        minY = y;
+                    if (x > maxX)
+                        maxX = x;
+                    if (y > maxY)
+                        maxY = y;
+                }
+            }
+        }
+        if (maxX < 0)
+            return null;
+        const cropW = maxX - minX + 1;
+        const cropH = maxY - minY + 1;
+        const colSig = [];
+        for (let x = 0; x < cropW; x++) {
+            const parts = [];
+            for (let y = 0; y < cropH; y++) {
+                const idx = ((minY + y) * width + (minX + x)) * 3;
+                parts.push(pixels[idx], pixels[idx + 1], pixels[idx + 2]);
+            }
+            colSig.push(parts.join(','));
         }
-        // Check for ROX1 magic
-        if (decompressed.length >= 4 && decompressed.subarray(0, 4).toString() === 'ROX1') {
-            decompressed = decompressed.subarray(4);
+        const colGroups = [];
+        for (let x = 0; x < colSig.length; x++) {
+            if (x === 0 || colSig[x] !== colSig[x - 1])
+                colGroups.push({ start: x, len: 1 });
+            else
+                colGroups[colGroups.length - 1].len++;
         }
-        // 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 } };
+        const rowSig = [];
+        for (let y = 0; y < cropH; y++) {
+            const parts = [];
+            for (let x = 0; x < cropW; x++) {
+                const idx = ((minY + y) * width + (minX + x)) * 3;
+                parts.push(pixels[idx], pixels[idx + 1], pixels[idx + 2]);
             }
+            rowSig.push(parts.join(','));
         }
-        catch {
-            // Fall through to raw buffer return
+        const rowGroups = [];
+        for (let y = 0; y < rowSig.length; y++) {
+            if (y === 0 || rowSig[y] !== rowSig[y - 1])
+                rowGroups.push({ start: y, len: 1 });
+            else
+                rowGroups[rowGroups.length - 1].len++;
         }
-        return { buf: decompressed, meta: { name } };
+        const outW = colGroups.length;
+        const outH = rowGroups.length;
+        const hasRun = colGroups.some(g => g.len > 1) || rowGroups.some(g => g.len > 1);
+        if (!hasRun)
+            return null;
+        const out = Buffer.alloc(outW * outH * 3);
+        for (let gy = 0; gy < outH; gy++) {
+            for (let gx = 0; gx < outW; gx++) {
+                const sx = minX + colGroups[gx].start;
+                const sy = minY + rowGroups[gy].start;
+                const baseIdx = (sy * width + sx) * 3;
+                const r = pixels[baseIdx], g = pixels[baseIdx + 1], b = pixels[baseIdx + 2];
+                for (let ry = 0; ry < rowGroups[gy].len; ry++) {
+                    for (let rx = 0; rx < colGroups[gx].len; rx++) {
+                        const ix = ((sy + ry) * width + (sx + rx)) * 3;
+                        if (pixels[ix] !== r || pixels[ix + 1] !== g || pixels[ix + 2] !== b)
+                            return null;
+                    }
+                }
+                const outIdx = (gy * outW + gx) * 3;
+                out[outIdx] = r;
+                out[outIdx + 1] = g;
+                out[outIdx + 2] = b;
+            }
+        }
+        return { width: outW, height: outH, data: out };
+    }
+    catch {
+        return null;
     }
-    return { buf: payload, meta: { name } };
 }

package/dist/utils/ecc.js

@@ -429,7 +429,6 @@ export function eccDecode(protected_) {
     // RS-decode each block
     let totalCorrected = 0;
     const decoded = [];
-    const k = dataPerBlock(nsym);
     for (let i = 0; i < numBlocks; i++) {
         const { data, corrected } = rsDecode(blocks[i], nsym);
         totalCorrected += corrected;

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/dist/utils/inspection.d.ts

@@ -1,4 +1,4 @@
-export declare function listFilesInPng(pngBuf: Buffer, opts?: {
+export declare function listFilesInPng(pngBuf: Buffer, _opts?: {
     includeSizes?: boolean;
 }): Promise<string[] | {
     name: string;

package/dist/utils/inspection.js

@@ -30,7 +30,7 @@ function tryExtractFileListFromChunks(chunks) {
     }
     return null;
 }
-export async function listFilesInPng(pngBuf, opts = {}) {
+export async function listFilesInPng(pngBuf, _opts = {}) {
     try {
         const chunks = native.extractPngChunks(pngBuf);
         const result = tryExtractFileListFromChunks(chunks);
@@ -210,7 +210,7 @@ export async function hasPassphraseInPng(pngBuf) {
                     idx += nameLen;
                     if (valid.length < idx + 4 + 1)
                         return;
-                    const payloadLen = valid.readUInt32BE(idx);
+                    valid.readUInt32BE(idx);
                     idx += 4;
                     if (valid.length < idx + 1)
                         return;

package/dist/utils/robust-audio.js

@@ -109,19 +109,6 @@ const GOERTZEL_COEFFS = CARRIERS.map(freq => {
     return { k, coeff: 2 * Math.cos(w) };
 });
 // ─── Signal Processing Primitives ───────────────────────────────────────────
-/**
- * Generate a raised-cosine windowed tone burst.
- */
-function generateTone(freq, numSamples, amplitude) {
-    const out = new Float64Array(numSamples);
-    const w = (2 * Math.PI * freq) / SAMPLE_RATE;
-    for (let n = 0; n < numSamples; n++) {
-        // Raised cosine window (Hann)
-        const window = 0.5 * (1 - Math.cos((2 * Math.PI * n) / (numSamples - 1)));
-        out[n] = amplitude * window * Math.sin(w * n);
-    }
-    return out;
-}
 /**
  * Goertzel algorithm: compute energy at a specific frequency.
  * Returns normalized power (0–1 range for unit-amplitude input).

package/dist/utils/robust-image.js

@@ -17,12 +17,8 @@ import { native } from './native.js';
 // ─── Configuration ──────────────────────────────────────────────────────────
 /** Finder pattern (7×7 blocks, like QR codes). */
 const FINDER_SIZE = 7;
-/** Alignment pattern (5×5 blocks). */
-const ALIGNMENT_SIZE = 5;
 /** Quiet zone around finder patterns (blocks). */
 const QUIET_ZONE = 1;
-/** Header area width in blocks (next to top-left finder). */
-const HEADER_BLOCKS = 20;
 /** Magic bytes for robust image format. */
 const ROBUST_IMG_MAGIC = Buffer.from('RBI1');
 // ─── Finder Pattern ─────────────────────────────────────────────────────────
@@ -43,22 +39,6 @@ function finderPattern() {
     }
     return p;
 }
-/**
- * Generate a 5×5 alignment pattern.
- */
-function alignmentPattern() {
-    const p = [];
-    for (let y = 0; y < ALIGNMENT_SIZE; y++) {
-        const row = [];
-        for (let x = 0; x < ALIGNMENT_SIZE; x++) {
-            const border = y === 0 || y === 4 || x === 0 || x === 4;
-            const center = y === 2 && x === 2;
-            row.push(border || center);
-        }
-        p.push(row);
-    }
-    return p;
-}
 /**
  * Compute grid layout: place finder patterns, quiet zones, and determine
  * which block positions are available for data.
@@ -294,12 +274,6 @@ const ECC_LEVEL_MAP = {
     quartile: 2,
     high: 3,
 };
-const ECC_LEVEL_REVERSE = {
-    0: 'low',
-    1: 'medium',
-    2: 'quartile',
-    3: 'high',
-};
 /**
  * Encode binary data into a lossy-resilient PNG image.
  *