roxify 1.3.2 → 1.4.1

package/dist/cli.js

@@ -6,7 +6,7 @@ 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 { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
-const VERSION = '1.3.2';
+const VERSION = '1.4.0';
 async function readLargeFile(filePath) {
     const st = statSync(filePath);
     if (st.size <= 2 * 1024 * 1024 * 1024) {
@@ -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, 3, 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, {
@@ -283,8 +284,9 @@ async function encodeCommand(args) {
         Object.assign(options, {
             mode,
             name: parsed.outputName || 'archive',
-            skipOptimization: true,
-            compressionLevel: 19,
+            skipOptimization: false,
+            compressionLevel: 12,
+            outputFormat: 'auto',
         });
         if (parsed.verbose)
             options.verbose = true;

package/dist/utils/constants.d.ts

@@ -3,6 +3,7 @@
 export declare const CHUNK_TYPE = "rXDT";
 export declare const MAGIC: Buffer;
 export declare const PIXEL_MAGIC: Buffer;
+export declare const PIXEL_MAGIC_BLOCK: Buffer;
 export declare const ENC_NONE = 0;
 export declare const ENC_AES = 1;
 export declare const ENC_XOR = 2;
@@ -36,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

@@ -1,6 +1,7 @@
 export const CHUNK_TYPE = 'rXDT';
 export const MAGIC = Buffer.from('ROX1');
 export const PIXEL_MAGIC = Buffer.from('PXL1');
+export const PIXEL_MAGIC_BLOCK = Buffer.from('BLK2');
 export const ENC_NONE = 0;
 export const ENC_AES = 1;
 export const ENC_XOR = 2;
@@ -20,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,9 +1,12 @@
+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';
-import { CHUNK_TYPE, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PNG_HEADER, } from './constants.js';
+import { CHUNK_TYPE, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
 import { DataFormatError, IncorrectPassphraseError, PassphraseRequiredError, } from './errors.js';
 import { colorsToBytes, deltaDecode, tryDecryptIfNeeded } from './helpers.js';
 import { cropAndReconstitute } from './reconstitution.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)) {
@@ -228,40 +277,93 @@ export async function decodePngToBinary(input, opts = {}) {
         const metadata = await sharp(processedBuf).metadata();
         const currentWidth = metadata.width;
         const currentHeight = metadata.height;
-        const rawRGB = Buffer.allocUnsafe(currentWidth * currentHeight * 3);
-        let writeOffset = 0;
-        const rowsPerChunk = 2000;
-        for (let startRow = 0; startRow < currentHeight; startRow += rowsPerChunk) {
-            const endRow = Math.min(startRow + rowsPerChunk, currentHeight);
-            const chunkHeight = endRow - startRow;
-            const { data: chunkData, info: chunkInfo } = await sharp(processedBuf)
+        let rawRGB = Buffer.alloc(0);
+        let isBlockEncoded = false;
+        if (currentWidth % 2 === 0 && currentHeight % 2 === 0) {
+            const { data: testData } = await sharp(processedBuf)
                 .extract({
                 left: 0,
-                top: startRow,
-                width: currentWidth,
-                height: chunkHeight,
+                top: 0,
+                width: Math.min(4, currentWidth),
+                height: Math.min(4, currentHeight),
             })
                 .raw()
                 .toBuffer({ resolveWithObject: true });
-            const channels = chunkInfo.channels;
-            const pixelsInChunk = currentWidth * chunkHeight;
-            if (channels === 3) {
-                chunkData.copy(rawRGB, writeOffset);
-                writeOffset += pixelsInChunk * 3;
-            }
-            else if (channels === 4) {
-                for (let i = 0; i < pixelsInChunk; i++) {
-                    rawRGB[writeOffset++] = chunkData[i * 4];
-                    rawRGB[writeOffset++] = chunkData[i * 4 + 1];
-                    rawRGB[writeOffset++] = chunkData[i * 4 + 2];
+            let hasBlockPattern = true;
+            for (let y = 0; y < Math.min(2, currentHeight / 2); y++) {
+                for (let x = 0; x < Math.min(2, currentWidth / 2); x++) {
+                    const px00 = (y * 2 * Math.min(4, currentWidth) + x * 2) * 3;
+                    const px01 = (y * 2 * Math.min(4, currentWidth) + (x * 2 + 1)) * 3;
+                    const px10 = ((y * 2 + 1) * Math.min(4, currentWidth) + x * 2) * 3;
+                    const px11 = ((y * 2 + 1) * Math.min(4, currentWidth) + (x * 2 + 1)) * 3;
+                    if (testData[px00] !== testData[px01] ||
+                        testData[px00] !== testData[px10] ||
+                        testData[px00] !== testData[px11] ||
+                        testData[px00 + 1] !== testData[px01 + 1] ||
+                        testData[px00 + 1] !== testData[px10 + 1] ||
+                        testData[px00 + 1] !== testData[px11 + 1]) {
+                        hasBlockPattern = false;
+                        break;
+                    }
+                }
+                if (!hasBlockPattern)
+                    break;
+            }
+            if (hasBlockPattern) {
+                isBlockEncoded = true;
+                const blocksWide = currentWidth / 2;
+                const blocksHigh = currentHeight / 2;
+                rawRGB = Buffer.alloc(blocksWide * blocksHigh * 3);
+                let outIdx = 0;
+                for (let by = 0; by < blocksHigh; by++) {
+                    for (let bx = 0; bx < blocksWide; bx++) {
+                        const { data: blockData } = await sharp(processedBuf)
+                            .extract({ left: bx * 2, top: by * 2, width: 1, height: 1 })
+                            .raw()
+                            .toBuffer({ resolveWithObject: true });
+                        rawRGB[outIdx++] = blockData[0];
+                        rawRGB[outIdx++] = blockData[1];
+                        rawRGB[outIdx++] = blockData[2];
+                    }
                 }
             }
-            if (opts.onProgress) {
-                opts.onProgress({
-                    phase: 'extract_pixels',
-                    loaded: endRow,
-                    total: currentHeight,
-                });
+        }
+        if (!isBlockEncoded) {
+            rawRGB = Buffer.allocUnsafe(currentWidth * currentHeight * 3);
+            let writeOffset = 0;
+            const rowsPerChunk = 2000;
+            for (let startRow = 0; startRow < currentHeight; startRow += rowsPerChunk) {
+                const endRow = Math.min(startRow + rowsPerChunk, currentHeight);
+                const chunkHeight = endRow - startRow;
+                const { data: chunkData, info: chunkInfo } = await sharp(processedBuf)
+                    .extract({
+                    left: 0,
+                    top: startRow,
+                    width: currentWidth,
+                    height: chunkHeight,
+                })
+                    .raw()
+                    .toBuffer({ resolveWithObject: true });
+                const channels = chunkInfo.channels;
+                const pixelsInChunk = currentWidth * chunkHeight;
+                if (channels === 3) {
+                    chunkData.copy(rawRGB, writeOffset);
+                    writeOffset += pixelsInChunk * 3;
+                }
+                else if (channels === 4) {
+                    for (let i = 0; i < pixelsInChunk; i++) {
+                        rawRGB[writeOffset++] = chunkData[i * 4];
+                        rawRGB[writeOffset++] = chunkData[i * 4 + 1];
+                        rawRGB[writeOffset++] = chunkData[i * 4 + 2];
+                    }
+                }
+                if (opts.onProgress) {
+                    opts.onProgress({
+                        phase: 'extract_pixels',
+                        loaded: endRow,
+                        total: currentHeight,
+                    });
+                }
             }
         }
         const firstPixels = [];
@@ -285,6 +387,7 @@ export async function decodePngToBinary(input, opts = {}) {
             }
         }
         let hasPixelMagic = false;
+        let hasBlockMagic = false;
         if (rawRGB.length >= 8 + PIXEL_MAGIC.length) {
             const widthFromDim = rawRGB.readUInt32BE(0);
             const heightFromDim = rawRGB.readUInt32BE(4);
@@ -293,11 +396,14 @@ export async function decodePngToBinary(input, opts = {}) {
                 rawRGB.slice(8, 8 + PIXEL_MAGIC.length).equals(PIXEL_MAGIC)) {
                 hasPixelMagic = true;
             }
+            else if (rawRGB.slice(8, 8 + PIXEL_MAGIC_BLOCK.length).equals(PIXEL_MAGIC_BLOCK)) {
+                hasBlockMagic = true;
+            }
         }
         let logicalWidth;
         let logicalHeight;
         let logicalData;
-        if (hasMarkerStart || hasPixelMagic) {
+        if (hasMarkerStart || hasPixelMagic || hasBlockMagic) {
             logicalWidth = currentWidth;
             logicalHeight = currentHeight;
             logicalData = rawRGB;
@@ -569,14 +675,24 @@ export async function decodePngToBinary(input, opts = {}) {
             let idx = 0;
             if (pixelBytes.length >= PIXEL_MAGIC.length) {
                 const at0 = pixelBytes.slice(0, PIXEL_MAGIC.length).equals(PIXEL_MAGIC);
+                const at0Block = pixelBytes
+                    .slice(0, PIXEL_MAGIC_BLOCK.length)
+                    .equals(PIXEL_MAGIC_BLOCK);
                 if (at0) {
                     idx = PIXEL_MAGIC.length;
                 }
+                else if (at0Block) {
+                    idx = PIXEL_MAGIC_BLOCK.length;
+                }
                 else {
                     const found = pixelBytes.indexOf(PIXEL_MAGIC);
+                    const foundBlock = pixelBytes.indexOf(PIXEL_MAGIC_BLOCK);
                     if (found !== -1) {
                         idx = found + PIXEL_MAGIC.length;
                     }
+                    else if (foundBlock !== -1) {
+                        idx = foundBlock + PIXEL_MAGIC_BLOCK.length;
+                    }
                 }
             }
             if (idx > 0) {

package/dist/utils/encoder.js

@@ -3,7 +3,7 @@ import { createCipheriv, pbkdf2Sync, randomBytes } from 'crypto';
 import sharp from 'sharp';
 import * as zlib from 'zlib';
 import { unpackBuffer } from '../pack.js';
-import { COMPRESSION_MARKERS, ENC_AES, ENC_NONE, ENC_XOR, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PNG_HEADER, } from './constants.js';
+import { COMPRESSION_MARKERS, ENC_AES, ENC_NONE, ENC_XOR, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
 import { crc32 } from './crc.js';
 import { colorsToBytes } from './helpers.js';
 import { optimizePngBuffer } from './optimization.js';
@@ -220,7 +220,9 @@ export async function encodeBinaryToPng(input, opts = {}) {
             lenBuf.writeUInt32BE(jsonBuf.length, 0);
             metaPixel = [...metaPixel, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf];
         }
-        const dataWithoutMarkers = [PIXEL_MAGIC, ...metaPixel];
+        const useBlockEncoding = opts.useBlockEncoding ?? true;
+        const pixelMagic = useBlockEncoding ? PIXEL_MAGIC_BLOCK : PIXEL_MAGIC;
+        const dataWithoutMarkers = [pixelMagic, ...metaPixel];
         const dataWithoutMarkersLen = dataWithoutMarkers.reduce((a, b) => a + b.length, 0);
         const padding = (3 - (dataWithoutMarkersLen % 3)) % 3;
         const paddedData = padding > 0
@@ -233,56 +235,188 @@ export async function encodeBinaryToPng(input, opts = {}) {
             compressionMarkerBytes,
             ...paddedData,
         ];
-        const bytesPerPixel = 3;
         const dataWithMarkersLen = dataWithMarkers.reduce((a, b) => a + b.length, 0);
-        const dataPixels = Math.ceil(dataWithMarkersLen / 3);
-        const totalPixels = dataPixels + MARKER_END.length;
-        const maxWidth = 16384;
-        let side = Math.ceil(Math.sqrt(totalPixels));
-        if (side < MARKER_END.length)
-            side = MARKER_END.length;
-        let logicalWidth;
-        let logicalHeight;
-        if (side <= maxWidth) {
-            logicalWidth = side;
-            logicalHeight = side;
-        }
-        else {
-            logicalWidth = Math.min(maxWidth, totalPixels);
-            logicalHeight = Math.ceil(totalPixels / logicalWidth);
-        }
-        const scale = 1;
-        const width = logicalWidth * scale;
-        const height = logicalHeight * scale;
-        const LARGE_IMAGE_PIXELS = 10000000;
-        const useManualPng = width * height > LARGE_IMAGE_PIXELS || !!process.env.ROX_FAST_PNG;
-        let raw;
-        let stride = 0;
-        if (useManualPng) {
-            stride = width * 3 + 1;
-            raw = Buffer.alloc(height * stride);
+        let width;
+        let height;
+        let bufScr;
+        if (useBlockEncoding) {
             const flatData = Buffer.concat(dataWithMarkers);
-            const markerEndBytes = Buffer.alloc(MARKER_END.length * 3);
-            for (let i = 0; i < MARKER_END.length; i++) {
-                markerEndBytes[i * 3] = MARKER_END[i].r;
-                markerEndBytes[i * 3 + 1] = MARKER_END[i].g;
-                markerEndBytes[i * 3 + 2] = MARKER_END[i].b;
-            }
-            const totalDataBytes = logicalWidth * logicalHeight * 3;
-            const fullData = Buffer.alloc(totalDataBytes);
-            const markerStartPos = (logicalHeight - 1) * logicalWidth * 3 +
-                (logicalWidth - MARKER_END.length) * 3;
-            flatData.copy(fullData, 0, 0, Math.min(flatData.length, markerStartPos));
-            markerEndBytes.copy(fullData, markerStartPos);
-            for (let row = 0; row < height; row++) {
-                raw[row * stride] = 0;
-                fullData.copy(raw, row * stride + 1, row * width * 3, (row + 1) * width * 3);
+            const blocksPerRow = Math.ceil(Math.sqrt(flatData.length));
+            const numRows = Math.ceil(flatData.length / blocksPerRow);
+            width = blocksPerRow * 2;
+            height = numRows * 2;
+            const rgbBuffer = Buffer.alloc(width * height * 3);
+            for (let i = 0; i < flatData.length; i++) {
+                const blockRow = Math.floor(i / blocksPerRow);
+                const blockCol = i % blocksPerRow;
+                const pixelRow = blockRow * 2;
+                const pixelCol = blockCol * 2;
+                const byte = flatData[i];
+                for (let dy = 0; dy < 2; dy++) {
+                    for (let dx = 0; dx < 2; dx++) {
+                        const px = (pixelRow + dy) * width + (pixelCol + dx);
+                        rgbBuffer[px * 3] = byte;
+                        rgbBuffer[px * 3 + 1] = byte;
+                        rgbBuffer[px * 3 + 2] = byte;
+                    }
+                }
             }
+            bufScr = await sharp(rgbBuffer, {
+                raw: { width, height, channels: 3 },
+            })
+                .png({
+                compressionLevel: 9,
+                adaptiveFiltering: true,
+                effort: 9,
+            })
+                .toBuffer();
         }
         else {
-            raw = Buffer.alloc(width * height * bytesPerPixel);
-            const flatData = Buffer.concat(dataWithMarkers);
-            flatData.copy(raw, 0, 0, Math.min(flatData.length, raw.length));
+            const bytesPerPixel = 3;
+            const dataPixels = Math.ceil(dataWithMarkersLen / 3);
+            const totalPixels = dataPixels + MARKER_END.length;
+            const maxWidth = 16384;
+            let side = Math.ceil(Math.sqrt(totalPixels));
+            if (side < MARKER_END.length)
+                side = MARKER_END.length;
+            let logicalWidth;
+            let logicalHeight;
+            if (side <= maxWidth) {
+                logicalWidth = side;
+                logicalHeight = side;
+            }
+            else {
+                logicalWidth = Math.min(maxWidth, totalPixels);
+                logicalHeight = Math.ceil(totalPixels / logicalWidth);
+            }
+            const scale = 1;
+            width = logicalWidth * scale;
+            height = logicalHeight * scale;
+            const LARGE_IMAGE_PIXELS = 10000000;
+            const useManualPng = (width * height > LARGE_IMAGE_PIXELS || !!process.env.ROX_FAST_PNG) &&
+                opts.outputFormat !== 'webp';
+            if (process.env.ROX_DEBUG) {
+                console.log(`[DEBUG] Width=${width}, Height=${height}, Pixels=${width * height}`);
+                console.log(`[DEBUG] outputFormat=${opts.outputFormat}, useManualPng=${useManualPng}`);
+            }
+            let raw;
+            let stride = 0;
+            if (useManualPng) {
+                stride = width * 3 + 1;
+                raw = Buffer.alloc(height * stride);
+                const flatData = Buffer.concat(dataWithMarkers);
+                const markerEndBytes = Buffer.alloc(MARKER_END.length * 3);
+                for (let i = 0; i < MARKER_END.length; i++) {
+                    markerEndBytes[i * 3] = MARKER_END[i].r;
+                    markerEndBytes[i * 3 + 1] = MARKER_END[i].g;
+                    markerEndBytes[i * 3 + 2] = MARKER_END[i].b;
+                }
+                const totalDataBytes = logicalWidth * logicalHeight * 3;
+                const fullData = Buffer.alloc(totalDataBytes);
+                const markerStartPos = (logicalHeight - 1) * logicalWidth * 3 +
+                    (logicalWidth - MARKER_END.length) * 3;
+                flatData.copy(fullData, 0, 0, Math.min(flatData.length, markerStartPos));
+                markerEndBytes.copy(fullData, markerStartPos);
+                for (let row = 0; row < height; row++) {
+                    raw[row * stride] = 0;
+                    fullData.copy(raw, row * stride + 1, row * width * 3, (row + 1) * width * 3);
+                }
+            }
+            else {
+                raw = Buffer.alloc(width * height * 3);
+                const flatData = Buffer.concat(dataWithMarkers);
+                flatData.copy(raw, 0, 0, Math.min(flatData.length, raw.length));
+            }
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'png_gen', loaded: 0, total: height });
+            if (useManualPng) {
+                const bytesPerRow = width * 3;
+                const scanlinesData = Buffer.alloc(height * (1 + bytesPerRow));
+                const progressStep = Math.max(1, Math.floor(height / 20));
+                for (let row = 0; row < height; row++) {
+                    scanlinesData[row * (1 + bytesPerRow)] = 0;
+                    const srcStart = row * stride + 1;
+                    const dstStart = row * (1 + bytesPerRow) + 1;
+                    raw.copy(scanlinesData, dstStart, srcStart, srcStart + bytesPerRow);
+                    if (opts.onProgress && row % progressStep === 0) {
+                        opts.onProgress({ phase: 'png_gen', loaded: row, total: height });
+                    }
+                }
+                if (opts.onProgress)
+                    opts.onProgress({ phase: 'png_compress', loaded: 0, total: 100 });
+                const idatData = zlib.deflateSync(scanlinesData, {
+                    level: 0,
+                    memLevel: 8,
+                    strategy: zlib.constants.Z_FILTERED,
+                });
+                raw = Buffer.alloc(0);
+                const ihdrData = Buffer.alloc(13);
+                ihdrData.writeUInt32BE(width, 0);
+                ihdrData.writeUInt32BE(height, 4);
+                ihdrData[8] = 8;
+                ihdrData[9] = 2;
+                ihdrData[10] = 0;
+                ihdrData[11] = 0;
+                ihdrData[12] = 0;
+                const ihdrType = Buffer.from('IHDR', 'utf8');
+                const ihdrCrc = crc32(ihdrData, crc32(ihdrType));
+                const ihdrCrcBuf = Buffer.alloc(4);
+                ihdrCrcBuf.writeUInt32BE(ihdrCrc, 0);
+                const ihdrLen = Buffer.alloc(4);
+                ihdrLen.writeUInt32BE(ihdrData.length, 0);
+                const idatType = Buffer.from('IDAT', 'utf8');
+                const idatCrc = crc32(idatData, crc32(idatType));
+                const idatCrcBuf = Buffer.alloc(4);
+                idatCrcBuf.writeUInt32BE(idatCrc, 0);
+                const idatLen = Buffer.alloc(4);
+                idatLen.writeUInt32BE(idatData.length, 0);
+                const iendType = Buffer.from('IEND', 'utf8');
+                const iendCrc = crc32(Buffer.alloc(0), crc32(iendType));
+                const iendCrcBuf = Buffer.alloc(4);
+                iendCrcBuf.writeUInt32BE(iendCrc, 0);
+                const iendLen = Buffer.alloc(4);
+                iendLen.writeUInt32BE(0, 0);
+                bufScr = Buffer.concat([
+                    PNG_HEADER,
+                    ihdrLen,
+                    ihdrType,
+                    ihdrData,
+                    ihdrCrcBuf,
+                    idatLen,
+                    idatType,
+                    idatData,
+                    idatCrcBuf,
+                    iendLen,
+                    iendType,
+                    iendCrcBuf,
+                ]);
+            }
+            else {
+                const outputFormat = opts.outputFormat || 'png';
+                if (outputFormat === 'webp') {
+                    bufScr = await sharp(raw, {
+                        raw: { width, height, channels: 3 },
+                    })
+                        .webp({
+                        lossless: true,
+                        quality: 100,
+                        effort: 6,
+                    })
+                        .toBuffer();
+                }
+                else {
+                    bufScr = await sharp(raw, {
+                        raw: { width, height, channels: 3 },
+                    })
+                        .png({
+                        compressionLevel: 3,
+                        palette: false,
+                        effort: 1,
+                        adaptiveFiltering: false,
+                    })
+                        .toBuffer();
+                }
+            }
         }
         payload.length = 0;
         dataWithMarkers.length = 0;
@@ -290,87 +424,9 @@ export async function encodeBinaryToPng(input, opts = {}) {
         meta.length = 0;
         paddedData.length = 0;
         dataWithoutMarkers.length = 0;
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 0, total: height });
-        let bufScr;
-        if (useManualPng) {
-            const bytesPerRow = width * 3;
-            const scanlinesData = Buffer.alloc(height * (1 + bytesPerRow));
-            const progressStep = Math.max(1, Math.floor(height / 20));
-            for (let row = 0; row < height; row++) {
-                scanlinesData[row * (1 + bytesPerRow)] = 0;
-                const srcStart = row * stride + 1;
-                const dstStart = row * (1 + bytesPerRow) + 1;
-                raw.copy(scanlinesData, dstStart, srcStart, srcStart + bytesPerRow);
-                if (opts.onProgress && row % progressStep === 0) {
-                    opts.onProgress({ phase: 'png_gen', loaded: row, total: height });
-                }
-            }
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'png_compress', loaded: 0, total: 100 });
-            const idatData = zlib.deflateSync(scanlinesData, {
-                level: 0,
-                memLevel: 8,
-                strategy: zlib.constants.Z_FILTERED,
-            });
-            raw = Buffer.alloc(0);
-            const ihdrData = Buffer.alloc(13);
-            ihdrData.writeUInt32BE(width, 0);
-            ihdrData.writeUInt32BE(height, 4);
-            ihdrData[8] = 8;
-            ihdrData[9] = 2;
-            ihdrData[10] = 0;
-            ihdrData[11] = 0;
-            ihdrData[12] = 0;
-            const ihdrType = Buffer.from('IHDR', 'utf8');
-            const ihdrCrc = crc32(ihdrData, crc32(ihdrType));
-            const ihdrCrcBuf = Buffer.alloc(4);
-            ihdrCrcBuf.writeUInt32BE(ihdrCrc, 0);
-            const ihdrLen = Buffer.alloc(4);
-            ihdrLen.writeUInt32BE(ihdrData.length, 0);
-            const idatType = Buffer.from('IDAT', 'utf8');
-            const idatCrc = crc32(idatData, crc32(idatType));
-            const idatCrcBuf = Buffer.alloc(4);
-            idatCrcBuf.writeUInt32BE(idatCrc, 0);
-            const idatLen = Buffer.alloc(4);
-            idatLen.writeUInt32BE(idatData.length, 0);
-            const iendType = Buffer.from('IEND', 'utf8');
-            const iendCrc = crc32(Buffer.alloc(0), crc32(iendType));
-            const iendCrcBuf = Buffer.alloc(4);
-            iendCrcBuf.writeUInt32BE(iendCrc, 0);
-            const iendLen = Buffer.alloc(4);
-            iendLen.writeUInt32BE(0, 0);
-            bufScr = Buffer.concat([
-                PNG_HEADER,
-                ihdrLen,
-                ihdrType,
-                ihdrData,
-                ihdrCrcBuf,
-                idatLen,
-                idatType,
-                idatData,
-                idatCrcBuf,
-                iendLen,
-                iendType,
-                iendCrcBuf,
-            ]);
-        }
-        else {
-            bufScr = await sharp(raw, {
-                raw: { width, height, channels: 3 },
-            })
-                .png({
-                compressionLevel: 3,
-                palette: false,
-                effort: 1,
-                adaptiveFiltering: false,
-            })
-                .toBuffer();
-        }
-        raw = Buffer.alloc(0);
         if (opts.onProgress)
             opts.onProgress({ phase: 'png_compress', loaded: 100, total: 100 });
-        if (opts.skipOptimization) {
+        if (opts.skipOptimization || opts.outputFormat === 'webp') {
             progressBar?.stop();
             return bufScr;
         }

package/dist/utils/helpers.d.ts

@@ -9,3 +9,10 @@ export declare function deltaEncode(data: Buffer): Buffer;
 export declare function deltaDecode(data: Buffer): Buffer;
 export declare function applyXor(buf: Buffer, passphrase: string): Buffer;
 export declare function tryDecryptIfNeeded(buf: Buffer, passphrase?: string): Buffer;
+export declare function generatePalette256(): Buffer;
+export declare function encodeDataToBlocks2x2(data: Buffer): {
+    buffer: Buffer;
+    width: number;
+    height: number;
+};
+export declare function decodeBlocksToData(indexedBuffer: Buffer, width: number, height: number): Buffer;

package/dist/utils/helpers.js

@@ -110,3 +110,43 @@ export function tryDecryptIfNeeded(buf, passphrase) {
     }
     return buf;
 }
+export function generatePalette256() {
+    const palette = Buffer.alloc(256 * 3);
+    for (let i = 0; i < 256; i++) {
+        palette[i * 3] = i;
+        palette[i * 3 + 1] = (i * 127) & 0xff;
+        palette[i * 3 + 2] = 255 - i;
+    }
+    return palette;
+}
+export function encodeDataToBlocks2x2(data) {
+    const totalBytes = data.length;
+    const totalBlocks = totalBytes;
+    const blocksPerRow = Math.ceil(Math.sqrt(totalBlocks));
+    const numRows = Math.ceil(totalBlocks / blocksPerRow);
+    const pixelWidth = blocksPerRow * 2;
+    const pixelHeight = numRows * 2;
+    const indexedBuffer = Buffer.alloc(pixelWidth * pixelHeight);
+    for (let i = 0; i < totalBytes; i++) {
+        const blockX = (i % blocksPerRow) * 2;
+        const blockY = Math.floor(i / blocksPerRow) * 2;
+        const value = data[i];
+        indexedBuffer[blockY * pixelWidth + blockX] = value;
+        indexedBuffer[blockY * pixelWidth + blockX + 1] = value;
+        indexedBuffer[(blockY + 1) * pixelWidth + blockX] = value;
+        indexedBuffer[(blockY + 1) * pixelWidth + blockX + 1] = value;
+    }
+    return { buffer: indexedBuffer, width: pixelWidth, height: pixelHeight };
+}
+export function decodeBlocksToData(indexedBuffer, width, height) {
+    const blocksPerRow = width / 2;
+    const numRows = height / 2;
+    const totalBlocks = blocksPerRow * numRows;
+    const data = Buffer.alloc(totalBlocks);
+    for (let i = 0; i < totalBlocks; i++) {
+        const blockX = (i % blocksPerRow) * 2;
+        const blockY = Math.floor(i / blocksPerRow) * 2;
+        data[i] = indexedBuffer[blockY * width + blockX];
+    }
+    return data;
+}

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

@@ -10,6 +10,7 @@ export interface EncodeOptions {
     encrypt?: 'auto' | 'aes' | 'xor' | 'none';
     _skipAuto?: boolean;
     output?: 'auto' | 'png' | 'rox';
+    outputFormat?: 'png' | 'webp';
     includeName?: boolean;
     includeFileList?: boolean;
     fileList?: Array<string | {
@@ -17,6 +18,7 @@ export interface EncodeOptions {
         size: number;
     }>;
     skipOptimization?: boolean;
+    useBlockEncoding?: boolean;
     onProgress?: (info: {
         phase: string;
         loaded?: number;
@@ -43,4 +45,5 @@ export interface DecodeOptions {
         total?: number;
     }) => void;
     showProgress?: boolean;
+    verbose?: boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.3.2",
+  "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",
@@ -22,7 +22,14 @@
     "build:cli": "cargo build --release --bin roxify_native && cp target/release/roxify_native dist/roxify-cli",
     "build:all": "npm run build:native && npm run build && npm run build:cli",
     "prepublishOnly": "npm run build:all",
-    "test": "node test/test-*.js",
+    "test": "npm run build && node test/run-all-tests.js",
+    "test:final": "node test/test-final-complete.js",
+    "test:benchmark": "node test/benchmark-large-data.js",
+    "test:stress": "node test/stress-test-datatypes.js",
+    "test:compare": "node test/compare-png-webp.js",
+    "test:formats": "node test/benchmark-image-formats.js",
+    "test:optimize": "node test/benchmark-auto-optimize.cjs",
+    "test:predict": "node test/test-fast-prediction.cjs",
     "cli": "node dist/cli.js"
   },
   "keywords": [

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)