roxify 1.0.0

package/dist/index.js

@@ -0,0 +1,1042 @@
+import { createCipheriv, createDecipheriv, pbkdf2Sync, randomBytes, } from 'crypto';
+import encode from 'png-chunks-encode';
+import extract from 'png-chunks-extract';
+import sharp from 'sharp';
+import * as zlib from 'zlib';
+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();
+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 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;
+}
+function tryBrotliDecompress(payload) {
+    return Buffer.from(zlib.brotliDecompressSync(payload));
+}
+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;
+}
+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];
+}
+async function loadRaw(imgInput) {
+    const { data, info } = await sharp(imgInput)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    return { data, info };
+}
+export async function cropAndReconstitute(input) {
+    const { data, info } = await loadRaw(input);
+    const w = info.width;
+    const h = info.height;
+    function at(x, y) {
+        const i = idxFor(x, y, w);
+        return [data[i], data[i + 1], data[i + 2], data[i + 3]];
+    }
+    let startPoint = null;
+    for (let y = 0; y < h && !startPoint; y++) {
+        for (let x = 0; x < w; x++) {
+            const p = at(x, y);
+            if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
+                continue;
+            let nx = x + 1;
+            while (nx < w && eqRGB(at(nx, y), p))
+                nx++;
+            if (nx >= w)
+                continue;
+            const a = at(nx, y);
+            let nx2 = nx + 1;
+            while (nx2 < w && eqRGB(at(nx2, y), a))
+                nx2++;
+            if (nx2 >= w)
+                continue;
+            const b = at(nx2, y);
+            const isRgb = a[0] === 0 &&
+                a[1] === 255 &&
+                a[2] === 0 &&
+                b[0] === 0 &&
+                b[1] === 0 &&
+                b[2] === 255;
+            if (isRgb) {
+                startPoint = { x, y, type: 'rgb' };
+                break;
+            }
+        }
+    }
+    let endPoint = null;
+    for (let y = h - 1; y >= 0 && !endPoint; y--) {
+        for (let x = w - 1; x >= 0; x--) {
+            const p = at(x, y);
+            if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
+                continue;
+            let nx = x - 1;
+            while (nx >= 0 && eqRGB(at(nx, y), p))
+                nx--;
+            if (nx < 0)
+                continue;
+            const a = at(nx, y);
+            let nx2 = nx - 1;
+            while (nx2 >= 0 && eqRGB(at(nx2, y), a))
+                nx2--;
+            if (nx2 < 0)
+                continue;
+            const b = at(nx2, y);
+            const isRgbReverse = a[0] === 0 &&
+                a[1] === 255 &&
+                a[2] === 0 &&
+                b[0] === 0 &&
+                b[1] === 0 &&
+                b[2] === 255;
+            if (isRgbReverse) {
+                endPoint = { x, y, type: 'bgr' };
+                break;
+            }
+        }
+    }
+    if (!startPoint)
+        throw new Error('Start pattern (RGB) not found');
+    if (!endPoint)
+        throw new Error('End pattern (BGR) not found');
+    const sx1 = Math.min(startPoint.x, endPoint.x);
+    const sy1 = Math.min(startPoint.y, endPoint.y);
+    const sx2 = Math.max(startPoint.x, endPoint.x);
+    const sy2 = Math.max(startPoint.y, endPoint.y);
+    const cropW = sx2 - sx1;
+    const cropH = sy2 - sy1;
+    if (cropW <= 0 || cropH <= 0)
+        throw new Error('Invalid crop dimensions');
+    const cropped = await sharp(input)
+        .extract({ left: sx1, top: sy1, width: cropW, height: cropH })
+        .png()
+        .toBuffer();
+    const { data: cdata, info: cinfo } = await sharp(cropped)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const cw = cinfo.width;
+    const ch = cinfo.height;
+    function cat(x, y) {
+        const i = idxFor(x, y, cw);
+        return [cdata[i], cdata[i + 1], cdata[i + 2], cdata[i + 3]];
+    }
+    function eq(a, b) {
+        return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];
+    }
+    function lineEq(l1, l2) {
+        if (l1.length !== l2.length)
+            return false;
+        for (let i = 0; i < l1.length; i++)
+            if (!eq(l1[i], l2[i]))
+                return false;
+        return true;
+    }
+    const compressedLines = [];
+    for (let y = 0; y < ch; y++) {
+        const line = [];
+        let x = 0;
+        while (x < cw) {
+            const current = cat(x, y);
+            if (current[0] === 0 && current[1] === 0 && current[2] === 0) {
+                x++;
+                continue;
+            }
+            line.push(current);
+            let nx = x + 1;
+            while (nx < cw && eq(cat(nx, y), current))
+                nx++;
+            x = nx;
+        }
+        if (line.length === 0)
+            continue;
+        if (compressedLines.length === 0 ||
+            !lineEq(compressedLines[compressedLines.length - 1], line))
+            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();
+    }
+    const newWidth = Math.max(...compressedLines.map((l) => l.length));
+    const newHeight = compressedLines.length + 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 < compressedLines.length; y++) {
+        const line = compressedLines[y];
+        const isSecondToLast = y === compressedLines.length - 1;
+        const startX = 0;
+        const effectiveLength = isSecondToLast
+            ? Math.max(0, line.length - 3)
+            : line.length;
+        for (let x = 0; x < effectiveLength; x++) {
+            const i = ((y * newWidth + startX + x) * 4) | 0;
+            out[i] = line[x][0];
+            out[i + 1] = line[x][1];
+            out[i + 2] = line[x][2];
+            out[i + 3] = line[x][3] === 0 ? 255 : line[x][3];
+        }
+        if (isSecondToLast) {
+            for (let x = effectiveLength; x < Math.min(effectiveLength + 3, newWidth); x++) {
+                const i = ((y * newWidth + x) * 4) | 0;
+                out[i] = 0;
+                out[i + 1] = 0;
+                out[i + 2] = 0;
+                out[i + 3] = 255;
+            }
+        }
+    }
+    const secondToLastY = newHeight - 2;
+    let secondToLastIsBlack = true;
+    for (let x = 0; x < newWidth; x++) {
+        const i = ((secondToLastY * newWidth + x) * 4) | 0;
+        if (out[i] !== 0 || out[i + 1] !== 0 || out[i + 2] !== 0) {
+            secondToLastIsBlack = false;
+            break;
+        }
+    }
+    let finalHeight = newHeight;
+    let finalOut = out;
+    if (secondToLastIsBlack) {
+        finalHeight = newHeight - 1;
+        finalOut = Buffer.alloc(newWidth * finalHeight * 4, 0);
+        for (let i = 0; i < finalOut.length; i += 4)
+            finalOut[i + 3] = 255;
+        for (let y = 0; y < newHeight - 2; y++) {
+            for (let x = 0; x < newWidth; x++) {
+                const srcI = ((y * newWidth + x) * 4) | 0;
+                const dstI = ((y * newWidth + x) * 4) | 0;
+                finalOut[dstI] = out[srcI];
+                finalOut[dstI + 1] = out[srcI + 1];
+                finalOut[dstI + 2] = out[srcI + 2];
+                finalOut[dstI + 3] = out[srcI + 3];
+            }
+        }
+    }
+    const lastY = finalHeight - 1;
+    for (let x = 0; x < newWidth; x++) {
+        const i = ((lastY * newWidth + x) * 4) | 0;
+        finalOut[i] = 0;
+        finalOut[i + 1] = 0;
+        finalOut[i + 2] = 0;
+        finalOut[i + 3] = 255;
+    }
+    if (newWidth >= 3) {
+        const bgrStart = newWidth - 3;
+        let i = ((lastY * newWidth + bgrStart) * 4) | 0;
+        finalOut[i] = 0;
+        finalOut[i + 1] = 0;
+        finalOut[i + 2] = 255;
+        finalOut[i + 3] = 255;
+        i = ((lastY * newWidth + bgrStart + 1) * 4) | 0;
+        finalOut[i] = 0;
+        finalOut[i + 1] = 255;
+        finalOut[i + 2] = 0;
+        finalOut[i + 3] = 255;
+        i = ((lastY * newWidth + bgrStart + 2) * 4) | 0;
+        finalOut[i] = 255;
+        finalOut[i + 1] = 0;
+        finalOut[i + 2] = 0;
+        finalOut[i + 3] = 255;
+    }
+    return sharp(finalOut, {
+        raw: { width: newWidth, 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
+ */
+export async function encodeBinaryToPng(input, opts = {}) {
+    let payload = Buffer.concat([MAGIC, input]);
+    const brQuality = typeof opts.brQuality === 'number' ? opts.brQuality : 11;
+    const mode = opts.mode === undefined ? 'screenshot' : opts.mode;
+    const useBrotli = opts.compression === 'br' ||
+        (opts.compression === undefined &&
+            (mode === 'compact' || mode === 'pixel' || mode === 'screenshot'));
+    if (useBrotli) {
+        payload = zlib.brotliCompressSync(payload, {
+            params: { [zlib.constants.BROTLI_PARAM_QUALITY]: brQuality },
+        });
+    }
+    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 (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]);
+        }
+        else if (encChoice === 'xor') {
+            const xored = applyXor(payload, opts.passphrase);
+            payload = Buffer.concat([Buffer.from([ENC_XOR]), xored]);
+        }
+        else if (encChoice === 'none') {
+            payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
+        }
+    }
+    else {
+        payload = Buffer.concat([Buffer.from([ENC_NONE]), payload]);
+    }
+    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);
+    const meta = Buffer.concat(metaParts);
+    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 = 2;
+        const metaPixel = Buffer.concat([
+            Buffer.from([version]),
+            Buffer.from([nameLen]),
+            nameBuf,
+            payloadLenBuf,
+            payload,
+        ]);
+        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 dataWithMarkerStart = Buffer.concat([markerStartBytes, paddedData]);
+        const bytesPerPixel = 3;
+        const dataPixels = Math.ceil(dataWithMarkerStart.length / 3);
+        let logicalWidth = Math.ceil(Math.sqrt(dataPixels));
+        if (logicalWidth < MARKER_END.length) {
+            logicalWidth = MARKER_END.length;
+        }
+        const dataRows = Math.ceil(dataPixels / logicalWidth);
+        const pixelsInLastRow = dataPixels % logicalWidth;
+        const spaceInLastRow = pixelsInLastRow === 0 ? logicalWidth : logicalWidth - pixelsInLastRow;
+        const needsExtraRow = spaceInLastRow < MARKER_END.length;
+        const logicalHeight = needsExtraRow ? dataRows + 1 : dataRows;
+        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 (ly < dataRows ||
+                    (ly === dataRows && linearIdx < dataPixels)) {
+                    const srcIdx = linearIdx * 3;
+                    r =
+                        srcIdx < dataWithMarkerStart.length
+                            ? dataWithMarkerStart[srcIdx]
+                            : 0;
+                    g =
+                        srcIdx + 1 < dataWithMarkerStart.length
+                            ? dataWithMarkerStart[srcIdx + 1]
+                            : 0;
+                    b =
+                        srcIdx + 2 < dataWithMarkerStart.length
+                            ? dataWithMarkerStart[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;
+                    }
+                }
+            }
+        }
+        return await sharp(raw, {
+            raw: { width, height, channels: 3 },
+        })
+            .png({
+            compressionLevel: 0,
+            palette: false,
+            effort: 1,
+            adaptiveFiltering: false,
+        })
+            .toBuffer();
+    }
+    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;
+        const metaPixel = Buffer.concat([
+            Buffer.from([version]),
+            Buffer.from([nameLen]),
+            nameBuf,
+            payloadLenBuf,
+            payload,
+        ]);
+        const full = Buffer.concat([PIXEL_MAGIC, metaPixel]);
+        const bytesPerPixel = 3;
+        const nPixels = Math.ceil((full.length + 8) / 3);
+        const side = Math.ceil(Math.sqrt(nPixels));
+        const width = Math.max(1, Math.min(side, 65535));
+        const height = 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) });
+        const tmp = Buffer.from(encode(chunksPixel));
+        const outPng = tmp.slice(0, 8).toString('hex') === PNG_HEADER_HEX
+            ? tmp
+            : Buffer.concat([PNG_HEADER, tmp]);
+        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) });
+        const out = Buffer.from(encode(chunks2));
+        return out.slice(0, 8).toString('hex') === PNG_HEADER_HEX
+            ? out
+            : Buffer.concat([PNG_HEADER, out]);
+    }
+    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
+ */
+export async function decodePngToBinary(pngBuf, opts = {}) {
+    if (pngBuf.slice(0, MAGIC.length).equals(MAGIC)) {
+        const d = pngBuf.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);
+        try {
+            payload = tryBrotliDecompress(payload);
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            if (opts.passphrase)
+                throw new Error('Incorrect passphrase (ROX format, brotli failed: ' + errMsg + ')');
+            throw new Error('ROX format brotli 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);
+        return { buf: payload, meta: { name } };
+    }
+    let chunks = [];
+    try {
+        const chunksRaw = extract(pngBuf);
+        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);
+        try {
+            payload = tryBrotliDecompress(payload);
+        }
+        catch (e) {
+            const errMsg = e instanceof Error ? e.message : String(e);
+            if (opts.passphrase)
+                throw new IncorrectPassphraseError('Incorrect passphrase (compact mode, brotli failed: ' + errMsg + ')');
+            throw new DataFormatError('Compact mode brotli 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);
+        return { buf: payload, meta: { name } };
+    }
+    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 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(data);
+            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 {
+                payload = tryBrotliDecompress(payload);
+            }
+            catch (e) {
+                const errMsg = e instanceof Error ? e.message : String(e);
+                if (opts.passphrase)
+                    throw new IncorrectPassphraseError('Incorrect passphrase (pixel mode, brotli failed: ' + errMsg + ')');
+                throw new DataFormatError('Pixel mode brotli 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);
+            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 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, 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 {
+                    payload = tryBrotliDecompress(payload);
+                }
+                catch (e) {
+                    const errMsg = e instanceof Error ? e.message : String(e);
+                    if (opts.passphrase)
+                        throw new IncorrectPassphraseError('Incorrect passphrase (pixel mode, brotli failed: ' +
+                            errMsg +
+                            ')');
+                    throw new DataFormatError('Pixel mode brotli 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);
+                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');
+}