roxify 1.4.0 → 1.5.0

package/dist/cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
-import cliProgress from 'cli-progress';
 import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { open } from 'fs/promises';
 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 * as cliProgress from './stub-progress.js';
 import { encodeWithRustCLI, isRustBinaryAvailable, } from './utils/rust-cli-wrapper.js';
 const VERSION = '1.4.0';
 async function readLargeFile(filePath) {
@@ -211,7 +211,8 @@ async function encodeCommand(args) {
                 });
             }, 500);
             const encryptType = parsed.encrypt === 'xor' ? 'xor' : 'aes';
-            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 19, parsed.passphrase, encryptType);
+            const fileName = basename(inputPaths[0]);
+            await encodeWithRustCLI(inputPaths.length === 1 ? resolvedInputs[0] : resolvedInputs[0], resolvedOutput, 12, parsed.passphrase, encryptType, fileName);
             clearInterval(progressInterval);
             const encodeTime = Date.now() - startTime;
             encodeBar.update(100, {
@@ -284,7 +285,7 @@ async function encodeCommand(args) {
             mode,
             name: parsed.outputName || 'archive',
             skipOptimization: false,
-            compressionLevel: 19,
+            compressionLevel: 12,
             outputFormat: 'auto',
         });
         if (parsed.verbose)

package/dist/hybrid-compression.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export interface CompressionStats {
     originalSize: number;
     compressedSize: number;

package/dist/hybrid-compression.js

@@ -1,10 +1,10 @@
+import { native } from './utils/native.js';
 let check_gpu_status;
 let entropy_estimate;
 let get_compression_stats;
 let hybrid_compress;
 let hybrid_decompress;
 try {
-    const native = require('../libroxify_native.node');
     check_gpu_status = native.check_gpu_status;
     entropy_estimate = native.entropy_estimate;
     get_compression_stats = native.get_compression_stats;

package/dist/minpng.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function encodeMinPng(rgb: Buffer, width: number, height: number): Promise<Buffer>;
 export declare function decodeMinPng(pngBuf: Buffer): Promise<{
     buf: Buffer;

package/dist/minpng.js

@@ -1,6 +1,20 @@
-import { compress as zstdCompress, decompress as zstdDecompress, } from '@mongodb-js/zstd';
-import encode from 'png-chunks-encode';
 import { deflateSync } from 'zlib';
+import { native } from './utils/native.js';
+let nativeZstdCompress = null;
+let nativeZstdDecompress = null;
+let nativeEncodePngChunks = null;
+try {
+    if (native?.nativeZstdCompress) {
+        nativeZstdCompress = native.nativeZstdCompress;
+    }
+    if (native?.nativeZstdDecompress) {
+        nativeZstdDecompress = native.nativeZstdDecompress;
+    }
+    if (native?.encodePngChunks) {
+        nativeEncodePngChunks = native.encodePngChunks;
+    }
+}
+catch (e) { }
 const PIXEL_MAGIC = Buffer.from('MNPG');
 const MARKER_START = [
     { r: 255, g: 0, b: 0 },
@@ -82,7 +96,10 @@ export async function encodeMinPng(rgb, width, height) {
         transformed[tIdx++] = b;
     }
     const transformedBuf = Buffer.from(transformed);
-    const compressed = Buffer.from(await zstdCompress(transformedBuf, 19));
+    if (!nativeZstdCompress) {
+        throw new Error('Native zstd compression not available');
+    }
+    const compressed = Buffer.from(nativeZstdCompress(transformedBuf, 19));
     const header = Buffer.alloc(4 + 1 + 4 + 4);
     PIXEL_MAGIC.copy(header, 0);
     header[4] = 1;
@@ -142,16 +159,29 @@ export async function encodeMinPng(rgb, width, height) {
         { name: 'IDAT', data: idat },
         { name: 'IEND', data: Buffer.alloc(0) },
     ];
-    return Buffer.from(encode(chunks));
+    if (nativeEncodePngChunks) {
+        return Buffer.from(nativeEncodePngChunks(chunks));
+    }
+    const PNG_SIG = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+    const output = [PNG_SIG];
+    for (const chunk of chunks) {
+        const type = Buffer.from(chunk.name, 'ascii');
+        const length = Buffer.alloc(4);
+        length.writeUInt32BE(chunk.data.length, 0);
+        const crcData = Buffer.concat([type, chunk.data]);
+        const crc = Buffer.alloc(4);
+        const crc32fast = native?.nativeCrc32;
+        const crcVal = crc32fast ? crc32fast(crcData) : 0;
+        crc.writeUInt32BE(crcVal, 0);
+        output.push(length, type, chunk.data, crc);
+    }
+    return Buffer.concat(output);
 }
 export async function decodeMinPng(pngBuf) {
-    const sharp = await import('sharp');
-    const { data, info } = await sharp
-        .default(pngBuf)
-        .raw()
-        .toBuffer({ resolveWithObject: true });
-    const currentWidth = info.width;
-    const currentHeight = info.height;
+    const rawData = native.sharpToRaw(pngBuf);
+    const data = rawData.pixels;
+    const currentWidth = rawData.width;
+    const currentHeight = rawData.height;
     const rawRGB = Buffer.alloc(currentWidth * currentHeight * 3);
     for (let i = 0; i < currentWidth * currentHeight; i++) {
         rawRGB[i * 3] = data[i * 3];
@@ -190,7 +220,10 @@ export async function decodeMinPng(pngBuf) {
     if (compStart + compressedLen > rawRGB.length)
         return null;
     const compressed = rawRGB.subarray(compStart, compStart + compressedLen);
-    const decompressed = Buffer.from(await zstdDecompress(compressed));
+    if (!nativeZstdDecompress) {
+        throw new Error('Native zstd decompression not available');
+    }
+    const decompressed = Buffer.from(nativeZstdDecompress(compressed));
     const indices = zigzagOrderIndices(origW, origH);
     const residualR = new Uint8Array(origW * origH);
     const residualG = new Uint8Array(origW * origH);

package/dist/pack.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export interface PackedFile {
     path: string;
     buf: Buffer;

package/dist/stub-progress.d.ts

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

package/dist/stub-progress.js

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

package/dist/utils/constants.d.ts

@@ -1,14 +1,12 @@
-/// <reference types="node" />
-/// <reference types="node" />
 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 MAGIC: Buffer<ArrayBuffer>;
+export declare const PIXEL_MAGIC: Buffer<ArrayBuffer>;
+export declare const PIXEL_MAGIC_BLOCK: Buffer<ArrayBuffer>;
 export declare const ENC_NONE = 0;
 export declare const ENC_AES = 1;
 export declare const ENC_XOR = 2;
-export declare const FILTER_ZERO: Buffer;
-export declare const PNG_HEADER: Buffer;
+export declare const FILTER_ZERO: Buffer<ArrayBuffer>;
+export declare const PNG_HEADER: Buffer<ArrayBuffer>;
 export declare const PNG_HEADER_HEX: string;
 export declare const MARKER_COLORS: {
     r: number;
@@ -37,3 +35,20 @@ export declare const COMPRESSION_MARKERS: {
         b: number;
     }[];
 };
+export declare const FORMAT_MARKERS: {
+    png: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    webp: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    jxl: {
+        r: number;
+        g: number;
+        b: number;
+    };
+};

package/dist/utils/constants.js

@@ -21,3 +21,8 @@ export const COMPRESSION_MARKERS = {
     zstd: [{ r: 0, g: 255, b: 0 }],
     lzma: [{ r: 255, g: 255, b: 0 }],
 };
+export const FORMAT_MARKERS = {
+    png: { r: 0, g: 255, b: 255 },
+    webp: { r: 255, g: 0, b: 255 },
+    jxl: { r: 255, g: 255, b: 0 },
+};

package/dist/utils/crc.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function crc32(buf: Buffer, previous?: number): number;
 export declare function adler32(buf: Buffer, prev?: number): number;

package/dist/utils/decoder.d.ts

@@ -1,4 +1,2 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { DecodeOptions, DecodeResult } from './types.js';
 export declare function decodePngToBinary(input: Buffer | string, opts?: DecodeOptions): Promise<DecodeResult>;

package/dist/utils/decoder.js

@@ -1,11 +1,12 @@
-import cliProgress from 'cli-progress';
-import { readFileSync } from 'fs';
-import extract from 'png-chunks-extract';
-import sharp from 'sharp';
+import { execFileSync } from 'child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
 import { unpackBuffer } from '../pack.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 { native } from './native.js';
 import { cropAndReconstitute } from './reconstitution.js';
 import { parallelZstdDecompress, tryZstdDecompress } from './zstd.js';
 async function tryDecompress(payload, onProgress) {
@@ -34,6 +35,52 @@ async function tryDecompress(payload, onProgress) {
         }
     }
 }
+function detectImageFormat(buf) {
+    if (buf.length < 12)
+        return 'unknown';
+    if (buf[0] === 0x89 &&
+        buf[1] === 0x50 &&
+        buf[2] === 0x4e &&
+        buf[3] === 0x47) {
+        return 'png';
+    }
+    if (buf[0] === 0x52 &&
+        buf[1] === 0x49 &&
+        buf[2] === 0x46 &&
+        buf[3] === 0x46 &&
+        buf[8] === 0x57 &&
+        buf[9] === 0x45 &&
+        buf[10] === 0x42 &&
+        buf[11] === 0x50) {
+        return 'webp';
+    }
+    if (buf[0] === 0xff && buf[1] === 0x0a) {
+        return 'jxl';
+    }
+    return 'unknown';
+}
+function convertToPng(buf, format) {
+    const tempDir = mkdtempSync(join(tmpdir(), 'rox-decode-'));
+    const inputPath = join(tempDir, format === 'webp' ? 'input.webp' : 'input.jxl');
+    const outputPath = join(tempDir, 'output.png');
+    try {
+        writeFileSync(inputPath, buf);
+        if (format === 'webp') {
+            execFileSync('dwebp', [inputPath, '-o', outputPath]);
+        }
+        else if (format === 'jxl') {
+            execFileSync('djxl', [inputPath, outputPath]);
+        }
+        const pngBuf = readFileSync(outputPath);
+        return pngBuf;
+    }
+    finally {
+        try {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (e) { }
+    }
+}
 export async function decodePngToBinary(input, opts = {}) {
     let pngBuf;
     if (Buffer.isBuffer(input)) {
@@ -41,11 +88,17 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     else {
         try {
-            const metadata = await sharp(input).metadata();
-            const rawBytesEstimate = (metadata.width || 0) * (metadata.height || 0) * 4;
-            const MAX_RAW_BYTES = 200 * 1024 * 1024;
-            if (rawBytesEstimate > MAX_RAW_BYTES) {
-                pngBuf = readFileSync(input);
+            if (native?.sharpMetadata) {
+                const inputBuf = readFileSync(input);
+                const metadata = native.sharpMetadata(inputBuf);
+                const rawBytesEstimate = metadata.width * metadata.height * 4;
+                const MAX_RAW_BYTES = 200 * 1024 * 1024;
+                if (rawBytesEstimate > MAX_RAW_BYTES) {
+                    pngBuf = inputBuf;
+                }
+                else {
+                    pngBuf = inputBuf;
+                }
             }
             else {
                 pngBuf = readFileSync(input);
@@ -62,10 +115,11 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     let progressBar = null;
     if (opts.showProgress) {
-        progressBar = new cliProgress.SingleBar({
-            format: ' {bar} {percentage}% | {step} | {elapsed}s',
-        }, cliProgress.Presets.shades_classic);
-        progressBar.start(100, 0, { step: 'Starting', elapsed: '0' });
+        progressBar = {
+            start: () => { },
+            update: () => { },
+            stop: () => { },
+        };
         const startTime = Date.now();
         if (!opts.onProgress) {
             opts.onProgress = (info) => {
@@ -79,10 +133,6 @@ export async function decodePngToBinary(input, opts = {}) {
                 else if (info.phase === 'done') {
                     pct = 100;
                 }
-                progressBar.update(Math.floor(pct), {
-                    step: info.phase.replace('_', ' '),
-                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
-                });
             };
         }
     }
@@ -90,28 +140,17 @@ export async function decodePngToBinary(input, opts = {}) {
         opts.onProgress({ phase: 'start' });
     let processedBuf = pngBuf;
     try {
-        const info = await sharp(pngBuf).metadata();
-        if (info.width && info.height) {
-            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.`);
-            }
-            if (false) {
-                const doubledBuffer = await sharp(pngBuf)
-                    .resize({
-                    width: info.width * 2,
-                    height: info.height * 2,
-                    kernel: 'nearest',
-                })
-                    .png()
-                    .toBuffer();
-                processedBuf = await cropAndReconstitute(doubledBuffer, opts.debugDir);
-            }
-            else {
-                processedBuf = pngBuf;
+        if (native?.sharpMetadata) {
+            const info = native.sharpMetadata(pngBuf);
+            if (info.width && info.height) {
+                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.`);
+                }
             }
         }
+        processedBuf = pngBuf;
     }
     catch (e) {
         if (e instanceof DataFormatError)
@@ -155,24 +194,30 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     let chunks = [];
     try {
-        const chunksRaw = extract(processedBuf);
-        chunks = chunksRaw.map((c) => ({
-            name: c.name,
-            data: Buffer.isBuffer(c.data)
-                ? c.data
-                : Buffer.from(c.data),
-        }));
+        if (native?.extractPngChunks) {
+            const chunksRaw = native.extractPngChunks(processedBuf);
+            chunks = chunksRaw.map((c) => ({
+                name: c.name,
+                data: Buffer.from(c.data),
+            }));
+        }
+        else {
+            throw new Error('Native PNG chunk extraction not available');
+        }
     }
     catch (e) {
         try {
             const withHeader = Buffer.concat([PNG_HEADER, pngBuf]);
-            const chunksRaw = extract(withHeader);
-            chunks = chunksRaw.map((c) => ({
-                name: c.name,
-                data: Buffer.isBuffer(c.data)
-                    ? c.data
-                    : Buffer.from(c.data),
-            }));
+            if (native?.extractPngChunks) {
+                const chunksRaw = native.extractPngChunks(withHeader);
+                chunks = chunksRaw.map((c) => ({
+                    name: c.name,
+                    data: Buffer.from(c.data),
+                }));
+            }
+            else {
+                throw new Error('Native PNG chunk extraction not available');
+            }
         }
         catch (e2) {
             chunks = [];
@@ -225,28 +270,21 @@ export async function decodePngToBinary(input, opts = {}) {
         return { buf: payload, meta: { name } };
     }
     try {
-        const metadata = await sharp(processedBuf).metadata();
+        const metadata = native.sharpMetadata(processedBuf);
         const currentWidth = metadata.width;
         const currentHeight = metadata.height;
         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: 0,
-                width: Math.min(4, currentWidth),
-                height: Math.min(4, currentHeight),
-            })
-                .raw()
-                .toBuffer({ resolveWithObject: true });
+            const rawData = native.sharpToRaw(processedBuf);
+            const testData = rawData.pixels;
             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;
+                    const px00 = (y * 2 * currentWidth + x * 2) * 3;
+                    const px01 = (y * 2 * currentWidth + (x * 2 + 1)) * 3;
+                    const px10 = ((y * 2 + 1) * currentWidth + x * 2) * 3;
+                    const px11 = ((y * 2 + 1) * currentWidth + (x * 2 + 1)) * 3;
                     if (testData[px00] !== testData[px01] ||
                         testData[px00] !== testData[px10] ||
                         testData[px00] !== testData[px11] ||
@@ -265,56 +303,28 @@ export async function decodePngToBinary(input, opts = {}) {
                 const blocksWide = currentWidth / 2;
                 const blocksHigh = currentHeight / 2;
                 rawRGB = Buffer.alloc(blocksWide * blocksHigh * 3);
+                const fullRaw = native.sharpToRaw(processedBuf);
+                const fullData = fullRaw.pixels;
                 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];
+                        const pixelOffset = (by * 2 * currentWidth + bx * 2) * 3;
+                        rawRGB[outIdx++] = fullData[pixelOffset];
+                        rawRGB[outIdx++] = fullData[pixelOffset + 1];
+                        rawRGB[outIdx++] = fullData[pixelOffset + 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 rawData = native.sharpToRaw(processedBuf);
+            rawRGB = Buffer.from(rawData.pixels);
+            if (opts.onProgress) {
+                opts.onProgress({
+                    phase: 'extract_pixels',
+                    loaded: currentHeight,
+                    total: currentHeight,
+                });
             }
         }
         const firstPixels = [];
@@ -361,22 +371,10 @@ export async function decodePngToBinary(input, opts = {}) {
         }
         else {
             const reconstructed = await cropAndReconstitute(processedBuf, opts.debugDir);
-            const { data: rdata, info: rinfo } = await sharp(reconstructed)
-                .raw()
-                .toBuffer({ resolveWithObject: true });
-            logicalWidth = rinfo.width;
-            logicalHeight = rinfo.height;
-            logicalData = Buffer.alloc(rinfo.width * rinfo.height * 3);
-            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];
-                }
-            }
+            const rawData = native.sharpToRaw(reconstructed);
+            logicalWidth = rawData.width;
+            logicalHeight = rawData.height;
+            logicalData = Buffer.from(rawData.pixels);
         }
         if (process.env.ROX_DEBUG) {
             console.log('DEBUG: Logical grid reconstructed:', logicalWidth, 'x', logicalHeight, '=', logicalWidth * logicalHeight, 'pixels');

package/dist/utils/encoder.d.ts

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