roxify 1.4.1 → 1.5.0

package/dist/utils/inspection.js

@@ -1,10 +1,9 @@
-import extract from 'png-chunks-extract';
-import sharp from 'sharp';
 import * as zlib from 'zlib';
 import { unpackBuffer } from '../pack.js';
 import { CHUNK_TYPE, ENC_AES, ENC_XOR, MAGIC, MARKER_COLORS, PIXEL_MAGIC, } from './constants.js';
 import { decodePngToBinary } from './decoder.js';
 import { PassphraseRequiredError } from './errors.js';
+import { native } from './native.js';
 import { cropAndReconstitute } from './reconstitution.js';
 /**
  * List files in a Rox PNG archive without decoding the full payload.
@@ -14,7 +13,7 @@ import { cropAndReconstitute } from './reconstitution.js';
  */
 export async function listFilesInPng(pngBuf, opts = {}) {
     try {
-        const chunks = extract(pngBuf);
+        const chunks = native.extractPngChunks(pngBuf);
         const ihdr = chunks.find((c) => c.name === 'IHDR');
         const idatChunks = chunks.filter((c) => c.name === 'IDAT');
         if (ihdr && idatChunks.length > 0) {
@@ -147,15 +146,13 @@ export async function listFilesInPng(pngBuf, opts = {}) {
     }
     try {
         try {
-            const { data, info } = await sharp(pngBuf)
-                .ensureAlpha()
-                .raw()
-                .toBuffer({ resolveWithObject: true });
-            const currentWidth = info.width;
-            const currentHeight = info.height;
+            const rawData = native.sharpToRaw(pngBuf);
+            const data = rawData.pixels;
+            const currentWidth = rawData.width;
+            const currentHeight = rawData.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] = data[i * 3];
                 rawRGB[i * 3 + 1] = data[i * 4 + 1];
                 rawRGB[i * 3 + 2] = data[i * 4 + 2];
             }
@@ -219,17 +216,15 @@ export async function listFilesInPng(pngBuf, opts = {}) {
     try {
         const reconstructed = await cropAndReconstitute(pngBuf);
         try {
-            const { data, info } = await sharp(reconstructed)
-                .ensureAlpha()
-                .raw()
-                .toBuffer({ resolveWithObject: true });
-            const currentWidth = info.width;
-            const currentHeight = info.height;
+            const rawData = native.sharpToRaw(reconstructed);
+            const data = rawData.pixels;
+            const currentWidth = rawData.width;
+            const currentHeight = rawData.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];
+                rawRGB[i * 3] = data[i * 3];
+                rawRGB[i * 3 + 1] = data[i * 3 + 1];
+                rawRGB[i * 3 + 2] = data[i * 3 + 2];
             }
             const found = rawRGB.indexOf(PIXEL_MAGIC);
             if (found !== -1) {
@@ -287,12 +282,10 @@ export async function listFilesInPng(pngBuf, opts = {}) {
         }
         catch (e) { }
         try {
-            const chunks = extract(reconstructed);
+            const chunks = native.extractPngChunks(reconstructed);
             const fileListChunk = chunks.find((c) => c.name === 'rXFL');
             if (fileListChunk) {
-                const data = Buffer.isBuffer(fileListChunk.data)
-                    ? fileListChunk.data
-                    : Buffer.from(fileListChunk.data);
+                const data = Buffer.from(fileListChunk.data);
                 const parsedFiles = JSON.parse(data.toString('utf8'));
                 if (parsedFiles.length > 0 &&
                     typeof parsedFiles[0] === 'object' &&
@@ -316,9 +309,7 @@ export async function listFilesInPng(pngBuf, opts = {}) {
             }
             const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);
             if (metaChunk) {
-                const dataBuf = Buffer.isBuffer(metaChunk.data)
-                    ? metaChunk.data
-                    : Buffer.from(metaChunk.data);
+                const dataBuf = Buffer.from(metaChunk.data);
                 const markerIdx = dataBuf.indexOf(Buffer.from('rXFL'));
                 if (markerIdx !== -1 && markerIdx + 8 <= dataBuf.length) {
                     const jsonLen = dataBuf.readUInt32BE(markerIdx + 4);
@@ -345,12 +336,10 @@ export async function listFilesInPng(pngBuf, opts = {}) {
     }
     catch (e) { }
     try {
-        const chunks = extract(pngBuf);
+        const chunks = native.extractPngChunks(pngBuf);
         const fileListChunk = chunks.find((c) => c.name === 'rXFL');
         if (fileListChunk) {
-            const data = Buffer.isBuffer(fileListChunk.data)
-                ? fileListChunk.data
-                : Buffer.from(fileListChunk.data);
+            const data = Buffer.from(fileListChunk.data);
             const parsedFiles = JSON.parse(data.toString('utf8'));
             if (parsedFiles.length > 0 &&
                 typeof parsedFiles[0] === 'object' &&
@@ -374,9 +363,7 @@ export async function listFilesInPng(pngBuf, opts = {}) {
         }
         const metaChunk = chunks.find((c) => c.name === CHUNK_TYPE);
         if (metaChunk) {
-            const dataBuf = Buffer.isBuffer(metaChunk.data)
-                ? metaChunk.data
-                : Buffer.from(metaChunk.data);
+            const dataBuf = Buffer.from(metaChunk.data);
             const markerIdx = dataBuf.indexOf(Buffer.from('rXFL'));
             if (markerIdx !== -1 && markerIdx + 8 <= dataBuf.length) {
                 const jsonLen = dataBuf.readUInt32BE(markerIdx + 4);
@@ -442,7 +429,7 @@ export async function hasPassphraseInPng(pngBuf) {
             return flag === ENC_AES || flag === ENC_XOR;
         }
         try {
-            const chunksRaw = extract(pngBuf);
+            const chunksRaw = native.extractPngChunks(pngBuf);
             const target = chunksRaw.find((c) => c.name === CHUNK_TYPE);
             if (target) {
                 const data = Buffer.isBuffer(target.data)
@@ -460,12 +447,8 @@ export async function hasPassphraseInPng(pngBuf) {
         }
         catch (e) { }
         try {
-            const sharpLib = await import('sharp');
-            const { data } = await sharpLib
-                .default(pngBuf)
-                .raw()
-                .toBuffer({ resolveWithObject: true });
-            const rawRGB = Buffer.from(data);
+            const rawData = native.sharpToRaw(pngBuf);
+            const rawRGB = Buffer.from(rawData.pixels);
             const markerLen = MARKER_COLORS.length * 3;
             for (let i = 0; i <= rawRGB.length - markerLen; i += 3) {
                 let ok = true;

package/dist/utils/native.d.ts

@@ -0,0 +1 @@
+export declare const native: any;

package/dist/utils/native.js

@@ -0,0 +1,7 @@
+import { createRequire } from 'module';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const require = createRequire(import.meta.url);
+export const native = require(join(__dirname, '../../libroxify_native.node'));

package/dist/utils/optimization.d.ts

@@ -1,3 +1 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function optimizePngBuffer(pngBuf: Buffer, fast?: boolean): Promise<Buffer>;

package/dist/utils/optimization.js

@@ -2,8 +2,6 @@ import { spawn, spawnSync } from 'child_process';
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { join } from 'path';
-import encode from 'png-chunks-encode';
-import extract from 'png-chunks-extract';
 import * as zlib from 'zlib';
 import { PNG_HEADER, PNG_HEADER_HEX } from './constants.js';
 export async function optimizePngBuffer(pngBuf, fast = false) {
@@ -11,6 +9,9 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
     if (pngBuf.length > MAX_OPTIMIZE_SIZE) {
         return pngBuf;
     }
+    if (fast) {
+        return pngBuf;
+    }
     const runCommandAsync = (cmd, args, timeout = 120000) => {
         return new Promise((resolve) => {
             try {
@@ -67,13 +68,12 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
     }
     catch (e) { }
     try {
-        const chunksRaw = extract(pngBuf);
+        const nativeExtract = require('../../libroxify_native.node');
+        const chunksRaw = nativeExtract.extractPngChunks(pngBuf);
         const ihdr = chunksRaw.find((c) => c.name === 'IHDR');
         if (!ihdr)
             return pngBuf;
-        const ihdrData = Buffer.isBuffer(ihdr.data)
-            ? ihdr.data
-            : Buffer.from(ihdr.data);
+        const ihdrData = Buffer.from(ihdr.data);
         const width = ihdrData.readUInt32BE(0);
         const height = ihdrData.readUInt32BE(4);
         const bitDepth = ihdrData[8];
@@ -81,9 +81,7 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
         if (bitDepth !== 8 || colorType !== 2)
             return pngBuf;
         const idatChunks = chunksRaw.filter((c) => c.name === 'IDAT');
-        const idatData = Buffer.concat(idatChunks.map((c) => Buffer.isBuffer(c.data)
-            ? c.data
-            : Buffer.from(c.data)));
+        const idatData = Buffer.concat(idatChunks.map((c) => Buffer.from(c.data)));
         let raw;
         try {
             raw = zlib.inflateSync(idatData);
@@ -204,7 +202,8 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                 ? buf
                 : Buffer.concat([PNG_HEADER, buf]);
         }
-        const out = ensurePng(Buffer.from(encode(newChunks)));
+        const nativeEnc = require('../../libroxify_native.node');
+        const out = ensurePng(Buffer.from(nativeEnc.encodePngChunks(newChunks)));
         let bestBuf = out.length < pngBuf.length ? out : pngBuf;
         const strategies = [
             zlib.constants.Z_DEFAULT_STRATEGY,
@@ -227,7 +226,8 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                 const idx = altChunks.findIndex((c) => c.name === 'IDAT');
                 if (idx !== -1)
                     altChunks[idx] = { name: 'IDAT', data: comp };
-                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                const nativeOptim = require('../../libroxify_native.node');
+                const candidate = ensurePng(Buffer.from(nativeOptim.encodePngChunks(altChunks)));
                 if (candidate.length < bestBuf.length)
                     bestBuf = candidate;
             }
@@ -245,7 +245,8 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                 const idx = altChunks.findIndex((c) => c.name === 'IDAT');
                 if (idx !== -1)
                     altChunks[idx] = { name: 'IDAT', data: Buffer.from(comp) };
-                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                const native = require('../../libroxify_native.node');
+                const candidate = ensurePng(Buffer.from(native.encodePngChunks(altChunks)));
                 if (candidate.length < bestBuf.length)
                     bestBuf = candidate;
             }
@@ -303,7 +304,8 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                                 const idx = altChunks.findIndex((c) => c.name === 'IDAT');
                                 if (idx !== -1)
                                     altChunks[idx] = { name: 'IDAT', data: comp };
-                                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                                const native = require('../../libroxify_native.node');
+                                const candidate = ensurePng(Buffer.from(native.encodePngChunks(altChunks)));
                                 if (candidate.length < bestBuf.length)
                                     bestBuf = candidate;
                             }
@@ -383,7 +385,8 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                 const idx = altChunks.findIndex((c) => c.name === 'IDAT');
                 if (idx !== -1)
                     altChunks[idx] = { name: 'IDAT', data: comp };
-                const candidate = ensurePng(Buffer.from(encode(altChunks)));
+                const nativeOptim2 = require('../../libroxify_native.node');
+                const candidate = ensurePng(Buffer.from(nativeOptim2.encodePngChunks(altChunks)));
                 if (candidate.length < bestBuf.length)
                     bestBuf = candidate;
             }
@@ -589,7 +592,8 @@ export async function optimizePngBuffer(pngBuf, fast = false) {
                         data: zlib.deflateSync(idxFilteredAllVar, { level: 9 }),
                     });
                     palChunksVar.push({ name: 'IEND', data: Buffer.alloc(0) });
-                    const palOutVar = ensurePng(Buffer.from(encode(palChunksVar)));
+                    const native = require('../../libroxify_native.node');
+                    const palOutVar = ensurePng(Buffer.from(native.encodePngChunks(palChunksVar)));
                     if (palOutVar.length < bestBuf.length)
                         bestBuf = palOutVar;
                 }

package/dist/utils/reconstitution.d.ts

@@ -1,3 +1 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function cropAndReconstitute(input: Buffer, debugDir?: string): Promise<Buffer>;

package/dist/utils/reconstitution.js

@@ -1,266 +1,3 @@
-import { join } from 'path';
-import sharp from 'sharp';
 export async function cropAndReconstitute(input, debugDir) {
-    async function loadRaw(imgInput) {
-        const { data, info } = await sharp(imgInput)
-            .ensureAlpha()
-            .raw()
-            .toBuffer({ resolveWithObject: true });
-        return { data, info };
-    }
-    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];
-    }
-    const { info } = await loadRaw(input);
-    const doubledBuffer = await sharp(input)
-        .resize({
-        width: info.width * 2,
-        height: info.height * 2,
-        kernel: 'nearest',
-    })
-        .png()
-        .toBuffer();
-    if (debugDir) {
-        await sharp(doubledBuffer).toFile(join(debugDir, 'doubled.png'));
-    }
-    const { data: doubledData, info: doubledInfo } = await loadRaw(doubledBuffer);
-    const w = doubledInfo.width, h = doubledInfo.height;
-    const at = (x, y) => {
-        const i = idxFor(x, y, w);
-        return [
-            doubledData[i],
-            doubledData[i + 1],
-            doubledData[i + 2],
-            doubledData[i + 3],
-        ];
-    };
-    const findPattern = (startX, startY, dirX, dirY, pattern) => {
-        for (let y = startY; y >= 0 && y < h; y += dirY) {
-            for (let x = startX; x >= 0 && x < w; x += dirX) {
-                const p = at(x, y);
-                if (p[0] !== 255 || p[1] !== 0 || p[2] !== 0)
-                    continue;
-                let nx = x + dirX;
-                while (nx >= 0 && nx < w && eqRGB(at(nx, y), p))
-                    nx += dirX;
-                if (nx < 0 || nx >= w)
-                    continue;
-                const a = at(nx, y);
-                let nx2 = nx + dirX;
-                while (nx2 >= 0 && nx2 < w && eqRGB(at(nx2, y), a))
-                    nx2 += dirX;
-                if (nx2 < 0 || nx2 >= w)
-                    continue;
-                const b = at(nx2, y);
-                if (a[0] === pattern[0][0] &&
-                    a[1] === pattern[0][1] &&
-                    a[2] === pattern[0][2] &&
-                    b[0] === pattern[1][0] &&
-                    b[1] === pattern[1][1] &&
-                    b[2] === pattern[1][2]) {
-                    return { x, y };
-                }
-            }
-        }
-        return null;
-    };
-    const startPoint = findPattern(0, 0, 1, 1, [
-        [0, 255, 0],
-        [0, 0, 255],
-    ]);
-    const endPoint = findPattern(w - 1, h - 1, -1, -1, [
-        [0, 255, 0],
-        [0, 0, 255],
-    ]);
-    if (!startPoint || !endPoint)
-        throw new Error('Patterns not found');
-    const sx1 = Math.min(startPoint.x, endPoint.x), sy1 = Math.min(startPoint.y, endPoint.y);
-    const sx2 = Math.max(startPoint.x, endPoint.x), sy2 = Math.max(startPoint.y, endPoint.y);
-    const cropW = sx2 - sx1 + 1, cropH = sy2 - sy1 + 1;
-    if (cropW <= 0 || cropH <= 0)
-        throw new Error('Invalid crop dimensions');
-    const cropped = await sharp(doubledBuffer)
-        .extract({ left: sx1, top: sy1, width: cropW, height: cropH })
-        .png()
-        .toBuffer();
-    const { data: cdata, info: cinfo } = await loadRaw(cropped);
-    const cw = cinfo.width, ch = cinfo.height;
-    const newWidth = cw, newHeight = ch + 1;
-    const out = Buffer.alloc(newWidth * newHeight * 4, 0);
-    for (let i = 0; i < out.length; i += 4)
-        out[i + 3] = 255;
-    for (let y = 0; y < ch; y++) {
-        for (let x = 0; x < cw; x++) {
-            const srcI = (y * cw + x) * 4;
-            const dstI = (y * newWidth + x) * 4;
-            out[dstI] = cdata[srcI];
-            out[dstI + 1] = cdata[srcI + 1];
-            out[dstI + 2] = cdata[srcI + 2];
-            out[dstI + 3] = cdata[srcI + 3];
-        }
-    }
-    for (let x = 0; x < newWidth; x++) {
-        const i = ((ch - 1) * newWidth + x) * 4;
-        out[i] = out[i + 1] = out[i + 2] = 0;
-        out[i + 3] = 255;
-        const j = (ch * newWidth + x) * 4;
-        out[j] = out[j + 1] = out[j + 2] = 0;
-        out[j + 3] = 255;
-    }
-    if (newWidth >= 3) {
-        const bgrStart = newWidth - 3;
-        const bgr = [
-            [0, 0, 255],
-            [0, 255, 0],
-            [255, 0, 0],
-        ];
-        for (let k = 0; k < 3; k++) {
-            const i = (ch * newWidth + bgrStart + k) * 4;
-            out[i] = bgr[k][0];
-            out[i + 1] = bgr[k][1];
-            out[i + 2] = bgr[k][2];
-            out[i + 3] = 255;
-        }
-    }
-    const getPixel = (x, y) => {
-        const i = (y * newWidth + x) * 4;
-        return [out[i], out[i + 1], out[i + 2], out[i + 3]];
-    };
-    const compressedLines = [];
-    for (let y = 0; y < newHeight; y++) {
-        const line = [];
-        for (let x = 0; x < newWidth; x++)
-            line.push(getPixel(x, y));
-        const isAllBlack = line.every((p) => p[0] === 0 && p[1] === 0 && p[2] === 0 && p[3] === 255);
-        if (!isAllBlack &&
-            (compressedLines.length === 0 ||
-                !line.every((p, i) => p.every((v, j) => v === compressedLines[compressedLines.length - 1][i][j])))) {
-            compressedLines.push(line);
-        }
-    }
-    if (compressedLines.length === 0) {
-        return sharp({
-            create: {
-                width: 1,
-                height: 1,
-                channels: 4,
-                background: { r: 0, g: 0, b: 0, alpha: 1 },
-            },
-        })
-            .png()
-            .toBuffer();
-    }
-    let finalWidth = newWidth, finalHeight = compressedLines.length;
-    let finalOut = Buffer.alloc(finalWidth * finalHeight * 4, 0);
-    for (let i = 0; i < finalOut.length; i += 4)
-        finalOut[i + 3] = 255;
-    for (let y = 0; y < finalHeight; y++) {
-        for (let x = 0; x < finalWidth; x++) {
-            const i = (y * finalWidth + x) * 4;
-            finalOut[i] = compressedLines[y][x][0];
-            finalOut[i + 1] = compressedLines[y][x][1];
-            finalOut[i + 2] = compressedLines[y][x][2];
-            finalOut[i + 3] = compressedLines[y][x][3] || 255;
-        }
-    }
-    if (finalHeight >= 1 && finalWidth >= 3) {
-        const lastY = finalHeight - 1;
-        for (let k = 0; k < 3; k++) {
-            const i = (lastY * finalWidth + finalWidth - 3 + k) * 4;
-            finalOut[i] = finalOut[i + 1] = finalOut[i + 2] = 0;
-            finalOut[i + 3] = 255;
-        }
-    }
-    if (finalWidth >= 2) {
-        const kept = [];
-        for (let x = 0; x < finalWidth; x++) {
-            if (kept.length === 0) {
-                kept.push(x);
-                continue;
-            }
-            const prevX = kept[kept.length - 1];
-            let same = true;
-            for (let y = 0; y < finalHeight; y++) {
-                const ia = (y * finalWidth + prevX) * 4, ib = (y * finalWidth + x) * 4;
-                if (finalOut[ia] !== finalOut[ib] ||
-                    finalOut[ia + 1] !== finalOut[ib + 1] ||
-                    finalOut[ia + 2] !== finalOut[ib + 2] ||
-                    finalOut[ia + 3] !== finalOut[ib + 3]) {
-                    same = false;
-                    break;
-                }
-            }
-            if (!same)
-                kept.push(x);
-        }
-        if (kept.length !== finalWidth) {
-            const newFinalWidth = kept.length;
-            const newOut = Buffer.alloc(newFinalWidth * finalHeight * 4, 0);
-            for (let i = 0; i < newOut.length; i += 4)
-                newOut[i + 3] = 255;
-            for (let nx = 0; nx < kept.length; nx++) {
-                const sx = kept[nx];
-                for (let y = 0; y < finalHeight; y++) {
-                    const srcI = (y * finalWidth + sx) * 4, dstI = (y * newFinalWidth + nx) * 4;
-                    newOut[dstI] = finalOut[srcI];
-                    newOut[dstI + 1] = finalOut[srcI + 1];
-                    newOut[dstI + 2] = finalOut[srcI + 2];
-                    newOut[dstI + 3] = finalOut[srcI + 3];
-                }
-            }
-            finalOut = newOut;
-            finalWidth = newFinalWidth;
-        }
-    }
-    if (finalHeight >= 2 && finalWidth >= 3) {
-        const secondLastY = finalHeight - 2;
-        const bgrSeq = [
-            [0, 0, 255],
-            [0, 255, 0],
-            [255, 0, 0],
-        ];
-        let hasBGR = true;
-        for (let k = 0; k < 3; k++) {
-            const i = (secondLastY * finalWidth + finalWidth - 3 + k) * 4;
-            if (finalOut[i] !== bgrSeq[k][0] ||
-                finalOut[i + 1] !== bgrSeq[k][1] ||
-                finalOut[i + 2] !== bgrSeq[k][2]) {
-                hasBGR = false;
-                break;
-            }
-        }
-        if (hasBGR) {
-            for (let k = 0; k < 3; k++) {
-                const i = (secondLastY * finalWidth + finalWidth - 3 + k) * 4;
-                finalOut[i] = finalOut[i + 1] = finalOut[i + 2] = 0;
-                finalOut[i + 3] = 255;
-            }
-        }
-    }
-    if (finalHeight >= 1 && finalWidth >= 1) {
-        const lastYFinal = finalHeight - 1;
-        const bgrSeq = [
-            [0, 0, 255],
-            [0, 255, 0],
-            [255, 0, 0],
-        ];
-        for (let k = 0; k < 3; k++) {
-            const sx = finalWidth - 3 + k;
-            if (sx >= 0) {
-                const i = (lastYFinal * finalWidth + sx) * 4;
-                finalOut[i] = bgrSeq[k][0];
-                finalOut[i + 1] = bgrSeq[k][1];
-                finalOut[i + 2] = bgrSeq[k][2];
-                finalOut[i + 3] = 255;
-            }
-        }
-    }
-    return sharp(finalOut, {
-        raw: { width: finalWidth, height: finalHeight, channels: 4 },
-    })
-        .png()
-        .toBuffer();
+    return input;
 }

package/dist/utils/rust-cli-wrapper.js

@@ -62,13 +62,7 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
         throw new Error('Rust CLI binary not found. Run: cargo build --release');
     }
     return new Promise((resolve, reject) => {
-        const args = [
-            'encode',
-            inputPath,
-            outputPath,
-            '--level',
-            String(compressionLevel),
-        ];
+        const args = ['encode', '--level', String(compressionLevel)];
         if (name) {
             args.push('--name', name);
         }
@@ -76,6 +70,7 @@ export async function encodeWithRustCLI(inputPath, outputPath, compressionLevel
             args.push('--passphrase', passphrase);
             args.push('--encrypt', encryptType);
         }
+        args.push(inputPath, outputPath);
         const proc = spawn(cliPath, args);
         let stderr = '';
         proc.stderr.on('data', (data) => {

package/dist/utils/types.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 import { PackedFile } from '../pack.js';
 export interface EncodeOptions {
     compression?: 'zstd';

package/dist/utils/zstd.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-/// <reference types="node" />
 export declare function compressStream(stream: AsyncGenerator<Buffer>, level?: number, onProgress?: (loaded: number, total: number) => void): Promise<{
     chunks: Buffer[];
     totalLength: number;