roxify 1.6.8 → 1.7.0

package/README.md

@@ -46,6 +46,7 @@ The core compression and image-processing logic is written in Rust and exposed t
 - **Audio container** -- encode data as structured multi-frequency tones (not white noise) in WAV files
 - **Directory packing** -- encode entire directory trees into a single PNG
 - **Screenshot reconstitution** -- recover data from photographed or screenshotted PNGs
+- **Stretch-resilient decoding** -- automatically un-stretches nearest-neighbor scaled images back to original pixel data
 - **CLI and programmatic API** -- use from the terminal or import as a library
 - **Cross-platform** -- prebuilt binaries for Linux x64, macOS x64/ARM64, and Windows x64
 - **Full TypeScript support** with exported types and TSDoc annotations
@@ -388,6 +389,21 @@ interface DecodeResult {
 | `screenshot` | Encodes data as RGB pixels in a standard PNG. The image looks like a gradient or noise pattern and survives re-uploads and social media processing. | Sharing on image-only platforms, bypassing file-type filters |
 | `compact` | Minimal 1x1 PNG with data embedded in a custom ancillary chunk (`rXDT`). Produces the smallest possible output. | Programmatic use, archival, maximum compression ratio |
 
+### Stretch-Resilient Decoding
+
+Roxify automatically detects and recovers data from **nearest-neighbor stretched** images. If a roxified PNG is scaled up (e.g., zoomed in a browser, pasted in a document, resized in an image editor with nearest-neighbor interpolation), the decoder:
+
+1. **Crops** the image to the non-background bounding box
+2. **Collapses** horizontal runs of identical pixels back to single logical pixels
+3. **Deduplicates** consecutive identical rows
+
+This means you can share a roxified image at any zoom level and it will still decode correctly. Non-uniform stretch factors and white padding are fully supported.
+
+```bash
+# Works even on stretched/zoomed screenshots
+rox decode zoomed-screenshot.png -o output/
+```
+
 ---
 
 ## Encryption
@@ -603,7 +619,7 @@ Input --> RS ECC Encode --> Interleave --> Block Encode (MFSK audio / QR-like im
 ### Decompression Pipeline
 
 ```
-Input --> PNG Parse --> AES-256-GCM Decrypt (optional) --> Zstd Decompress --> Output
+Input --> PNG Parse --> Un-stretch (if needed) --> AES-256-GCM Decrypt (optional) --> Zstd Decompress --> Output
 ```
 
 ### Lossy-Resilient Decode Pipeline

package/dist/utils/decoder.d.ts

@@ -1,4 +1,17 @@
 import { DecodeOptions, DecodeResult } from './types.js';
+/**
+ * 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 declare function unstretchImage(rawRGB: Buffer, width: number, height: number, tolerance?: number): {
+    data: Buffer;
+    width: number;
+    height: number;
+} | null;
 /**
  * Decode a ROX PNG or buffer into the original binary payload or files list.
  *

package/dist/utils/decoder.js

@@ -15,6 +15,133 @@ import { parallelZstdDecompress, tryZstdDecompress } 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 };
+}
 async function tryDecompress(payload, onProgress) {
     return await parallelZstdDecompress(payload, onProgress);
 }
@@ -458,29 +585,56 @@ export async function decodePngToBinary(input, opts = {}) {
                 hasBlockMagic = true;
             }
         }
-        let logicalWidth;
-        let logicalHeight;
-        let logicalData;
+        let logicalWidth = 0;
+        let logicalHeight = 0;
+        let logicalData = Buffer.alloc(0);
         if (hasMarkerStart || hasPixelMagic || hasBlockMagic) {
             logicalWidth = currentWidth;
             logicalHeight = currentHeight;
             logicalData = rawRGB;
         }
         else {
-            if (process.env.ROX_DEBUG || opts.debugDir) {
-                console.log('DEBUG: about to call cropAndReconstitute, debugDir=', opts.debugDir);
+            // 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;
             }
-            const reconstructed = await cropAndReconstitute(processedBuf, opts.debugDir);
-            if (process.env.ROX_DEBUG || opts.debugDir) {
-                console.log('DEBUG: cropAndReconstitute returned, reconstructed len=', reconstructed.length);
+            catch (reconErr) {
+                if (process.env.ROX_DEBUG) {
+                    console.log('DEBUG: cropAndReconstitute failed:', reconErr instanceof Error ? reconErr.message : reconErr);
+                }
             }
-            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));
+            // 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');
+                }
             }
-            logicalWidth = rawData.width;
-            logicalHeight = rawData.height;
-            logicalData = Buffer.from(rawData.pixels);
         }
         if (process.env.ROX_DEBUG) {
             console.log('DEBUG: Logical grid reconstructed:', logicalWidth, 'x', logicalHeight, '=', logicalWidth * logicalHeight, 'pixels');

package/dist/utils/native.js

@@ -1,21 +1,26 @@
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { arch, platform } from 'os';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
+import { fileURLToPath } from 'url';
 function getNativeModule() {
     let moduleDir;
     let nativeRequire;
+    // In ESM, __dirname is not available — derive it from import.meta.url
+    // which always points to the actual file location on disk.
+    const esmFilename = fileURLToPath(import.meta.url);
+    const esmDirname = dirname(esmFilename);
     if (typeof __dirname !== 'undefined') {
         moduleDir = __dirname;
         nativeRequire = require;
     }
     else {
-        moduleDir = process.cwd();
+        moduleDir = esmDirname;
         try {
             nativeRequire = require;
         }
         catch {
-            nativeRequire = createRequire(process.cwd() + '/package.json');
+            nativeRequire = createRequire(esmFilename);
         }
     }
     function getNativePath() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.6.8",
+  "version": "1.7.0",
   "type": "module",
   "description": "Ultra-lightweight PNG steganography with native Rust acceleration. Encode binary data into PNG images with zstd compression.",
   "main": "dist/index.js",