roxify 1.1.7 → 1.1.9

package/README.md

@@ -28,8 +28,8 @@ npm install roxify
 
 ```bash
 npx rox encode <inputName>.ext (<outputName>.png)
-
 npx rox decode <inputName>.png (<outputName>.ext)
+npx rox list <inputName>.png
 ```
 
 If no output name is provided:
@@ -37,154 +37,63 @@ If no output name is provided:
 - Encoding: output defaults to `<inputName>.png`.
 - Decoding: if the image contains the original filename it will be restored; otherwise the output will be `decoded.bin`.
 
-**Commands:**
-
-- `encode <input>... [output]` — Encode file(s)/directory to PNG
-- `decode <input> [output]` — Decode PNG to file(s)
-- `list <input>` — List files in archive without decoding
-
 **Options:**
 
 - `-p, --passphrase <pass>` — Encrypt with AES-256-GCM
-- `-m, --mode <mode>` — Encoding mode: `screenshot` (default), `pixel`, `compact`, `chunk`
-- `-q, --quality <0-22>` — Roxify compression level (default: 22)
-- `--no-compress` — Disable compression
-- `--files <list>` — Extract only specified files (comma-separated, for archives)
 - `-v, --verbose` — Show detailed errors
 
 Run `npx rox help` for full options.
 
 ## API Usage
 
+### Basic Encoding and Decoding
+
 ```js
-import { encodeBinaryToPng, decodePngToBinary, listFilesInPng } from 'roxify';
+import { readFileSync, writeFileSync } from 'fs';
+import { encodeBinaryToPng } from 'roxify';
 
-// Encode a file
-const data = Buffer.from('Hello world');
-const png = await encodeBinaryToPng(data, {
-  mode: 'screenshot',
-  name: 'message.txt',
+const fileName = 'input.bin';
+const inputBuffer = readFileSync(fileName);
+const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+  name: fileName,
 });
-
-// Decode
-const { buf, meta } = await decodePngToBinary(png);
-console.log(buf.toString('utf8'));
-console.log(meta?.name);
-
-// List files in archive
-const files = listFilesInPng(png);
-console.log(files);
-
-// Selective extraction
-const result = await decodePngToBinary(png, { files: ['file1.txt'] });
-if (result.files) {
-  // result.files contains only the selected files
-}
+writeFileSync('output.png', pngBuffer);
 ```
 
-## Example: Progress Logging
-
-````js
-import { encodeBinaryToPng, decodePngToBinary } from 'roxify';
-
-const data = Buffer.from('Large data to encode...');
-
-// Encode with progress logging
-const png = await encodeBinaryToPng(data, {
-  onProgress: (info) => {
-    console.log(`Encoding phase: ${info.phase}`);
-    if (info.loaded && info.total) {
-      const percent = Math.round((info.loaded / info.total) * 100);
-      console.log(`Progress: ${percent}% (${info.loaded}/${info.total} bytes)`);
-    }
-  },
-});
-
-
-Node.js (detailed chunk progress example)
-
 ```js
-import { encodeBinaryToPng } from 'roxify';
 import { readFileSync, writeFileSync } from 'fs';
+import { decodePngToBinary } from 'roxify';
 
-const buf = readFileSync('test-data/testVideo.mp4');
-const png = await encodeBinaryToPng(buf, {
-  showProgress: false,
-  onProgress(info) {
-    if (info.phase === 'compress_progress' && info.loaded && info.total) {
-      const percent = Math.round((info.loaded / info.total) * 100);
-      console.log(`[progress] ${info.phase} ${percent}% (${info.loaded}/${info.total} chunks)`);
-    } else {
-      console.log(`[progress] ${info.phase} ${info.loaded || ''}/${info.total || ''}`);
-    }
-  },
-});
+const pngFromDisk = readFileSync('output.png');
+const { buf, meta } = await decodePngToBinary(pngFromDisk);
+writeFileSync(meta?.name ?? 'decoded.txt', buf);
+```
 
-writeFileSync('out.png', png);
-````
+### With Passphrase
 
-// Decode with progress logging
-const { buf } = await decodePngToBinary(png, {
-onProgress: (info) => {
-console.log(`Decoding phase: ${info.phase}`);
-},
+```js
+const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+  name: fileName,
+  passphrase: 'mysecret',
 });
-
-````
-
-**API:**
-
-- `encodeBinaryToPng(input: Buffer, opts?: EncodeOptions): Promise<Buffer>`
-- `decodePngToBinary(pngBuf: Buffer, opts?: DecodeOptions): Promise<DecodeResult>`
-- `listFilesInPng(pngBuf: Buffer): string[] | null`
-
-**EncodeOptions:**
-
-- `mode` — `'screenshot'` | `'pixel'` | `'compact'` | `'chunk'` (default: `'screenshot'`)
-- `name` — Original filename (embedded as metadata)
-- `passphrase` — Encryption passphrase (uses AES-256-GCM)
-- `compression` — `'Roxify'` | `'none'` (default: `'Roxify'`)
-- `brQuality` — Roxify compression level 0-22 (default: 22)
-- `showProgress` — Display progress bar (default: `false`)
-- `onProgress` — Callback for progress updates: `(info: { phase: string; loaded?: number; total?: number }) => void`
-- `includeFileList` — Include file list for archives (default: `true` for directories)
-
-**DecodeOptions:**
-
-- `passphrase` — Decryption passphrase
-- `files` — List of files to extract selectively (for archives)
-- `showProgress` — Display progress bar (default: `false`)
-- `onProgress` — Callback for progress updates: `(info: { phase: string; loaded?: number; total?: number }) => void`
-
-**DecodeResult:**
-
-- `buf?: Buffer` — Decoded data (if not selective extraction)
-- `files?: PackedFile[]` — Extracted files (if selective extraction)
-- `meta?: { name?: string }` — Metadata
-
-## Example: Archive with Selective Extraction
+```
 
 ```js
-import { encodeBinaryToPng, decodePngToBinary, listFilesInPng } from 'roxify';
-
-// Pack a directory
-const fs = require('fs');
-const dirData = packPaths(['myfolder']); // From pack.js
-const png = await encodeBinaryToPng(dirData.buf, {
-  includeFileList: true,
-  fileList: dirData.list,
+const { buf, meta } = await decodePngToBinary(pngFromDisk, {
+  passphrase: 'mysecret',
 });
+```
 
-// List files without decoding
-const files = listFilesInPng(png);
-console.log('Files:', files);
+### With Progress Logging
 
-// Extract only one file
-const result = await decodePngToBinary(png, { files: ['myfolder/file.txt'] });
-if (result.files) {
-  fs.writeFileSync('extracted.txt', result.files[0].buf);
-}
-````
+```js
+const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+  name: fileName,
+  onProgress: (info) => {
+    console.log(`Phase: ${info.phase}, Loaded: ${info.loaded}/${info.total}`);
+  },
+});
+```
 
 ## Requirements
 

package/dist/cli.js

@@ -4,7 +4,7 @@ import { mkdirSync, readFileSync, statSync, writeFileSync } from 'fs';
 import { basename, dirname, join, resolve } from 'path';
 import { DataFormatError, decodePngToBinary, encodeBinaryToPng, IncorrectPassphraseError, listFilesInPng, PassphraseRequiredError, } from './index.js';
 import { packPaths, unpackBuffer } from './pack.js';
-const VERSION = '1.1.7';
+const VERSION = '1.1.9';
 function showHelp() {
     console.log(`
 ROX CLI — Encode/decode binary in PNG
@@ -190,9 +190,7 @@ async function encodeCommand(args) {
                 options.fileList = packResult.list;
             }
             else {
-                const startRead = Date.now();
                 inputBuffer = readFileSync(resolvedInput);
-                const readTime = Date.now() - startRead;
                 console.log('');
                 displayName = basename(resolvedInput);
             }
@@ -213,7 +211,6 @@ async function encodeCommand(args) {
         const encodeBar = new cliProgress.SingleBar({
             format: ' {bar} {percentage}% | {step} | {elapsed}s',
         }, cliProgress.Presets.shades_classic);
-        let totalMB = Math.max(1, Math.round(inputBuffer.length / 1024 / 1024));
         encodeBar.start(100, 0, {
             step: 'Starting',
             elapsed: '0',
@@ -461,7 +458,7 @@ async function listCommand(args) {
     const resolvedInput = resolve(inputPath);
     try {
         const inputBuffer = readFileSync(resolvedInput);
-        const fileList = listFilesInPng(inputBuffer);
+        const fileList = await listFilesInPng(inputBuffer);
         if (fileList) {
             console.log(`Files in ${resolvedInput}:`);
             for (const file of fileList) {

package/dist/index.d.ts

@@ -157,6 +157,19 @@ export declare function cropAndReconstitute(input: Buffer, debugDir?: string): P
  * @param input - Data to encode
  * @param opts - Encoding options
  * @public
+ * @example
+ * ```typescript
+* import { readFileSync, writeFileSync } from 'fs';
+* import { encodeBinaryToPng } from 'roxify';
+*
+* const fileName = 'input.bin'; //Path of your input file here
+* const inputBuffer = readFileSync(fileName);
+* const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+*   name: fileName,
+* });
+* writeFileSync('output.png', pngBuffer);
+
+ * ```
  */
 export declare function encodeBinaryToPng(input: Buffer, opts?: EncodeOptions): Promise<Buffer>;
 /**
@@ -166,6 +179,13 @@ export declare function encodeBinaryToPng(input: Buffer, opts?: EncodeOptions):
  * @param pngBuf - PNG data
  * @param opts - Options (passphrase for encrypted inputs)
  * @public
+ * @example
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { decodePngToBinary } from 'roxify';
+ *
+ * const pngFromDisk = readFileSync('output.png'); //Path of the encoded PNG here
+ * const { buf, meta } = await decodePngToBinary(pngFromDisk);
+ * writeFileSync(meta?.name ?? 'decoded.txt', buf);
  */
 export declare function decodePngToBinary(pngBuf: Buffer, opts?: DecodeOptions): Promise<DecodeResult>;
 export { packPaths, unpackBuffer } from './pack.js';
@@ -175,4 +195,4 @@ export { packPaths, unpackBuffer } from './pack.js';
  * @param pngBuf - PNG data
  * @public
  */
-export declare function listFilesInPng(pngBuf: Buffer): string[] | null;
+export declare function listFilesInPng(pngBuf: Buffer): Promise<string[] | null>;

package/dist/index.js

@@ -90,7 +90,6 @@ async function parallelZstdCompress(payload, level = 22, onProgress) {
     if (payload.length <= chunkSize) {
         return Buffer.from(await zstdCompress(payload, level));
     }
-    const chunks = [];
     const promises = [];
     const totalChunks = Math.ceil(payload.length / chunkSize);
     let completedChunks = 0;
@@ -131,6 +130,8 @@ async function parallelZstdDecompress(payload, onProgress, onChunk, outPath) {
     }
     const magic = payload.readUInt32BE(0);
     if (magic !== 0x5a535444) {
+        if (process.env.ROX_DEBUG)
+            console.log('tryZstdDecompress: invalid magic');
         onProgress?.({ phase: 'decompress_start', total: 1 });
         const d = Buffer.from(await zstdDecompress(payload));
         onProgress?.({ phase: 'decompress_progress', loaded: 1, total: 1 });
@@ -211,9 +212,6 @@ function applyXor(buf, passphrase) {
     }
     return out;
 }
-function tryBrotliDecompress(payload) {
-    return Buffer.from(zlib.brotliDecompressSync(payload));
-}
 async function tryZstdDecompress(payload, onProgress, onChunk, outPath) {
     return await parallelZstdDecompress(payload, onProgress, onChunk, outPath);
 }
@@ -253,19 +251,6 @@ function tryDecryptIfNeeded(buf, passphrase) {
     }
     return buf;
 }
-function idxFor(x, y, width) {
-    return (y * width + x) * 4;
-}
-function eqRGB(a, b) {
-    return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
-}
-async function loadRaw(imgInput) {
-    const { data, info } = await sharp(imgInput)
-        .ensureAlpha()
-        .raw()
-        .toBuffer({ resolveWithObject: true });
-    return { data, info };
-}
 export async function cropAndReconstitute(input, debugDir) {
     async function loadRaw(imgInput) {
         const { data, info } = await sharp(imgInput)
@@ -280,7 +265,7 @@ export async function cropAndReconstitute(input, debugDir) {
     function eqRGB(a, b) {
         return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];
     }
-    const { data, info } = await loadRaw(input);
+    const { info } = await loadRaw(input);
     const doubledBuffer = await sharp(input)
         .resize({
         width: info.width * 2,
@@ -537,6 +522,19 @@ export async function cropAndReconstitute(input, debugDir) {
  * @param input - Data to encode
  * @param opts - Encoding options
  * @public
+ * @example
+ * ```typescript
+* import { readFileSync, writeFileSync } from 'fs';
+* import { encodeBinaryToPng } from 'roxify';
+*
+* const fileName = 'input.bin'; //Path of your input file here
+* const inputBuffer = readFileSync(fileName);
+* const pngBuffer = await encodeBinaryToPng(inputBuffer, {
+*   name: fileName,
+* });
+* writeFileSync('output.png', pngBuffer);
+
+ * ```
  */
 export async function encodeBinaryToPng(input, opts = {}) {
     let progressBar = null;
@@ -572,9 +570,7 @@ export async function encodeBinaryToPng(input, opts = {}) {
         }
     }
     let payload = Buffer.concat([MAGIC, input]);
-    const brQuality = typeof opts.brQuality === 'number' ? opts.brQuality : 11;
     const mode = opts.mode === undefined ? 'screenshot' : opts.mode;
-    const compression = opts.compression || 'zstd';
     if (opts.onProgress)
         opts.onProgress({ phase: 'compress_start', total: payload.length });
     const useDelta = mode !== 'screenshot';
@@ -622,8 +618,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
             payload = Buffer.concat([Buffer.from([ENC_AES]), salt, iv, tag, enc]);
             if (opts.onProgress)
                 opts.onProgress({ phase: 'encrypt_done' });
-        }
-        else if (encChoice === 'xor') {
             const xored = applyXor(payload, opts.passphrase);
             payload = Buffer.concat([Buffer.from([ENC_XOR]), xored]);
             if (opts.onProgress)
@@ -651,7 +645,13 @@ export async function encodeBinaryToPng(input, opts = {}) {
         metaParts.push(Buffer.from([0]));
     }
     metaParts.push(payload);
-    const meta = Buffer.concat(metaParts);
+    let meta = Buffer.concat(metaParts);
+    if (opts.includeFileList && opts.fileList) {
+        const jsonBuf = Buffer.from(JSON.stringify(opts.fileList), 'utf8');
+        const lenBuf = Buffer.alloc(4);
+        lenBuf.writeUInt32BE(jsonBuf.length, 0);
+        meta = Buffer.concat([meta, Buffer.from('rXFL', 'utf8'), lenBuf, jsonBuf]);
+    }
     if (opts.output === 'rox') {
         return Buffer.concat([MAGIC, meta]);
     }
@@ -663,13 +663,24 @@ export async function encodeBinaryToPng(input, opts = {}) {
         const payloadLenBuf = Buffer.alloc(4);
         payloadLenBuf.writeUInt32BE(payload.length, 0);
         const version = 1;
-        const metaPixel = Buffer.concat([
+        let metaPixel = Buffer.concat([
             Buffer.from([version]),
             Buffer.from([nameLen]),
             nameBuf,
             payloadLenBuf,
             payload,
         ]);
+        if (opts.includeFileList && opts.fileList) {
+            const jsonBuf = Buffer.from(JSON.stringify(opts.fileList), 'utf8');
+            const lenBuf = Buffer.alloc(4);
+            lenBuf.writeUInt32BE(jsonBuf.length, 0);
+            metaPixel = Buffer.concat([
+                metaPixel,
+                Buffer.from('rXFL', 'utf8'),
+                lenBuf,
+                jsonBuf,
+            ]);
+        }
         const dataWithoutMarkers = Buffer.concat([PIXEL_MAGIC, metaPixel]);
         const padding = (3 - (dataWithoutMarkers.length % 3)) % 3;
         const paddedData = padding > 0
@@ -750,15 +761,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
             adaptiveFiltering: true,
         })
             .toBuffer();
-        if (opts.includeFileList && opts.fileList) {
-            const chunks = extract(bufScr);
-            const fileListChunk = {
-                name: 'rXFL',
-                data: Buffer.from(JSON.stringify(opts.fileList), 'utf8'),
-            };
-            chunks.splice(-1, 0, fileListChunk);
-            bufScr = Buffer.from(encode(chunks));
-        }
         if (opts.onProgress)
             opts.onProgress({ phase: 'done', loaded: bufScr.length });
         progressBar?.stop();
@@ -772,13 +774,24 @@ export async function encodeBinaryToPng(input, opts = {}) {
         const payloadLenBuf = Buffer.alloc(4);
         payloadLenBuf.writeUInt32BE(payload.length, 0);
         const version = 1;
-        const metaPixel = Buffer.concat([
+        let metaPixel = Buffer.concat([
             Buffer.from([version]),
             Buffer.from([nameLen]),
             nameBuf,
             payloadLenBuf,
             payload,
         ]);
+        if (opts.includeFileList && opts.fileList) {
+            const jsonBuf = Buffer.from(JSON.stringify(opts.fileList), 'utf8');
+            const lenBuf = Buffer.alloc(4);
+            lenBuf.writeUInt32BE(jsonBuf.length, 0);
+            metaPixel = Buffer.concat([
+                metaPixel,
+                Buffer.from('rXFL', 'utf8'),
+                lenBuf,
+                jsonBuf,
+            ]);
+        }
         const full = Buffer.concat([PIXEL_MAGIC, metaPixel]);
         const bytesPerPixel = 3;
         const nPixels = Math.ceil((full.length + 8) / 3);
@@ -860,12 +873,6 @@ export async function encodeBinaryToPng(input, opts = {}) {
         chunks2.push({ name: 'IHDR', data: ihdrData });
         chunks2.push({ name: 'IDAT', data: idatData });
         chunks2.push({ name: CHUNK_TYPE, data: meta });
-        if (opts.includeFileList && opts.fileList) {
-            chunks2.push({
-                name: 'rXFL',
-                data: Buffer.from(JSON.stringify(opts.fileList), 'utf8'),
-            });
-        }
         chunks2.push({ name: 'IEND', data: Buffer.alloc(0) });
         if (opts.onProgress)
             opts.onProgress({ phase: 'png_gen' });
@@ -887,6 +894,13 @@ export async function encodeBinaryToPng(input, opts = {}) {
  * @param pngBuf - PNG data
  * @param opts - Options (passphrase for encrypted inputs)
  * @public
+ * @example
+ * import { readFileSync, writeFileSync } from 'fs';
+ * import { decodePngToBinary } from 'roxify';
+ *
+ * const pngFromDisk = readFileSync('output.png'); //Path of the encoded PNG here
+ * const { buf, meta } = await decodePngToBinary(pngFromDisk);
+ * writeFileSync(meta?.name ?? 'decoded.txt', buf);
  */
 export async function decodePngToBinary(pngBuf, opts = {}) {
     let progressBar = null;
@@ -926,9 +940,6 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
             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.`);
             }
-            const MAX_DOUBLE_BYTES = 200 * 1024 * 1024;
-            const doubledPixels = info.width * 2 * (info.height * 2);
-            const doubledBytesEstimate = doubledPixels * 4;
             if (false) {
                 const doubledBuffer = await sharp(pngBuf)
                     .resize({
@@ -1479,7 +1490,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
                         await tryZstdDecompress(payload, (info) => {
                             if (opts.onProgress)
                                 opts.onProgress(info);
-                        }, async (decChunk, idxChunk, totalChunks) => {
+                        }, async (decChunk) => {
                             let outChunk = decChunk;
                             if (version === 3) {
                                 const out = Buffer.alloc(decChunk.length);
@@ -1518,7 +1529,7 @@ export async function decodePngToBinary(pngBuf, opts = {}) {
                                 await writeInChunks(ws, outChunk, 64 * 1024);
                             }
                         });
-                        await new Promise((res, rej) => ws.end(() => res()));
+                        await new Promise((res) => ws.end(() => res()));
                         if (opts.onProgress)
                             opts.onProgress({ phase: 'done' });
                         progressBar?.stop();
@@ -1589,7 +1600,60 @@ export { packPaths, unpackBuffer } from './pack.js';
  * @param pngBuf - PNG data
  * @public
  */
-export function listFilesInPng(pngBuf) {
+export async function listFilesInPng(pngBuf) {
+    try {
+        try {
+            const { data, info } = await sharp(pngBuf)
+                .ensureAlpha()
+                .raw()
+                .toBuffer({ resolveWithObject: true });
+            const currentWidth = info.width;
+            const currentHeight = info.height;
+            const rawRGB = Buffer.alloc(currentWidth * currentHeight * 3);
+            for (let i = 0; i < currentWidth * currentHeight; i++) {
+                rawRGB[i * 3] = data[i * 4];
+                rawRGB[i * 3 + 1] = data[i * 4 + 1];
+                rawRGB[i * 3 + 2] = data[i * 4 + 2];
+            }
+            const found = rawRGB.indexOf(PIXEL_MAGIC);
+            if (found !== -1) {
+                let idx = found + PIXEL_MAGIC.length;
+                if (idx + 2 <= rawRGB.length) {
+                    const version = rawRGB[idx++];
+                    const nameLen = rawRGB[idx++];
+                    if (process.env.ROX_DEBUG)
+                        console.log('listFilesInPng: pixel version', version, 'nameLen', nameLen);
+                    if (nameLen > 0 && idx + nameLen <= rawRGB.length) {
+                        idx += nameLen;
+                    }
+                    if (idx + 4 <= rawRGB.length) {
+                        const payloadLen = rawRGB.readUInt32BE(idx);
+                        idx += 4;
+                        const afterPayload = idx + payloadLen;
+                        if (afterPayload <= rawRGB.length) {
+                            if (afterPayload + 8 <= rawRGB.length) {
+                                const marker = rawRGB
+                                    .slice(afterPayload, afterPayload + 4)
+                                    .toString('utf8');
+                                if (marker === 'rXFL') {
+                                    const jsonLen = rawRGB.readUInt32BE(afterPayload + 4);
+                                    const jsonStart = afterPayload + 8;
+                                    const jsonEnd = jsonStart + jsonLen;
+                                    if (jsonEnd <= rawRGB.length) {
+                                        const jsonBuf = rawRGB.slice(jsonStart, jsonEnd);
+                                        const files = JSON.parse(jsonBuf.toString('utf8'));
+                                        return files.sort();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (e) { }
+    }
+    catch (e) { }
     try {
         const chunks = extract(pngBuf);
         const fileListChunk = chunks.find((c) => c.name === 'rXFL');
@@ -1598,17 +1662,23 @@ export function listFilesInPng(pngBuf) {
                 ? fileListChunk.data
                 : Buffer.from(fileListChunk.data);
             const files = JSON.parse(data.toString('utf8'));
-            const dirs = new Set();
-            for (const file of files) {
-                const parts = file.split('/');
-                let path = '';
-                for (let i = 0; i < parts.length - 1; i++) {
-                    path += parts[i] + '/';
-                    dirs.add(path);
+            return files.sort();
+        }
+        const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);
+        if (metaChunk) {
+            const dataBuf = Buffer.isBuffer(metaChunk.data)
+                ? metaChunk.data
+                : Buffer.from(metaChunk.data);
+            const markerIdx = dataBuf.indexOf(Buffer.from('rXFL'));
+            if (markerIdx !== -1 && markerIdx + 8 <= dataBuf.length) {
+                const jsonLen = dataBuf.readUInt32BE(markerIdx + 4);
+                const jsonStart = markerIdx + 8;
+                const jsonEnd = jsonStart + jsonLen;
+                if (jsonEnd <= dataBuf.length) {
+                    const files = JSON.parse(dataBuf.slice(jsonStart, jsonEnd).toString('utf8'));
+                    return files.sort();
                 }
             }
-            const all = [...dirs, ...files];
-            return all.sort();
         }
     }
     catch (e) { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roxify",
-  "version": "1.1.7",
+  "version": "1.1.9",
   "description": "Encode binary data into PNG images with Zstd compression and decode them back. Supports CLI and programmatic API (Node.js ESM).",
   "type": "module",
   "main": "dist/index.js",
@@ -16,21 +16,24 @@
     "build": "tsc",
     "check-publish": "node ../scripts/check-publish.js roxify",
     "cli": "node dist/cli.js",
-    "test": "npm run build && node test/pack.test.js && node test/screenshot.test.js"
+    "test": "npm run build && node test/pack.test.js && node test/screenshot.test.js && node test/list.test.js"
   },
   "keywords": [
     "steganography",
     "png",
-    "brotli",
-    "rox",
-    "compress",
-    "decompress",
+    "zstd",
+    "compression",
+    "encryption",
     "encode",
     "decode",
     "cli",
     "nodejs",
     "esm",
-    "qrcode"
+    "data-embedding",
+    "file-archive",
+    "lossless",
+    "aes-gcm",
+    "binary-data"
   ],
   "author": "RoxCompressor",
   "license": "UNLICENSED",