roxify 1.13.8 → 1.14.0

package/dist/cli.js

@@ -3,7 +3,7 @@ import { readdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { open } from 'fs/promises';
 import { basename, dirname, join, resolve } from 'path';
 import * as cliProgress from './stub-progress.js';
-import { decodeWithRustCLI, encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
+import { encodeWithRustCLI, havepassphraseWithRustCLI, isRustBinaryAvailable, listWithRustCLI, } from './utils/rust-cli-wrapper.js';
 async function loadJsEngine() {
     const indexMod = await import('./index.js');
     const packMod = await import('./pack.js');
@@ -20,7 +20,7 @@ async function loadJsEngine() {
         VFSIndexEntry: undefined,
     };
 }
-const VERSION = '1.13.8';
+const VERSION = '1.14.0';
 function getDirectorySize(dirPath) {
     let totalSize = 0;
     try {
@@ -315,13 +315,6 @@ async function encodeCommand(args) {
         }
     }
     catch (e) { }
-    let anyInputDir = false;
-    try {
-        anyInputDir = resolvedInputs.some((p) => statSync(p).isDirectory());
-    }
-    catch (e) {
-        anyInputDir = false;
-    }
     if (isRustBinaryAvailable() && !parsed.forceTs && containerMode !== 'sound' && parsed.compression !== 'bwt-ans') {
         try {
             console.log(`Encoding to ${resolvedOutput} (Using native Rust encoder)\n`);
@@ -598,24 +591,33 @@ async function decodeCommand(args) {
     }
     const resolvedInput = resolve(inputPath);
     const resolvedOutput = parsed.output || outputPath || '.';
-    if (!isRustBinaryAvailable()) {
-        console.error('Error: Rust decoder binary not found');
-        process.exit(1);
-    }
     try {
         console.log(' ');
         console.log('Decoding... (Using native Rust decoder)\n');
         const startTime = Date.now();
         const decodeBar = new cliProgress.SingleBar({ format: ' {bar} {percentage}% | {step} | {elapsed}s' }, cliProgress.Presets.shades_classic);
         decodeBar.start(100, 0, { step: 'Decoding', elapsed: '0' });
-        await decodeWithRustCLI(resolvedInput, resolvedOutput, parsed.passphrase, parsed.files, parsed.dict, parsed.ramBudgetMb, (current, total, step) => {
-            const pct = total > 0 ? Math.floor((current / total) * 100) : 0;
-            const elapsed = Math.floor((Date.now() - startTime) / 1000);
-            decodeBar.update(Math.min(pct, 99), {
-                step: step || 'Decoding',
-                elapsed: String(elapsed),
-            });
-        });
+        const js = await loadJsEngine();
+        const result = await js.decodePngToBinary(readFileSync(resolvedInput));
+        if (result.files && result.files.length > 0) {
+            const outputDir = resolve(resolvedOutput);
+            for (const file of result.files) {
+                const dest = join(outputDir, file.path);
+                const parent = dirname(dest);
+                try {
+                    await import('fs/promises').then(({ mkdir }) => mkdir(parent, { recursive: true }));
+                }
+                catch { }
+                writeFileSync(dest, file.buf);
+            }
+        }
+        else if (result.buf) {
+            const outputFile = resolvedOutput === '.' ? join(process.cwd(), result.meta?.name || basename(resolvedInput).replace(/\.[^.]+$/, '')) : resolvedOutput;
+            writeFileSync(outputFile, result.buf);
+        }
+        else {
+            throw new Error('Decoded result is empty');
+        }
         const decodeTime = Date.now() - startTime;
         decodeBar.update(100, { step: 'done', elapsed: String(Math.floor(decodeTime / 1000)) });
         decodeBar.stop();

package/dist/stub-progress.d.ts

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

package/dist/stub-progress.js

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

package/dist/utils/decoder.d.ts

@@ -42,4 +42,13 @@ import { DecodeOptions, DecodeResult } from './types.js';
  * @param opts - Optional decode options.
  * @returns A Promise resolving to DecodeResult ({ buf, meta } or { files }).
  */
-export declare function decodePngToBinary(input: Buffer | string, opts?: DecodeOptions): Promise<DecodeResult>;
+export declare function decodePngToBinary(input: Buffer | string, _opts?: DecodeOptions): Promise<DecodeResult>;
+/**
+ * Detect and reverse simple pixel-stretching where each logical pixel
+ * is repeated in an Fx×Fy block. Returns { width, height, data } or null.
+ */
+export declare function unstretchImage(pixels: Buffer, width: number, height: number): {
+    width: number;
+    height: number;
+    data: Buffer<ArrayBuffer>;
+} | null;

package/dist/utils/decoder.js

@@ -1,7 +1,6 @@
 import { readFileSync } from 'fs';
 import { native } from './native.js';
 import { unpackBuffer } from '../pack.js';
-const PXL1_MAGIC = Buffer.from([0x50, 0x58, 0x4c, 0x31]); // "PXL1"
 /**
  * Find PXL1 magic in pixel buffer
  */
@@ -116,7 +115,7 @@ function extractPayloadFromPixels(pixels) {
  * @param opts - Optional decode options.
  * @returns A Promise resolving to DecodeResult ({ buf, meta } or { files }).
  */
-export async function decodePngToBinary(input, opts = {}) {
+export async function decodePngToBinary(input, _opts = {}) {
     // Get PNG buffer
     let pngBuf;
     if (Buffer.isBuffer(input)) {
@@ -125,11 +124,14 @@ export async function decodePngToBinary(input, opts = {}) {
     else {
         pngBuf = readFileSync(input);
     }
-    // Decode PNG to RGB pixels
-    const rgbResult = native.pngToRgb(pngBuf);
-    const pixels = Buffer.from(rgbResult.pixels);
-    // Extract payload from pixels
-    const { payload, name } = extractPayloadFromPixels(pixels);
+    const payload = Buffer.from(native.extractPayloadFromPng(pngBuf));
+    let name;
+    try {
+        const rgbResult = native.pngToRgb(pngBuf);
+        const pixels = Buffer.from(rgbResult.pixels);
+        ({ name } = extractPayloadFromPixels(pixels));
+    }
+    catch { }
     if (payload.length === 0) {
         throw new Error('Empty payload extracted');
     }
@@ -171,3 +173,105 @@ export async function decodePngToBinary(input, opts = {}) {
     }
     return { buf: decompressed, meta: { name } };
 }
+/**
+ * Detect and reverse simple pixel-stretching where each logical pixel
+ * is repeated in an Fx×Fy block. Returns { width, height, data } or null.
+ */
+export function unstretchImage(pixels, width, height) {
+    if (!Buffer.isBuffer(pixels))
+        return null;
+    if (pixels.length !== width * height * 3)
+        return null;
+    try {
+        let allWhite = true;
+        for (let i = 0; i < pixels.length; i += 3) {
+            if (!(pixels[i] === 255 && pixels[i + 1] === 255 && pixels[i + 2] === 255)) {
+                allWhite = false;
+                break;
+            }
+        }
+        if (allWhite)
+            return null;
+        let minX = width, minY = height, maxX = -1, maxY = -1;
+        for (let y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++) {
+                const idx = (y * width + x) * 3;
+                if (!(pixels[idx] === 255 && pixels[idx + 1] === 255 && pixels[idx + 2] === 255)) {
+                    if (x < minX)
+                        minX = x;
+                    if (y < minY)
+                        minY = y;
+                    if (x > maxX)
+                        maxX = x;
+                    if (y > maxY)
+                        maxY = y;
+                }
+            }
+        }
+        if (maxX < 0)
+            return null;
+        const cropW = maxX - minX + 1;
+        const cropH = maxY - minY + 1;
+        const colSig = [];
+        for (let x = 0; x < cropW; x++) {
+            const parts = [];
+            for (let y = 0; y < cropH; y++) {
+                const idx = ((minY + y) * width + (minX + x)) * 3;
+                parts.push(pixels[idx], pixels[idx + 1], pixels[idx + 2]);
+            }
+            colSig.push(parts.join(','));
+        }
+        const colGroups = [];
+        for (let x = 0; x < colSig.length; x++) {
+            if (x === 0 || colSig[x] !== colSig[x - 1])
+                colGroups.push({ start: x, len: 1 });
+            else
+                colGroups[colGroups.length - 1].len++;
+        }
+        const rowSig = [];
+        for (let y = 0; y < cropH; y++) {
+            const parts = [];
+            for (let x = 0; x < cropW; x++) {
+                const idx = ((minY + y) * width + (minX + x)) * 3;
+                parts.push(pixels[idx], pixels[idx + 1], pixels[idx + 2]);
+            }
+            rowSig.push(parts.join(','));
+        }
+        const rowGroups = [];
+        for (let y = 0; y < rowSig.length; y++) {
+            if (y === 0 || rowSig[y] !== rowSig[y - 1])
+                rowGroups.push({ start: y, len: 1 });
+            else
+                rowGroups[rowGroups.length - 1].len++;
+        }
+        const outW = colGroups.length;
+        const outH = rowGroups.length;
+        const hasRun = colGroups.some(g => g.len > 1) || rowGroups.some(g => g.len > 1);
+        if (!hasRun)
+            return null;
+        const out = Buffer.alloc(outW * outH * 3);
+        for (let gy = 0; gy < outH; gy++) {
+            for (let gx = 0; gx < outW; gx++) {
+                const sx = minX + colGroups[gx].start;
+                const sy = minY + rowGroups[gy].start;
+                const baseIdx = (sy * width + sx) * 3;
+                const r = pixels[baseIdx], g = pixels[baseIdx + 1], b = pixels[baseIdx + 2];
+                for (let ry = 0; ry < rowGroups[gy].len; ry++) {
+                    for (let rx = 0; rx < colGroups[gx].len; rx++) {
+                        const ix = ((sy + ry) * width + (sx + rx)) * 3;
+                        if (pixels[ix] !== r || pixels[ix + 1] !== g || pixels[ix + 2] !== b)
+                            return null;
+                    }
+                }
+                const outIdx = (gy * outW + gx) * 3;
+                out[outIdx] = r;
+                out[outIdx + 1] = g;
+                out[outIdx + 2] = b;
+            }
+        }
+        return { width: outW, height: outH, data: out };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/ecc.js

@@ -429,7 +429,6 @@ export function eccDecode(protected_) {
     // RS-decode each block
     let totalCorrected = 0;
     const decoded = [];
-    const k = dataPerBlock(nsym);
     for (let i = 0; i < numBlocks; i++) {
         const { data, corrected } = rsDecode(blocks[i], nsym);
         totalCorrected += corrected;

package/dist/utils/inspection.d.ts

@@ -1,4 +1,4 @@
-export declare function listFilesInPng(pngBuf: Buffer, opts?: {
+export declare function listFilesInPng(pngBuf: Buffer, _opts?: {
     includeSizes?: boolean;
 }): Promise<string[] | {
     name: string;

package/dist/utils/inspection.js

@@ -30,7 +30,7 @@ function tryExtractFileListFromChunks(chunks) {
     }
     return null;
 }
-export async function listFilesInPng(pngBuf, opts = {}) {
+export async function listFilesInPng(pngBuf, _opts = {}) {
     try {
         const chunks = native.extractPngChunks(pngBuf);
         const result = tryExtractFileListFromChunks(chunks);
@@ -210,7 +210,7 @@ export async function hasPassphraseInPng(pngBuf) {
                     idx += nameLen;
                     if (valid.length < idx + 4 + 1)
                         return;
-                    const payloadLen = valid.readUInt32BE(idx);
+                    valid.readUInt32BE(idx);
                     idx += 4;
                     if (valid.length < idx + 1)
                         return;

package/dist/utils/robust-audio.js

@@ -109,19 +109,6 @@ const GOERTZEL_COEFFS = CARRIERS.map(freq => {
     return { k, coeff: 2 * Math.cos(w) };
 });
 // ─── Signal Processing Primitives ───────────────────────────────────────────
-/**
- * Generate a raised-cosine windowed tone burst.
- */
-function generateTone(freq, numSamples, amplitude) {
-    const out = new Float64Array(numSamples);
-    const w = (2 * Math.PI * freq) / SAMPLE_RATE;
-    for (let n = 0; n < numSamples; n++) {
-        // Raised cosine window (Hann)
-        const window = 0.5 * (1 - Math.cos((2 * Math.PI * n) / (numSamples - 1)));
-        out[n] = amplitude * window * Math.sin(w * n);
-    }
-    return out;
-}
 /**
  * Goertzel algorithm: compute energy at a specific frequency.
  * Returns normalized power (0–1 range for unit-amplitude input).

package/dist/utils/robust-image.js

@@ -17,12 +17,8 @@ import { native } from './native.js';
 // ─── Configuration ──────────────────────────────────────────────────────────
 /** Finder pattern (7×7 blocks, like QR codes). */
 const FINDER_SIZE = 7;
-/** Alignment pattern (5×5 blocks). */
-const ALIGNMENT_SIZE = 5;
 /** Quiet zone around finder patterns (blocks). */
 const QUIET_ZONE = 1;
-/** Header area width in blocks (next to top-left finder). */
-const HEADER_BLOCKS = 20;
 /** Magic bytes for robust image format. */
 const ROBUST_IMG_MAGIC = Buffer.from('RBI1');
 // ─── Finder Pattern ─────────────────────────────────────────────────────────
@@ -43,22 +39,6 @@ function finderPattern() {
     }
     return p;
 }
-/**
- * Generate a 5×5 alignment pattern.
- */
-function alignmentPattern() {
-    const p = [];
-    for (let y = 0; y < ALIGNMENT_SIZE; y++) {
-        const row = [];
-        for (let x = 0; x < ALIGNMENT_SIZE; x++) {
-            const border = y === 0 || y === 4 || x === 0 || x === 4;
-            const center = y === 2 && x === 2;
-            row.push(border || center);
-        }
-        p.push(row);
-    }
-    return p;
-}
 /**
  * Compute grid layout: place finder patterns, quiet zones, and determine
  * which block positions are available for data.
@@ -294,12 +274,6 @@ const ECC_LEVEL_MAP = {
     quartile: 2,
     high: 3,
 };
-const ECC_LEVEL_REVERSE = {
-    0: 'low',
-    1: 'medium',
-    2: 'quartile',
-    3: 'high',
-};
 /**
  * Encode binary data into a lossy-resilient PNG image.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.13.8",
+  "version": "1.14.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",
@@ -10,34 +10,17 @@
     "roxify": "dist/cli.js"
   },
   "files": [
-    "dist",
-    "roxify_native-x86_64-unknown-linux-gnu.node",
-    "roxify_native-i686-unknown-linux-gnu.node",
-    "roxify_native-aarch64-unknown-linux-gnu.node",
-    "roxify_native-x86_64-apple-darwin.node",
-    "roxify_native-aarch64-apple-darwin.node",
-    "roxify_native-x86_64-pc-windows-msvc.node",
-    "roxify_native-i686-pc-windows-msvc.node",
-    "roxify_native-aarch64-pc-windows-msvc.node",
-    "roxify_native-x86_64-pc-windows-gnu.node",
-    "libroxify_native-x86_64-unknown-linux-gnu.node",
-    "libroxify_native-i686-unknown-linux-gnu.node",
-    "libroxify_native-aarch64-unknown-linux-gnu.node",
-    "libroxify_native-x86_64-apple-darwin.node",
-    "libroxify_native-aarch64-apple-darwin.node",
-    "dist/roxify_native.exe",
-    "dist/roxify_native",
-    "dist/roxify_native-macos-arm64",
-    "dist/roxify_native-macos-x64",
-    "dist/rox-macos-universal",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
     "scripts/postinstall.cjs",
-    "native",
-    "Cargo.toml",
+    "roxify_native-*.node",
+    "libroxify_native-*.node",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "build": "tsc",
+    "bundle": "esbuild src/cli.ts --bundle --platform=node --target=node18 --outfile=dist/cli.js --format=esm --minify --external:./index.js --external:./pack.js && tsc --emitDeclarationOnly --declaration --declarationDir dist",
     "prebuild:pkg": "node scripts/copy-cli-binary.js",
     "build:native": "cargo build --release --lib",
     "build:native:linux": "cargo build --release --lib --target x86_64-unknown-linux-gnu",
@@ -59,7 +42,7 @@
     "clean:targets": "node scripts/clean-artifacts.js",
     "release:prepare": "npm run build && npm run build:native:targets && node scripts/prepare-release.cjs",
     "release:github": "npm run release:prepare && node scripts/create-gh-release.cjs",
-    "package:prepare": "npm run build && npm run build:native:targets && node scripts/pack-npm.cjs",
+    "package:prepare": "npm run build && npm run bundle && npm run build:native:targets && node scripts/pack-npm.cjs",
     "publish:npm": "npm run package:prepare && echo 'Run npm publish --access public'",
     "release:flow": "node scripts/release-flow.cjs",
     "release:flow:auto": "AUTO_PUBLISH=1 node scripts/release-flow.cjs",
@@ -103,12 +86,12 @@
   "devDependencies": {
     "@types/node": "^22.0.0",
     "pkg": "^5.8.1",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "esbuild": "^0.18.0",
+    "pngjs": "^7.0.0"
   },
   "engines": {
     "node": ">=18.0.0"
   },
-  "dependencies": {
-    "pngjs": "^7.0.0"
-  }
-}
+  "dependencies": {}
+}

package/scripts/postinstall.cjs

@@ -1,5 +1,5 @@
 const { execSync } = require('child_process');
-const { existsSync, copyFileSync, mkdirSync } = require('fs');
+const { existsSync, copyFileSync, mkdirSync, readdirSync, unlinkSync } = require('fs');
 const { join } = require('path');
 const { platform, arch } = require('os');
 
@@ -157,5 +157,26 @@ function ensureNativeLib() {
       }
 }
 
-ensureCliBinary();
+if (process.env.ROXIFY_ENABLE_RUST_CLI === '1') {
+      ensureCliBinary();
+}
 ensureNativeLib();
+
+// Cleanup: remove other platform .node artifacts to reduce disk usage after install
+try {
+      const triples = getTriples();
+      if (triples && triples.length) {
+            const files = readdirSync(root);
+            for (const f of files) {
+                  // match roxify_native-<triple>.node or libroxify_native-<triple>.node
+                  const m = f.match(/^(lib)?roxify_native-(.+)\.node$/);
+                  if (m) {
+                        const fileTriple = m[2];
+                        // keep if fileTriple is one of the allowed triples
+                        if (!triples.includes(fileTriple)) {
+                              try { unlinkSync(join(root, f)); console.log(`roxify: removed ${f}`); } catch (e) { }
+                        }
+                  }
+            }
+      }
+} catch (e) { }

package/Cargo.toml

@@ -1,91 +0,0 @@
-[package]
-name = "roxify_native"
-version = "1.13.8"
-edition = "2021"
-publish = false
-
-[lib]
-name = "roxify_native"
-crate-type = ["cdylib"]
-path = "native/lib.rs"
-
-[[bin]]
-name = "roxify_native"
-path = "native/main.rs"
-
-[[bin]]
-name = "bench_hybrid"
-path = "native/bench_hybrid.rs"
-
-[[bin]]
-name = "test_stages"
-path = "native/test_stages.rs"
-
-[[bin]]
-name = "test_small_bwt"
-path = "native/test_small_bwt.rs"
-
-[dev-dependencies]
-
-[dependencies]
-napi = "2"
-napi-derive = "2"
-rayon = "1.7"
-zstd = { version = "0.11", features = ["zstdmt"] }
-crc32fast = "1.3"
-num_cpus = "1.16"
-clap = { version = "4", features = ["derive"] }
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-anyhow = "1.0"
-png = "0.18.0"
-image = { version = "0.25", default-features = false, features = ["png"] }
-# indicatif removed from default deps to reduce heavy build graph
-walkdir = "2.5.0"
-tar = "0.4"
-aes-gcm = "0.10"
-aes = "0.8"
-ctr = "0.9"
-cipher = { version = "0.4", features = ["std"] }
-hmac = "0.12"
-pbkdf2 = "0.12"
-rand = "0.8"
-sha2 = "0.10"
-mimalloc = "0.1"
-simd-adler32 = "0.3"
-
-memmap2 = "0.9"
-bytemuck = { version = "1.14", features = ["derive"] }
-tokio = { version = "1", features = ["sync", "rt"], optional = true }
-parking_lot = "0.12"
-libsais = { version = "0.2.0", default-features = false }
-libc = "0.2"
-
-[features]
-default = []
-async = ["tokio"]
-
-[profile.release]
-opt-level = 3
-lto = "fat"
-codegen-units = 1
-strip = true
-panic = "abort"
-
-[profile.release-size]
-inherits = "release"
-opt-level = "z"
-lto = true
-strip = true
-
-[profile.fastdev]
-# Fast development profile for minimal user CPU and fast compilation.
-# Lower optimization and high codegen units to parallelize compilation work,
-# enable incremental to speed up subsequent incremental builds.
-inherits = "release"
-opt-level = 1
-lto = false
-codegen-units = 16
-debug = false
-incremental = true
-panic = "abort"