roxify 1.2.5 → 1.2.7

package/dist/cli.js

@@ -4,7 +4,7 @@ import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join, resolve } from 'path';
 import { DataFormatError, decodePngToBinary, encodeBinaryToPng, hasPassphraseInPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
 import { packPathsGenerator, unpackBuffer } from './pack.js';
-const VERSION = '1.2.4';
+const VERSION = '1.2.6';
 function showHelp() {
     console.log(`
 ROX CLI — Encode/decode binary in PNG
@@ -24,6 +24,8 @@ Options:
   -e, --encrypt <type>      auto|aes|xor|none
   --no-compress             Disable compression
   -o, --output <path>       Output file path
+  -s, --sizes               Show file sizes in 'list' output (default)
+  --no-sizes                Disable file size reporting in 'list'
   --files <list>            Extract only specified files (comma-separated)
   --view-reconst            Export the reconstituted PNG for debugging
   --debug                   Export debug images (doubled.png, reconstructed.png)
@@ -51,6 +53,14 @@ function parseArgs(args) {
                 parsed.viewReconst = true;
                 i++;
             }
+            else if (key === 'sizes') {
+                parsed.sizes = true;
+                i++;
+            }
+            else if (key === 'no-sizes') {
+                parsed.sizes = false;
+                i++;
+            }
             else if (key === 'debug') {
                 parsed.debug = true;
                 i++;
@@ -92,6 +102,11 @@ function parseArgs(args) {
                     parsed.verbose = true;
                     i += 1;
                     break;
+                case 's':
+                    parsed.sizes = true;
+                    i += 1;
+                    break;
+                    break;
                 case 'd':
                     parsed.debugDir = value;
                     i += 2;
@@ -202,7 +217,10 @@ async function encodeCommand(args) {
             inputSizeVal = totalSize;
             displayName = parsed.outputName || 'archive';
             options.includeFileList = true;
-            options.fileList = index.map((e) => e.path);
+            options.fileList = index.map((e) => ({
+                name: e.path,
+                size: e.size,
+            }));
         }
         else {
             const resolvedInput = resolvedInputs[0];
@@ -214,14 +232,17 @@ async function encodeCommand(args) {
                 inputSizeVal = totalSize;
                 displayName = parsed.outputName || basename(resolvedInput);
                 options.includeFileList = true;
-                options.fileList = index.map((e) => e.path);
+                options.fileList = index.map((e) => ({
+                    name: e.path,
+                    size: e.size,
+                }));
             }
             else {
                 inputData = readFileSync(resolvedInput);
                 inputSizeVal = inputData.length;
                 displayName = basename(resolvedInput);
                 options.includeFileList = true;
-                options.fileList = [basename(resolvedInput)];
+                options.fileList = [{ name: basename(resolvedInput), size: st.size }];
             }
         }
         options.name = displayName;
@@ -283,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;
@@ -404,7 +425,8 @@ async function decodeCommand(args) {
             const baseDir = parsed.output || outputPath || '.';
             const totalBytes = result.files.reduce((s, f) => s + f.buf.length, 0);
             const extractBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
-            extractBar.start(totalBytes, 0, { step: 'Writing files' });
+            const extractStart = Date.now();
+            extractBar.start(totalBytes, 0, { step: 'Writing files', elapsed: '0' });
             let written = 0;
             for (const file of result.files) {
                 const fullPath = join(baseDir, file.path);
@@ -412,9 +434,15 @@ async function decodeCommand(args) {
                 mkdirSync(dir, { recursive: true });
                 writeFileSync(fullPath, file.buf);
                 written += file.buf.length;
-                extractBar.update(written, { step: `Writing ${file.path}` });
+                extractBar.update(written, {
+                    step: `Writing ${file.path}`,
+                    elapsed: String(Math.floor((Date.now() - extractStart) / 1000)),
+                });
             }
-            extractBar.update(totalBytes, { step: 'Done' });
+            extractBar.update(totalBytes, {
+                step: 'Done',
+                elapsed: String(Math.floor((Date.now() - extractStart) / 1000)),
+            });
             extractBar.stop();
             console.log(`\nSuccess!`);
             console.log(`Unpacked ${result.files.length} files to directory : ${resolve(baseDir)}`);
@@ -424,20 +452,12 @@ async function decodeCommand(args) {
             const unpacked = unpackBuffer(result.buf);
             if (unpacked) {
                 const baseDir = parsed.output || outputPath || '.';
-                const totalBytes = unpacked.files.reduce((s, f) => s + f.buf.length, 0);
-                const extractBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
-                extractBar.start(totalBytes, 0, { step: 'Writing files' });
-                let written = 0;
                 for (const file of unpacked.files) {
                     const fullPath = join(baseDir, file.path);
                     const dir = dirname(fullPath);
                     mkdirSync(dir, { recursive: true });
                     writeFileSync(fullPath, file.buf);
-                    written += file.buf.length;
-                    extractBar.update(written, { step: `Writing ${file.path}` });
                 }
-                extractBar.update(totalBytes, { step: 'Done' });
-                extractBar.stop();
                 console.log(`\nSuccess!`);
                 console.log(`Time: ${decodeTime}ms`);
                 console.log(`Unpacked ${unpacked.files.length} files to current directory`);
@@ -506,11 +526,18 @@ async function listCommand(args) {
     const resolvedInput = resolve(inputPath);
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const fileList = await listFilesInPng(inputBuffer);
+        const fileList = await listFilesInPng(inputBuffer, {
+            includeSizes: parsed.sizes !== false,
+        });
         if (fileList) {
             console.log(`Files in ${resolvedInput}:`);
             for (const file of fileList) {
-                console.log(`  ${file}`);
+                if (typeof file === 'string') {
+                    console.log(`  ${file}`);
+                }
+                else {
+                    console.log(`  ${file.name} (${file.size} bytes)`);
+                }
             }
         }
         else {

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>;