@peekling/cli 0.1.0

package/dist/png.js

@@ -0,0 +1,169 @@
+import { inspectImageStructure } from "@peekling/runtime/pack";
+import { inflateSync } from "node:zlib";
+import { PNG } from "pngjs";
+const SIGNATURE = Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]);
+const ADAM7_PASSES = [
+    [0, 0, 8, 8],
+    [4, 0, 8, 8],
+    [0, 4, 4, 8],
+    [2, 0, 4, 4],
+    [0, 2, 2, 4],
+    [1, 0, 2, 2],
+    [0, 1, 1, 2],
+];
+const COLOR_CHANNELS = {
+    0: 1,
+    2: 3,
+    3: 1,
+    4: 2,
+    6: 4,
+};
+function crc32(buffer) {
+    let crc = 0xffffffff;
+    for (const byte of buffer) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ (0xedb88320 & -(crc & 1));
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+    const name = Buffer.from(type, "ascii");
+    const output = Buffer.alloc(12 + data.length);
+    output.writeUInt32BE(data.length, 0);
+    name.copy(output, 4);
+    data.copy(output, 8);
+    output.writeUInt32BE(crc32(Buffer.concat([name, data])), 8 + data.length);
+    return output;
+}
+export function createFixtureAtlas(rows = 3) {
+    const width = 512;
+    const height = rows * 32;
+    const stride = width / 4 + 1;
+    const pixels = Buffer.alloc(stride * height);
+    const pixel = (x, y, value) => {
+        const offset = y * stride + 1 + (x >> 2);
+        pixels[offset] = pixels[offset] | (value << (6 - (x & 3) * 2));
+    };
+    const usedCells = Math.min(rows * 16, 48);
+    for (let cell = 0; cell < usedCells; cell++) {
+        const originX = (cell % 16) * 32;
+        const originY = Math.floor(cell / 16) * 32;
+        for (let y = 8; y < 24; y++) {
+            for (let x = 8; x < 24; x++) {
+                const edge = x < 10 || x > 21 || y < 10 || y > 21;
+                if (!edge && !((x + y + cell) % 11 === 0))
+                    continue;
+                pixel(originX + x, originY + y, 1 + (cell % 2));
+            }
+        }
+        const markerX = 11 + (cell % 2) * 8;
+        const markerY = 13 + (Math.floor(cell / 2) % 2) * 6;
+        for (let y = markerY; y < markerY + 3; y++) {
+            for (let x = markerX; x < markerX + 3; x++) {
+                pixel(originX + x, originY + y, 3);
+            }
+        }
+    }
+    const header = Buffer.alloc(13);
+    header.writeUInt32BE(width, 0);
+    header.writeUInt32BE(height, 4);
+    header.set([2, 3, 0, 0, 0], 8);
+    return Buffer.concat([
+        SIGNATURE,
+        chunk("IHDR", header),
+        chunk("PLTE", Buffer.from([0, 0, 0, 74, 144, 226, 226, 130, 74, 255, 255, 255])),
+        chunk("tRNS", Buffer.from([0, 255, 255, 255])),
+        chunk("IDAT", storedDeflate(pixels)),
+        chunk("IEND", Buffer.alloc(0)),
+    ]);
+}
+export function inspectPng(buffer) {
+    const structure = inspectImageStructure(buffer, "image/png");
+    const imageData = [];
+    let cursor = 8;
+    while (cursor + 12 <= buffer.length) {
+        const length = buffer.readUInt32BE(cursor);
+        const end = cursor + 12 + length;
+        const type = buffer.toString("ascii", cursor + 4, cursor + 8);
+        const expectedCrc = buffer.readUInt32BE(end - 4);
+        const actualCrc = crc32(buffer.subarray(cursor + 4, end - 4));
+        if (actualCrc !== expectedCrc)
+            throw new Error(`PNG ${type} chunk CRC is invalid`);
+        if (type === "IDAT")
+            imageData.push(buffer.subarray(cursor + 8, end - 4));
+        cursor = end;
+        if (type === "IEND")
+            break;
+    }
+    const expectedInflatedBytes = inflatedPngByteLength(buffer, structure.width, structure.height);
+    const compressedBytes = Buffer.concat(imageData);
+    let inflatedBytes;
+    let consumedBytes;
+    try {
+        const result = inflateSync(compressedBytes, {
+            info: true,
+            maxOutputLength: expectedInflatedBytes,
+        });
+        inflatedBytes = result.buffer;
+        consumedBytes = result.engine.bytesWritten;
+    }
+    catch {
+        throw new Error("atlas is not a decodable PNG file");
+    }
+    if (inflatedBytes.length !== expectedInflatedBytes ||
+        consumedBytes !== compressedBytes.length)
+        throw new Error("atlas is not a decodable PNG file");
+    let decoded;
+    try {
+        decoded = PNG.sync.read(buffer, { checkCRC: true });
+    }
+    catch {
+        throw new Error("atlas is not a decodable PNG file");
+    }
+    if (decoded.width !== structure.width ||
+        decoded.height !== structure.height ||
+        decoded.data.length !== structure.width * structure.height * 4)
+        throw new Error("decoded PNG geometry does not match IHDR");
+    return {
+        width: structure.width,
+        height: structure.height,
+        hasAlpha: structure.hasAlpha,
+    };
+}
+function inflatedPngByteLength(buffer, width, height) {
+    const bitsPerPixel = COLOR_CHANNELS[buffer[25]] * buffer[24];
+    if (buffer[28] === 0)
+        return filteredPassByteLength(width, height, bitsPerPixel);
+    return ADAM7_PASSES.reduce((total, [startX, startY, stepX, stepY]) => total +
+        filteredPassByteLength(passLength(width, startX, stepX), passLength(height, startY, stepY), bitsPerPixel), 0);
+}
+function passLength(size, start, step) {
+    return size <= start ? 0 : Math.ceil((size - start) / step);
+}
+function filteredPassByteLength(width, height, bitsPerPixel) {
+    return width === 0 || height === 0
+        ? 0
+        : height * (Math.ceil((width * bitsPerPixel) / 8) + 1);
+}
+function storedDeflate(data) {
+    const parts = [Buffer.from([0x78, 0x01])];
+    for (let offset = 0; offset < data.length; offset += 65_535) {
+        const length = Math.min(65_535, data.length - offset);
+        const header = Buffer.alloc(5);
+        header[0] = offset + length === data.length ? 1 : 0;
+        header.writeUInt16LE(length, 1);
+        header.writeUInt16LE(~length & 0xffff, 3);
+        parts.push(header, data.subarray(offset, offset + length));
+    }
+    let a = 1;
+    let b = 0;
+    for (const byte of data) {
+        a = (a + byte) % 65_521;
+        b = (b + a) % 65_521;
+    }
+    const checksum = Buffer.alloc(4);
+    checksum.writeUInt32BE(((b << 16) | a) >>> 0);
+    parts.push(checksum);
+    return Buffer.concat(parts);
+}

package/dist/zip.d.ts

@@ -0,0 +1,2 @@
+export declare function readZipEntries(archive: Buffer): Map<string, Buffer>;
+//# sourceMappingURL=zip.d.ts.map

package/dist/zip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../src/zip.ts"],"names":[],"mappings":"AAkBA,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAkHnE"}

package/dist/zip.js

@@ -0,0 +1,119 @@
+import { inflateRawSync } from "node:zlib";
+const MAX_ENTRIES = 128;
+const MAX_TOTAL = 64 * 1024 * 1024;
+function safeEntry(name) {
+    return (name.length > 0 &&
+        name.length <= 256 &&
+        !name.startsWith("/") &&
+        !name.includes("\\") &&
+        !/[\u0000-\u001f\u007f:]/.test(name) &&
+        name
+            .split("/")
+            .every((part) => part !== "" && part !== "." && part !== ".."));
+}
+export function readZipEntries(archive) {
+    if (archive.length < 22)
+        throw new Error(".codex-pet is not a supported ZIP archive");
+    let eocd = -1;
+    for (let offset = archive.length - 22; offset >= Math.max(0, archive.length - 65_557); offset--) {
+        if (archive.readUInt32LE(offset) === 0x06054b50) {
+            eocd = offset;
+            break;
+        }
+    }
+    if (eocd < 0)
+        throw new Error(".codex-pet is not a supported ZIP archive");
+    if (archive.readUInt16LE(eocd + 4) !== 0 ||
+        archive.readUInt16LE(eocd + 6) !== 0 ||
+        archive.readUInt16LE(eocd + 8) !== archive.readUInt16LE(eocd + 10))
+        throw new Error("Multi-disk and ZIP64 .codex-pet archives are unsupported");
+    const entries = archive.readUInt16LE(eocd + 10);
+    const directorySize = archive.readUInt32LE(eocd + 12);
+    let offset = archive.readUInt32LE(eocd + 16);
+    if (entries > MAX_ENTRIES ||
+        offset + directorySize > eocd ||
+        offset + directorySize > archive.length) {
+        throw new Error(".codex-pet archive exceeds safe directory limits");
+    }
+    const result = new Map();
+    let total = 0;
+    for (let index = 0; index < entries; index++) {
+        if (offset + 46 > archive.length)
+            throw new Error("ZIP directory is truncated");
+        if (archive.readUInt32LE(offset) !== 0x02014b50)
+            throw new Error("ZIP directory is malformed");
+        const flags = archive.readUInt16LE(offset + 8);
+        const method = archive.readUInt16LE(offset + 10);
+        const compressed = archive.readUInt32LE(offset + 20);
+        const uncompressed = archive.readUInt32LE(offset + 24);
+        const nameLength = archive.readUInt16LE(offset + 28);
+        const extraLength = archive.readUInt16LE(offset + 30);
+        const commentLength = archive.readUInt16LE(offset + 32);
+        const localOffset = archive.readUInt32LE(offset + 42);
+        const next = offset + 46 + nameLength + extraLength + commentLength;
+        if (next > archive.length)
+            throw new Error("ZIP directory is truncated");
+        let name;
+        try {
+            name = new TextDecoder("utf-8", { fatal: true }).decode(archive.subarray(offset + 46, offset + 46 + nameLength));
+        }
+        catch {
+            throw new Error("ZIP entry name is not valid UTF-8");
+        }
+        offset = next;
+        if (name.endsWith("/"))
+            continue;
+        if (!safeEntry(name))
+            throw new Error(`Unsafe ZIP entry path: ${name}`);
+        if ((flags & 1) !== 0)
+            throw new Error(`Encrypted ZIP entry is unsupported: ${name}`);
+        if (result.has(name))
+            throw new Error(`Duplicate ZIP entry: ${name}`);
+        if (uncompressed > 32 * 1024 * 1024 ||
+            (total += uncompressed) > MAX_TOTAL) {
+            throw new Error(".codex-pet archive exceeds safe uncompressed size limits");
+        }
+        if (localOffset + 30 > archive.length ||
+            archive.readUInt32LE(localOffset) !== 0x04034b50)
+            throw new Error("ZIP local header is malformed");
+        if (archive.readUInt16LE(localOffset + 8) !== method ||
+            archive.readUInt16LE(localOffset + 6) !== flags)
+            throw new Error(`ZIP headers disagree for ${name}`);
+        const localName = archive.readUInt16LE(localOffset + 26);
+        const localExtra = archive.readUInt16LE(localOffset + 28);
+        const start = localOffset + 30 + localName + localExtra;
+        if (start + compressed > archive.length || start + compressed > eocd)
+            throw new Error(`ZIP entry data is truncated: ${name}`);
+        const localPath = new TextDecoder("utf-8", { fatal: true }).decode(archive.subarray(localOffset + 30, localOffset + 30 + localName));
+        if (localPath !== name)
+            throw new Error(`ZIP headers disagree for ${name}`);
+        if (compressed > 0 &&
+            uncompressed > 1024 * 1024 &&
+            uncompressed / compressed > 1000)
+            throw new Error(`ZIP compression ratio is unsafe for ${name}`);
+        const bytes = archive.subarray(start, start + compressed);
+        let value;
+        if (method === 0)
+            value = Buffer.from(bytes);
+        else if (method === 8)
+            value = inflateRawSync(bytes, { maxOutputLength: 32 * 1024 * 1024 });
+        else
+            throw new Error(`Unsupported ZIP compression method for ${name}`);
+        if (value.length !== uncompressed)
+            throw new Error(`ZIP size mismatch for ${name}`);
+        if (crc32(value) !==
+            archive.readUInt32LE(offset - commentLength - extraLength - nameLength - 46 + 16))
+            throw new Error(`ZIP checksum mismatch for ${name}`);
+        result.set(name, value);
+    }
+    return result;
+}
+function crc32(bytes) {
+    let crc = 0xffffffff;
+    for (const byte of bytes) {
+        crc ^= byte;
+        for (let bit = 0; bit < 8; bit++)
+            crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
+    }
+    return (crc ^ 0xffffffff) >>> 0;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "@peekling/cli",
+  "version": "0.1.0",
+  "description": "Inspect Peekling configuration and author data-only character packs",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Prajwal S. Venkateshmurthy",
+    "url": "https://prajwal.me"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/peekling/peekling-engine.git"
+  },
+  "homepage": "https://github.com/peekling/peekling-engine#readme",
+  "bugs": {
+    "url": "https://github.com/peekling/peekling-engine/issues"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=22.14.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "dist/**/*.d.ts.map",
+    "README.md",
+    "LICENSE",
+    "NOTICE",
+    "AUTHORS",
+    "LICENSING.md"
+  ],
+  "bin": {
+    "peekling": "./dist/bin.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@peekling/adapter-codex-pet": "0.1.0",
+    "@peekling/preflight": "0.1.0",
+    "@peekling/runtime": "0.1.0",
+    "pngjs": "^7.0.0"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "prepack": "npm --prefix ../.. run build",
+    "test": "npm run build && node --test --experimental-strip-types test/*.test.ts",
+    "typecheck": "tsc -b --pretty false"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "typescript": "^7.0.2"
+  }
+}