roxify 1.13.4 → 1.13.6

package/dist/utils/decoder.js

@@ -1,219 +1,13 @@
-import { execFileSync } from 'child_process';
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { unpackBuffer } from '../pack.js';
-import { isWav, wavToBytes } from './audio.js';
-import { CHUNK_TYPE, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
-import { DataFormatError, IncorrectPassphraseError, PassphraseRequiredError, } from './errors.js';
-import { colorsToBytes, deltaDecode, tryDecryptIfNeeded } from './helpers.js';
+import { readFileSync } from 'fs';
 import { native } from './native.js';
-import { cropAndReconstitute } from './reconstitution.js';
-import { decodeRobustAudio, isRobustAudioWav } from './robust-audio.js';
-import { decodeRobustImage, isRobustImage } from './robust-image.js';
-import { parallelZstdDecompress } from './zstd.js';
-function isColorMatch(r1, g1, b1, r2, g2, b2) {
-    return Math.abs(r1 - r2) + Math.abs(g1 - g2) + Math.abs(b1 - b2) < 50;
-}
-/**
- * Un-stretch an image that was nearest-neighbor scaled.
- * 1. Crops to non-background bounding box
- * 2. Collapses horizontal runs of identical pixels into single pixels
- * 3. Removes duplicate consecutive rows
- *
- * Returns null if the image doesn't appear to be stretched.
- */
-export function unstretchImage(rawRGB, width, height, tolerance = 0) {
-    if (width <= 0 || height <= 0 || rawRGB.length < width * height * 3) {
-        return null;
-    }
-    // Step 1: Find bounding box of non-background pixels
-    // Background = white-ish (all channels >= 240)
-    let minX = width, maxX = -1, minY = height, maxY = -1;
-    for (let y = 0; y < height; y++) {
-        const rowBase = y * width * 3;
-        for (let x = 0; x < width; x++) {
-            const idx = rowBase + x * 3;
-            const r = rawRGB[idx], g = rawRGB[idx + 1], b = rawRGB[idx + 2];
-            // Skip background: white or near-white
-            if (r >= 240 && g >= 240 && b >= 240)
-                continue;
-            if (x < minX)
-                minX = x;
-            if (x > maxX)
-                maxX = x;
-            if (y < minY)
-                minY = y;
-            if (y > maxY)
-                maxY = y;
-        }
-    }
-    if (maxX < minX || maxY < minY)
-        return null; // all background
-    const cropW = maxX - minX + 1;
-    const cropH = maxY - minY + 1;
-    // Don't process tiny images
-    if (cropW < 2 || cropH < 2)
-        return null;
-    // Step 2: Collapse horizontal runs per row + deduplicate rows
-    const pixelsMatch = (buf, i1, i2) => {
-        if (tolerance === 0) {
-            return (buf[i1] === buf[i2] &&
-                buf[i1 + 1] === buf[i2 + 1] &&
-                buf[i1 + 2] === buf[i2 + 2]);
-        }
-        return (Math.abs(buf[i1] - buf[i2]) +
-            Math.abs(buf[i1 + 1] - buf[i2 + 1]) +
-            Math.abs(buf[i1 + 2] - buf[i2 + 2]) <=
-            tolerance);
-    };
-    const logicalRows = [];
-    let logicalW = -1;
-    let prevRowKey = '';
-    for (let y = minY; y <= maxY; y++) {
-        const rowBase = y * width * 3;
-        const pixels = [];
-        let prevIdx = -1;
-        for (let x = minX; x <= maxX; x++) {
-            const idx = rowBase + x * 3;
-            if (prevIdx >= 0 && pixelsMatch(rawRGB, idx, prevIdx)) {
-                continue; // same as previous pixel, skip (collapse run)
-            }
-            pixels.push(rawRGB[idx], rawRGB[idx + 1], rawRGB[idx + 2]);
-            prevIdx = idx;
-        }
-        // Compute row key for dedup
-        const rowKey = pixels.join(',');
-        if (rowKey === prevRowKey) {
-            continue; // duplicate row, skip
-        }
-        prevRowKey = rowKey;
-        const rowW = pixels.length / 3;
-        if (logicalW === -1) {
-            logicalW = rowW;
-        }
-        else if (rowW !== logicalW) {
-            // A uniform-color row collapses to 1 pixel — expand to logicalW
-            if (rowW === 1 && logicalW > 1) {
-                const r = pixels[0], g = pixels[1], b = pixels[2];
-                for (let f = 1; f < logicalW; f++) {
-                    pixels.push(r, g, b);
-                }
-            }
-            else if (logicalW === 1 && rowW > 1) {
-                // First row was uniform, adopt new width and expand it
-                const prevRow = logicalRows[logicalRows.length - 1];
-                if (prevRow) {
-                    const pr = prevRow.pixels[0], pg = prevRow.pixels[1], pb = prevRow.pixels[2];
-                    prevRow.pixels = [];
-                    for (let f = 0; f < rowW; f++) {
-                        prevRow.pixels.push(pr, pg, pb);
-                    }
-                }
-                logicalW = rowW;
-            }
-            else {
-                // Inconsistent row widths → not a clean stretch
-                // Try with tolerance if we haven't already
-                if (tolerance === 0) {
-                    return unstretchImage(rawRGB, width, height, 30);
-                }
-                return null;
-            }
-        }
-        logicalRows.push({ pixels, key: rowKey });
-    }
-    if (logicalRows.length === 0 || logicalW <= 0)
-        return null;
-    const logicalH = logicalRows.length;
-    // Sanity: must have actually reduced the image
-    if (logicalW >= cropW && logicalH >= cropH)
-        return null;
-    // Build output buffer
-    const data = Buffer.allocUnsafe(logicalW * logicalH * 3);
-    let outIdx = 0;
-    for (const row of logicalRows) {
-        for (let i = 0; i < row.pixels.length; i++) {
-            data[outIdx++] = row.pixels[i];
-        }
-    }
-    if (process.env.ROX_DEBUG) {
-        console.log(`DEBUG: unstretch ${width}x${height} → crop ${cropW}x${cropH} → logical ${logicalW}x${logicalH}`);
-    }
-    return { data, width: logicalW, height: logicalH };
-}
-const RBW1_MAGIC = Buffer.from('RBW1');
-async function tryDecompress(payload, onProgress) {
-    if (payload.length >= 4 && payload.subarray(0, 4).equals(RBW1_MAGIC) && native?.hybridDecompress) {
-        if (onProgress)
-            onProgress({ phase: 'decompress_start', total: 1 });
-        const result = Buffer.from(native.hybridDecompress(payload));
-        if (onProgress)
-            onProgress({ phase: 'decompress_done', loaded: 1, total: 1 });
-        return result;
-    }
-    return await parallelZstdDecompress(payload, onProgress);
-}
-function detectImageFormat(buf) {
-    if (buf.length < 12)
-        return 'unknown';
-    if (buf[0] === 0x89 &&
-        buf[1] === 0x50 &&
-        buf[2] === 0x4e &&
-        buf[3] === 0x47) {
-        return 'png';
-    }
-    if (buf[0] === 0x52 &&
-        buf[1] === 0x49 &&
-        buf[2] === 0x46 &&
-        buf[3] === 0x46 &&
-        buf[8] === 0x57 &&
-        buf[9] === 0x45 &&
-        buf[10] === 0x42 &&
-        buf[11] === 0x50) {
-        return 'webp';
-    }
-    if (buf[0] === 0xff && buf[1] === 0x0a) {
-        return 'jxl';
-    }
-    return 'unknown';
-}
-function convertToPng(buf, format) {
-    const tempDir = mkdtempSync(join(tmpdir(), 'rox-decode-'));
-    const inputPath = join(tempDir, format === 'webp' ? 'input.webp' : 'input.jxl');
-    const outputPath = join(tempDir, 'output.png');
-    try {
-        writeFileSync(inputPath, buf);
-        if (format === 'webp') {
-            execFileSync('dwebp', [inputPath, '-o', outputPath]);
-        }
-        else if (format === 'jxl') {
-            execFileSync('djxl', [inputPath, outputPath]);
-        }
-        const pngBuf = readFileSync(outputPath);
-        return pngBuf;
-    }
-    finally {
-        try {
-            rmSync(tempDir, { recursive: true, force: true });
-        }
-        catch (e) { }
-    }
-}
+import { unpackBuffer } from '../pack.js';
 /**
  * Decode a ROX PNG or buffer into the original binary payload or files list.
+ * This function uses the Rust native implementation exclusively.
  *
  * @param input - Buffer or path to a PNG file.
  * @param opts - Optional decode options.
  * @returns A Promise resolving to DecodeResult ({ buf, meta } or { files }).
- *
- * @example
- * ```js
- * import { decodePngToBinary } from 'roxify';
- * const png = fs.readFileSync('out.png');
- * const res = await decodePngToBinary(png);
- * console.log(res.meta?.name, res.buf.toString('utf8'));
- * ```
  */
 export async function decodePngToBinary(input, opts = {}) {
     let pngBuf;
@@ -221,1046 +15,53 @@ export async function decodePngToBinary(input, opts = {}) {
         pngBuf = input;
     }
     else {
+        pngBuf = readFileSync(input);
+    }
+    // --- Native decoder: let Rust handle extraction/decompression/decryption ---
+    const payload = Buffer.from(native.extractPayloadFromPng(pngBuf));
+    if (payload.length === 0) {
+        throw new Error('No payload found in PNG');
+    }
+    // Extract name from payload header (version byte, name length, name)
+    let name;
+    let dataOffset = 0;
+    if (payload.length > 2) {
+        const version = payload[0];
+        const nameLen = payload[1];
+        dataOffset = 2;
+        if (nameLen > 0 && payload.length >= 2 + nameLen + 8) {
+            name = payload.subarray(2, 2 + nameLen).toString('utf8');
+            dataOffset = 2 + nameLen;
+        }
+        // Read payload length (8 bytes, big-endian, after name)
+        const payloadLen = Number(payload.readBigUInt64BE(dataOffset));
+        dataOffset += 8;
+        // The actual compressed/encrypted data starts at dataOffset
+        let compressedData = payload.subarray(dataOffset, dataOffset + payloadLen);
+        // Try to decompress with zstd if needed
+        let decompressed;
         try {
-            if (native?.sharpMetadata) {
-                const inputBuf = readFileSync(input);
-                const metadata = native.sharpMetadata(inputBuf);
-                const rawBytesEstimate = metadata.width * metadata.height * 4;
-                const MAX_RAW_BYTES = 200 * 1024 * 1024;
-                if (rawBytesEstimate > MAX_RAW_BYTES) {
-                    pngBuf = inputBuf;
-                }
-                else {
-                    pngBuf = inputBuf;
-                }
-            }
-            else {
-                pngBuf = readFileSync(input);
-            }
-        }
-        catch (e) {
-            try {
-                pngBuf = readFileSync(input);
-            }
-            catch (e2) {
-                throw e;
-            }
-        }
-    }
-    let progressBar = null;
-    if (opts.showProgress) {
-        progressBar = {
-            start: () => { },
-            update: () => { },
-            stop: () => { },
-        };
-        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;
-                }
-            };
-        }
-    }
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'start' });
-    let processedBuf = pngBuf;
-    try {
-        if (native?.sharpMetadata) {
-            const info = native.sharpMetadata(pngBuf);
-            if (info.width && info.height) {
-                const MAX_RAW_BYTES = 1200 * 1024 * 1024;
-                const rawBytesEstimate = info.width * info.height * 4;
-                if (rawBytesEstimate > MAX_RAW_BYTES) {
-                    throw new DataFormatError(`Image too large to decode in-process (${Math.round(rawBytesEstimate / 1024 / 1024)} MB). Increase Node heap or use a smaller image/compact mode.`);
-                }
-            }
-        }
-        processedBuf = pngBuf;
-    }
-    catch (e) {
-        if (e instanceof DataFormatError)
-            throw e;
-    }
-    if (opts.onProgress)
-        opts.onProgress({ phase: 'processed' });
-    // ─── Robust audio detection (lossy-resilient WAV) ──────────────────────────
-    if (isWav(processedBuf) && isRobustAudioWav(processedBuf)) {
-        try {
-            const result = decodeRobustAudio(processedBuf);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            progressBar?.stop();
-            // Try unpack multi-file archive
-            try {
-                const unpack = unpackBuffer(result.data);
-                if (unpack && unpack.files && unpack.files.length > 0) {
-                    return { files: unpack.files, correctedErrors: result.correctedErrors };
-                }
-            }
-            catch (e) { }
-            return { buf: result.data, correctedErrors: result.correctedErrors };
-        }
-        catch (e) {
-            // Fall through to legacy WAV decoding
-        }
-    }
-    // ─── WAV container detection ───────────────────────────────────────────────
-    if (isWav(processedBuf)) {
-        const pcmData = wavToBytes(processedBuf);
-        // The WAV payload starts with PIXEL_MAGIC ("PXL1")
-        if (pcmData.length >= 4 && pcmData.subarray(0, 4).equals(PIXEL_MAGIC)) {
-            let idx = 4; // skip PIXEL_MAGIC
-            const version = pcmData[idx++];
-            const nameLen = pcmData[idx++];
-            let name;
-            if (nameLen > 0) {
-                name = pcmData.subarray(idx, idx + nameLen).toString('utf8');
-                idx += nameLen;
-            }
-            const payloadLen = pcmData.readUInt32BE(idx);
-            idx += 4;
-            const rawPayload = pcmData.subarray(idx, idx + payloadLen);
-            idx += payloadLen;
-            // Check for rXFL file list after payload
-            let fileListJson;
-            if (idx + 8 < pcmData.length &&
-                pcmData.subarray(idx, idx + 4).toString('utf8') === 'rXFL') {
-                idx += 4;
-                const jsonLen = pcmData.readUInt32BE(idx);
-                idx += 4;
-                fileListJson = pcmData.subarray(idx, idx + jsonLen).toString('utf8');
-            }
-            let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-            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 (WAV mode, zstd failed: ' + errMsg + ')');
-                throw new DataFormatError('WAV mode zstd decompression failed: ' + errMsg);
-            }
-            if (!payload.subarray(0, MAGIC.length).equals(MAGIC)) {
-                throw new DataFormatError('Invalid ROX format in WAV (missing ROX1 magic after decompression)');
-            }
-            payload = payload.subarray(MAGIC.length);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            progressBar?.stop();
-            // Try unpack multi-file archive
-            try {
-                const unpack = unpackBuffer(payload);
-                if (unpack && unpack.files && unpack.files.length > 0) {
-                    return { files: unpack.files, meta: { name } };
-                }
-            }
-            catch (e) { }
-            return { buf: payload, meta: { name } };
-        }
-    }
-    // ─── Robust image detection (lossy-resilient PNG) ──────────────────────────
-    try {
-        if (isRobustImage(processedBuf)) {
-            const result = decodeRobustImage(processedBuf);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            progressBar?.stop();
-            try {
-                const unpack = unpackBuffer(result.data);
-                if (unpack && unpack.files && unpack.files.length > 0) {
-                    return { files: unpack.files, correctedErrors: result.correctedErrors };
-                }
-            }
-            catch (e) { }
-            return { buf: result.data, correctedErrors: result.correctedErrors };
-        }
-    }
-    catch (e) {
-        // Fall through to standard decoding
-    }
-    // ─── MAGIC header (compact mode) ──────────────────────────────────────────
-    if (processedBuf.subarray(0, MAGIC.length).equals(MAGIC)) {
-        const d = processedBuf.subarray(MAGIC.length);
-        const nameLen = d[0];
-        let idx = 1;
-        let name;
-        if (nameLen > 0) {
-            name = d.subarray(idx, idx + nameLen).toString('utf8');
-            idx += nameLen;
-        }
-        const rawPayload = d.subarray(idx);
-        let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-        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.subarray(0, MAGIC.length).equals(MAGIC)) {
-            throw new Error('Invalid ROX format (ROX direct: missing ROX1 magic after decompression)');
-        }
-        payload = payload.subarray(MAGIC.length);
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done' });
-        progressBar?.stop();
-        return { buf: payload, meta: { name } };
-    }
-    let chunks = [];
-    try {
-        if (native?.extractPngChunks) {
-            const chunksRaw = native.extractPngChunks(processedBuf);
-            chunks = chunksRaw.map((c) => ({
-                name: c.name,
-                data: Buffer.from(c.data),
-            }));
-        }
-        else {
-            throw new Error('Native PNG chunk extraction not available');
-        }
-    }
-    catch (e) {
-        try {
-            const withHeader = Buffer.concat([PNG_HEADER, pngBuf]);
-            if (native?.extractPngChunks) {
-                const chunksRaw = native.extractPngChunks(withHeader);
-                chunks = chunksRaw.map((c) => ({
-                    name: c.name,
-                    data: Buffer.from(c.data),
-                }));
-            }
-            else {
-                throw new Error('Native PNG chunk extraction not available');
-            }
+            decompressed = Buffer.from(native.nativeZstdDecompress(compressedData));
         }
-        catch (e2) {
-            chunks = [];
+        catch {
+            // If decompression fails, use raw data
+            decompressed = compressedData;
         }
-    }
-    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;
+        // Check for ROX1 magic
+        if (decompressed.length >= 4 && decompressed.subarray(0, 4).toString() === 'ROX1') {
+            decompressed = decompressed.subarray(4);
         }
-        const rawPayload = d.slice(idx);
-        if (rawPayload.length === 0)
-            throw new DataFormatError('Compact mode payload empty');
-        let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'decompress_start' });
+        // Try to unpack as multi-file archive
         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 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();
+            const unpacked = unpackBuffer(decompressed);
+            if (unpacked && unpacked.files && unpacked.files.length > 0) {
                 return { files: unpacked.files, meta: { name } };
             }
         }
-        if (opts.onProgress)
-            opts.onProgress({ phase: 'done' });
-        progressBar?.stop();
-        return { buf: payload, meta: { name } };
-    }
-    try {
-        const metadata = native.sharpMetadata(processedBuf);
-        const currentWidth = metadata.width;
-        const currentHeight = metadata.height;
-        let rawRGB = Buffer.alloc(0);
-        let isBlockEncoded = false;
-        if (currentWidth % 2 === 0 && currentHeight % 2 === 0) {
-            const rawData = native.sharpToRaw(processedBuf);
-            const testData = rawData.pixels;
-            let hasBlockPattern = true;
-            for (let y = 0; y < Math.min(2, currentHeight / 2); y++) {
-                for (let x = 0; x < Math.min(2, currentWidth / 2); x++) {
-                    const px00 = (y * 2 * currentWidth + x * 2) * 3;
-                    const px01 = (y * 2 * currentWidth + (x * 2 + 1)) * 3;
-                    const px10 = ((y * 2 + 1) * currentWidth + x * 2) * 3;
-                    const px11 = ((y * 2 + 1) * currentWidth + (x * 2 + 1)) * 3;
-                    if (testData[px00] !== testData[px01] ||
-                        testData[px00] !== testData[px10] ||
-                        testData[px00] !== testData[px11] ||
-                        testData[px00 + 1] !== testData[px01 + 1] ||
-                        testData[px00 + 1] !== testData[px10 + 1] ||
-                        testData[px00 + 1] !== testData[px11 + 1]) {
-                        hasBlockPattern = false;
-                        break;
-                    }
-                }
-                if (!hasBlockPattern)
-                    break;
-            }
-            if (hasBlockPattern) {
-                isBlockEncoded = true;
-                const blocksWide = currentWidth / 2;
-                const blocksHigh = currentHeight / 2;
-                rawRGB = Buffer.alloc(blocksWide * blocksHigh * 3);
-                const fullRaw = native.sharpToRaw(processedBuf);
-                const fullData = fullRaw.pixels;
-                let outIdx = 0;
-                for (let by = 0; by < blocksHigh; by++) {
-                    for (let bx = 0; bx < blocksWide; bx++) {
-                        const pixelOffset = (by * 2 * currentWidth + bx * 2) * 3;
-                        rawRGB[outIdx++] = fullData[pixelOffset];
-                        rawRGB[outIdx++] = fullData[pixelOffset + 1];
-                        rawRGB[outIdx++] = fullData[pixelOffset + 2];
-                    }
-                }
-            }
-        }
-        if (!isBlockEncoded) {
-            const rawData = native.sharpToRaw(processedBuf);
-            rawRGB = Buffer.from(rawData.pixels);
-            if (opts.onProgress) {
-                opts.onProgress({
-                    phase: 'extract_pixels',
-                    loaded: currentHeight,
-                    total: currentHeight,
-                });
-            }
-        }
-        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 (!isColorMatch(firstPixels[i].r, firstPixels[i].g, firstPixels[i].b, MARKER_START[i].r, MARKER_START[i].g, MARKER_START[i].b)) {
-                    hasMarkerStart = false;
-                    break;
-                }
-            }
-        }
-        let hasPixelMagic = false;
-        let hasBlockMagic = 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;
-            }
-            else if (rawRGB.slice(8, 8 + PIXEL_MAGIC_BLOCK.length).equals(PIXEL_MAGIC_BLOCK)) {
-                hasBlockMagic = true;
-            }
-        }
-        let logicalWidth = 0;
-        let logicalHeight = 0;
-        let logicalData = Buffer.alloc(0);
-        if (hasMarkerStart || hasPixelMagic || hasBlockMagic) {
-            logicalWidth = currentWidth;
-            logicalHeight = currentHeight;
-            logicalData = rawRGB;
-        }
-        else {
-            // Try cropAndReconstitute first (for screenshots with markers)
-            let reconSuccess = false;
-            try {
-                if (process.env.ROX_DEBUG || opts.debugDir) {
-                    console.log('DEBUG: about to call cropAndReconstitute, debugDir=', opts.debugDir);
-                }
-                const reconstructed = await cropAndReconstitute(processedBuf, opts.debugDir);
-                if (process.env.ROX_DEBUG || opts.debugDir) {
-                    console.log('DEBUG: cropAndReconstitute returned, reconstructed len=', reconstructed.length);
-                }
-                const rawData = native.sharpToRaw(reconstructed);
-                if (process.env.ROX_DEBUG || opts.debugDir) {
-                    console.log('DEBUG: rawData from reconstructed:', rawData.width, 'x', rawData.height, 'pixels=', Math.floor(rawData.pixels.length / 3));
-                }
-                logicalWidth = rawData.width;
-                logicalHeight = rawData.height;
-                logicalData = Buffer.from(rawData.pixels);
-                reconSuccess = true;
-            }
-            catch (reconErr) {
-                if (process.env.ROX_DEBUG) {
-                    console.log('DEBUG: cropAndReconstitute failed:', reconErr instanceof Error ? reconErr.message : reconErr);
-                }
-            }
-            // Fallback: try un-stretching (nearest-neighbor scaled images)
-            if (!reconSuccess) {
-                const pixelW = isBlockEncoded ? currentWidth / 2 : currentWidth;
-                const pixelH = isBlockEncoded ? currentHeight / 2 : currentHeight;
-                if (process.env.ROX_DEBUG) {
-                    console.log(`DEBUG: trying unstretch on ${pixelW}x${pixelH} rawRGB`);
-                }
-                const unstretched = unstretchImage(rawRGB, pixelW, pixelH);
-                if (unstretched) {
-                    logicalWidth = unstretched.width;
-                    logicalHeight = unstretched.height;
-                    logicalData = unstretched.data;
-                }
-                else {
-                    throw new Error('No valid markers found and image unstretch failed');
-                }
-            }
-        }
-        if (process.env.ROX_DEBUG) {
-            console.log('DEBUG: Logical grid reconstructed:', logicalWidth, 'x', logicalHeight, '=', logicalWidth * logicalHeight, 'pixels');
-        }
-        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 = await tryDecompress(payload, (info) => {
-                    if (opts.onProgress)
-                        opts.onProgress(info);
-                });
-                if (version === 3) {
-                    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 } };
-        }
-        const totalPixels = (logicalData.length / 3) | 0;
-        let startIdx = -1;
-        for (let i = 0; i <= totalPixels - MARKER_START.length; i++) {
-            let match = true;
-            for (let mi = 0; mi < MARKER_START.length && match; mi++) {
-                const offset = (i + mi) * 3;
-                if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_START[mi].r, MARKER_START[mi].g, 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', totalPixels, '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 ||
-                            !isColorMatch(logicalData[idx], logicalData[idx + 1], logicalData[idx + 2], MARKER_START[mi].r, MARKER_START[mi].g, 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})`);
-                        }
-                        const newDataLen = rectWidth * rectHeight * 3;
-                        const newData = Buffer.allocUnsafe(newDataLen);
-                        let writeIdx = 0;
-                        for (let ry = y; ry <= endY; ry++) {
-                            for (let rx = x; rx <= endX; rx++) {
-                                const idx = (ry * logicalWidth + rx) * 3;
-                                newData[writeIdx++] = logicalData[idx];
-                                newData[writeIdx++] = logicalData[idx + 1];
-                                newData[writeIdx++] = logicalData[idx + 2];
-                            }
-                        }
-                        logicalData = newData;
-                        logicalWidth = rectWidth;
-                        logicalHeight = rectHeight;
-                        startIdx = 0;
-                        found2D = true;
-                    }
-                }
-            }
-            if (!found2D) {
-                if (process.env.ROX_DEBUG) {
-                    const first20 = [];
-                    for (let i = 0; i < Math.min(20, totalPixels); i++) {
-                        const offset = i * 3;
-                        first20.push(`(${logicalData[offset]},${logicalData[offset + 1]},${logicalData[offset + 2]})`);
-                    }
-                    console.log('DEBUG: First 20 pixels:', first20.join(' '));
-                }
-                throw new Error('Marker START not found - image format not supported');
-            }
-        }
-        if (process.env.ROX_DEBUG && startIdx === 0) {
-            console.log(`DEBUG: MARKER_START at index ${startIdx}, grid size: ${totalPixels}`);
-        }
-        const dataStartPixel = startIdx + MARKER_START.length + 1;
-        const curTotalPixels = (logicalData.length / 3) | 0;
-        if (curTotalPixels < dataStartPixel + MARKER_END.length) {
-            if (process.env.ROX_DEBUG) {
-                console.log('DEBUG: grid too small:', curTotalPixels, 'pixels');
-            }
-            throw new Error('Marker START or END not found - image format not supported');
-        }
-        for (let i = 0; i < MARKER_START.length; i++) {
-            const offset = (startIdx + i) * 3;
-            if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_START[i].r, MARKER_START[i].g, MARKER_START[i].b)) {
-                throw new Error('Marker START not found - image format not supported');
-            }
-        }
-        let compression = 'zstd';
-        if (curTotalPixels > startIdx + MARKER_START.length) {
-            const compOffset = (startIdx + MARKER_START.length) * 3;
-            const compPixel = {
-                r: logicalData[compOffset],
-                g: logicalData[compOffset + 1],
-                b: logicalData[compOffset + 2],
-            };
-            if (compPixel.r === 0 && compPixel.g === 255 && compPixel.b === 0) {
-                compression = 'zstd';
-            }
-            else {
-                compression = 'zstd';
-            }
-        }
-        if (process.env.ROX_DEBUG) {
-            console.log(`DEBUG: Detected compression: ${compression}`);
-        }
-        let endStartPixel = -1;
-        const lastLineStart = (logicalHeight - 1) * logicalWidth;
-        const endMarkerStartCol = logicalWidth - MARKER_END.length;
-        if (lastLineStart + endMarkerStartCol < curTotalPixels) {
-            let matchEnd = true;
-            for (let mi = 0; mi < MARKER_END.length && matchEnd; mi++) {
-                const pixelIdx = lastLineStart + endMarkerStartCol + mi;
-                if (pixelIdx >= curTotalPixels) {
-                    matchEnd = false;
-                    break;
-                }
-                const offset = pixelIdx * 3;
-                if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_END[mi].r, MARKER_END[mi].g, MARKER_END[mi].b)) {
-                    matchEnd = false;
-                }
-            }
-            if (matchEnd) {
-                endStartPixel = lastLineStart + endMarkerStartCol - startIdx;
-                if (process.env.ROX_DEBUG) {
-                    console.log(`DEBUG: Found END marker at last line, col ${endMarkerStartCol}`);
-                }
-            }
-        }
-        if (endStartPixel === -1) {
-            const scanLines = Math.min(logicalHeight, 5);
-            for (let row = logicalHeight - 1; row >= logicalHeight - scanLines && endStartPixel === -1; row--) {
-                const rowStart = row * logicalWidth;
-                for (let col = logicalWidth - MARKER_END.length; col >= 0 && endStartPixel === -1; col--) {
-                    let match = true;
-                    for (let mi = 0; mi < MARKER_END.length && match; mi++) {
-                        const pixelIdx = rowStart + col + mi;
-                        if (pixelIdx >= curTotalPixels) {
-                            match = false;
-                            break;
-                        }
-                        const offset = pixelIdx * 3;
-                        if (!isColorMatch(logicalData[offset], logicalData[offset + 1], logicalData[offset + 2], MARKER_END[mi].r, MARKER_END[mi].g, MARKER_END[mi].b)) {
-                            match = false;
-                        }
-                    }
-                    if (match) {
-                        endStartPixel = rowStart + col - startIdx;
-                        if (process.env.ROX_DEBUG) {
-                            console.log(`DEBUG: Found END marker via scan at row=${row}, col=${col}`);
-                        }
-                    }
-                }
-            }
-        }
-        if (endStartPixel === -1) {
-            if (process.env.ROX_DEBUG) {
-                console.log('DEBUG: END marker not found at expected position');
-                const lastLinePixels = [];
-                for (let i = Math.max(0, lastLineStart); i < curTotalPixels && i < lastLineStart + 20; i++) {
-                    const offset = i * 3;
-                    lastLinePixels.push(`(${logicalData[offset]},${logicalData[offset + 1]},${logicalData[offset + 2]})`);
-                }
-                console.log('DEBUG: Last line pixels:', lastLinePixels.join(' '));
-            }
-            endStartPixel = curTotalPixels - startIdx;
-        }
-        const dataPixelCount = endStartPixel - (MARKER_START.length + 1);
-        const srcByteOffset = dataStartPixel * 3;
-        const byteCount = dataPixelCount * 3;
-        const pixelBytes = Buffer.allocUnsafe(byteCount);
-        if (Buffer.isBuffer(logicalData)) {
-            logicalData.copy(pixelBytes, 0, srcByteOffset, srcByteOffset + byteCount);
-        }
-        else {
-            for (let i = 0; i < byteCount; i++) {
-                pixelBytes[i] = logicalData[srcByteOffset + i];
-            }
-        }
-        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));
-            }
-            if (opts.debugDir) {
-                try {
-                    console.log('DEBUG: writing extracted pixel bytes to', opts.debugDir);
-                    writeFileSync(join(opts.debugDir, 'extracted-pixel-bytes.bin'), pixelBytes);
-                    writeFileSync(join(opts.debugDir, 'extracted-pixel-head.hex'), pixelBytes.slice(0, 512).toString('hex'));
-                }
-                catch (e) {
-                    console.log('DEBUG: failed writing extracted bytes', e?.message ?? e);
-                }
-            }
-        }
-        try {
-            let idx = 0;
-            if (pixelBytes.length >= PIXEL_MAGIC.length) {
-                const at0 = pixelBytes.slice(0, PIXEL_MAGIC.length).equals(PIXEL_MAGIC);
-                const at0Block = pixelBytes
-                    .slice(0, PIXEL_MAGIC_BLOCK.length)
-                    .equals(PIXEL_MAGIC_BLOCK);
-                if (at0) {
-                    idx = PIXEL_MAGIC.length;
-                }
-                else if (at0Block) {
-                    idx = PIXEL_MAGIC_BLOCK.length;
-                }
-                else {
-                    const found = pixelBytes.indexOf(PIXEL_MAGIC);
-                    const foundBlock = pixelBytes.indexOf(PIXEL_MAGIC_BLOCK);
-                    if (found !== -1) {
-                        idx = found + PIXEL_MAGIC.length;
-                    }
-                    else if (foundBlock !== -1) {
-                        idx = foundBlock + PIXEL_MAGIC_BLOCK.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;
-                if (idx + 4 <= pixelBytes.length) {
-                    const marker = pixelBytes.slice(idx, idx + 4).toString('utf8');
-                    if (marker === 'rXFL') {
-                        idx += 4;
-                        if (idx + 4 <= pixelBytes.length) {
-                            const jsonLen = pixelBytes.readUInt32BE(idx);
-                            idx += 4;
-                            idx += jsonLen;
-                        }
-                    }
-                }
-                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 = 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 +
-                            ')');
-                    try {
-                        if (process.env.ROX_DEBUG)
-                            console.log('DEBUG: decompress failed, attempting cropAndReconstitute fallback');
-                        const reconstructed = await cropAndReconstitute(processedBuf, opts.debugDir);
-                        const raw2 = native.sharpToRaw(reconstructed);
-                        let logicalData2 = Buffer.from(raw2.pixels);
-                        let logicalWidth2 = raw2.width;
-                        let logicalHeight2 = raw2.height;
-                        let startIdx2 = -1;
-                        const totalPixels2 = (logicalData2.length / 3) | 0;
-                        for (let i2 = 0; i2 <= totalPixels2 - MARKER_START.length; i2++) {
-                            let match2 = true;
-                            for (let mi2 = 0; mi2 < MARKER_START.length && match2; mi2++) {
-                                const offset2 = (i2 + mi2) * 3;
-                                if (logicalData2[offset2] !== MARKER_START[mi2].r ||
-                                    logicalData2[offset2 + 1] !== MARKER_START[mi2].g ||
-                                    logicalData2[offset2 + 2] !== MARKER_START[mi2].b) {
-                                    match2 = false;
-                                }
-                            }
-                            if (match2) {
-                                startIdx2 = i2;
-                                break;
-                            }
-                        }
-                        if (startIdx2 === -1) {
-                            let found2D2 = false;
-                            for (let y = 0; y < logicalHeight2 && !found2D2; y++) {
-                                for (let x = 0; x <= logicalWidth2 - MARKER_START.length && !found2D2; x++) {
-                                    let match = true;
-                                    for (let mi = 0; mi < MARKER_START.length && match; mi++) {
-                                        const idx = (y * logicalWidth2 + (x + mi)) * 3;
-                                        if (idx + 2 >= logicalData2.length ||
-                                            !isColorMatch(logicalData2[idx], logicalData2[idx + 1], logicalData2[idx + 2], MARKER_START[mi].r, MARKER_START[mi].g, MARKER_START[mi].b)) {
-                                            match = false;
-                                        }
-                                    }
-                                    if (match) {
-                                        let endX = x + MARKER_START.length - 1;
-                                        let endY = y;
-                                        for (let scanY = y; scanY < logicalHeight2; scanY++) {
-                                            let rowHasData = false;
-                                            for (let scanX = x; scanX < logicalWidth2; scanX++) {
-                                                const scanIdx = (scanY * logicalWidth2 + scanX) * 3;
-                                                if (scanIdx + 2 < logicalData2.length) {
-                                                    const r = logicalData2[scanIdx];
-                                                    const g = logicalData2[scanIdx + 1];
-                                                    const b = logicalData2[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;
-                                        const newDataLen = rectWidth * rectHeight * 3;
-                                        const newData = Buffer.allocUnsafe(newDataLen);
-                                        let writeIdx = 0;
-                                        for (let ry = y; ry <= endY; ry++) {
-                                            for (let rx = x; rx <= endX; rx++) {
-                                                const idx = (ry * logicalWidth2 + rx) * 3;
-                                                newData[writeIdx++] = logicalData2[idx];
-                                                newData[writeIdx++] = logicalData2[idx + 1];
-                                                newData[writeIdx++] = logicalData2[idx + 2];
-                                            }
-                                        }
-                                        logicalData2 = newData;
-                                        logicalWidth2 = rectWidth;
-                                        logicalHeight2 = rectHeight;
-                                        startIdx2 = 0;
-                                        found2D2 = true;
-                                    }
-                                }
-                            }
-                            if (!found2D2)
-                                throw new DataFormatError('Screenshot fallback failed: START not found');
-                        }
-                        const curTotalPixels2 = (logicalData2.length / 3) | 0;
-                        const lastLineStart2 = (logicalHeight2 - 1) * logicalWidth2;
-                        const endMarkerStartCol2 = logicalWidth2 - MARKER_END.length;
-                        let endStartPixel2 = -1;
-                        if (lastLineStart2 + endMarkerStartCol2 < curTotalPixels2) {
-                            let matchEnd2 = true;
-                            for (let mi = 0; mi < MARKER_END.length && matchEnd2; mi++) {
-                                const pixelIdx = lastLineStart2 + endMarkerStartCol2 + mi;
-                                if (pixelIdx >= curTotalPixels2) {
-                                    matchEnd2 = false;
-                                    break;
-                                }
-                                const offset = pixelIdx * 3;
-                                if (!isColorMatch(logicalData2[offset], logicalData2[offset + 1], logicalData2[offset + 2], MARKER_END[mi].r, MARKER_END[mi].g, MARKER_END[mi].b)) {
-                                    matchEnd2 = false;
-                                }
-                            }
-                            if (matchEnd2) {
-                                endStartPixel2 =
-                                    lastLineStart2 + endMarkerStartCol2 - startIdx2;
-                                if (process.env.ROX_DEBUG) {
-                                    console.log('DEBUG: Found END marker in fallback at last line');
-                                }
-                            }
-                        }
-                        if (endStartPixel2 === -1) {
-                            const scanLines2 = Math.min(logicalHeight2, 5);
-                            for (let row2 = logicalHeight2 - 1; row2 >= logicalHeight2 - scanLines2 && endStartPixel2 === -1; row2--) {
-                                const rowStart2 = row2 * logicalWidth2;
-                                for (let col2 = logicalWidth2 - MARKER_END.length; col2 >= 0 && endStartPixel2 === -1; col2--) {
-                                    let m2 = true;
-                                    for (let mi = 0; mi < MARKER_END.length && m2; mi++) {
-                                        const pixelIdx2 = rowStart2 + col2 + mi;
-                                        if (pixelIdx2 >= curTotalPixels2) {
-                                            m2 = false;
-                                            break;
-                                        }
-                                        const off2 = pixelIdx2 * 3;
-                                        if (!isColorMatch(logicalData2[off2], logicalData2[off2 + 1], logicalData2[off2 + 2], MARKER_END[mi].r, MARKER_END[mi].g, MARKER_END[mi].b)) {
-                                            m2 = false;
-                                        }
-                                    }
-                                    if (m2) {
-                                        endStartPixel2 = rowStart2 + col2 - startIdx2;
-                                    }
-                                }
-                            }
-                        }
-                        if (endStartPixel2 === -1) {
-                            if (process.env.ROX_DEBUG) {
-                                console.log('DEBUG: END marker not found in fallback; using end of grid');
-                            }
-                            endStartPixel2 = curTotalPixels2 - startIdx2;
-                        }
-                        const dataPixelCount2 = endStartPixel2 - (MARKER_START.length + 1);
-                        const pixelBytes2 = Buffer.allocUnsafe(dataPixelCount2 * 3);
-                        for (let i2 = 0; i2 < dataPixelCount2; i2++) {
-                            const srcOffset = (startIdx2 + MARKER_START.length + 1 + i2) * 3;
-                            const dstOffset = i2 * 3;
-                            pixelBytes2[dstOffset] = logicalData2[srcOffset];
-                            pixelBytes2[dstOffset + 1] = logicalData2[srcOffset + 1];
-                            pixelBytes2[dstOffset + 2] = logicalData2[srcOffset + 2];
-                        }
-                        const foundPX = pixelBytes2.indexOf(PIXEL_MAGIC);
-                        if (process.env.ROX_DEBUG)
-                            console.log('DEBUG: PIXEL_MAGIC index in fallback:', foundPX);
-                        if (pixelBytes2.length >= PIXEL_MAGIC.length) {
-                            let ii = 0;
-                            const at0 = pixelBytes2
-                                .slice(0, PIXEL_MAGIC.length)
-                                .equals(PIXEL_MAGIC);
-                            if (at0)
-                                ii = PIXEL_MAGIC.length;
-                            else {
-                                const found = pixelBytes2.indexOf(PIXEL_MAGIC);
-                                if (found !== -1)
-                                    ii = found + PIXEL_MAGIC.length;
-                            }
-                            if (ii > 0) {
-                                const version2 = pixelBytes2[ii++];
-                                const nameLen2 = pixelBytes2[ii++];
-                                const payloadLen2 = pixelBytes2.readUInt32BE(ii + nameLen2);
-                                const rawPayload2 = pixelBytes2.slice(ii + nameLen2 + 4, ii + nameLen2 + 4 + payloadLen2);
-                                let payload2 = tryDecryptIfNeeded(rawPayload2, opts.passphrase);
-                                payload2 = await tryDecompress(payload2, (info) => {
-                                    if (opts.onProgress)
-                                        opts.onProgress(info);
-                                });
-                                if (!payload2.slice(0, MAGIC.length).equals(MAGIC)) {
-                                    throw new DataFormatError('Screenshot fallback failed: missing ROX1 magic after decompression');
-                                }
-                                payload2 = payload2.slice(MAGIC.length);
-                                if (opts.files) {
-                                    const unpacked2 = unpackBuffer(payload2, opts.files);
-                                    if (unpacked2) {
-                                        if (opts.onProgress)
-                                            opts.onProgress({ phase: 'done' });
-                                        progressBar?.stop();
-                                        return { files: unpacked2.files, meta: { name } };
-                                    }
-                                }
-                                if (opts.onProgress)
-                                    opts.onProgress({ phase: 'done' });
-                                progressBar?.stop();
-                                return { buf: payload2, meta: { name } };
-                            }
-                        }
-                        throw new DataFormatError('Screenshot mode zstd decompression failed: ' + errMsg);
-                    }
-                    catch (e2) {
-                        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;
-        }
-        try {
-            const rawPayload = Buffer.from(native.extractPayloadFromPng(processedBuf));
-            let payload = tryDecryptIfNeeded(rawPayload, opts.passphrase);
-            payload = await tryDecompress(payload, (info) => {
-                if (opts.onProgress)
-                    opts.onProgress(info);
-            });
-            if (!payload.slice(0, MAGIC.length).equals(MAGIC)) {
-                throw new DataFormatError('Missing ROX1 magic after native extraction');
-            }
-            payload = payload.slice(MAGIC.length);
-            const nameFromPng = native.extractNameFromPng
-                ? (() => { try {
-                    return native.extractNameFromPng(processedBuf);
-                }
-                catch {
-                    return undefined;
-                } })()
-                : undefined;
-            return { buf: payload, meta: { name: nameFromPng } };
-        }
-        catch (nativeErr) {
-            if (nativeErr instanceof PassphraseRequiredError ||
-                nativeErr instanceof IncorrectPassphraseError ||
-                nativeErr instanceof DataFormatError) {
-                throw nativeErr;
-            }
+        catch {
+            // Fall through to raw buffer return
         }
-        const errMsg = e instanceof Error ? e.message : String(e);
-        throw new Error('Failed to decode PNG: ' + errMsg);
+        return { buf: decompressed, meta: { name } };
     }
-    throw new DataFormatError('No valid data found in image');
+    return { buf: payload, meta: { name } };
 }