roxify 1.6.5 → 1.6.7

package/dist/utils/encoder.js

@@ -1,10 +1,13 @@
 import { createCipheriv, pbkdf2Sync, randomBytes } from 'crypto';
 import * as zlib from 'zlib';
 import { unpackBuffer } from '../pack.js';
+import { bytesToWav } from './audio.js';
 import { COMPRESSION_MARKERS, ENC_AES, ENC_NONE, ENC_XOR, MAGIC, MARKER_END, MARKER_START, PIXEL_MAGIC, PIXEL_MAGIC_BLOCK, PNG_HEADER, } from './constants.js';
 import { crc32 } from './crc.js';
 import { colorsToBytes } from './helpers.js';
 import { native } from './native.js';
+import { encodeRobustAudio } from './robust-audio.js';
+import { encodeRobustImage } from './robust-image.js';
 import { parallelZstdCompress } from './zstd.js';
 /**
  * Encode a buffer or array of buffers into a PNG image (ROX format).
@@ -56,6 +59,105 @@ export async function encodeBinaryToPng(input, opts = {}) {
             };
         }
     }
+    const compressionLevel = opts.compressionLevel ?? 19;
+    // ─── Lossy-resilient encoding fast path ────────────────────────────────────
+    // When lossyResilient is true, use QR-code-style block encoding with
+    // Reed-Solomon FEC. This produces output that survives lossy compression.
+    if (opts.lossyResilient) {
+        const inputBuf = Array.isArray(input) ? Buffer.concat(input) : input;
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'compress_start', total: inputBuf.length });
+        if (opts.container === 'sound') {
+            // Robust audio encoding (multi-tone FSK + RS ECC)
+            const result = encodeRobustAudio(inputBuf, {
+                eccLevel: opts.eccLevel ?? 'medium',
+            });
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            progressBar?.stop();
+            return result;
+        }
+        else {
+            // Robust image encoding (QR-code-like blocks + RS ECC)
+            const result = encodeRobustImage(inputBuf, {
+                blockSize: opts.robustBlockSize ?? 4,
+                eccLevel: opts.eccLevel ?? 'medium',
+            });
+            if (opts.onProgress)
+                opts.onProgress({ phase: 'done' });
+            progressBar?.stop();
+            return result;
+        }
+    }
+    // --- Native encoder fast path: let Rust handle compression/encryption/PNG ---
+    // This must be checked BEFORE TS compression to avoid double-compression.
+    if (typeof native.nativeEncodePngWithNameAndFilelist === 'function' &&
+        opts.includeFileList &&
+        opts.fileList) {
+        const fileName = opts.name || undefined;
+        const inputBuf = Array.isArray(input) ? Buffer.concat(input) : input;
+        let sizeMap = null;
+        try {
+            const unpack = unpackBuffer(inputBuf);
+            if (unpack) {
+                sizeMap = {};
+                for (const ef of unpack.files)
+                    sizeMap[ef.path] = ef.buf.length;
+            }
+        }
+        catch (e) { }
+        const normalized = opts.fileList.map((f) => {
+            if (typeof f === 'string')
+                return { name: f, size: sizeMap && sizeMap[f] ? sizeMap[f] : 0 };
+            if (f && typeof f === 'object') {
+                if (f.name)
+                    return { name: f.name, size: f.size ?? 0 };
+                if (f.path)
+                    return { name: f.path, size: f.size ?? 0 };
+            }
+            return { name: String(f), size: 0 };
+        });
+        const fileListJson = JSON.stringify(normalized);
+        if (opts.onProgress)
+            opts.onProgress({ phase: 'compress_start', total: inputBuf.length });
+        // ── WAV container (--sound) via native Rust encoder ──
+        if (opts.container === 'sound') {
+            if (typeof native.nativeEncodeWavWithEncryptionNameAndFilelist === 'function' &&
+                opts.passphrase && opts.encrypt && opts.encrypt !== 'auto') {
+                const result = native.nativeEncodeWavWithEncryptionNameAndFilelist(inputBuf, compressionLevel, opts.passphrase, opts.encrypt, fileName, fileListJson);
+                if (opts.onProgress)
+                    opts.onProgress({ phase: 'done' });
+                progressBar?.stop();
+                return Buffer.from(result);
+            }
+            else if (typeof native.nativeEncodeWavWithNameAndFilelist === 'function') {
+                const result = native.nativeEncodeWavWithNameAndFilelist(inputBuf, compressionLevel, fileName, fileListJson);
+                if (opts.onProgress)
+                    opts.onProgress({ phase: 'done' });
+                progressBar?.stop();
+                return Buffer.from(result);
+            }
+            // fallthrough to TS WAV path below if native WAV not available
+        }
+        // ── PNG container (default) via native Rust encoder ──
+        if (opts.container !== 'sound') {
+            if (opts.passphrase && opts.encrypt && opts.encrypt !== 'auto') {
+                const result = native.nativeEncodePngWithEncryptionNameAndFilelist(inputBuf, compressionLevel, opts.passphrase, opts.encrypt, fileName, fileListJson);
+                if (opts.onProgress)
+                    opts.onProgress({ phase: 'done' });
+                progressBar?.stop();
+                return Buffer.from(result);
+            }
+            else {
+                const result = native.nativeEncodePngWithNameAndFilelist(inputBuf, compressionLevel, fileName, fileListJson);
+                if (opts.onProgress)
+                    opts.onProgress({ phase: 'done' });
+                progressBar?.stop();
+                return Buffer.from(result);
+            }
+        }
+    }
+    // --- TypeScript compression/encryption pipeline ---
     let payloadInput;
     let totalLen = 0;
     if (Array.isArray(input)) {
@@ -68,7 +170,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
     }
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_start', total: totalLen });
-    const compressionLevel = opts.compressionLevel ?? 19;
     let payload = await parallelZstdCompress(payloadInput, compressionLevel, (loaded, total) => {
         if (opts.onProgress) {
             opts.onProgress({
@@ -77,7 +178,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
                 total,
             });
         }
-    });
+    }, opts.dict);
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_done', loaded: payload.length });
     if (Array.isArray(input)) {
@@ -148,48 +249,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
     const payloadTotalLen = payload.reduce((a, b) => a + b.length, 0);
     if (opts.onProgress)
         opts.onProgress({ phase: 'meta_prep_done', loaded: payloadTotalLen });
-    if (typeof native.nativeEncodePngWithNameAndFilelist === 'function' &&
-        opts.includeFileList &&
-        opts.fileList) {
-        const fileName = opts.name || undefined;
-        let sizeMap = null;
-        if (!Array.isArray(input)) {
-            try {
-                const unpack = unpackBuffer(input);
-                if (unpack) {
-                    sizeMap = {};
-                    for (const ef of unpack.files)
-                        sizeMap[ef.path] = ef.buf.length;
-                }
-            }
-            catch (e) { }
-        }
-        const normalized = opts.fileList.map((f) => {
-            if (typeof f === 'string')
-                return { name: f, size: sizeMap && sizeMap[f] ? sizeMap[f] : 0 };
-            if (f && typeof f === 'object') {
-                if (f.name)
-                    return { name: f.name, size: f.size ?? 0 };
-                if (f.path)
-                    return { name: f.path, size: f.size ?? 0 };
-            }
-            return { name: String(f), size: 0 };
-        });
-        const fileListJson = JSON.stringify(normalized);
-        const flatPayload = Buffer.concat(payload);
-        if (opts.passphrase && opts.encrypt && opts.encrypt !== 'auto') {
-            const result = native.nativeEncodePngWithEncryptionNameAndFilelist(flatPayload, compressionLevel, opts.passphrase, opts.encrypt, fileName, fileListJson);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            return Buffer.from(result);
-        }
-        else {
-            const result = native.nativeEncodePngWithNameAndFilelist(flatPayload, compressionLevel, fileName, fileListJson);
-            if (opts.onProgress)
-                opts.onProgress({ phase: 'done' });
-            return Buffer.from(result);
-        }
-    }
     const metaParts = [];
     const includeName = opts.includeName === undefined ? true : !!opts.includeName;
     if (includeName && opts.name) {
@@ -233,10 +292,57 @@ export async function encodeBinaryToPng(input, opts = {}) {
     if (opts.output === 'rox') {
         return Buffer.concat([MAGIC, ...meta]);
     }
+    // ─── WAV container (TS fallback path) ──────────────────────────────────────
+    if (opts.container === 'sound') {
+        const nameBuf = opts.name ? Buffer.from(opts.name, 'utf8') : Buffer.alloc(0);
+        const nameLen = nameBuf.length;
+        const payloadLenBuf = Buffer.alloc(4);
+        payloadLenBuf.writeUInt32BE(payloadTotalLen, 0);
+        const version = 1;
+        let wavPayload = [
+            PIXEL_MAGIC,
+            Buffer.from([version]),
+            Buffer.from([nameLen]),
+            nameBuf,
+            payloadLenBuf,
+            ...payload,
+        ];
+        if (opts.includeFileList && opts.fileList) {
+            let sizeMapW = null;
+            if (!Array.isArray(input)) {
+                try {
+                    const unpack = unpackBuffer(input);
+                    if (unpack) {
+                        sizeMapW = {};
+                        for (const ef of unpack.files)
+                            sizeMapW[ef.path] = ef.buf.length;
+                    }
+                }
+                catch (e) { }
+            }
+            const normalizedW = opts.fileList.map((f) => {
+                if (typeof f === 'string')
+                    return { name: f, size: sizeMapW && sizeMapW[f] ? sizeMapW[f] : 0 };
+                if (f && typeof f === 'object') {
+                    if (f.name)
+                        return { name: f.name, size: f.size ?? 0 };
+                    if (f.path)
+                        return { name: f.path, size: f.size ?? 0 };
+                }
+                return { name: String(f), size: 0 };
+            });
+            const jsonBufW = Buffer.from(JSON.stringify(normalizedW), 'utf8');
+            const lenBufW = Buffer.alloc(4);
+            lenBufW.writeUInt32BE(jsonBufW.length, 0);
+            wavPayload = [...wavPayload, Buffer.from('rXFL', 'utf8'), lenBufW, jsonBufW];
+        }
+        const wavData = bytesToWav(Buffer.concat(wavPayload));
+        payload.length = 0;
+        progressBar?.stop();
+        return wavData;
+    }
     {
-        const nameBuf = opts.name
-            ? Buffer.from(opts.name, 'utf8')
-            : Buffer.alloc(0);
+        const nameBuf = opts.name ? Buffer.from(opts.name, 'utf8') : Buffer.alloc(0);
         const nameLen = nameBuf.length;
         const payloadLenBuf = Buffer.alloc(4);
         payloadLenBuf.writeUInt32BE(payloadTotalLen, 0);
@@ -282,8 +388,8 @@ export async function encodeBinaryToPng(input, opts = {}) {
         const dataWithoutMarkers = [pixelMagic, ...metaPixel];
         const dataWithoutMarkersLen = dataWithoutMarkers.reduce((a, b) => a + b.length, 0);
         const padding = (3 - (dataWithoutMarkersLen % 3)) % 3;
-        const paddedData = padding > 0
-            ? [...dataWithoutMarkers, Buffer.alloc(padding)]
+        const paddedData = padding > 0 ?
+            [...dataWithoutMarkers, Buffer.alloc(padding)]
             : dataWithoutMarkers;
         const markerStartBytes = colorsToBytes(MARKER_START);
         const compressionMarkerBytes = colorsToBytes(COMPRESSION_MARKERS.zstd);

package/dist/utils/native.js

@@ -1,8 +1,7 @@
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
 import { arch, platform } from 'os';
-import { dirname, resolve } from 'path';
-import { fileURLToPath } from 'url';
+import { join, resolve } from 'path';
 function getNativeModule() {
     let moduleDir;
     let nativeRequire;
@@ -11,18 +10,18 @@ function getNativeModule() {
         nativeRequire = require;
     }
     else {
-        // ESM: derive module directory from this file's URL and create a require based on it
-        moduleDir = dirname(fileURLToPath(import.meta.url));
+        moduleDir = process.cwd();
         try {
             nativeRequire = require;
         }
         catch {
-            nativeRequire = createRequire(import.meta.url);
+            nativeRequire = createRequire(process.cwd() + '/package.json');
         }
     }
     function getNativePath() {
         const platformMap = {
             linux: 'x86_64-unknown-linux-gnu',
+            darwin: arch() === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin',
             win32: 'x86_64-pc-windows-gnu',
         };
         const platformAltMap = {
@@ -30,6 +29,7 @@ function getNativeModule() {
         };
         const extMap = {
             linux: 'so',
+            darwin: 'dylib',
             win32: 'node',
         };
         const currentPlatform = platform();
@@ -39,18 +39,12 @@ function getNativeModule() {
         if (!target || !ext) {
             throw new Error(`Unsupported platform: ${currentPlatform}`);
         }
-        const targets = targetAlt ? [target, targetAlt] : [target];
-        const candidates = [];
-        const pushIf = (...paths) => {
-            for (const p of paths)
-                candidates.push(p);
-        };
-        // Try multiple locations relative to the compiled JS file (dist),
-        // package root and common 'dist' directories used by packaging tools.
-        for (const t of targets) {
-            pushIf(resolve(moduleDir, `../roxify_native-${t}.node`), resolve(moduleDir, `../libroxify_native-${t}.node`), resolve(moduleDir, `../../roxify_native-${t}.node`), resolve(moduleDir, `../../libroxify_native-${t}.node`), resolve(moduleDir, `../dist/roxify_native-${t}.node`), resolve(moduleDir, `../../dist/roxify_native-${t}.node`));
-        }
-        pushIf(resolve(moduleDir, '../roxify_native.node'), resolve(moduleDir, '../libroxify_native.node'), resolve(moduleDir, '../../roxify_native.node'), resolve(moduleDir, '../../libroxify_native.node'), resolve(moduleDir, '../dist/roxify_native.node'), resolve(moduleDir, '../../dist/roxify_native.node'));
+        const prebuiltPath = join(moduleDir, '../../roxify_native.node');
+        const prebuiltLibPath = join(moduleDir, '../../libroxify_native.node');
+        const bundlePath = join(moduleDir, '../roxify_native.node');
+        const bundleLibPath = join(moduleDir, '../libroxify_native.node');
+        const bundlePathWithTarget = join(moduleDir, `../roxify_native-${target}.node`);
+        const bundleLibPathWithTarget = join(moduleDir, `../libroxify_native-${target}.node`);
         let root = moduleDir && moduleDir !== '.' ? moduleDir : process.cwd();
         while (root.length > 1 &&
             !existsSync(resolve(root, 'package.json')) &&
@@ -60,13 +54,38 @@ function getNativeModule() {
                 break;
             root = parent;
         }
+        const bundleNode = resolve(moduleDir, '../roxify_native.node');
+        const bundleLibNode = resolve(moduleDir, '../libroxify_native.node');
+        const bundleNodeWithTarget = resolve(moduleDir, `../roxify_native-${target}.node`);
+        const bundleLibNodeWithTarget = resolve(moduleDir, `../libroxify_native-${target}.node`);
+        const repoNode = resolve(root, 'roxify_native.node');
+        const repoLibNode = resolve(root, 'libroxify_native.node');
+        const repoNodeWithTarget = resolve(root, `roxify_native-${target}.node`);
+        const repoLibNodeWithTarget = resolve(root, `libroxify_native-${target}.node`);
+        const targetNode = resolve(root, 'target/release/roxify_native.node');
+        const targetSo = resolve(root, 'target/release/roxify_native.so');
+        const targetLibSo = resolve(root, 'target/release/libroxify_native.so');
+        const nodeModulesNode = resolve(root, 'node_modules/roxify/roxify_native.node');
+        const nodeModulesNodeWithTarget = resolve(root, `node_modules/roxify/roxify_native-${target}.node`);
+        const prebuiltNode = resolve(moduleDir, '../../roxify_native.node');
+        const prebuiltLibNode = resolve(moduleDir, '../../libroxify_native.node');
+        const prebuiltNodeWithTarget = resolve(moduleDir, `../../roxify_native-${target}.node`);
+        const prebuiltLibNodeWithTarget = resolve(moduleDir, `../../libroxify_native-${target}.node`);
+        // Support multiple possible OS triples (e.g. windows-gnu and windows-msvc)
+        const targets = targetAlt ? [target, targetAlt] : [target];
+        const candidates = [];
         for (const t of targets) {
-            pushIf(resolve(root, `roxify_native-${t}.node`), resolve(root, `libroxify_native-${t}.node`), resolve(root, `dist/roxify_native-${t}.node`));
+            const bundleNodeWithT = resolve(moduleDir, `../roxify_native-${t}.node`);
+            const bundleLibNodeWithT = resolve(moduleDir, `../libroxify_native-${t}.node`);
+            const repoNodeWithT = resolve(root, `roxify_native-${t}.node`);
+            const repoLibNodeWithT = resolve(root, `libroxify_native-${t}.node`);
+            const nodeModulesNodeWithT = resolve(root, `node_modules/roxify/roxify_native-${t}.node`);
+            const prebuiltNodeWithT = resolve(moduleDir, `../../roxify_native-${t}.node`);
+            const prebuiltLibNodeWithT = resolve(moduleDir, `../../libroxify_native-${t}.node`);
+            candidates.push(bundleLibNodeWithT, bundleNodeWithT, repoLibNodeWithT, repoNodeWithT, nodeModulesNodeWithT, prebuiltLibNodeWithT, prebuiltNodeWithT);
         }
-        pushIf(resolve(root, 'roxify_native.node'), resolve(root, 'libroxify_native.node'), resolve(root, 'dist/roxify_native.node'), resolve(root, 'target/release/roxify_native.node'), resolve(root, 'target/release/libroxify_native.so'), resolve(root, 'target/release/roxify_native.so'), resolve(root, 'node_modules/roxify/roxify_native.node'));
-        // Remove duplicates while preserving order
-        const uniqueCandidates = [...new Set(candidates)];
-        for (const c of uniqueCandidates) {
+        candidates.push(bundleLibNode, bundleNode, repoLibNode, repoNode, targetNode, targetLibSo, targetSo, nodeModulesNode, prebuiltLibNode, prebuiltNode);
+        for (const c of candidates) {
             try {
                 if (!existsSync(c))
                     continue;
@@ -84,11 +103,9 @@ function getNativeModule() {
                 }
                 return c;
             }
-            catch (e) {
-                // ignore errors while checking candidates
-            }
+            catch { }
         }
-        throw new Error(`Native module not found for ${currentPlatform}-${arch()}. Checked: ${uniqueCandidates.join(' ')}`);
+        throw new Error(`Native module not found for ${currentPlatform}-${arch()}. Checked: ${candidates.join(' ')}`);
     }
     return nativeRequire(getNativePath());
 }

package/dist/utils/robust-audio.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Lossy-Resilient Audio Encoding (WAV container).
+ *
+ * Encodes binary data as multi-frequency tones (OFDM-like) that survive
+ * lossy audio compression (MP3, AAC, OGG Vorbis). The output sounds like
+ * a series of harmonious chords — not white noise.
+ *
+ * Architecture:
+ *   1. Data is protected with Reed-Solomon ECC (configurable level).
+ *   2. Each byte is transmitted as 8 simultaneous frequency channels
+ *      (one bit per channel: tone present = 1, absent = 0).
+ *   3. Raised-cosine windowing prevents spectral splatter.
+ *   4. A chirp sync preamble enables frame alignment after lossy re-encoding.
+ *
+ * Frequency plan:
+ *   8 carriers at 600, 900, 1200, 1500, 1800, 2100, 2400, 2700 Hz.
+ *   All within the 300–3400 Hz band preserved by most lossy codecs.
+ *
+ * Throughput: ~17 bytes/sec raw (with default symbol timing).
+ */
+import { EccLevel } from './ecc.js';
+export interface RobustAudioEncodeOptions {
+    /** Error correction level. Default: 'medium'. */
+    eccLevel?: EccLevel;
+}
+export interface RobustAudioDecodeResult {
+    data: Buffer;
+    correctedErrors: number;
+}
+/**
+ * Encode binary data into a lossy-resilient WAV file.
+ *
+ * The output uses multi-frequency tones (not white noise) and includes
+ * Reed-Solomon error correction for recovery after MP3/AAC/OGG compression.
+ *
+ * @param data - Raw data to encode.
+ * @param opts - Encoding options.
+ * @returns WAV file as a Buffer.
+ */
+export declare function encodeRobustAudio(data: Buffer, opts?: RobustAudioEncodeOptions): Buffer;
+/**
+ * Decode binary data from a lossy-resilient WAV file.
+ *
+ * Handles WAV files that have been re-encoded through lossy codecs.
+ *
+ * @param wav - WAV file buffer (16-bit PCM preferred, 8-bit also accepted).
+ * @returns Decoded data and error correction stats.
+ */
+export declare function decodeRobustAudio(wav: Buffer): RobustAudioDecodeResult;
+/**
+ * Check if a buffer looks like a robust-audio-encoded WAV.
+ * Detects the sync preamble signature.
+ */
+export declare function isRobustAudioWav(buf: Buffer): boolean;