roxify 1.2.4 → 1.2.6

package/dist/index.js

@@ -1,2641 +1,13 @@
-import { compress as zstdCompress, decompress as zstdDecompress, } from '@mongodb-js/zstd';
-import { spawn, spawnSync } from 'child_process';
-import cliProgress from 'cli-progress';
-import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes, } from 'crypto';
-import { createReadStream, createWriteStream, existsSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import encode from 'png-chunks-encode';
-import extract from 'png-chunks-extract';
-import sharp from 'sharp';
-import * as zlib from 'zlib';
-import { unpackBuffer } from './pack.js';
-const CHUNK_TYPE = 'rXDT';
-const MAGIC = Buffer.from('ROX1');
-const PIXEL_MAGIC = Buffer.from('PXL1');
-const ENC_NONE = 0;
-const ENC_AES = 1;
-const ENC_XOR = 2;
-export class PassphraseRequiredError extends Error {
-    constructor(message = 'Passphrase required') {
-        super(message);
-        this.name = 'PassphraseRequiredError';
-    }
-}
-export class IncorrectPassphraseError extends Error {
-    constructor(message = 'Incorrect passphrase') {
-        super(message);
-        this.name = 'IncorrectPassphraseError';
-    }
-}
-export class DataFormatError extends Error {
-    constructor(message = 'Data format error') {
-        super(message);
-        this.name = 'DataFormatError';
-    }
-}
-const PNG_HEADER = Buffer.from([
-    0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
-]);
-const PNG_HEADER_HEX = PNG_HEADER.toString('hex');
-const MARKER_COLORS = [
-    { r: 255, g: 0, b: 0 },
-    { r: 0, g: 255, b: 0 },
-    { r: 0, g: 0, b: 255 },
-];
-const MARKER_START = MARKER_COLORS;
-const MARKER_END = [...MARKER_COLORS].reverse();
-const CHUNK_SIZE = 8 * 1024;
-async function writeInChunks(ws, buf, chunkSize = CHUNK_SIZE) {
-    for (let i = 0; i < buf.length; i += chunkSize) {
-        const part = buf.slice(i, i + chunkSize);
-        if (!ws.write(part))
-            await new Promise((resolve) => ws.once('drain', resolve));
-        await new Promise((resolve) => setTimeout(resolve, 50));
-    }
-}
-const COMPRESSION_MARKERS = {
-    zstd: [{ r: 0, g: 255, b: 0 }],
-    lzma: [{ r: 255, g: 255, b: 0 }],
-};
-function colorsToBytes(colors) {
-    const buf = Buffer.alloc(colors.length * 3);
-    for (let i = 0; i < colors.length; i++) {
-        buf[i * 3] = colors[i].r;
-        buf[i * 3 + 1] = colors[i].g;
-        buf[i * 3 + 2] = colors[i].b;
-    }
-    return buf;
-}
-function deltaEncode(data) {
-    if (data.length === 0)
-        return data;
-    const out = Buffer.alloc(data.length);
-    out[0] = data[0];
-    for (let i = 1; i < data.length; i++) {
-        out[i] = (data[i] - data[i - 1] + 256) & 0xff;
-    }
-    return out;
-}
-function deltaDecode(data) {
-    if (data.length === 0)
-        return data;
-    const out = Buffer.alloc(data.length);
-    out[0] = data[0];
-    for (let i = 1; i < data.length; i++) {
-        out[i] = (out[i - 1] + data[i]) & 0xff;
-    }
-    return out;
-}
-async function parallelZstdCompress(payload, level = 11, onProgress) {
-    const chunkSize = 1024 * 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 promises = [];
-    const totalChunks = Math.ceil(payload.length / chunkSize);
-    let completedChunks = 0;
-    for (let i = 0; i < payload.length; i += chunkSize) {
-        const chunk = payload.slice(i, Math.min(i + chunkSize, payload.length));
-        promises.push(zstdCompress(chunk, level).then((compressed) => {
-            completedChunks++;
-            if (onProgress) {
-                onProgress(completedChunks, totalChunks);
-            }
-            return Buffer.from(compressed);
-        }));
-    }
-    const compressedChunks = await Promise.all(promises);
-    const chunkSizes = Buffer.alloc(compressedChunks.length * 4);
-    for (let i = 0; i < compressedChunks.length; i++) {
-        chunkSizes.writeUInt32BE(compressedChunks[i].length, i * 4);
-    }
-    const header = Buffer.alloc(8);
-    header.writeUInt32BE(0x5a535444, 0);
-    header.writeUInt32BE(compressedChunks.length, 4);
-    return Buffer.concat([header, chunkSizes, ...compressedChunks]);
-}
-async function parallelZstdDecompress(payload, onProgress, onChunk, outPath) {
-    if (payload.length < 8) {
-        onProgress?.({ phase: 'decompress_start', total: 1 });
-        const d = Buffer.from(await zstdDecompress(payload));
-        if (onChunk)
-            await onChunk(d, 0, 1);
-        onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
-        onProgress?.({ phase: 'decompress_done', loaded: 1, total: 1 });
-        if (outPath) {
-            const ws = createWriteStream(outPath);
-            await writeInChunks(ws, d);
-            ws.end();
-        }
-        return onChunk ? Buffer.alloc(0) : d;
-    }
-    const magic = payload.readUInt32BE(0);
-    if (magic !== 0x5a535444) {
-        if (process.env.ROX_DEBUG)
-            console.log('tryZstdDecompress: invalid magic');
-        onProgress?.({ phase: 'decompress_start', total: 1 });
-        const d = Buffer.from(await zstdDecompress(payload));
-        onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
-        onProgress?.({ phase: 'decompress_done', loaded: 1, total: 1 });
-        if (outPath) {
-            const ws = createWriteStream(outPath);
-            await writeInChunks(ws, d);
-            ws.end();
-        }
-        return d;
-    }
-    const numChunks = payload.readUInt32BE(4);
-    const chunkSizes = [];
-    let offset = 8;
-    for (let i = 0; i < numChunks; i++) {
-        chunkSizes.push(payload.readUInt32BE(offset));
-        offset += 4;
-    }
-    onProgress?.({ phase: 'decompress_start', total: numChunks });
-    const tempFiles = [];
-    for (let i = 0; i < numChunks; i++) {
-        const size = chunkSizes[i];
-        const chunk = payload.slice(offset, offset + size);
-        offset += size;
-        const tempFile = join(tmpdir(), `rox_chunk_${Date.now()}_${i}.tmp`);
-        const wsChunk = createWriteStream(tempFile);
-        const dec = Buffer.from(await zstdDecompress(chunk));
-        if (onChunk) {
-            await onChunk(dec, i + 1, numChunks);
-            unlinkSync(tempFile);
-        }
-        else {
-            await writeInChunks(wsChunk, dec);
-            await new Promise((res) => wsChunk.end(() => res()));
-            tempFiles.push(tempFile);
-        }
-        onProgress?.({
-            phase: 'decompress_progress',
-            loaded: i + 1,
-            total: numChunks,
-        });
-    }
-    onProgress?.({
-        phase: 'decompress_done',
-        loaded: numChunks,
-        total: numChunks,
-    });
-    if (onChunk) {
-        return Buffer.alloc(0);
-    }
-    if (outPath || tempFiles.length > 0) {
-        const finalPath = outPath || join(tmpdir(), `rox_final_${Date.now()}.tmp`);
-        const ws = createWriteStream(finalPath);
-        for (const tempFile of tempFiles) {
-            const rs = createReadStream(tempFile);
-            await new Promise((resolve, reject) => {
-                rs.on('data', (chunk) => ws.write(chunk));
-                rs.on('end', resolve);
-                rs.on('error', reject);
-            });
-            unlinkSync(tempFile);
-        }
-        await new Promise((res) => ws.end(() => res()));
-        if (!outPath) {
-            const finalBuf = readFileSync(finalPath);
-            unlinkSync(finalPath);
-            return finalBuf;
-        }
-        return Buffer.alloc(0);
-    }
-    return Buffer.alloc(0);
-}
-export async function optimizePngBuffer(pngBuf, fast = false) {
-    const runCommandAsync = (cmd, args, timeout = 120000) => {
-        return new Promise((resolve) => {
-            try {
-                const child = spawn(cmd, args, { windowsHide: true, stdio: 'ignore' });
-                let killed = false;
-                const to = setTimeout(() => {
-                    killed = true;
-                    try {
-                        child.kill('SIGTERM');
-                    }
-                    catch (e) { }
-                }, timeout);
-                child.on('close', (code) => {
-                    clearTimeout(to);
-                    if (killed)
-                        resolve({ error: new Error('timeout') });
-                    else
-                        resolve({ code: code ?? 0 });
-                });
-                child.on('error', (err) => {
-                    clearTimeout(to);
-                    resolve({ error: err });
-                });
-            }
-            catch (err) {
-                resolve({ error: err });
-            }
-        });
-    };
-    try {
-        const inPath = join(tmpdir(), `rox_zop_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
-        const outPath = inPath + '.out.png';
-        writeFileSync(inPath, pngBuf);
-        const iterations = fast ? 15 : 40;
-        const args = [
-            '-y',
-            `--iterations=${iterations}`,
-            '--filters=01234mepb',
-            inPath,
-            outPath,
-        ];
-        const runCommandAsync = (cmd, args, timeout = 120000) => {
-            return new Promise((resolve) => {
-                try {
-                    const child = spawn(cmd, args, {
-                        windowsHide: true,
-                        stdio: 'ignore',
-                    });
-                    let killed = false;
-                    const to = setTimeout(() => {
-                        killed = true;
-                        try {
-                            child.kill('SIGTERM');
-                        }
-                        catch (e) { }
-                    }, timeout);
-                    child.on('close', (code) => {
-                        clearTimeout(to);
-                        if (killed)
-                            resolve({ error: new Error('timeout') });
-                        else
-                            resolve({ code: code ?? 0 });
-                    });
-                    child.on('error', (err) => {
-                        clearTimeout(to);
-                        resolve({ error: err });
-                    });
-                }
-                catch (err) {
-                    resolve({ error: err });
-                }
-            });
-        };
-        const res = await runCommandAsync('zopflipng', args, 120000);
-        if (!res.error && existsSync(outPath)) {
-            const outBuf = readFileSync(outPath);
-            try {
-                unlinkSync(inPath);
-                unlinkSync(outPath);
-            }
-            catch (e) { }
-            return outBuf.length < pngBuf.length ? outBuf : pngBuf;
-        }
-        if (fast)
-            return pngBuf;
-    }
-    catch (e) { }
-    try {
-        const chunksRaw = extract(pngBuf);
-        const ihdr = chunksRaw.find((c) => c.name === 'IHDR');
-        if (!ihdr)
-            return pngBuf;
-        const ihdrData = Buffer.isBuffer(ihdr.data)
-            ? ihdr.data
-            : Buffer.from(ihdr.data);
-        const width = ihdrData.readUInt32BE(0);
-        const height = ihdrData.readUInt32BE(4);
-        const bitDepth = ihdrData[8];
-        const colorType = ihdrData[9];
-        if (bitDepth !== 8 || colorType !== 2)
-            return pngBuf;
-        const idatChunks = chunksRaw.filter((c) => c.name === 'IDAT');
-        const idatData = Buffer.concat(idatChunks.map((c) => Buffer.isBuffer(c.data)
-            ? c.data
-            : Buffer.from(c.data)));
-        let raw;
-        try {
-            raw = zlib.inflateSync(idatData);
-        }
-        catch (e) {
-            return pngBuf;
-        }
-        const bytesPerPixel = 3;
-        const rowBytes = width * bytesPerPixel;
-        const inRowLen = rowBytes + 1;
-        if (raw.length !== inRowLen * height)
-            return pngBuf;
-        function paethPredict(a, b, c) {
-            const p = a + b - c;
-            const pa = Math.abs(p - a);
-            const pb = Math.abs(p - b);
-            const pc = Math.abs(p - c);
-            if (pa <= pb && pa <= pc)
-                return a;
-            if (pb <= pc)
-                return b;
-            return c;
-        }
-        const outRows = [];
-        let prevRow = null;
-        for (let y = 0; y < height; y++) {
-            const rowStart = y * inRowLen + 1;
-            const row = raw.slice(rowStart, rowStart + rowBytes);
-            let bestSum = Infinity;
-            let bestFiltered = null;
-            for (let f = 0; f <= 4; f++) {
-                const filtered = Buffer.alloc(rowBytes);
-                let sum = 0;
-                for (let i = 0; i < rowBytes; i++) {
-                    const val = row[i];
-                    let outv = 0;
-                    const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
-                    const up = prevRow ? prevRow[i] : 0;
-                    const upLeft = prevRow && i - bytesPerPixel >= 0 ? prevRow[i - bytesPerPixel] : 0;
-                    if (f === 0) {
-                        outv = val;
-                    }
-                    else if (f === 1) {
-                        outv = (val - left + 256) & 0xff;
-                    }
-                    else if (f === 2) {
-                        outv = (val - up + 256) & 0xff;
-                    }
-                    else if (f === 3) {
-                        const avg = Math.floor((left + up) / 2);
-                        outv = (val - avg + 256) & 0xff;
-                    }
-                    else {
-                        const p = paethPredict(left, up, upLeft);
-                        outv = (val - p + 256) & 0xff;
-                    }
-                    filtered[i] = outv;
-                    const signed = outv > 127 ? outv - 256 : outv;
-                    sum += Math.abs(signed);
-                }
-                if (sum < bestSum) {
-                    bestSum = sum;
-                    bestFiltered = filtered;
-                }
-            }
-            const rowBuf = Buffer.alloc(1 + rowBytes);
-            let chosenFilter = 0;
-            for (let f = 0; f <= 4; f++) {
-                const filtered = Buffer.alloc(rowBytes);
-                for (let i = 0; i < rowBytes; i++) {
-                    const val = row[i];
-                    const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
-                    const up = prevRow ? prevRow[i] : 0;
-                    const upLeft = prevRow && i - bytesPerPixel >= 0 ? prevRow[i - bytesPerPixel] : 0;
-                    if (f === 0)
-                        filtered[i] = val;
-                    else if (f === 1)
-                        filtered[i] = (val - left + 256) & 0xff;
-                    else if (f === 2)
-                        filtered[i] = (val - up + 256) & 0xff;
-                    else if (f === 3)
-                        filtered[i] = (val - Math.floor((left + up) / 2) + 256) & 0xff;
-                    else
-                        filtered[i] = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
-                }
-                if (filtered.equals(bestFiltered)) {
-                    chosenFilter = f;
-                    break;
-                }
-            }
-            rowBuf[0] = chosenFilter;
-            bestFiltered.copy(rowBuf, 1);
-            outRows.push(rowBuf);
-            prevRow = row;
-        }
-        const filteredAll = Buffer.concat(outRows);
-        const compressed = zlib.deflateSync(filteredAll, {
-            level: 9,
-            memLevel: 9,
-            strategy: zlib.constants.Z_DEFAULT_STRATEGY,
-        });
-        const newChunks = [];
-        for (const c of chunksRaw) {
-            if (c.name === 'IDAT')
-                continue;
-            newChunks.push({
-                name: c.name,
-                data: Buffer.isBuffer(c.data)
-                    ? c.data
-                    : Buffer.from(c.data),
-            });
-        }
-        const iendIndex = newChunks.findIndex((c) => c.name === 'IEND');
-        const insertIndex = iendIndex >= 0 ? iendIndex : newChunks.length;
-        newChunks.splice(insertIndex, 0, { name: 'IDAT', data: compressed });
-        function ensurePng(buf) {
-            return buf.slice(0, 8).toString('hex') === PNG_HEADER_HEX
-                ? buf
-                : Buffer.concat([PNG_HEADER, buf]);
-        }
-        const out = ensurePng(Buffer.from(encode(newChunks)));
-        let bestBuf = out.length < pngBuf.length ? out : pngBuf;
-        const strategies = [
-            zlib.constants.Z_DEFAULT_STRATEGY,
-            zlib.constants.Z_FILTERED,
-            zlib.constants.Z_RLE,
-            ...(zlib.constants.Z_HUFFMAN_ONLY ? [zlib.constants.Z_HUFFMAN_ONLY] : []),
-            ...(zlib.constants.Z_FIXED ? [zlib.constants.Z_FIXED] : []),
-        ];
-        for (const strat of strategies) {
-            try {
-                const comp = zlib.deflateSync(raw, {
-                    level: 9,
-                    memLevel: 9,
-                    strategy: strat,
-                });
-                const altChunks = newChunks.map((c) => ({
-                    name: c.name,
-                    data: c.data,
-                }));
-                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
-                if (idx !== -1)
-                    altChunks[idx] = { name: 'IDAT', data: comp };
-                const candidate = ensurePng(Buffer.from(encode(altChunks)));
-                if (candidate.length < bestBuf.length)
-                    bestBuf = candidate;
-            }
-            catch (e) { }
-        }
-        try {
-            const fflate = await import('fflate');
-            const fflateDeflateSync = fflate.deflateSync;
-            try {
-                const comp = fflateDeflateSync(filteredAll);
-                const altChunks = newChunks.map((c) => ({
-                    name: c.name,
-                    data: c.data,
-                }));
-                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
-                if (idx !== -1)
-                    altChunks[idx] = { name: 'IDAT', data: Buffer.from(comp) };
-                const candidate = ensurePng(Buffer.from(encode(altChunks)));
-                if (candidate.length < bestBuf.length)
-                    bestBuf = candidate;
-            }
-            catch (e) { }
-        }
-        catch (e) { }
-        const windowBitsOpts = [15, 12, 9];
-        const memLevelOpts = [9, 8];
-        for (let f = 0; f <= 4; f++) {
-            try {
-                const filteredAllGlobalRows = [];
-                let prevRowG = null;
-                for (let y = 0; y < height; y++) {
-                    const row = raw.slice(y * inRowLen + 1, y * inRowLen + 1 + rowBytes);
-                    const filtered = Buffer.alloc(rowBytes);
-                    for (let i = 0; i < rowBytes; i++) {
-                        const val = row[i];
-                        const left = i - bytesPerPixel >= 0 ? row[i - bytesPerPixel] : 0;
-                        const up = prevRowG ? prevRowG[i] : 0;
-                        const upLeft = prevRowG && i - bytesPerPixel >= 0
-                            ? prevRowG[i - bytesPerPixel]
-                            : 0;
-                        if (f === 0)
-                            filtered[i] = val;
-                        else if (f === 1)
-                            filtered[i] = (val - left + 256) & 0xff;
-                        else if (f === 2)
-                            filtered[i] = (val - up + 256) & 0xff;
-                        else if (f === 3)
-                            filtered[i] = (val - Math.floor((left + up) / 2) + 256) & 0xff;
-                        else
-                            filtered[i] = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
-                    }
-                    const rowBuf = Buffer.alloc(1 + rowBytes);
-                    rowBuf[0] = f;
-                    filtered.copy(rowBuf, 1);
-                    filteredAllGlobalRows.push(rowBuf);
-                    prevRowG = row;
-                }
-                const filteredAllGlobal = Buffer.concat(filteredAllGlobalRows);
-                for (const strat2 of strategies) {
-                    for (const wb of windowBitsOpts) {
-                        for (const ml of memLevelOpts) {
-                            try {
-                                const comp = zlib.deflateSync(filteredAllGlobal, {
-                                    level: 9,
-                                    memLevel: ml,
-                                    strategy: strat2,
-                                    windowBits: wb,
-                                });
-                                const altChunks = newChunks.map((c) => ({
-                                    name: c.name,
-                                    data: c.data,
-                                }));
-                                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
-                                if (idx !== -1)
-                                    altChunks[idx] = { name: 'IDAT', data: comp };
-                                const candidate = ensurePng(Buffer.from(encode(altChunks)));
-                                if (candidate.length < bestBuf.length)
-                                    bestBuf = candidate;
-                            }
-                            catch (e) { }
-                        }
-                    }
-                }
-            }
-            catch (e) { }
-        }
-        try {
-            const zopIterations = [1000, 2000];
-            zopIterations.push(5000, 10000, 20000);
-            for (const iters of zopIterations) {
-                try {
-                    const zIn = join(tmpdir(), `rox_zop_in_${Date.now()}_${Math.random()
-                        .toString(36)
-                        .slice(2)}.png`);
-                    const zOut = zIn + '.out.png';
-                    writeFileSync(zIn, bestBuf);
-                    const args2 = [
-                        '-y',
-                        `--iterations=${iters}`,
-                        '--filters=01234mepb',
-                        zIn,
-                        zOut,
-                    ];
-                    try {
-                        const r2 = await runCommandAsync('zopflipng', args2, 240000);
-                        if (!r2.error && existsSync(zOut)) {
-                            const zbuf = readFileSync(zOut);
-                            try {
-                                unlinkSync(zIn);
-                                unlinkSync(zOut);
-                            }
-                            catch (e) { }
-                            if (zbuf.length < bestBuf.length)
-                                bestBuf = zbuf;
-                        }
-                    }
-                    catch (e) { }
-                }
-                catch (e) { }
-            }
-        }
-        catch (e) { }
-        try {
-            const advIn = join(tmpdir(), `rox_adv_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
-            writeFileSync(advIn, bestBuf);
-            const rAdv = spawnSync('advdef', ['-z4', '-i10', advIn], {
-                windowsHide: true,
-                stdio: 'ignore',
-                timeout: 120000,
-            });
-            if (!rAdv.error && existsSync(advIn)) {
-                const advBuf = readFileSync(advIn);
-                try {
-                    unlinkSync(advIn);
-                }
-                catch (e) { }
-                if (advBuf.length < bestBuf.length)
-                    bestBuf = advBuf;
-            }
-        }
-        catch (e) { }
-        for (const strat of strategies) {
-            try {
-                const comp = zlib.deflateSync(filteredAll, {
-                    level: 9,
-                    memLevel: 9,
-                    strategy: strat,
-                });
-                const altChunks = newChunks.map((c) => ({
-                    name: c.name,
-                    data: c.data,
-                }));
-                const idx = altChunks.findIndex((c) => c.name === 'IDAT');
-                if (idx !== -1)
-                    altChunks[idx] = { name: 'IDAT', data: comp };
-                const candidate = ensurePng(Buffer.from(encode(altChunks)));
-                if (candidate.length < bestBuf.length)
-                    bestBuf = candidate;
-            }
-            catch (e) { }
-        }
-        try {
-            const pixels = Buffer.alloc(width * height * 3);
-            let prev = null;
-            for (let y = 0; y < height; y++) {
-                const f = raw[y * inRowLen];
-                const row = raw.slice(y * inRowLen + 1, y * inRowLen + 1 + rowBytes);
-                const recon = Buffer.alloc(rowBytes);
-                for (let i = 0; i < rowBytes; i++) {
-                    const left = i - 3 >= 0 ? recon[i - 3] : 0;
-                    const up = prev ? prev[i] : 0;
-                    const upLeft = prev && i - 3 >= 0 ? prev[i - 3] : 0;
-                    let v = row[i];
-                    if (f === 0) {
-                    }
-                    else if (f === 1)
-                        v = (v + left) & 0xff;
-                    else if (f === 2)
-                        v = (v + up) & 0xff;
-                    else if (f === 3)
-                        v = (v + Math.floor((left + up) / 2)) & 0xff;
-                    else
-                        v = (v + paethPredict(left, up, upLeft)) & 0xff;
-                    recon[i] = v;
-                }
-                recon.copy(pixels, y * rowBytes);
-                prev = recon;
-            }
-            const paletteMap = new Map();
-            const palette = [];
-            for (let i = 0; i < pixels.length; i += 3) {
-                const key = `${pixels[i]},${pixels[i + 1]},${pixels[i + 2]}`;
-                if (!paletteMap.has(key)) {
-                    paletteMap.set(key, paletteMap.size);
-                    palette.push(pixels[i], pixels[i + 1], pixels[i + 2]);
-                    if (paletteMap.size > 256)
-                        break;
-                }
-            }
-            if (paletteMap.size <= 256) {
-                const idxRowLen = 1 + width * 1;
-                const idxRows = [];
-                for (let y = 0; y < height; y++) {
-                    const rowIdx = Buffer.alloc(width);
-                    for (let x = 0; x < width; x++) {
-                        const pos = (y * width + x) * 3;
-                        const key = `${pixels[pos]},${pixels[pos + 1]},${pixels[pos + 2]}`;
-                        rowIdx[x] = paletteMap.get(key);
-                    }
-                    let bestRowFilter = 0;
-                    let bestRowSum = Infinity;
-                    let bestRowFiltered = null;
-                    for (let f = 0; f <= 4; f++) {
-                        const filteredRow = Buffer.alloc(width);
-                        let sum = 0;
-                        for (let i = 0; i < width; i++) {
-                            const val = rowIdx[i];
-                            let outv = 0;
-                            const left = i - 1 >= 0 ? rowIdx[i - 1] : 0;
-                            const up = y > 0 ? idxRows[y - 1][i] : 0;
-                            const upLeft = y > 0 && i - 1 >= 0 ? idxRows[y - 1][i - 1] : 0;
-                            if (f === 0)
-                                outv = val;
-                            else if (f === 1)
-                                outv = (val - left + 256) & 0xff;
-                            else if (f === 2)
-                                outv = (val - up + 256) & 0xff;
-                            else if (f === 3)
-                                outv = (val - Math.floor((left + up) / 2) + 256) & 0xff;
-                            else
-                                outv = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
-                            filteredRow[i] = outv;
-                            const signed = outv > 127 ? outv - 256 : outv;
-                            sum += Math.abs(signed);
-                        }
-                        if (sum < bestRowSum) {
-                            bestRowSum = sum;
-                            bestRowFilter = f;
-                            bestRowFiltered = filteredRow;
-                        }
-                    }
-                    const rowBuf = Buffer.alloc(idxRowLen);
-                    rowBuf[0] = bestRowFilter;
-                    bestRowFiltered.copy(rowBuf, 1);
-                    idxRows.push(rowBuf);
-                }
-                const freqMap = new Map();
-                for (let i = 0; i < pixels.length; i += 3) {
-                    const key = `${pixels[i]},${pixels[i + 1]},${pixels[i + 2]}`;
-                    freqMap.set(key, (freqMap.get(key) || 0) + 1);
-                }
-                const paletteVariants = [];
-                paletteVariants.push({
-                    paletteArr: palette.slice(),
-                    map: new Map(paletteMap),
-                });
-                const freqSorted = Array.from(freqMap.entries()).sort((a, b) => b[1] - a[1]);
-                if (freqSorted.length > 0) {
-                    const pal2 = [];
-                    const map2 = new Map();
-                    let pi = 0;
-                    for (const [k] of freqSorted) {
-                        const parts = k.split(',').map((s) => Number(s));
-                        pal2.push(parts[0], parts[1], parts[2]);
-                        map2.set(k, pi++);
-                        if (pi >= 256)
-                            break;
-                    }
-                    if (map2.size <= 256)
-                        paletteVariants.push({ paletteArr: pal2, map: map2 });
-                }
-                for (const variant of paletteVariants) {
-                    const pSize = variant.map.size;
-                    const bitDepth = pSize <= 2 ? 1 : pSize <= 4 ? 2 : pSize <= 16 ? 4 : 8;
-                    const idxRowsVar = [];
-                    for (let y = 0; y < height; y++) {
-                        const rowIdx = Buffer.alloc(width);
-                        for (let x = 0; x < width; x++) {
-                            const pos = (y * width + x) * 3;
-                            const key = `${pixels[pos]},${pixels[pos + 1]},${pixels[pos + 2]}`;
-                            rowIdx[x] = variant.map.get(key);
-                        }
-                        idxRowsVar.push(rowIdx);
-                    }
-                    function packRowIndices(rowIdx, bitDepth) {
-                        if (bitDepth === 8)
-                            return rowIdx;
-                        const bitsPerRow = width * bitDepth;
-                        const outLen = Math.ceil(bitsPerRow / 8);
-                        const out = Buffer.alloc(outLen);
-                        let bitPos = 0;
-                        for (let i = 0; i < width; i++) {
-                            const val = rowIdx[i] & ((1 << bitDepth) - 1);
-                            for (let b = 0; b < bitDepth; b++) {
-                                const bit = (val >> (bitDepth - 1 - b)) & 1;
-                                const byteIdx = Math.floor(bitPos / 8);
-                                const shift = 7 - (bitPos % 8);
-                                out[byteIdx] |= bit << shift;
-                                bitPos++;
-                            }
-                        }
-                        return out;
-                    }
-                    const packedRows = [];
-                    for (let y = 0; y < height; y++) {
-                        const packed = packRowIndices(idxRowsVar[y], bitDepth);
-                        let bestRowFilter = 0;
-                        let bestRowSum = Infinity;
-                        let bestRowFiltered = null;
-                        for (let f = 0; f <= 4; f++) {
-                            const filteredRow = Buffer.alloc(packed.length);
-                            let sum = 0;
-                            for (let i = 0; i < packed.length; i++) {
-                                const val = packed[i];
-                                const left = i - 1 >= 0 ? packed[i - 1] : 0;
-                                const up = y > 0 ? packedRows[y - 1][i] : 0;
-                                const upLeft = y > 0 && i - 1 >= 0 ? packedRows[y - 1][i - 1] : 0;
-                                let outv = 0;
-                                if (f === 0)
-                                    outv = val;
-                                else if (f === 1)
-                                    outv = (val - left + 256) & 0xff;
-                                else if (f === 2)
-                                    outv = (val - up + 256) & 0xff;
-                                else if (f === 3)
-                                    outv = (val - Math.floor((left + up) / 2) + 256) & 0xff;
-                                else
-                                    outv = (val - paethPredict(left, up, upLeft) + 256) & 0xff;
-                                filteredRow[i] = outv;
-                                const signed = outv > 127 ? outv - 256 : outv;
-                                sum += Math.abs(signed);
-                            }
-                            if (sum < bestRowSum) {
-                                bestRowSum = sum;
-                                bestRowFilter = f;
-                                bestRowFiltered = filteredRow;
-                            }
-                        }
-                        const rowBuf = Buffer.alloc(1 + packed.length);
-                        rowBuf[0] = bestRowFilter;
-                        bestRowFiltered.copy(rowBuf, 1);
-                        packedRows.push(rowBuf);
-                    }
-                    const idxFilteredAllVar = Buffer.concat(packedRows);
-                    const palettesBufVar = Buffer.from(variant.paletteArr);
-                    const palChunksVar = [];
-                    const ihdr = Buffer.alloc(13);
-                    ihdr.writeUInt32BE(width, 0);
-                    ihdr.writeUInt32BE(height, 4);
-                    ihdr[8] = bitDepth;
-                    ihdr[9] = 3;
-                    ihdr[10] = 0;
-                    ihdr[11] = 0;
-                    ihdr[12] = 0;
-                    palChunksVar.push({ name: 'IHDR', data: ihdr });
-                    palChunksVar.push({ name: 'PLTE', data: palettesBufVar });
-                    palChunksVar.push({
-                        name: 'IDAT',
-                        data: zlib.deflateSync(idxFilteredAllVar, { level: 9 }),
-                    });
-                    palChunksVar.push({ name: 'IEND', data: Buffer.alloc(0) });
-                    const palOutVar = ensurePng(Buffer.from(encode(palChunksVar)));
-                    if (palOutVar.length < bestBuf.length)
-                        bestBuf = palOutVar;
-                }
-            }
-        }
-        catch (e) { }
-        const externalAttempts = [
-            { cmd: 'oxipng', args: ['-o', '6', '--strip', 'all'] },
-            { cmd: 'optipng', args: ['-o7'] },
-            { cmd: 'pngcrush', args: ['-brute', '-reduce'] },
-            { cmd: 'pngout', args: [] },
-        ];
-        for (const tool of externalAttempts) {
-            try {
-                const tIn = join(tmpdir(), `rox_ext_in_${Date.now()}_${Math.random().toString(36).slice(2)}.png`);
-                const tOut = tIn + '.out.png';
-                writeFileSync(tIn, bestBuf);
-                const args = tool.args.concat([tIn, tOut]);
-                const r = spawnSync(tool.cmd, args, {
-                    windowsHide: true,
-                    stdio: 'ignore',
-                    timeout: 240000,
-                });
-                if (!r.error && existsSync(tOut)) {
-                    const outb = readFileSync(tOut);
-                    try {
-                        unlinkSync(tIn);
-                        unlinkSync(tOut);
-                    }
-                    catch (e) { }
-                    if (outb.length < bestBuf.length)
-                        bestBuf = outb;
-                }
-                else {
-                    try {
-                        unlinkSync(tIn);
-                    }
-                    catch (e) { }
-                }
-            }
-            catch (e) { }
-        }
-        return bestBuf;
-    }
-    catch (e) {
-        return pngBuf;
-    }
-}
-function applyXor(buf, passphrase) {
-    const key = Buffer.from(passphrase, 'utf8');
-    const out = Buffer.alloc(buf.length);
-    for (let i = 0; i < buf.length; i++) {
-        out[i] = buf[i] ^ key[i % key.length];
-    }
-    return out;
-}
-async function tryZstdDecompress(payload, onProgress, onChunk, outPath) {
-    return await parallelZstdDecompress(payload, onProgress, onChunk, outPath);
-}
-async function tryDecompress(payload, onProgress, onChunk, outPath) {
-    try {
-        return await parallelZstdDecompress(payload, onProgress, onChunk, outPath);
-    }
-    catch (e) {
-        try {
-            const mod = await import('lzma-purejs');
-            const decompressFn = mod && (mod.decompress || (mod.LZMA && mod.LZMA.decompress));
-            if (!decompressFn)
-                throw new Error('No lzma decompress');
-            const dec = await new Promise((resolve, reject) => {
-                try {
-                    decompressFn(Buffer.from(payload), (out) => resolve(out));
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
-            const dBuf = Buffer.isBuffer(dec) ? dec : Buffer.from(dec);
-            if (onChunk) {
-                await onChunk(dBuf, 1, 1);
-                return Buffer.alloc(0);
-            }
-            if (outPath) {
-                const ws = createWriteStream(outPath);
-                await writeInChunks(ws, dBuf);
-                ws.end();
-                return Buffer.alloc(0);
-            }
-            return dBuf;
-        }
-        catch (e2) {
-            throw e;
-        }
-    }
-}
-function tryDecryptIfNeeded(buf, passphrase) {
-    if (!buf || buf.length === 0)
-        return buf;
-    const flag = buf[0];
-    if (flag === ENC_AES) {
-        const MIN_AES_LEN = 1 + 16 + 12 + 16 + 1;
-        if (buf.length < MIN_AES_LEN)
-            throw new IncorrectPassphraseError();
-        if (!passphrase)
-            throw new PassphraseRequiredError();
-        const salt = buf.slice(1, 17);
-        const iv = buf.slice(17, 29);
-        const tag = buf.slice(29, 45);
-        const enc = buf.slice(45);
-        const PBKDF2_ITERS = 1000000;
-        const key = pbkdf2Sync(passphrase, salt, PBKDF2_ITERS, 32, 'sha256');
-        const dec = createDecipheriv('aes-256-gcm', key, iv);
-        dec.setAuthTag(tag);
-        try {
-            const decrypted = Buffer.concat([dec.update(enc), dec.final()]);
-            return decrypted;
-        }
-        catch (e) {
-            throw new IncorrectPassphraseError();
-        }
-    }
-    if (flag === ENC_XOR) {
-        if (!passphrase)
-            throw new PassphraseRequiredError();
-        return applyXor(buf.slice(1), passphrase);
-    }
-    if (flag === ENC_NONE) {
-        return buf.slice(1);
-    }
-    return buf;
-}
-export async function cropAndReconstitute(input, debugDir) {
-    async function loadRaw(imgInput) {
-        const { data, info } = await sharp(imgInput)
-            .ensureAlpha()
-            .raw()
-            .toBuffer({ resolveWithObject: true });
-        return { data, info };
-    }
-    function idxFor(x, y, width) {
-        return (y * width + x) * 4;
-    }
-    function eqRGB(a, b) {
-        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-    }
-    const { info } = await loadRaw(input);
-    const doubledBuffer = await sharp(input)
-        .resize({
-        width: info.width * 2,
-        height: info.height * 2,
-        kernel: 'nearest',
-    })
-        .png()
-        .toBuffer();
-    if (debugDir) {
-        await sharp(doubledBuffer).toFile(join(debugDir, 'doubled.png'));
-    }
-    const { data: doubledData, info: doubledInfo } = await loadRaw(doubledBuffer);
-    const w = doubledInfo.width, h = doubledInfo.height;
-    const at = (x, y) => {
-        const i = idxFor(x, y, w);
-        return [
-            doubledData[i],
-            doubledData[i + 1],
-            doubledData[i + 2],
-            doubledData[i + 3],
-        ];
-    };
-    const findPattern = (startX, startY, dirX, dirY, pattern) => {
-        for (let y = startY; y >= 0 && y < h; y += dirY) {
-            for (let x = startX; x >= 0 && x < w; x += dirX) {
-                const p = at(x, y);
-                if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
-                    continue;
-                let nx = x + dirX;
-                while (nx >= 0 && nx < w && eqRGB(at(nx, y), p))
-                    nx += dirX;
-                if (nx < 0 || nx >= w)
-                    continue;
-                const a = at(nx, y);
-                let nx2 = nx + dirX;
-                while (nx2 >= 0 && nx2 < w && eqRGB(at(nx2, y), a))
-                    nx2 += dirX;
-                if (nx2 < 0 || nx2 >= w)
-                    continue;
-                const b = at(nx2, y);
-                if (a[0] === pattern[0][0] &&
-                    a[1] === pattern[0][1] &&
-                    a[2] === pattern[0][2] &&
-                    b[0] === pattern[1][0] &&
-                    b[1] === pattern[1][1] &&
-                    b[2] === pattern[1][2]) {
-                    return { x, y };
-                }
-            }
-        }
-        return null;
-    };
-    const startPoint = findPattern(0, 0, 1, 1, [
-        [0, 255, 0],
-        [0, 0, 255],
-    ]);
-    const endPoint = findPattern(w - 1, h - 1, -1, -1, [
-        [0, 255, 0],
-        [0, 0, 255],
-    ]);
-    if (!startPoint || !endPoint)
-        throw new Error('Patterns not found');
-    const sx1 = Math.min(startPoint.x, endPoint.x), sy1 = Math.min(startPoint.y, endPoint.y);
-    const sx2 = Math.max(startPoint.x, endPoint.x), sy2 = Math.max(startPoint.y, endPoint.y);
-    const cropW = sx2 - sx1 + 1, cropH = sy2 - sy1 + 1;
-    if (cropW <= 0 || cropH <= 0)
-        throw new Error('Invalid crop dimensions');
-    const cropped = await sharp(doubledBuffer)
-        .extract({ left: sx1, top: sy1, width: cropW, height: cropH })
-        .png()
-        .toBuffer();
-    const { data: cdata, info: cinfo } = await loadRaw(cropped);
-    const cw = cinfo.width, ch = cinfo.height;
-    const newWidth = cw, newHeight = ch + 1;
-    const out = Buffer.alloc(newWidth * newHeight * 4, 0);
-    for (let i = 0; i < out.length; i += 4)
-        out[i + 3] = 255;
-    for (let y = 0; y < ch; y++) {
-        for (let x = 0; x < cw; x++) {
-            const srcI = (y * cw + x) * 4;
-            const dstI = (y * newWidth + x) * 4;
-            out[dstI] = cdata[srcI];
-            out[dstI + 1] = cdata[srcI + 1];
-            out[dstI + 2] = cdata[srcI + 2];
-            out[dstI + 3] = cdata[srcI + 3];
-        }
-    }
-    for (let x = 0; x < newWidth; x++) {
-        const i = ((ch - 1) * newWidth + x) * 4;
-        out[i] = out[i + 1] = out[i + 2] = 0;
-        out[i + 3] = 255;
-        const j = (ch * newWidth + x) * 4;
-        out[j] = out[j + 1] = out[j + 2] = 0;
-        out[j + 3] = 255;
-    }
-    if (newWidth >= 3) {
-        const bgrStart = newWidth - 3;
-        const bgr = [
-            [0, 0, 255],
-            [0, 255, 0],
-            [255, 0, 0],
-        ];
-        for (let k = 0; k < 3; k++) {
-            const i = (ch * newWidth + bgrStart + k) * 4;
-            out[i] = bgr[k][0];
-            out[i + 1] = bgr[k][1];
-            out[i + 2] = bgr[k][2];
-            out[i + 3] = 255;
-        }
-    }
-    const getPixel = (x, y) => {
-        const i = (y * newWidth + x) * 4;
-        return [out[i], out[i + 1], out[i + 2], out[i + 3]];
-    };
-    const compressedLines = [];
-    for (let y = 0; y < newHeight; y++) {
-        const line = [];
-        for (let x = 0; x < newWidth; x++)
-            line.push(getPixel(x, y));
-        const isAllBlack = line.every((p) => p[0] === 0 && p[1] === 0 && p[2] === 0 && p[3] === 255);
-        if (!isAllBlack &&
-            (compressedLines.length === 0 ||
-                !line.every((p, i) => p.every((v, j) => v === compressedLines[compressedLines.length - 1][i][j])))) {
-            compressedLines.push(line);
-        }
-    }
-    if (compressedLines.length === 0) {
-        return sharp({
-            create: {
-                width: 1,
-                height: 1,
-                channels: 4,
-                background: { r: 0, g: 0, b: 0, alpha: 1 },
-            },
-        })
-            .png()
-            .toBuffer();
-    }
-    let finalWidth = newWidth, finalHeight = compressedLines.length;
-    let finalOut = Buffer.alloc(finalWidth * finalHeight * 4, 0);
-    for (let i = 0; i < finalOut.length; i += 4)
-        finalOut[i + 3] = 255;
-    for (let y = 0; y < finalHeight; y++) {
-        for (let x = 0; x < finalWidth; x++) {
-            const i = (y * finalWidth + x) * 4;
-            finalOut[i] = compressedLines[y][x][0];
-            finalOut[i + 1] = compressedLines[y][x][1];
-            finalOut[i + 2] = compressedLines[y][x][2];
-            finalOut[i + 3] = compressedLines[y][x][3] || 255;
-        }
-    }
-    if (finalHeight >= 1 && finalWidth >= 3) {
-        const lastY = finalHeight - 1;
-        for (let k = 0; k < 3; k++) {
-            const i = (lastY * finalWidth + finalWidth - 3 + k) * 4;
-            finalOut[i] = finalOut[i + 1] = finalOut[i + 2] = 0;
-            finalOut[i + 3] = 255;
-        }
-    }
-    if (finalWidth >= 2) {
-        const kept = [];
-        for (let x = 0; x < finalWidth; x++) {
-            if (kept.length === 0) {
-                kept.push(x);
-                continue;
-            }
-            const prevX = kept[kept.length - 1];
-            let same = true;
-            for (let y = 0; y < finalHeight; y++) {
-                const ia = (y * finalWidth + prevX) * 4, ib = (y * finalWidth + x) * 4;
-                if (finalOut[ia] !== finalOut[ib] ||
-                    finalOut[ia + 1] !== finalOut[ib + 1] ||
-                    finalOut[ia + 2] !== finalOut[ib + 2] ||
-                    finalOut[ia + 3] !== finalOut[ib + 3]) {
-                    same = false;
-                    break;
-                }
-            }
-            if (!same)
-                kept.push(x);
-        }
-        if (kept.length !== finalWidth) {
-            const newFinalWidth = kept.length;
-            const newOut = Buffer.alloc(newFinalWidth * finalHeight * 4, 0);
-            for (let i = 0; i < newOut.length; i += 4)
-                newOut[i + 3] = 255;
-            for (let nx = 0; nx < kept.length; nx++) {
-                const sx = kept[nx];
-                for (let y = 0; y < finalHeight; y++) {
-                    const srcI = (y * finalWidth + sx) * 4, dstI = (y * newFinalWidth + nx) * 4;
-                    newOut[dstI] = finalOut[srcI];
-                    newOut[dstI + 1] = finalOut[srcI + 1];
-                    newOut[dstI + 2] = finalOut[srcI + 2];
-                    newOut[dstI + 3] = finalOut[srcI + 3];
-                }
-            }
-            finalOut = newOut;
-            finalWidth = newFinalWidth;
-        }
-    }
-    if (finalHeight >= 2 && finalWidth >= 3) {
-        const secondLastY = finalHeight - 2;
-        const bgrSeq = [
-            [0, 0, 255],
-            [0, 255, 0],
-            [255, 0, 0],
-        ];
-        let hasBGR = true;
-        for (let k = 0; k < 3; k++) {
-            const i = (secondLastY * finalWidth + finalWidth - 3 + k) * 4;
-            if (finalOut[i] !== bgrSeq[k][0] ||
-                finalOut[i + 1] !== bgrSeq[k][1] ||
-                finalOut[i + 2] !== bgrSeq[k][2]) {
-                hasBGR = false;
-                break;
-            }
-        }
-        if (hasBGR) {
-            for (let k = 0; k < 3; k++) {
-                const i = (secondLastY * finalWidth + finalWidth - 3 + k) * 4;
-                finalOut[i] = finalOut[i + 1] = finalOut[i + 2] = 0;
-                finalOut[i + 3] = 255;
-            }
-        }
-    }
-    if (finalHeight >= 1 && finalWidth >= 1) {
-        const lastYFinal = finalHeight - 1;
-        const bgrSeq = [
-            [0, 0, 255],
-            [0, 255, 0],
-            [255, 0, 0],
-        ];
-        for (let k = 0; k < 3; k++) {
-            const sx = finalWidth - 3 + k;
-            if (sx >= 0) {
-                const i = (lastYFinal * finalWidth + sx) * 4;
-                finalOut[i] = bgrSeq[k][0];
-                finalOut[i + 1] = bgrSeq[k][1];
-                finalOut[i + 2] = bgrSeq[k][2];
-                finalOut[i + 3] = 255;
-            }
-        }
-    }
-    return sharp(finalOut, {
-        raw: { width: finalWidth, height: finalHeight, channels: 4 },
-    })
-        .png()
-        .toBuffer();
-}
-/**
- * Encode a Buffer into a PNG wrapper. Supports optional compression and
- * encryption. Defaults are chosen for a good balance between speed and size.
- *
- * @param input - Data to encode
- * @param opts - Encoding options
- * @public
- * @example
- * ```typescript
-* import { readFileSync, writeFileSync } from 'fs';
-* import { encodeBinaryToPng } from 'roxify';
-*
-* const fileName = 'input.bin'; //Path of your input file here
-* const inputBuffer = readFileSync(fileName);
-* const pngBuffer = await encodeBinaryToPng(inputBuffer, {
-*   name: fileName,
-* });
-* writeFileSync('output.png', pngBuffer);
-
- * ```
- */
-export async function encodeBinaryToPng(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' });
-        const startTime = Date.now();
-        if (!opts.onProgress) {
-            opts.onProgress = (info) => {
-                let pct = 0;
-                if (info.phase === 'compress_progress' && info.loaded && info.total) {
-                    pct = (info.loaded / info.total) * 50;
-                }
-                else if (info.phase === 'compress_done') {
-                    pct = 50;
-                }
-                else if (info.phase === 'encrypt_done') {
-                    pct = 80;
-                }
-                else if (info.phase === 'png_gen') {
-                    pct = 90;
-                }
-                else if (info.phase === 'done') {
-                    pct = 100;
-                }
-                progressBar.update(Math.floor(pct), {
-                    step: info.phase.replace('_', ' '),
-                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
-                });
-            };
-        }
-    }
-    let payload = Buffer.concat([MAGIC, input]);
-    const mode = opts.mode === undefined ? 'screenshot' : opts.mode;
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'compress_start', total: payload.length });
-    const useDelta = mode !== 'screenshot';
-    const deltaEncoded = useDelta ? deltaEncode(payload) : payload;
-    payload = await parallelZstdCompress(deltaEncoded, 11, (loaded, total) => {
-        if (opts.onProgress) {
-            opts.onProgress({
-                phase: 'compress_progress',
-                loaded,
-                total,
-            });
-        }
-    });
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'compress_done', loaded: payload.length });
-    if (opts.passphrase && !opts.encrypt) {
-        opts.encrypt = 'aes';
-    }
-    if (opts.encrypt === 'auto' && !opts._skipAuto) {
-        const candidates = ['none', 'xor', 'aes'];
-        const candidateBufs = [];
-        for (const c of candidates) {
-            const testBuf = await encodeBinaryToPng(input, {
-                ...opts,
-                encrypt: c,
-                _skipAuto: true,
-            });
-            candidateBufs.push({ enc: c, buf: testBuf });
-        }
-        candidateBufs.sort((a, b) => a.buf.length - b.buf.length);
-        return candidateBufs[0].buf;
-    }
-    if (opts.passphrase && opts.encrypt && opts.encrypt !== 'auto') {
-        const encChoice = opts.encrypt;
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'encrypt_start' });
-        if (encChoice === 'aes') {
-            const salt = randomBytes(16);
-            const iv = randomBytes(12);
-            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 tag = cipher.getAuthTag();
-            payload = Buffer.concat([Buffer.from([ENC_AES]), salt, iv, tag, enc]);
-            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]);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'encrypt_done' });
-        }
-        else if (encChoice === 'none') {
-            payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'encrypt_done' });
-        }
-    }
-    else {
-        payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
-    }
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'meta_prep_done', loaded: payload.length });
-    const metaParts = [];
-    const includeName = opts.includeName === undefined ? true : !!opts.includeName;
-    if (includeName && opts.name) {
-        const nameBuf = Buffer.from(opts.name, 'utf8');
-        metaParts.push(Buffer.from([nameBuf.length]));
-        metaParts.push(nameBuf);
-    }
-    else {
-        metaParts.push(Buffer.from([0]));
-    }
-    metaParts.push(payload);
-    let meta = Buffer.concat(metaParts);
-    if (opts.includeFileList && opts.fileList) {
-        const jsonBuf = Buffer.from(JSON.stringify(opts.fileList), 'utf8');
-        const lenBuf = Buffer.alloc(4);
-        lenBuf.writeUInt32BE(jsonBuf.length, 0);
-        meta = Buffer.concat([meta, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf]);
-    }
-    if (opts.output === 'rox') {
-        return Buffer.concat([MAGIC, meta]);
-    }
-    if (mode === 'screenshot') {
-        const nameBuf = opts.name
-            ? Buffer.from(opts.name, 'utf8')
-            : Buffer.alloc(0);
-        const nameLen = nameBuf.length;
-        const payloadLenBuf = Buffer.alloc(4);
-        payloadLenBuf.writeUInt32BE(payload.length, 0);
-        const version = 1;
-        let metaPixel = Buffer.concat([
-            Buffer.from([version]),
-            Buffer.from([nameLen]),
-            nameBuf,
-            payloadLenBuf,
-            payload,
-        ]);
-        if (opts.includeFileList && opts.fileList) {
-            const jsonBuf = Buffer.from(JSON.stringify(opts.fileList), 'utf8');
-            const lenBuf = Buffer.alloc(4);
-            lenBuf.writeUInt32BE(jsonBuf.length, 0);
-            metaPixel = Buffer.concat([
-                metaPixel,
-                Buffer.from('rXFL', 'utf8'),
-                lenBuf,
-                jsonBuf,
-            ]);
-        }
-        const dataWithoutMarkers = Buffer.concat([PIXEL_MAGIC, metaPixel]);
-        const padding = (3 - (dataWithoutMarkers.length % 3)) % 3;
-        const paddedData = padding > 0
-            ? Buffer.concat([dataWithoutMarkers, Buffer.alloc(padding)])
-            : dataWithoutMarkers;
-        const markerStartBytes = colorsToBytes(MARKER_START);
-        const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);
-        const dataWithMarkers = Buffer.concat([
-            markerStartBytes,
-            compressionMarkerBytes,
-            paddedData,
-        ]);
-        const bytesPerPixel = 3;
-        const dataPixels = Math.ceil(dataWithMarkers.length / 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 raw = Buffer.alloc(width * height * bytesPerPixel);
-        for (let ly = 0; ly < logicalHeight; ly++) {
-            for (let lx = 0; lx < logicalWidth; lx++) {
-                const linearIdx = ly * logicalWidth + lx;
-                let r = 0, g = 0, b = 0;
-                if (ly === logicalHeight - 1 &&
-                    lx >= logicalWidth - MARKER_END.length) {
-                    const markerIdx = lx - (logicalWidth - MARKER_END.length);
-                    r = MARKER_END[markerIdx].r;
-                    g = MARKER_END[markerIdx].g;
-                    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;
-                }
-                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 (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);
-        let bufScr = await sharp(raw, {
-            raw: { width, height, channels: 3 },
-        })
-            .png({
-            compressionLevel: 6,
-            palette: false,
-            effort: 1,
-            adaptiveFiltering: false,
-        })
-            .toBuffer();
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', 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;
-        }
-    }
-    if (mode === 'pixel') {
-        const nameBuf = opts.name
-            ? Buffer.from(opts.name, 'utf8')
-            : Buffer.alloc(0);
-        const nameLen = nameBuf.length;
-        const payloadLenBuf = Buffer.alloc(4);
-        payloadLenBuf.writeUInt32BE(payload.length, 0);
-        const version = 1;
-        let metaPixel = Buffer.concat([
-            Buffer.from([version]),
-            Buffer.from([nameLen]),
-            nameBuf,
-            payloadLenBuf,
-            payload,
-        ]);
-        if (opts.includeFileList && opts.fileList) {
-            const jsonBuf = Buffer.from(JSON.stringify(opts.fileList), 'utf8');
-            const lenBuf = Buffer.alloc(4);
-            lenBuf.writeUInt32BE(jsonBuf.length, 0);
-            metaPixel = Buffer.concat([
-                metaPixel,
-                Buffer.from('rXFL', 'utf8'),
-                lenBuf,
-                jsonBuf,
-            ]);
-        }
-        const full = Buffer.concat([PIXEL_MAGIC, metaPixel]);
-        const bytesPerPixel = 3;
-        const nPixels = Math.ceil((full.length + 8) / 3);
-        const desiredSide = Math.ceil(Math.sqrt(nPixels));
-        const sideClamped = Math.max(1, Math.min(desiredSide, 65535));
-        const width = sideClamped;
-        const height = sideClamped === desiredSide ? sideClamped : Math.ceil(nPixels / width);
-        const dimHeader = Buffer.alloc(8);
-        dimHeader.writeUInt32BE(width, 0);
-        dimHeader.writeUInt32BE(height, 4);
-        const fullWithDim = Buffer.concat([dimHeader, full]);
-        const rowLen = 1 + width * bytesPerPixel;
-        const raw = Buffer.alloc(rowLen * height);
-        for (let y = 0; y < height; y++) {
-            const rowOffset = y * rowLen;
-            raw[rowOffset] = 0;
-            for (let x = 0; x < width; x++) {
-                const srcIdx = (y * width + x) * 3;
-                const dstIdx = rowOffset + 1 + x * bytesPerPixel;
-                raw[dstIdx] = srcIdx < fullWithDim.length ? fullWithDim[srcIdx] : 0;
-                raw[dstIdx + 1] =
-                    srcIdx + 1 < fullWithDim.length ? fullWithDim[srcIdx + 1] : 0;
-                raw[dstIdx + 2] =
-                    srcIdx + 2 < fullWithDim.length ? fullWithDim[srcIdx + 2] : 0;
-            }
-        }
-        const idatData = zlib.deflateSync(raw, {
-            level: 6,
-            memLevel: 8,
-            strategy: zlib.constants.Z_RLE,
-        });
-        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 chunksPixel = [];
-        chunksPixel.push({ name: 'IHDR', data: ihdrData });
-        chunksPixel.push({ name: 'IDAT', data: idatData });
-        chunksPixel.push({ name: 'IEND', data: Buffer.alloc(0) });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 0, total: 2 });
-        const tmp = Buffer.from(encode(chunksPixel));
-        const outPng = tmp.slice(0, 8).toString('hex') === PNG_HEADER_HEX
-            ? tmp
-            : Buffer.concat([PNG_HEADER, tmp]);
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 1, total: 2 });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done', loaded: outPng.length });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done', loaded: outPng.length });
-        try {
-            const optimized = await optimizePngBuffer(outPng);
-            try {
-                const verified = await decodePngToBinary(optimized);
-                if (verified.buf && verified.buf.equals(input)) {
-                    progressBar?.stop();
-                    return optimized;
-                }
-            }
-            catch (e) { }
-            progressBar?.stop();
-            return outPng;
-        }
-        catch (e) {
-            progressBar?.stop();
-            return outPng;
-        }
-    }
-    if (mode === 'compact') {
-        const bytesPerPixel = 4;
-        const side = 1;
-        const width = side;
-        const height = side;
-        const rowLen = 1 + width * bytesPerPixel;
-        const raw = Buffer.alloc(rowLen * height);
-        for (let y = 0; y < height; y++) {
-            raw[y * rowLen] = 0;
-        }
-        const idatData = zlib.deflateSync(raw, {
-            level: 9,
-            memLevel: 9,
-            strategy: zlib.constants.Z_DEFAULT_STRATEGY,
-        });
-        const ihdrData = Buffer.alloc(13);
-        ihdrData.writeUInt32BE(width, 0);
-        ihdrData.writeUInt32BE(height, 4);
-        ihdrData[8] = 8;
-        ihdrData[9] = 6;
-        ihdrData[10] = 0;
-        ihdrData[11] = 0;
-        ihdrData[12] = 0;
-        const chunks2 = [];
-        chunks2.push({ name: 'IHDR', data: ihdrData });
-        chunks2.push({ name: 'IDAT', data: idatData });
-        chunks2.push({ name: CHUNK_TYPE, data: meta });
-        chunks2.push({ name: 'IEND', data: Buffer.alloc(0) });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 0, total: 2 });
-        const out = Buffer.from(encode(chunks2));
-        const outBuf = out.slice(0, 8).toString('hex') === PNG_HEADER_HEX
-            ? out
-            : Buffer.concat([PNG_HEADER, out]);
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'png_gen', loaded: 1, total: 2 });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done', loaded: outBuf.length });
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done', loaded: outBuf.length });
-        try {
-            const optimized = await optimizePngBuffer(outBuf);
-            try {
-                const verified = await decodePngToBinary(optimized);
-                if (verified.buf && verified.buf.equals(input)) {
-                    progressBar?.stop();
-                    return optimized;
-                }
-            }
-            catch (e) { }
-            progressBar?.stop();
-            return outBuf;
-        }
-        catch (e) {
-            progressBar?.stop();
-            return outBuf;
-        }
-    }
-    throw new Error(`Unsupported mode: ${mode}`);
-}
-/**
- * Decode a PNG produced by this library back to the original Buffer.
- * Supports the ROX binary format, rXDT chunk, and pixel encodings.
- *
- * @param pngBuf - PNG data
- * @param opts - Options (passphrase for encrypted inputs)
- * @public
- * @example
- * import { readFileSync, writeFileSync } from 'fs';
- * import { decodePngToBinary } from 'roxify';
- *
- * const pngFromDisk = readFileSync('output.png'); //Path of the encoded PNG here
- * const { buf, meta } = await decodePngToBinary(pngFromDisk);
- * writeFileSync(meta?.name ?? 'decoded.txt', buf);
- */
-export async function decodePngToBinary(pngBuf, 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' });
-        const startTime = Date.now();
-        if (!opts.onProgress) {
-            opts.onProgress = (info) => {
-                let pct = 0;
-                if (info.phase === 'start') {
-                    pct = 10;
-                }
-                else if (info.phase === 'decompress') {
-                    pct = 50;
-                }
-                else if (info.phase === 'done') {
-                    pct = 100;
-                }
-                progressBar.update(Math.floor(pct), {
-                    step: info.phase.replace('_', ' '),
-                    elapsed: String(Math.floor((Date.now() - startTime) / 1000)),
-                });
-            };
-        }
-    }
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'start' });
-    let processedBuf = pngBuf;
-    try {
-        const info = await sharp(pngBuf).metadata();
-        if (info.width && info.height) {
-            const MAX_RAW_BYTES = 150 * 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;
-            }
-        }
-    }
-    catch (e) { }
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'processed' });
-    if (processedBuf.slice(0, MAGIC.length).equals(MAGIC)) {
-        const d = processedBuf.slice(MAGIC.length);
-        const nameLen = d[0];
-        let idx = 1;
-        let name;
-        if (nameLen > 0) {
-            name = d.slice(idx, idx + nameLen).toString('utf8');
-            idx += nameLen;
-        }
-        const rawPayload = d.slice(idx);
-        let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-        if (opts.outPath) {
-            const ws = createWriteStream(opts.outPath, { highWaterMark: 64 * 1024 });
-            let headerBuf = Buffer.alloc(0);
-            let headerSkipped = false;
-            await tryDecompress(payload, (info) => {
-                if (opts.onProgress)
-                    opts.onProgress(info);
-            }, async (decChunk) => {
-                if (!headerSkipped) {
-                    if (decChunk.length < MAGIC.length) {
-                        headerBuf = Buffer.concat([headerBuf, decChunk]);
-                        return;
-                    }
-                    const mag = decChunk.slice(0, MAGIC.length);
-                    if (!mag.equals(MAGIC)) {
-                        ws.close();
-                        throw new Error('Invalid ROX format (ROX direct: missing ROX1 magic after decompression)');
-                    }
-                    const toWriteBuf = decChunk.slice(MAGIC.length);
-                    if (toWriteBuf.length > 0) {
-                        await writeInChunks(ws, toWriteBuf, 16 * 1024);
-                    }
-                    headerBuf = Buffer.alloc(0);
-                    headerSkipped = true;
-                }
-                else {
-                    await writeInChunks(ws, decChunk, 64 * 1024);
-                }
-            });
-            await new Promise((res) => ws.end(() => res()));
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            progressBar?.stop();
-            return { meta: { name } };
-        }
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'decompress_start' });
-        try {
-            payload = await tryDecompress(payload, (info) => {
-                if (opts.onProgress)
-                    opts.onProgress(info);
-            });
-        }
-        catch (e) {
-            const errMsg = e instanceof Error ? e.message : String(e);
-            if (opts.passphrase)
-                throw new IncorrectPassphraseError('Incorrect passphrase (compact mode, zstd failed: ' + errMsg + ')');
-            throw new DataFormatError('Compact mode zstd decompression failed: ' + errMsg);
-        }
-        if (!payload.slice(0, MAGIC.length).equals(MAGIC)) {
-            throw new Error('Invalid ROX format (ROX direct: missing ROX1 magic after decompression)');
-        }
-        payload = payload.slice(MAGIC.length);
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done' });
-        progressBar?.stop();
-        return { buf: payload, meta: { name } };
-    }
-    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),
-        }));
-    }
-    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),
-            }));
-        }
-        catch (e2) {
-            chunks = [];
-        }
-    }
-    const target = chunks.find((c) => c.name === CHUNK_TYPE);
-    if (target) {
-        const d = target.data;
-        const nameLen = d[0];
-        let idx = 1;
-        let name;
-        if (nameLen > 0) {
-            name = d.slice(idx, idx + nameLen).toString('utf8');
-            idx += nameLen;
-        }
-        const rawPayload = d.slice(idx);
-        if (rawPayload.length === 0)
-            throw new DataFormatError('Compact mode payload empty');
-        let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-        if (opts.outPath) {
-            const ws = createWriteStream(opts.outPath, { highWaterMark: 64 * 1024 });
-            let headerBuf = Buffer.alloc(0);
-            let headerSkipped = false;
-            await tryDecompress(payload, (info) => {
-                if (opts.onProgress)
-                    opts.onProgress(info);
-            }, async (decChunk) => {
-                if (!headerSkipped) {
-                    if (decChunk.length < MAGIC.length) {
-                        headerBuf = Buffer.concat([headerBuf, decChunk]);
-                        return;
-                    }
-                    const mag = decChunk.slice(0, MAGIC.length);
-                    if (!mag.equals(MAGIC)) {
-                        ws.close();
-                        throw new DataFormatError('Invalid ROX format (compact mode: missing ROX1 magic after decompression)');
-                    }
-                    const toWriteBuf = decChunk.slice(MAGIC.length);
-                    if (toWriteBuf.length > 0) {
-                        await writeInChunks(ws, toWriteBuf);
-                    }
-                    headerBuf = Buffer.alloc(0);
-                    headerSkipped = true;
-                }
-                else {
-                    await writeInChunks(ws, decChunk, 64 * 1024);
-                }
-            });
-            await new Promise((res) => ws.end(() => res()));
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            progressBar?.stop();
-            return { meta: { name } };
-        }
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'decompress_start' });
-        try {
-            payload = await tryZstdDecompress(payload, (info) => {
-                if (opts.onProgress)
-                    opts.onProgress(info);
-            });
-        }
-        catch (e) {
-            const errMsg = e instanceof Error ? e.message : String(e);
-            if (opts.passphrase)
-                throw new IncorrectPassphraseError('Incorrect passphrase (compact mode, zstd failed: ' + errMsg + ')');
-            throw new DataFormatError('Compact mode zstd decompression failed: ' + errMsg);
-        }
-        if (!payload.slice(0, MAGIC.length).equals(MAGIC)) {
-            throw new DataFormatError('Invalid ROX format (compact mode: missing ROX1 magic after decompression)');
-        }
-        payload = payload.slice(MAGIC.length);
-        if (opts.files) {
-            const unpacked = unpackBuffer(payload, opts.files);
-            if (unpacked) {
-                if (opts.onProgress)
-                    opts.onProgress({ phase: 'done' });
-                progressBar?.stop();
-                return { files: unpacked.files, meta: { name } };
-            }
-        }
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done' });
-        progressBar?.stop();
-        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 firstPixels = [];
-        for (let i = 0; i < Math.min(MARKER_START.length, rawRGB.length / 3); i++) {
-            firstPixels.push({
-                r: rawRGB[i * 3],
-                g: rawRGB[i * 3 + 1],
-                b: rawRGB[i * 3 + 2],
-            });
-        }
-        let hasMarkerStart = false;
-        if (firstPixels.length === MARKER_START.length) {
-            hasMarkerStart = true;
-            for (let i = 0; i < MARKER_START.length; i++) {
-                if (firstPixels[i].r !== MARKER_START[i].r ||
-                    firstPixels[i].g !== MARKER_START[i].g ||
-                    firstPixels[i].b !== MARKER_START[i].b) {
-                    hasMarkerStart = false;
-                    break;
-                }
-            }
-        }
-        let hasPixelMagic = false;
-        if (rawRGB.length >= 8 + PIXEL_MAGIC.length) {
-            const widthFromDim = rawRGB.readUInt32BE(0);
-            const heightFromDim = rawRGB.readUInt32BE(4);
-            if (widthFromDim === currentWidth &&
-                heightFromDim === currentHeight &&
-                rawRGB.slice(8, 8 + PIXEL_MAGIC.length).equals(PIXEL_MAGIC)) {
-                hasPixelMagic = true;
-            }
-        }
-        let logicalWidth;
-        let logicalHeight;
-        let logicalData;
-        if (hasMarkerStart || hasPixelMagic) {
-            logicalWidth = currentWidth;
-            logicalHeight = currentHeight;
-            logicalData = rawRGB;
-        }
-        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 (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');
-            }
-            let idx = 8 + PIXEL_MAGIC.length;
-            const version = logicalData[idx++];
-            const nameLen = logicalData[idx++];
-            let name;
-            if (nameLen > 0 && nameLen < 256) {
-                name = logicalData.slice(idx, idx + nameLen).toString('utf8');
-                idx += nameLen;
-            }
-            const payloadLen = logicalData.readUInt32BE(idx);
-            idx += 4;
-            const available = logicalData.length - idx;
-            if (available < payloadLen) {
-                throw new DataFormatError(`Pixel payload truncated: expected ${payloadLen} bytes but only ${available} available`);
-            }
-            const rawPayload = logicalData.slice(idx, idx + payloadLen);
-            let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-            try {
-                if (opts.outPath) {
-                    await tryDecompress(payload, (info) => {
-                        if (opts.onProgress)
-                            opts.onProgress(info);
-                    }, undefined, opts.outPath);
-                }
-                else {
-                    payload = await tryZstdDecompress(payload, (info) => {
-                        if (opts.onProgress)
-                            opts.onProgress(info);
-                    });
-                }
-                if (version === 3) {
-                    if (opts.outPath) {
-                        throw new Error('outPath not supported with delta encoding yet');
-                    }
-                    else {
-                        payload = deltaDecode(payload);
-                    }
-                }
-            }
-            catch (e) { }
-            if (!payload.slice(0, MAGIC.length).equals(MAGIC)) {
-                throw new DataFormatError('Invalid ROX format (pixel mode: missing ROX1 magic after decompression)');
-            }
-            payload = payload.slice(MAGIC.length);
-            return { buf: payload, meta: { name } };
-        }
-        let startIdx = -1;
-        for (let i = 0; i <= finalGrid.length - 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) {
-                    match = false;
-                }
-            }
-            if (match) {
-                startIdx = i;
-                break;
-            }
-        }
-        if (startIdx === -1) {
-            if (process.env.ROX_DEBUG) {
-                console.log('DEBUG: MARKER_START not found in grid of', finalGrid.length, 'pixels');
-                console.log('DEBUG: Trying 2D scan for START marker...');
-            }
-            let found2D = false;
-            for (let y = 0; y < logicalHeight && !found2D; y++) {
-                for (let x = 0; x <= logicalWidth - MARKER_START.length && !found2D; x++) {
-                    let match = true;
-                    for (let mi = 0; mi < MARKER_START.length && match; mi++) {
-                        const idx = (y * logicalWidth + (x + mi)) * 3;
-                        if (idx + 2 >= logicalData.length ||
-                            logicalData[idx] !== MARKER_START[mi].r ||
-                            logicalData[idx + 1] !== MARKER_START[mi].g ||
-                            logicalData[idx + 2] !== MARKER_START[mi].b) {
-                            match = false;
-                        }
-                    }
-                    if (match) {
-                        if (process.env.ROX_DEBUG) {
-                            console.log(`DEBUG: Found START marker in 2D at (${x}, ${y})`);
-                        }
-                        let endX = x + MARKER_START.length - 1;
-                        let endY = y;
-                        for (let scanY = y; scanY < logicalHeight; scanY++) {
-                            let rowHasData = false;
-                            for (let scanX = x; scanX < logicalWidth; scanX++) {
-                                const scanIdx = (scanY * logicalWidth + scanX) * 3;
-                                if (scanIdx + 2 < logicalData.length) {
-                                    const r = logicalData[scanIdx];
-                                    const g = logicalData[scanIdx + 1];
-                                    const b = logicalData[scanIdx + 2];
-                                    const isBackground = (r === 100 && g === 120 && b === 110) ||
-                                        (r === 0 && g === 0 && b === 0) ||
-                                        (r >= 50 &&
-                                            r <= 220 &&
-                                            g >= 50 &&
-                                            g <= 220 &&
-                                            b >= 50 &&
-                                            b <= 220 &&
-                                            Math.abs(r - g) < 70 &&
-                                            Math.abs(r - b) < 70 &&
-                                            Math.abs(g - b) < 70);
-                                    if (!isBackground) {
-                                        rowHasData = true;
-                                        if (scanX > endX) {
-                                            endX = scanX;
-                                        }
-                                    }
-                                }
-                            }
-                            if (rowHasData) {
-                                endY = scanY;
-                            }
-                            else if (scanY > y) {
-                                break;
-                            }
-                        }
-                        const rectWidth = endX - x + 1;
-                        const rectHeight = endY - y + 1;
-                        if (process.env.ROX_DEBUG) {
-                            console.log(`DEBUG: Extracted rectangle: ${rectWidth}x${rectHeight} from (${x},${y})`);
-                        }
-                        finalGrid.length = 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],
-                                });
-                            }
-                        }
-                        startIdx = 0;
-                        found2D = true;
-                    }
-                }
-            }
-            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(' '));
-                }
-                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}`);
-        }
-        const gridFromStart = finalGrid.slice(startIdx);
-        if (gridFromStart.length < MARKER_START.length + MARKER_END.length) {
-            if (process.env.ROX_DEBUG) {
-                console.log('DEBUG: gridFromStart too small:', gridFromStart.length, '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) {
-                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 (compPixel.r === 0 && compPixel.g === 255 && compPixel.b === 0) {
-                compression = 'zstd';
-            }
-            else {
-                compression = 'zstd';
-            }
-        }
-        if (process.env.ROX_DEBUG) {
-            console.log(`DEBUG: Detected compression: ${compression}`);
-        }
-        let endStartIdx = -1;
-        const lastLineStart = (logicalHeight - 1) * logicalWidth;
-        const endMarkerStartCol = logicalWidth - MARKER_END.length;
-        if (lastLineStart + endMarkerStartCol < finalGrid.length) {
-            let matchEnd = true;
-            for (let mi = 0; mi < MARKER_END.length && matchEnd; mi++) {
-                const idx = lastLineStart + endMarkerStartCol + mi;
-                if (idx >= finalGrid.length) {
-                    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) {
-                    matchEnd = false;
-                }
-            }
-            if (matchEnd) {
-                endStartIdx = lastLineStart + endMarkerStartCol - startIdx;
-                if (process.env.ROX_DEBUG) {
-                    console.log(`DEBUG: Found END marker at last line, col ${endMarkerStartCol}`);
-                }
-            }
-        }
-        if (endStartIdx === -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;
-        }
-        if (process.env.ROX_DEBUG) {
-            console.log('DEBUG: extracted len', pixelBytes.length);
-            console.log('DEBUG: extracted head', pixelBytes.slice(0, 32).toString('hex'));
-            const found = pixelBytes.indexOf(PIXEL_MAGIC);
-            console.log('DEBUG: PIXEL_MAGIC index:', found);
-            if (found !== -1) {
-                console.log('DEBUG: PIXEL_MAGIC head:', pixelBytes.slice(found, found + 64).toString('hex'));
-                const markerEndBytes = colorsToBytes(MARKER_END);
-                console.log('DEBUG: MARKER_END index:', pixelBytes.indexOf(markerEndBytes));
-            }
-        }
-        try {
-            let idx = 0;
-            if (pixelBytes.length >= PIXEL_MAGIC.length) {
-                const at0 = pixelBytes.slice(0, PIXEL_MAGIC.length).equals(PIXEL_MAGIC);
-                if (at0) {
-                    idx = PIXEL_MAGIC.length;
-                }
-                else {
-                    const found = pixelBytes.indexOf(PIXEL_MAGIC);
-                    if (found !== -1) {
-                        idx = found + PIXEL_MAGIC.length;
-                    }
-                }
-            }
-            if (idx > 0) {
-                const version = pixelBytes[idx++];
-                const nameLen = pixelBytes[idx++];
-                let name;
-                if (nameLen > 0 && nameLen < 256) {
-                    name = pixelBytes.slice(idx, idx + nameLen).toString('utf8');
-                    idx += nameLen;
-                }
-                const payloadLen = pixelBytes.readUInt32BE(idx);
-                idx += 4;
-                const available = pixelBytes.length - idx;
-                if (available < payloadLen) {
-                    throw new DataFormatError(`Pixel payload truncated: expected ${payloadLen} bytes but only ${available} available`);
-                }
-                const rawPayload = pixelBytes.slice(idx, idx + payloadLen);
-                let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-                try {
-                    if (opts.outPath) {
-                        const ws = createWriteStream(opts.outPath, {
-                            highWaterMark: 64 * 1024,
-                        });
-                        let headerBuf = Buffer.alloc(0);
-                        let headerSkipped = false;
-                        let lastOutByte = null;
-                        await tryZstdDecompress(payload, (info) => {
-                            if (opts.onProgress)
-                                opts.onProgress(info);
-                        }, async (decChunk) => {
-                            let outChunk = decChunk;
-                            if (version === 3) {
-                                const out = Buffer.alloc(decChunk.length);
-                                for (let i = 0; i < decChunk.length; i++) {
-                                    if (i === 0) {
-                                        out[0] =
-                                            typeof lastOutByte === 'number'
-                                                ? (lastOutByte + decChunk[0]) & 0xff
-                                                : decChunk[0];
-                                    }
-                                    else {
-                                        out[i] = (out[i - 1] + decChunk[i]) & 0xff;
-                                    }
-                                }
-                                lastOutByte = out[out.length - 1];
-                                outChunk = out;
-                            }
-                            if (!headerSkipped) {
-                                if (outChunk.length < MAGIC.length) {
-                                    headerBuf = Buffer.concat([headerBuf, outChunk]);
-                                    return;
-                                }
-                                const mag = outChunk.slice(0, MAGIC.length);
-                                if (!mag.equals(MAGIC)) {
-                                    ws.close();
-                                    throw new DataFormatError('Invalid ROX format (pixel mode: missing ROX1 magic after decompression)');
-                                }
-                                const toWriteBuf = outChunk.slice(MAGIC.length);
-                                if (toWriteBuf.length > 0) {
-                                    await writeInChunks(ws, toWriteBuf, 64 * 1024);
-                                }
-                                headerBuf = Buffer.alloc(0);
-                                headerSkipped = true;
-                            }
-                            else {
-                                await writeInChunks(ws, outChunk, 64 * 1024);
-                            }
-                        });
-                        await new Promise((res) => ws.end(() => res()));
-                        if (opts.onProgress)
-                            opts.onProgress({ phase: 'done' });
-                        progressBar?.stop();
-                        return { meta: { name } };
-                    }
-                    else {
-                        payload = await tryDecompress(payload, (info) => {
-                            if (opts.onProgress)
-                                opts.onProgress(info);
-                        });
-                        if (version === 3) {
-                            payload = deltaDecode(payload);
-                        }
-                    }
-                }
-                catch (e) {
-                    const errMsg = e instanceof Error ? e.message : String(e);
-                    if (opts.passphrase)
-                        throw new IncorrectPassphraseError(`Incorrect passphrase (screenshot mode, zstd failed: ` +
-                            errMsg +
-                            ')');
-                    throw new DataFormatError(`Screenshot mode zstd decompression failed: ` + errMsg);
-                }
-                if (!payload.slice(0, MAGIC.length).equals(MAGIC)) {
-                    throw new DataFormatError('Invalid ROX format (pixel mode: missing ROX1 magic after decompression)');
-                }
-                payload = payload.slice(MAGIC.length);
-                if (opts.files) {
-                    const unpacked = unpackBuffer(payload, opts.files);
-                    if (unpacked) {
-                        if (opts.onProgress)
-                            opts.onProgress({ phase: 'done' });
-                        progressBar?.stop();
-                        return { files: unpacked.files, meta: { name } };
-                    }
-                }
-                if (opts.onProgress)
-                    opts.onProgress({ phase: 'done' });
-                progressBar?.stop();
-                return { buf: payload, meta: { name } };
-            }
-        }
-        catch (e) {
-            if (e instanceof PassphraseRequiredError ||
-                e instanceof IncorrectPassphraseError ||
-                e instanceof DataFormatError) {
-                throw e;
-            }
-            const errMsg = e instanceof Error ? e.message : String(e);
-            throw new Error('Failed to extract data from screenshot: ' + errMsg);
-        }
-    }
-    catch (e) {
-        if (e instanceof PassphraseRequiredError ||
-            e instanceof IncorrectPassphraseError ||
-            e instanceof DataFormatError) {
-            throw e;
-        }
-        const errMsg = e instanceof Error ? e.message : String(e);
-        throw new Error('Failed to decode PNG: ' + errMsg);
-    }
-    throw new DataFormatError('No valid data found in image');
-}
+export * from './utils/constants.js';
+export * from './utils/crc.js';
+export * from './utils/decoder.js';
+export * from './utils/encoder.js';
+export * from './utils/errors.js';
+export * from './utils/helpers.js';
+export * from './utils/inspection.js';
+export * from './utils/optimization.js';
+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';
-/**
- * List files in a Rox PNG archive without decoding the full payload.
- * Returns the file list if available, otherwise null.
- * @param pngBuf - PNG data
- * @public
- */
-export async function listFilesInPng(pngBuf) {
-    try {
-        try {
-            const { data, info } = await sharp(pngBuf)
-                .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 found = rawRGB.indexOf(PIXEL_MAGIC);
-            if (found !== -1) {
-                let idx = found + PIXEL_MAGIC.length;
-                if (idx + 2 <= rawRGB.length) {
-                    const version = rawRGB[idx++];
-                    const nameLen = rawRGB[idx++];
-                    if (process.env.ROX_DEBUG)
-                        console.log('listFilesInPng: pixel version', version, 'nameLen', nameLen);
-                    if (nameLen > 0 && idx + nameLen <= rawRGB.length) {
-                        idx += nameLen;
-                    }
-                    if (idx + 4 <= rawRGB.length) {
-                        const payloadLen = rawRGB.readUInt32BE(idx);
-                        idx += 4;
-                        const afterPayload = idx + payloadLen;
-                        if (afterPayload <= rawRGB.length) {
-                            if (afterPayload + 8 <= rawRGB.length) {
-                                const marker = rawRGB
-                                    .slice(afterPayload, afterPayload + 4)
-                                    .toString('utf8');
-                                if (marker === 'rXFL') {
-                                    const jsonLen = rawRGB.readUInt32BE(afterPayload + 4);
-                                    const jsonStart = afterPayload + 8;
-                                    const jsonEnd = jsonStart + jsonLen;
-                                    if (jsonEnd <= rawRGB.length) {
-                                        const jsonBuf = rawRGB.slice(jsonStart, jsonEnd);
-                                        const files = JSON.parse(jsonBuf.toString('utf8'));
-                                        return files.sort();
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) { }
-    }
-    catch (e) { }
-    try {
-        const reconstructed = await cropAndReconstitute(pngBuf);
-        try {
-            const { data, info } = await sharp(reconstructed)
-                .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 found = rawRGB.indexOf(PIXEL_MAGIC);
-            if (found !== -1) {
-                let idx = found + PIXEL_MAGIC.length;
-                if (idx + 2 <= rawRGB.length) {
-                    const version = rawRGB[idx++];
-                    const nameLen = rawRGB[idx++];
-                    if (process.env.ROX_DEBUG)
-                        console.log('listFilesInPng (reconstructed): pixel version', version, 'nameLen', nameLen);
-                    if (nameLen > 0 && idx + nameLen <= rawRGB.length) {
-                        idx += nameLen;
-                    }
-                    if (idx + 4 <= rawRGB.length) {
-                        const payloadLen = rawRGB.readUInt32BE(idx);
-                        idx += 4;
-                        const afterPayload = idx + payloadLen;
-                        if (afterPayload <= rawRGB.length) {
-                            if (afterPayload + 8 <= rawRGB.length) {
-                                const marker = rawRGB
-                                    .slice(afterPayload, afterPayload + 4)
-                                    .toString('utf8');
-                                if (marker === 'rXFL') {
-                                    const jsonLen = rawRGB.readUInt32BE(afterPayload + 4);
-                                    const jsonStart = afterPayload + 8;
-                                    const jsonEnd = jsonStart + jsonLen;
-                                    if (jsonEnd <= rawRGB.length) {
-                                        const jsonBuf = rawRGB.slice(jsonStart, jsonEnd);
-                                        const files = JSON.parse(jsonBuf.toString('utf8'));
-                                        return files.sort();
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) { }
-        try {
-            const chunks = extract(reconstructed);
-            const fileListChunk = chunks.find((c) => c.name === 'rXFL');
-            if (fileListChunk) {
-                const data = Buffer.isBuffer(fileListChunk.data)
-                    ? fileListChunk.data
-                    : Buffer.from(fileListChunk.data);
-                const files = JSON.parse(data.toString('utf8'));
-                return files.sort();
-            }
-            const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);
-            if (metaChunk) {
-                const dataBuf = Buffer.isBuffer(metaChunk.data)
-                    ? metaChunk.data
-                    : Buffer.from(metaChunk.data);
-                const markerIdx = dataBuf.indexOf(Buffer.from('rXFL'));
-                if (markerIdx !== -1 && markerIdx + 8 <= dataBuf.length) {
-                    const jsonLen = dataBuf.readUInt32BE(markerIdx + 4);
-                    const jsonStart = markerIdx + 8;
-                    const jsonEnd = jsonStart + jsonLen;
-                    if (jsonEnd <= dataBuf.length) {
-                        const files = JSON.parse(dataBuf.slice(jsonStart, jsonEnd).toString('utf8'));
-                        return files.sort();
-                    }
-                }
-            }
-        }
-        catch (e) { }
-    }
-    catch (e) { }
-    try {
-        const chunks = extract(pngBuf);
-        const fileListChunk = chunks.find((c) => c.name === 'rXFL');
-        if (fileListChunk) {
-            const data = Buffer.isBuffer(fileListChunk.data)
-                ? fileListChunk.data
-                : Buffer.from(fileListChunk.data);
-            const files = JSON.parse(data.toString('utf8'));
-            return files.sort();
-        }
-        const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);
-        if (metaChunk) {
-            const dataBuf = Buffer.isBuffer(metaChunk.data)
-                ? metaChunk.data
-                : Buffer.from(metaChunk.data);
-            const markerIdx = dataBuf.indexOf(Buffer.from('rXFL'));
-            if (markerIdx !== -1 && markerIdx + 8 <= dataBuf.length) {
-                const jsonLen = dataBuf.readUInt32BE(markerIdx + 4);
-                const jsonStart = markerIdx + 8;
-                const jsonEnd = jsonStart + jsonLen;
-                if (jsonEnd <= dataBuf.length) {
-                    const files = JSON.parse(dataBuf.slice(jsonStart, jsonEnd).toString('utf8'));
-                    return files.sort();
-                }
-            }
-        }
-    }
-    catch (e) { }
-    return null;
-}
-/**
- * Detect if a PNG/ROX buffer contains an encrypted payload (requires passphrase)
- * Returns true if encryption flag indicates AES or XOR.
- */
-export async function hasPassphraseInPng(pngBuf) {
-    try {
-        if (pngBuf.slice(0, MAGIC.length).equals(MAGIC)) {
-            let offset = MAGIC.length;
-            if (offset >= pngBuf.length)
-                return false;
-            const nameLen = pngBuf.readUInt8(offset);
-            offset += 1 + nameLen;
-            if (offset >= pngBuf.length)
-                return false;
-            const flag = pngBuf[offset];
-            return flag === ENC_AES || flag === ENC_XOR;
-        }
-        try {
-            const chunksRaw = extract(pngBuf);
-            const target = chunksRaw.find((c) => c.name === CHUNK_TYPE);
-            if (target) {
-                const data = Buffer.isBuffer(target.data)
-                    ? target.data
-                    : Buffer.from(target.data);
-                if (data.length >= 1) {
-                    const nameLen = data.readUInt8(0);
-                    const payloadStart = 1 + nameLen;
-                    if (payloadStart < data.length) {
-                        const flag = data[payloadStart];
-                        return flag === ENC_AES || flag === ENC_XOR;
-                    }
-                }
-            }
-        }
-        catch (e) { }
-        try {
-            const sharpLib = await import('sharp');
-            const { data } = await sharpLib
-                .default(pngBuf)
-                .raw()
-                .toBuffer({ resolveWithObject: true });
-            const rawRGB = Buffer.from(data);
-            const markerLen = MARKER_COLORS.length * 3;
-            for (let i = 0; i <= rawRGB.length - markerLen; i += 3) {
-                let ok = true;
-                for (let m = 0; m < MARKER_COLORS.length; m++) {
-                    const j = i + m * 3;
-                    if (rawRGB[j] !== MARKER_COLORS[m].r ||
-                        rawRGB[j + 1] !== MARKER_COLORS[m].g ||
-                        rawRGB[j + 2] !== MARKER_COLORS[m].b) {
-                        ok = false;
-                        break;
-                    }
-                }
-                if (!ok)
-                    continue;
-                const headerStart = i + markerLen;
-                if (headerStart + PIXEL_MAGIC.length >= rawRGB.length)
-                    continue;
-                if (!rawRGB
-                    .slice(headerStart, headerStart + PIXEL_MAGIC.length)
-                    .equals(PIXEL_MAGIC))
-                    continue;
-                const metaStart = headerStart + PIXEL_MAGIC.length;
-                if (metaStart + 2 >= rawRGB.length)
-                    continue;
-                const nameLen = rawRGB[metaStart + 1];
-                const payloadLenOff = metaStart + 2 + nameLen;
-                const payloadStart = payloadLenOff + 4;
-                if (payloadStart >= rawRGB.length)
-                    continue;
-                const flag = rawRGB[payloadStart];
-                return flag === ENC_AES || flag === ENC_XOR;
-            }
-        }
-        catch (e) { }
-        try {
-            await decodePngToBinary(pngBuf, { showProgress: false });
-            return false;
-        }
-        catch (e) {
-            if (e instanceof PassphraseRequiredError)
-                return true;
-            if (e.message && e.message.toLowerCase().includes('passphrase'))
-                return true;
-            return false;
-        }
-    }
-    catch (e) {
-        return false;
-    }
-}