roxify 1.3.1 → 1.4.0

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.1';
+const VERSION = '1.4.0';
 async function readLargeFile(filePath) {
     const st = statSync(filePath);
     if (st.size <= 2 * 1024 * 1024 * 1024) {
@@ -211,7 +211,7 @@ 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);
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 19, parsed.passphrase, encryptType);
             clearInterval(progressInterval);
             const encodeTime = Date.now() - startTime;
             encodeBar.update(100, {
@@ -283,8 +283,9 @@ async function encodeCommand(args) {
         Object.assign(options, {
             mode,
             name: parsed.outputName || 'archive',
-            skipOptimization: true,
+            skipOptimization: false,
             compressionLevel: 19,
+            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;

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;

package/dist/utils/decoder.js

@@ -3,7 +3,7 @@ import { readFileSync } from 'fs';
 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';
@@ -228,40 +228,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 (opts.onProgress) {
-                opts.onProgress({
-                    phase: 'extract_pixels',
-                    loaded: endRow,
-                    total: currentHeight,
-                });
+            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 (!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 +338,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 +347,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 +626,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.js

@@ -5,16 +5,52 @@ import { fileURLToPath } from 'url';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 function findRustBinary() {
-    const possiblePaths = [
-        join(__dirname, '..', '..', 'target', 'release', 'roxify_native'),
-        join(__dirname, '..', 'dist', 'roxify-cli'),
-        '/usr/local/bin/roxify_native',
+    const candidates = [];
+    const binNames = process.platform === 'win32'
+        ? ['roxify-cli.exe', 'roxify_cli.exe', 'roxify_native.exe']
+        : ['roxify-cli', 'roxify_cli', 'roxify_native'];
+    // Possible locations relative to this file (works in repo and in packaged dist)
+    const relativeDirs = [
+        join(__dirname, '..', '..', 'target', 'release'),
+        join(__dirname, '..', '..', 'dist'),
+        join(__dirname, '..'),
+        join(__dirname, '..', '..'),
     ];
-    for (const path of possiblePaths) {
-        if (existsSync(path)) {
-            return path;
+    for (const dir of relativeDirs) {
+        for (const name of binNames) {
+            candidates.push(join(dir, name));
         }
     }
+    // Common global paths
+    if (process.platform !== 'win32') {
+        candidates.push('/usr/local/bin/roxify_native');
+        candidates.push('/usr/bin/roxify_native');
+    }
+    for (const p of candidates) {
+        try {
+            if (existsSync(p))
+                return p;
+        }
+        catch (e) { }
+    }
+    // Search in PATH for common binary names
+    try {
+        const which = process.platform === 'win32' ? 'where' : 'which';
+        const { execSync } = require('child_process');
+        for (const name of binNames) {
+            try {
+                const out = execSync(`${which} ${name}`, { encoding: 'utf-8' })
+                    .split('\n')[0]
+                    .trim();
+                if (out && existsSync(out))
+                    return out;
+            }
+            catch (e) {
+                // ignore
+            }
+        }
+    }
+    catch (e) { }
     return null;
 }
 export function isRustBinaryAvailable() {

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.3.1",
+  "version": "1.4.0",
   "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": [