roxify 1.2.6 → 1.2.7

package/dist/cli.js

@@ -304,7 +304,7 @@ async function encodeCommand(args) {
             for await (const chunk of inputData) {
                 chunks.push(chunk);
             }
-            inputBuffer = Buffer.concat(chunks);
+            inputBuffer = chunks;
         }
         else {
             inputBuffer = inputData;

package/dist/index.d.ts

@@ -10,4 +10,4 @@ export * from './utils/reconstitution.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { decodeMinPng, encodeMinPng } from './minpng.js';
-export { packPaths, unpackBuffer } from './pack.js';
+export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/index.js

@@ -10,4 +10,4 @@ export * from './utils/reconstitution.js';
 export * from './utils/types.js';
 export * from './utils/zstd.js';
 export { decodeMinPng, encodeMinPng } from './minpng.js';
-export { packPaths, unpackBuffer } from './pack.js';
+export { packPaths, packPathsToParts, unpackBuffer } from './pack.js';

package/dist/pack.d.ts

@@ -10,6 +10,10 @@ export interface VFSIndexEntry {
     offset: number;
     size: number;
 }
+export declare function packPathsToParts(paths: string[], baseDir?: string, onProgress?: (readBytes: number, totalBytes: number, currentFile?: string) => void): {
+    parts: Buffer[];
+    list: string[];
+};
 export declare function packPaths(paths: string[], baseDir?: string, onProgress?: (readBytes: number, totalBytes: number, currentFile?: string) => void): {
     buf: Buffer;
     list: string[];

package/dist/pack.js

@@ -14,7 +14,7 @@ function* collectFilesGenerator(paths) {
         }
     }
 }
-export function packPaths(paths, baseDir, onProgress) {
+export function packPathsToParts(paths, baseDir, onProgress) {
     const files = [];
     for (const f of collectFilesGenerator(paths)) {
         files.push(f);
@@ -48,6 +48,10 @@ export function packPaths(paths, baseDir, onProgress) {
     header.writeUInt32BE(0x524f5850, 0);
     header.writeUInt32BE(files.length, 4);
     parts.unshift(header);
+    return { parts, list };
+}
+export function packPaths(paths, baseDir, onProgress) {
+    const { parts, list } = packPathsToParts(paths, baseDir, onProgress);
     return { buf: Buffer.concat(parts), list };
 }
 export function unpackBuffer(buf, fileList) {

package/dist/utils/crc.js

@@ -16,7 +16,7 @@ export function crc32(buf, previous = 0) {
     for (let i = 0; i < buf.length; i++) {
         crc = CRC_TABLE[(crc ^ buf[i]) & 0xff] ^ (crc >>> 8);
     }
-    return crc ^ 0xffffffff;
+    return (crc ^ 0xffffffff) >>> 0;
 }
 export function adler32(buf, prev = 1) {
     let s1 = prev & 0xffff;

package/dist/utils/decoder.js

@@ -92,7 +92,7 @@ export async function decodePngToBinary(input, opts = {}) {
     try {
         const info = await sharp(pngBuf).metadata();
         if (info.width && info.height) {
-            const MAX_RAW_BYTES = 150 * 1024 * 1024;
+            const MAX_RAW_BYTES = 1200 * 1024 * 1024;
             const rawBytesEstimate = info.width * info.height * 4;
             if (rawBytesEstimate > MAX_RAW_BYTES) {
                 throw new DataFormatError(`Image too large to decode in-process (${Math.round(rawBytesEstimate / 1024 / 1024)} MB). Increase Node heap or use a smaller image/compact mode.`);
@@ -225,17 +225,44 @@ export async function decodePngToBinary(input, opts = {}) {
         return { buf: payload, meta: { name } };
     }
     try {
-        const { data, info } = await sharp(processedBuf)
-            .ensureAlpha()
-            .raw()
-            .toBuffer({ resolveWithObject: true });
-        const currentWidth = info.width;
-        const currentHeight = info.height;
-        const rawRGB = Buffer.alloc(currentWidth * currentHeight * 3);
-        for (let i = 0; i < currentWidth * currentHeight; i++) {
-            rawRGB[i * 3] = data[i * 4];
-            rawRGB[i * 3 + 1] = data[i * 4 + 1];
-            rawRGB[i * 3 + 2] = data[i * 4 + 2];
+        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)
+                .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 = [];
         for (let i = 0; i < Math.min(MARKER_START.length, rawRGB.length / 3); i++) {
@@ -278,29 +305,25 @@ export async function decodePngToBinary(input, opts = {}) {
         else {
             const reconstructed = await cropAndReconstitute(processedBuf, opts.debugDir);
             const { data: rdata, info: rinfo } = await sharp(reconstructed)
-                .ensureAlpha()
                 .raw()
                 .toBuffer({ resolveWithObject: true });
             logicalWidth = rinfo.width;
             logicalHeight = rinfo.height;
             logicalData = Buffer.alloc(rinfo.width * rinfo.height * 3);
-            for (let i = 0; i < rinfo.width * rinfo.height; i++) {
-                logicalData[i * 3] = rdata[i * 4];
-                logicalData[i * 3 + 1] = rdata[i * 4 + 1];
-                logicalData[i * 3 + 2] = rdata[i * 4 + 2];
+            if (rinfo.channels === 3) {
+                rdata.copy(logicalData);
+            }
+            else if (rinfo.channels === 4) {
+                for (let i = 0; i < logicalWidth * logicalHeight; i++) {
+                    logicalData[i * 3] = rdata[i * 4];
+                    logicalData[i * 3 + 1] = rdata[i * 4 + 1];
+                    logicalData[i * 3 + 2] = rdata[i * 4 + 2];
+                }
             }
         }
         if (process.env.ROX_DEBUG) {
             console.log('DEBUG: Logical grid reconstructed:', logicalWidth, 'x', logicalHeight, '=', logicalWidth * logicalHeight, 'pixels');
         }
-        const finalGrid = [];
-        for (let i = 0; i < logicalData.length; i += 3) {
-            finalGrid.push({
-                r: logicalData[i],
-                g: logicalData[i + 1],
-                b: logicalData[i + 2],
-            });
-        }
         if (hasPixelMagic) {
             if (logicalData.length < 8 + PIXEL_MAGIC.length) {
                 throw new DataFormatError('Pixel mode data too short');
@@ -337,15 +360,15 @@ export async function decodePngToBinary(input, opts = {}) {
             payload = payload.slice(MAGIC.length);
             return { buf: payload, meta: { name } };
         }
+        const totalPixels = (logicalData.length / 3) | 0;
         let startIdx = -1;
-        for (let i = 0; i <= finalGrid.length - MARKER_START.length; i++) {
+        for (let i = 0; i <= totalPixels - MARKER_START.length; i++) {
             let match = true;
             for (let mi = 0; mi < MARKER_START.length && match; mi++) {
-                const p = finalGrid[i + mi];
-                if (!p ||
-                    p.r !== MARKER_START[mi].r ||
-                    p.g !== MARKER_START[mi].g ||
-                    p.b !== MARKER_START[mi].b) {
+                const offset = (i + mi) * 3;
+                if (logicalData[offset] !== MARKER_START[mi].r ||
+                    logicalData[offset + 1] !== MARKER_START[mi].g ||
+                    logicalData[offset + 2] !== MARKER_START[mi].b) {
                     match = false;
                 }
             }
@@ -356,7 +379,7 @@ export async function decodePngToBinary(input, opts = {}) {
         }
         if (startIdx === -1) {
             if (process.env.ROX_DEBUG) {
-                console.log('DEBUG: MARKER_START not found in grid of', finalGrid.length, 'pixels');
+                console.log('DEBUG: MARKER_START not found in grid of', totalPixels, 'pixels');
                 console.log('DEBUG: Trying 2D scan for START marker...');
             }
             let found2D = false;
@@ -417,17 +440,20 @@ export async function decodePngToBinary(input, opts = {}) {
                         if (process.env.ROX_DEBUG) {
                             console.log(`DEBUG: Extracted rectangle: ${rectWidth}x${rectHeight} from (${x},${y})`);
                         }
-                        finalGrid.length = 0;
+                        const newDataLen = rectWidth * rectHeight * 3;
+                        const newData = Buffer.allocUnsafe(newDataLen);
+                        let writeIdx = 0;
                         for (let ry = y; ry <= endY; ry++) {
                             for (let rx = x; rx <= endX; rx++) {
                                 const idx = (ry * logicalWidth + rx) * 3;
-                                finalGrid.push({
-                                    r: logicalData[idx],
-                                    g: logicalData[idx + 1],
-                                    b: logicalData[idx + 2],
-                                });
+                                newData[writeIdx++] = logicalData[idx];
+                                newData[writeIdx++] = logicalData[idx + 1];
+                                newData[writeIdx++] = logicalData[idx + 2];
                             }
                         }
+                        logicalData = newData;
+                        logicalWidth = rectWidth;
+                        logicalHeight = rectHeight;
                         startIdx = 0;
                         found2D = true;
                     }
@@ -435,34 +461,43 @@ export async function decodePngToBinary(input, opts = {}) {
             }
             if (!found2D) {
                 if (process.env.ROX_DEBUG) {
-                    console.log('DEBUG: First 20 pixels:', finalGrid
-                        .slice(0, 20)
-                        .map((p) => `(${p.r},${p.g},${p.b})`)
-                        .join(' '));
+                    const first20 = [];
+                    for (let i = 0; i < Math.min(20, totalPixels); i++) {
+                        const offset = i * 3;
+                        first20.push(`(${logicalData[offset]},${logicalData[offset + 1]},${logicalData[offset + 2]})`);
+                    }
+                    console.log('DEBUG: First 20 pixels:', first20.join(' '));
                 }
                 throw new Error('Marker START not found - image format not supported');
             }
         }
         if (process.env.ROX_DEBUG && startIdx === 0) {
-            console.log(`DEBUG: MARKER_START at index ${startIdx}, grid size: ${finalGrid.length}`);
+            console.log(`DEBUG: MARKER_START at index ${startIdx}, grid size: ${totalPixels}`);
         }
-        const gridFromStart = finalGrid.slice(startIdx);
-        if (gridFromStart.length < MARKER_START.length + MARKER_END.length) {
+        const dataStartPixel = startIdx + MARKER_START.length + 1;
+        const curTotalPixels = (logicalData.length / 3) | 0;
+        if (curTotalPixels < dataStartPixel + MARKER_END.length) {
             if (process.env.ROX_DEBUG) {
-                console.log('DEBUG: gridFromStart too small:', gridFromStart.length, 'pixels');
+                console.log('DEBUG: grid too small:', curTotalPixels, 'pixels');
             }
             throw new Error('Marker START or END not found - image format not supported');
         }
         for (let i = 0; i < MARKER_START.length; i++) {
-            if (gridFromStart[i].r !== MARKER_START[i].r ||
-                gridFromStart[i].g !== MARKER_START[i].g ||
-                gridFromStart[i].b !== MARKER_START[i].b) {
+            const offset = (startIdx + i) * 3;
+            if (logicalData[offset] !== MARKER_START[i].r ||
+                logicalData[offset + 1] !== MARKER_START[i].g ||
+                logicalData[offset + 2] !== MARKER_START[i].b) {
                 throw new Error('Marker START not found - image format not supported');
             }
         }
         let compression = 'zstd';
-        if (gridFromStart.length > MARKER_START.length) {
-            const compPixel = gridFromStart[MARKER_START.length];
+        if (curTotalPixels > startIdx + MARKER_START.length) {
+            const compOffset = (startIdx + MARKER_START.length) * 3;
+            const compPixel = {
+                r: logicalData[compOffset],
+                g: logicalData[compOffset + 1],
+                b: logicalData[compOffset + 2],
+            };
             if (compPixel.r === 0 && compPixel.g === 255 && compPixel.b === 0) {
                 compression = 'zstd';
             }
@@ -473,47 +508,51 @@ export async function decodePngToBinary(input, opts = {}) {
         if (process.env.ROX_DEBUG) {
             console.log(`DEBUG: Detected compression: ${compression}`);
         }
-        let endStartIdx = -1;
+        let endStartPixel = -1;
         const lastLineStart = (logicalHeight - 1) * logicalWidth;
         const endMarkerStartCol = logicalWidth - MARKER_END.length;
-        if (lastLineStart + endMarkerStartCol < finalGrid.length) {
+        if (lastLineStart + endMarkerStartCol < curTotalPixels) {
             let matchEnd = true;
             for (let mi = 0; mi < MARKER_END.length && matchEnd; mi++) {
-                const idx = lastLineStart + endMarkerStartCol + mi;
-                if (idx >= finalGrid.length) {
+                const pixelIdx = lastLineStart + endMarkerStartCol + mi;
+                if (pixelIdx >= curTotalPixels) {
                     matchEnd = false;
                     break;
                 }
-                const p = finalGrid[idx];
-                if (p.r !== MARKER_END[mi].r ||
-                    p.g !== MARKER_END[mi].g ||
-                    p.b !== MARKER_END[mi].b) {
+                const offset = pixelIdx * 3;
+                if (logicalData[offset] !== MARKER_END[mi].r ||
+                    logicalData[offset + 1] !== MARKER_END[mi].g ||
+                    logicalData[offset + 2] !== MARKER_END[mi].b) {
                     matchEnd = false;
                 }
             }
             if (matchEnd) {
-                endStartIdx = lastLineStart + endMarkerStartCol - startIdx;
+                endStartPixel = lastLineStart + endMarkerStartCol - startIdx;
                 if (process.env.ROX_DEBUG) {
                     console.log(`DEBUG: Found END marker at last line, col ${endMarkerStartCol}`);
                 }
             }
         }
-        if (endStartIdx === -1) {
+        if (endStartPixel === -1) {
             if (process.env.ROX_DEBUG) {
                 console.log('DEBUG: END marker not found at expected position');
-                console.log('DEBUG: Last line pixels:', finalGrid
-                    .slice(Math.max(0, lastLineStart), finalGrid.length)
-                    .map((p) => `(${p.r},${p.g},${p.b})`)
-                    .join(' '));
-            }
-            endStartIdx = gridFromStart.length;
-        }
-        const dataGrid = gridFromStart.slice(MARKER_START.length + 1, endStartIdx);
-        const pixelBytes = Buffer.alloc(dataGrid.length * 3);
-        for (let i = 0; i < dataGrid.length; i++) {
-            pixelBytes[i * 3] = dataGrid[i].r;
-            pixelBytes[i * 3 + 1] = dataGrid[i].g;
-            pixelBytes[i * 3 + 2] = dataGrid[i].b;
+                const lastLinePixels = [];
+                for (let i = Math.max(0, lastLineStart); i < curTotalPixels && i < lastLineStart + 20; i++) {
+                    const offset = i * 3;
+                    lastLinePixels.push(`(${logicalData[offset]},${logicalData[offset + 1]},${logicalData[offset + 2]})`);
+                }
+                console.log('DEBUG: Last line pixels:', lastLinePixels.join(' '));
+            }
+            endStartPixel = curTotalPixels - startIdx;
+        }
+        const dataPixelCount = endStartPixel - (MARKER_START.length + 1);
+        const pixelBytes = Buffer.allocUnsafe(dataPixelCount * 3);
+        for (let i = 0; i < dataPixelCount; i++) {
+            const srcOffset = (dataStartPixel + i) * 3;
+            const dstOffset = i * 3;
+            pixelBytes[dstOffset] = logicalData[srcOffset];
+            pixelBytes[dstOffset + 1] = logicalData[srcOffset + 1];
+            pixelBytes[dstOffset + 2] = logicalData[srcOffset + 2];
         }
         if (process.env.ROX_DEBUG) {
             console.log('DEBUG: extracted len', pixelBytes.length);

package/dist/utils/encoder.d.ts

@@ -1,4 +1,4 @@
 /// <reference types="node" />
 /// <reference types="node" />
 import { EncodeOptions } from './types.js';
-export declare function encodeBinaryToPng(input: Buffer, opts?: EncodeOptions): Promise<Buffer>;
+export declare function encodeBinaryToPng(input: Buffer | Buffer[], opts?: EncodeOptions): Promise<Buffer>;

package/dist/utils/encoder.js

@@ -1,11 +1,11 @@
 import cliProgress from 'cli-progress';
 import { createCipheriv, pbkdf2Sync, randomBytes } from 'crypto';
-import encode from 'png-chunks-encode';
 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, PNG_HEADER_HEX, } from './constants.js';
-import { applyXor, colorsToBytes } from './helpers.js';
+import { COMPRESSION_MARKERS, ENC_AES, ENC_NONE, ENC_XOR, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PNG_HEADER, } from './constants.js';
+import { crc32 } from './crc.js';
+import { colorsToBytes } from './helpers.js';
 import { optimizePngBuffer } from './optimization.js';
 import { parallelZstdCompress } from './zstd.js';
 export async function encodeBinaryToPng(input, opts = {}) {
@@ -41,11 +41,19 @@ export async function encodeBinaryToPng(input, opts = {}) {
             };
         }
     }
-    let payload = Buffer.concat([MAGIC, input]);
+    let payloadInput;
+    let totalLen = 0;
+    if (Array.isArray(input)) {
+        payloadInput = [MAGIC, ...input];
+        totalLen = MAGIC.length + input.reduce((a, b) => a + b.length, 0);
+    }
+    else {
+        payloadInput = [MAGIC, input];
+        totalLen = MAGIC.length + input.length;
+    }
     if (opts.onProgress)
-        opts.onProgress({ phase: 'compress_start', total: payload.length });
-    const deltaEncoded = payload;
-    payload = await parallelZstdCompress(deltaEncoded, 19, (loaded, total) => {
+        opts.onProgress({ phase: 'compress_start', total: totalLen });
+    let payload = await parallelZstdCompress(payloadInput, 15, (loaded, total) => {
         if (opts.onProgress) {
             opts.onProgress({
                 phase: 'compress_progress',
@@ -56,6 +64,9 @@ export async function encodeBinaryToPng(input, opts = {}) {
     });
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_done', loaded: payload.length });
+    if (Array.isArray(input)) {
+        input.length = 0;
+    }
     if (opts.passphrase && !opts.encrypt) {
         opts.encrypt = 'aes';
     }
@@ -83,29 +94,44 @@ export async function encodeBinaryToPng(input, opts = {}) {
             const PBKDF2_ITERS = 1000000;
             const key = pbkdf2Sync(opts.passphrase, salt, PBKDF2_ITERS, 32, 'sha256');
             const cipher = createCipheriv('aes-256-gcm', key, iv);
-            const enc = Buffer.concat([cipher.update(payload), cipher.final()]);
+            const encParts = [];
+            for (const chunk of payload) {
+                encParts.push(cipher.update(chunk));
+            }
+            encParts.push(cipher.final());
             const tag = cipher.getAuthTag();
-            payload = Buffer.concat([Buffer.from([ENC_AES]), salt, iv, tag, enc]);
+            payload = [Buffer.from([ENC_AES]), salt, iv, tag, ...encParts];
             if (opts.onProgress)
                 opts.onProgress({ phase: 'encrypt_done' });
         }
         else if (encChoice === 'xor') {
-            const xored = applyXor(payload, opts.passphrase);
-            payload = Buffer.concat([Buffer.from([ENC_XOR]), xored]);
+            const xoredParts = [];
+            let offset = 0;
+            const keyBuf = Buffer.from(opts.passphrase, 'utf8');
+            for (const chunk of payload) {
+                const out = Buffer.alloc(chunk.length);
+                for (let i = 0; i < chunk.length; i++) {
+                    out[i] = chunk[i] ^ keyBuf[(offset + i) % keyBuf.length];
+                }
+                offset += chunk.length;
+                xoredParts.push(out);
+            }
+            payload = [Buffer.from([ENC_XOR]), ...xoredParts];
             if (opts.onProgress)
                 opts.onProgress({ phase: 'encrypt_done' });
         }
         else if (encChoice === 'none') {
-            payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
+            payload = [Buffer.from([ENC_NONE]), ...payload];
             if (opts.onProgress)
                 opts.onProgress({ phase: 'encrypt_done' });
         }
     }
     else {
-        payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
+        payload = [Buffer.from([ENC_NONE]), ...payload];
     }
+    const payloadTotalLen = payload.reduce((a, b) => a + b.length, 0);
     if (opts.onProgress)
-        opts.onProgress({ phase: 'meta_prep_done', loaded: payload.length });
+        opts.onProgress({ phase: 'meta_prep_done', loaded: payloadTotalLen });
     const metaParts = [];
     const includeName = opts.includeName === undefined ? true : !!opts.includeName;
     if (includeName && opts.name) {
@@ -116,19 +142,20 @@ export async function encodeBinaryToPng(input, opts = {}) {
     else {
         metaParts.push(Buffer.from([0]));
     }
-    metaParts.push(payload);
-    let meta = Buffer.concat(metaParts);
+    let meta = [...metaParts, ...payload];
     if (opts.includeFileList && opts.fileList) {
         let sizeMap = null;
-        try {
-            const unpack = unpackBuffer(input);
-            if (unpack) {
-                sizeMap = {};
-                for (const ef of unpack.files)
-                    sizeMap[ef.path] = ef.buf.length;
+        if (!Array.isArray(input)) {
+            try {
+                const unpack = unpackBuffer(input);
+                if (unpack) {
+                    sizeMap = {};
+                    for (const ef of unpack.files)
+                        sizeMap[ef.path] = ef.buf.length;
+                }
             }
+            catch (e) { }
         }
-        catch (e) { }
         const normalized = opts.fileList.map((f) => {
             if (typeof f === 'string')
                 return { name: f, size: sizeMap && sizeMap[f] ? sizeMap[f] : 0 };
@@ -143,10 +170,10 @@ export async function encodeBinaryToPng(input, opts = {}) {
         const jsonBuf = Buffer.from(JSON.stringify(normalized), 'utf8');
         const lenBuf = Buffer.alloc(4);
         lenBuf.writeUInt32BE(jsonBuf.length, 0);
-        meta = Buffer.concat([meta, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf]);
+        meta = [...meta, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf];
     }
     if (opts.output === 'rox') {
-        return Buffer.concat([MAGIC, meta]);
+        return Buffer.concat([MAGIC, ...meta]);
     }
     {
         const nameBuf = opts.name
@@ -154,26 +181,28 @@ export async function encodeBinaryToPng(input, opts = {}) {
             : Buffer.alloc(0);
         const nameLen = nameBuf.length;
         const payloadLenBuf = Buffer.alloc(4);
-        payloadLenBuf.writeUInt32BE(payload.length, 0);
+        payloadLenBuf.writeUInt32BE(payloadTotalLen, 0);
         const version = 1;
-        let metaPixel = Buffer.concat([
+        let metaPixel = [
             Buffer.from([version]),
             Buffer.from([nameLen]),
             nameBuf,
             payloadLenBuf,
-            payload,
-        ]);
+            ...payload,
+        ];
         if (opts.includeFileList && opts.fileList) {
             let sizeMap2 = null;
-            try {
-                const unpack = unpackBuffer(input);
-                if (unpack) {
-                    sizeMap2 = {};
-                    for (const ef of unpack.files)
-                        sizeMap2[ef.path] = ef.buf.length;
+            if (!Array.isArray(input)) {
+                try {
+                    const unpack = unpackBuffer(input);
+                    if (unpack) {
+                        sizeMap2 = {};
+                        for (const ef of unpack.files)
+                            sizeMap2[ef.path] = ef.buf.length;
+                    }
                 }
+                catch (e) { }
             }
-            catch (e) { }
             const normalized = opts.fileList.map((f) => {
                 if (typeof f === 'string')
                     return { name: f, size: sizeMap2 && sizeMap2[f] ? sizeMap2[f] : 0 };
@@ -188,27 +217,24 @@ export async function encodeBinaryToPng(input, opts = {}) {
             const jsonBuf = Buffer.from(JSON.stringify(normalized), 'utf8');
             const lenBuf = Buffer.alloc(4);
             lenBuf.writeUInt32BE(jsonBuf.length, 0);
-            metaPixel = Buffer.concat([
-                metaPixel,
-                Buffer.from('rXFL', 'utf8'),
-                lenBuf,
-                jsonBuf,
-            ]);
+            metaPixel = [...metaPixel, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf];
         }
-        const dataWithoutMarkers = Buffer.concat([PIXEL_MAGIC, metaPixel]);
-        const padding = (3 - (dataWithoutMarkers.length % 3)) % 3;
+        const dataWithoutMarkers = [PIXEL_MAGIC, ...metaPixel];
+        const dataWithoutMarkersLen = dataWithoutMarkers.reduce((a, b) => a + b.length, 0);
+        const padding = (3 - (dataWithoutMarkersLen % 3)) % 3;
         const paddedData = padding > 0
-            ? Buffer.concat([dataWithoutMarkers, Buffer.alloc(padding)])
+            ? [...dataWithoutMarkers, Buffer.alloc(padding)]
             : dataWithoutMarkers;
         const markerStartBytes = colorsToBytes(MARKER_START);
         const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);
-        const dataWithMarkers = Buffer.concat([
+        const dataWithMarkers = [
             markerStartBytes,
             compressionMarkerBytes,
-            paddedData,
-        ]);
+            ...paddedData,
+        ];
         const bytesPerPixel = 3;
-        const dataPixels = Math.ceil(dataWithMarkers.length / 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));
@@ -227,8 +253,37 @@ export async function encodeBinaryToPng(input, opts = {}) {
         const scale = 1;
         const width = logicalWidth * scale;
         const height = logicalHeight * scale;
-        const raw = Buffer.alloc(width * height * bytesPerPixel);
+        const LARGE_IMAGE_PIXELS = 50000000;
+        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);
+        }
+        else {
+            raw = Buffer.alloc(width * height * bytesPerPixel);
+        }
+        let currentBufIdx = 0;
+        let currentBufOffset = 0;
+        const getNextByte = () => {
+            while (currentBufIdx < dataWithMarkers.length) {
+                const buf = dataWithMarkers[currentBufIdx];
+                if (currentBufOffset < buf.length) {
+                    return buf[currentBufOffset++];
+                }
+                currentBufIdx++;
+                currentBufOffset = 0;
+            }
+            return 0;
+        };
         for (let ly = 0; ly < logicalHeight; ly++) {
+            if (useManualPng) {
+                for (let sy = 0; sy < scale; sy++) {
+                    const py = ly * scale + sy;
+                    raw[py * stride] = 0;
+                }
+            }
             for (let lx = 0; lx < logicalWidth; lx++) {
                 const linearIdx = ly * logicalWidth + lx;
                 let r = 0, g = 0, b = 0;
@@ -240,107 +295,126 @@ export async function encodeBinaryToPng(input, opts = {}) {
                     b = MARKER_END[markerIdx].b;
                 }
                 else if (linearIdx < dataPixels) {
-                    const srcIdx = linearIdx * 3;
-                    r = srcIdx < dataWithMarkers.length ? dataWithMarkers[srcIdx] : 0;
-                    g =
-                        srcIdx + 1 < dataWithMarkers.length
-                            ? dataWithMarkers[srcIdx + 1]
-                            : 0;
-                    b =
-                        srcIdx + 2 < dataWithMarkers.length
-                            ? dataWithMarkers[srcIdx + 2]
-                            : 0;
+                    r = getNextByte();
+                    g = getNextByte();
+                    b = getNextByte();
                 }
                 for (let sy = 0; sy < scale; sy++) {
                     for (let sx = 0; sx < scale; sx++) {
                         const px = lx * scale + sx;
                         const py = ly * scale + sy;
-                        const dstIdx = (py * width + px) * 3;
-                        raw[dstIdx] = r;
-                        raw[dstIdx + 1] = g;
-                        raw[dstIdx + 2] = b;
+                        if (useManualPng) {
+                            const dstIdx = py * stride + 1 + px * 3;
+                            raw[dstIdx] = r;
+                            raw[dstIdx + 1] = g;
+                            raw[dstIdx + 2] = b;
+                        }
+                        else {
+                            const dstIdx = (py * width + px) * 3;
+                            raw[dstIdx] = r;
+                            raw[dstIdx + 1] = g;
+                            raw[dstIdx + 2] = b;
+                        }
                     }
                 }
             }
         }
+        payload.length = 0;
+        dataWithMarkers.length = 0;
+        metaPixel.length = 0;
+        meta.length = 0;
+        paddedData.length = 0;
+        dataWithoutMarkers.length = 0;
         if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 0, total: 100 });
-        let loaded = 0;
-        const progressInterval = setInterval(() => {
-            loaded = Math.min(loaded + 2, 98);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'png_gen', loaded, total: 100 });
-        }, 50);
+            opts.onProgress({ phase: 'png_gen', loaded: 0, total: height });
         let bufScr;
-        const LARGE_IMAGE_PIXELS = 50000000;
-        if (width * height > LARGE_IMAGE_PIXELS || process.env.ROX_FAST_PNG) {
-            const idatData = zlib.deflateSync(raw, {
-                level: 6,
+        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: 3,
                 memLevel: 8,
                 strategy: zlib.constants.Z_DEFAULT_STRATEGY,
             });
-            const ihdrData2 = Buffer.alloc(13);
-            ihdrData2.writeUInt32BE(width, 0);
-            ihdrData2.writeUInt32BE(height, 4);
-            ihdrData2[8] = 8;
-            ihdrData2[9] = 2;
-            ihdrData2[10] = 0;
-            ihdrData2[11] = 0;
-            ihdrData2[12] = 0;
-            const chunks2 = [];
-            chunks2.push({ name: 'IHDR', data: ihdrData2 });
-            chunks2.push({ name: 'IDAT', data: idatData });
-            chunks2.push({ name: 'IEND', data: Buffer.alloc(0) });
-            const tmp = Buffer.from(encode(chunks2));
-            bufScr =
-                tmp.slice(0, 8).toString('hex') === PNG_HEADER_HEX
-                    ? tmp
-                    : Buffer.concat([PNG_HEADER, tmp]);
+            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: 6,
+                compressionLevel: 3,
                 palette: false,
                 effort: 1,
                 adaptiveFiltering: false,
             })
                 .toBuffer();
         }
+        raw = Buffer.alloc(0);
         if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 100, total: 100 });
+            opts.onProgress({ phase: 'png_compress', loaded: 100, total: 100 });
         if (opts.onProgress)
             opts.onProgress({ phase: 'optimizing', loaded: 0, total: 100 });
-        let optInterval = null;
-        if (opts.onProgress) {
-            let optLoaded = 0;
-            optInterval = setInterval(() => {
-                optLoaded = Math.min(optLoaded + 5, 95);
-                opts.onProgress?.({
-                    phase: 'optimizing',
-                    loaded: optLoaded,
-                    total: 100,
-                });
-            }, 100);
-        }
         try {
             const optimized = await optimizePngBuffer(bufScr, true);
-            clearInterval(progressInterval);
-            if (optInterval) {
-                clearInterval(optInterval);
-                optInterval = null;
-            }
             if (opts.onProgress)
                 opts.onProgress({ phase: 'optimizing', loaded: 100, total: 100 });
             progressBar?.stop();
             return optimized;
         }
         catch (e) {
-            clearInterval(progressInterval);
-            if (optInterval)
-                clearInterval(optInterval);
             progressBar?.stop();
             return bufScr;
         }

package/dist/utils/optimization.js

@@ -7,6 +7,10 @@ import extract from 'png-chunks-extract';
 import * as zlib from 'zlib';
 import { PNG_HEADER, PNG_HEADER_HEX } from './constants.js';
 export async function optimizePngBuffer(pngBuf, fast = false) {
+    const MAX_OPTIMIZE_SIZE = 50 * 1024 * 1024;
+    if (pngBuf.length > MAX_OPTIMIZE_SIZE) {
+        return pngBuf;
+    }
     const runCommandAsync = (cmd, args, timeout = 120000) => {
         return new Promise((resolve) => {
             try {

package/dist/utils/zstd.d.ts

@@ -4,7 +4,7 @@ export declare function compressStream(stream: AsyncGenerator<Buffer>, level?: n
     chunks: Buffer[];
     totalLength: number;
 }>;
-export declare function parallelZstdCompress(payload: Buffer, level?: number, onProgress?: (loaded: number, total: number) => void): Promise<Buffer>;
+export declare function parallelZstdCompress(payload: Buffer | Buffer[], level?: number, onProgress?: (loaded: number, total: number) => void): Promise<Buffer[]>;
 export declare function parallelZstdDecompress(payload: Buffer, onProgress?: (info: {
     phase: string;
     loaded?: number;

package/dist/utils/zstd.js

@@ -26,22 +26,35 @@ export async function compressStream(stream, level = 19, onProgress) {
 }
 export async function parallelZstdCompress(payload, level = 19, onProgress) {
     const chunkSize = 8 * 1024 * 1024;
-    if (payload.length <= chunkSize) {
-        if (onProgress)
-            onProgress(0, 1);
-        const result = await zstdCompress(payload, level);
-        if (onProgress)
-            onProgress(1, 1);
-        return Buffer.from(result);
-    }
     const chunks = [];
-    for (let i = 0; i < payload.length; i += chunkSize) {
-        const chunk = payload.subarray(i, Math.min(i + chunkSize, payload.length));
-        chunks.push(chunk);
+    if (Array.isArray(payload)) {
+        for (const p of payload) {
+            if (p.length <= chunkSize) {
+                chunks.push(p);
+            }
+            else {
+                for (let i = 0; i < p.length; i += chunkSize) {
+                    chunks.push(p.subarray(i, Math.min(i + chunkSize, p.length)));
+                }
+            }
+        }
+    }
+    else {
+        if (payload.length <= chunkSize) {
+            if (onProgress)
+                onProgress(0, 1);
+            const result = await zstdCompress(payload, level);
+            if (onProgress)
+                onProgress(1, 1);
+            return [Buffer.from(result)];
+        }
+        for (let i = 0; i < payload.length; i += chunkSize) {
+            chunks.push(payload.subarray(i, Math.min(i + chunkSize, payload.length)));
+        }
     }
     const totalChunks = chunks.length;
     let completedChunks = 0;
-    const concurrency = Math.max(1, Math.min(8, cpus().length));
+    const concurrency = Math.max(1, Math.min(4, cpus().length));
     const compressedChunks = new Array(totalChunks);
     let idx = 0;
     const worker = async () => {
@@ -65,7 +78,7 @@ export async function parallelZstdCompress(payload, level = 19, onProgress) {
     const header = Buffer.alloc(8);
     header.writeUInt32BE(0x5a535444, 0);
     header.writeUInt32BE(compressedChunks.length, 4);
-    return Buffer.concat([header, chunkSizes, ...compressedChunks]);
+    return [header, chunkSizes, ...compressedChunks];
 }
 export async function parallelZstdDecompress(payload, onProgress) {
     if (payload.length < 8) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "Encode binary data into PNG images with Zstd compression and decode them back. Supports CLI and programmatic API (Node.js ESM).",
   "type": "module",
   "main": "dist/index.js",