qlogicagent 2.13.5 → 2.13.7

package/dist/runtime/pet/petdex-asset.test.js

@@ -1,257 +0,0 @@
-import { createHash } from "node:crypto";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { createCanvas } from "@napi-rs/canvas";
-import { afterEach, describe, expect, it } from "vitest";
-import { createDefaultPetdexAnimations } from "@xiaozhiclaw/pet-core";
-import { PETDEX_ANIMATION_IDS, PETDEX_ATLAS_CONTRACT, PETDEX_SCHEMA, buildPetdexAssetImport, createPetdexAssetFromSpritesheet, loadPetdexAssetPackage, validatePetdexAssetManifest, writePetdexAssetPackage, } from "./petdex-asset.js";
-import { loadPetFile } from "./pet-file-loader.js";
-const tmpDirs = [];
-afterEach(() => {
-    for (const dir of tmpDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-describe("Petdex asset validation", () => {
-    it("accepts a canonical 8x9 1536x1872 WebP package with matching sha256", async () => {
-        const dir = makeTempDir("petdex-valid-");
-        const webp = makeWebp(PETDEX_ATLAS_CONTRACT.width, PETDEX_ATLAS_CONTRACT.height);
-        const manifest = makeManifest({ sha256: sha256(webp) });
-        const file = writePackage(dir, {
-            "pet.json": Buffer.from(JSON.stringify(manifest), "utf-8"),
-            "spritesheet.webp": webp,
-        });
-        const asset = await loadPetdexAssetPackage(file);
-        expect(asset.manifest.schema).toBe(PETDEX_SCHEMA);
-        expect(asset.manifest.atlas).toMatchObject(PETDEX_ATLAS_CONTRACT);
-        expect(asset.validation).toMatchObject({
-            schema: "qlogic.petdex.validation.v1",
-            assetId: "petdex_test",
-            valid: true,
-            errors: [],
-            atlas: {
-                width: 1536,
-                height: 1872,
-                sha256: sha256(webp),
-            },
-            animations: {
-                ids: [...PETDEX_ANIMATION_IDS],
-                minFrame: 0,
-                maxFrame: 69,
-            },
-        });
-    });
-    it("rejects atlas geometry that is not exactly 8x9 cells in a 1536x1872 WebP sheet", () => {
-        const webp = makeWebp(1535, 1872);
-        const manifest = makeManifest({
-            atlas: { width: 1535 },
-            sha256: sha256(webp),
-        });
-        expect(() => validatePetdexAssetManifest(manifest, webp)).toThrow(/1536x1872/);
-    });
-    it("rejects a spritesheet whose sha256 does not match pet.json", () => {
-        const webp = makeWebp(1536, 1872);
-        const manifest = makeManifest({ sha256: "0".repeat(64) });
-        expect(() => validatePetdexAssetManifest(manifest, webp)).toThrow(/sha256/i);
-    });
-    it("rejects opaque contact sheets instead of accepting visually invalid Petdex atlases", async () => {
-        const webp = await makeOpaqueWebp(1536, 1872);
-        const manifest = makeManifest({ sha256: sha256(webp) });
-        expect(() => validatePetdexAssetManifest(manifest, webp)).toThrow(/transparent background alpha/i);
-    });
-    it("rejects an animation whose frame count does not match its row spec", () => {
-        const webp = makeWebp(1536, 1872);
-        const manifest = makeManifest({
-            sha256: sha256(webp),
-            // idle must be exactly 6 frames; 8 was the old fixed-row assumption.
-            animations: {
-                idle: { row: 0, frames: [0, 1, 2, 3, 4, 5, 6, 7], durations: [1, 1, 1, 1, 1, 1, 1, 1], loop: true },
-            },
-        });
-        expect(() => validatePetdexAssetManifest(manifest, webp)).toThrow(/idle must have exactly 6 frames/);
-    });
-    it("rejects unsafe package entry and manifest image paths", async () => {
-        const dir = makeTempDir("petdex-unsafe-");
-        const webp = makeWebp(1536, 1872);
-        const unsafeManifest = makeManifest({
-            sha256: sha256(webp),
-            atlas: { image: "../spritesheet.webp" },
-        });
-        const unsafeFile = writePackage(dir, {
-            "pet.json": Buffer.from(JSON.stringify(unsafeManifest), "utf-8"),
-            "../spritesheet.webp": webp,
-        });
-        await expect(loadPetdexAssetPackage(unsafeFile)).rejects.toThrow(/unsafe path/i);
-    });
-    it("rejects legacy SVG state .pet packages instead of sanitizing or falling back", async () => {
-        const dir = makeTempDir("petdex-svg-");
-        const legacyPackage = writePackage(dir, {
-            "manifest.json": Buffer.from(JSON.stringify({
-                version: 1,
-                name: "Legacy",
-                author: "old forge",
-                created: "2026-06-03T00:00:00.000Z",
-                dimensions: { width: 128, height: 128 },
-                states: { idle: { file: "idle.svg", loop: true } },
-            }), "utf-8"),
-            "idle.svg": Buffer.from("<svg />", "utf-8"),
-        });
-        await expect(loadPetFile(legacyPackage)).rejects.toThrow(/SVG .*not supported/i);
-    });
-});
-describe("Petdex import builder", () => {
-    it("writes canonical pet.json, spritesheet.webp, and validation.json", async () => {
-        const dir = makeTempDir("petdex-import-");
-        const webp = makeWebp(1536, 1872);
-        const manifest = makeManifest({ sha256: sha256(webp) });
-        const sourcePackage = writePackage(dir, {
-            "pet.json": Buffer.from(JSON.stringify(manifest), "utf-8"),
-            "spritesheet.webp": webp,
-        });
-        const targetDir = path.join(dir, "asset");
-        const result = await buildPetdexAssetImport(sourcePackage, targetDir);
-        expect(result.summary).toMatchObject({
-            id: "petdex_test",
-            assetKind: "petdex",
-            sourceKind: "upload",
-            name: "Test Pet",
-            description: "A valid Petdex pet",
-            createdAt: "2026-06-03T00:00:00.000Z",
-            updatedAt: "2026-06-03T00:00:00.000Z",
-            atlas: {
-                format: "webp",
-                columns: 8,
-                rows: 9,
-                frameCount: 72,
-                cellWidth: 192,
-                cellHeight: 208,
-                width: 1536,
-                height: 1872,
-                sha256: sha256(webp),
-            },
-        });
-        expect(result.summary.animations).toBeDefined();
-        expect(result.summary.thumbnail).toEqual({ frame: 0 });
-        expect(fs.existsSync(path.join(targetDir, "pet.json"))).toBe(true);
-        expect(fs.readFileSync(path.join(targetDir, "spritesheet.webp"))).toEqual(webp);
-        expect(JSON.parse(fs.readFileSync(path.join(targetDir, "validation.json"), "utf-8"))).toMatchObject({
-            schema: "qlogic.petdex.validation.v1",
-            assetId: "petdex_test",
-            valid: true,
-            errors: [],
-            atlas: { width: 1536, height: 1872, sha256: sha256(webp) },
-        });
-    });
-});
-describe("Petdex package writer", () => {
-    it("writes a .petdex package that the canonical importer can read back", async () => {
-        const dir = makeTempDir("petdex-package-");
-        const webp = await makeRealWebp(1536, 1872);
-        const generated = await createPetdexAssetFromSpritesheet({
-            id: "petdex_written",
-            name: "Written Pet",
-            description: "A written package pet",
-            prompt: "write a pet package",
-            spritesheet: webp,
-        });
-        const packagePath = await writePetdexAssetPackage({
-            ...generated,
-            outputDir: dir,
-            fileName: "written.petdex",
-        });
-        expect(path.basename(packagePath)).toBe("written.petdex");
-        const loaded = await loadPetdexAssetPackage(packagePath);
-        expect(loaded.manifest).toEqual(generated.asset);
-        expect(loaded.spritesheet).toEqual(generated.spritesheet);
-        expect(loaded.validation).toMatchObject({
-            schema: "qlogic.petdex.validation.v1",
-            assetId: "petdex_written",
-            valid: true,
-        });
-    });
-});
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tmpDirs.push(dir);
-    return dir;
-}
-function makeManifest(overrides = {}) {
-    return {
-        schema: PETDEX_SCHEMA,
-        id: "petdex_test",
-        assetKind: "petdex",
-        name: "Test Pet",
-        description: "A valid Petdex pet",
-        createdAt: "2026-06-03T00:00:00.000Z",
-        updatedAt: "2026-06-03T00:00:00.000Z",
-        source: { kind: "upload", prompt: null },
-        atlas: {
-            image: "spritesheet.webp",
-            ...PETDEX_ATLAS_CONTRACT,
-            sha256: overrides.sha256 ?? "f".repeat(64),
-            ...(overrides.atlas ?? {}),
-        },
-        animations: {
-            ...createDefaultPetdexAnimations(),
-            ...(overrides.animations ?? {}),
-        },
-        thumbnail: { frame: 0 },
-    };
-}
-function sha256(buffer) {
-    return createHash("sha256").update(buffer).digest("hex");
-}
-function makeWebp(width, height) {
-    const payload = Buffer.alloc(10);
-    payload[0] = 0x10;
-    writeUInt24LE(payload, width - 1, 4);
-    writeUInt24LE(payload, height - 1, 7);
-    const chunk = Buffer.concat([Buffer.from("VP8X"), uint32LE(payload.length), payload]);
-    const riffSize = 4 + chunk.length;
-    return Buffer.concat([Buffer.from("RIFF"), uint32LE(riffSize), Buffer.from("WEBP"), chunk]);
-}
-async function makeRealWebp(width, height) {
-    const canvas = createCanvas(width, height);
-    const ctx = canvas.getContext("2d");
-    ctx.clearRect(0, 0, width, height);
-    ctx.fillStyle = "#2563eb";
-    ctx.fillRect(64, 64, 128, 128);
-    return Buffer.from(await canvas.encode("webp"));
-}
-async function makeOpaqueWebp(width, height) {
-    const canvas = createCanvas(width, height);
-    const ctx = canvas.getContext("2d");
-    ctx.fillStyle = "#ffffff";
-    ctx.fillRect(0, 0, width, height);
-    ctx.fillStyle = "#2563eb";
-    ctx.fillRect(64, 64, 128, 128);
-    return Buffer.from(await canvas.encode("webp"));
-}
-function writePackage(dir, entries) {
-    const output = Buffer.concat(Object.entries(entries).map(([name, data]) => {
-        const nameBuffer = Buffer.from(name, "utf-8");
-        const header = Buffer.alloc(30);
-        header.writeUInt32LE(0x04034b50, 0);
-        header.writeUInt16LE(20, 4);
-        header.writeUInt16LE(0, 6);
-        header.writeUInt16LE(0, 8);
-        header.writeUInt32LE(data.length, 18);
-        header.writeUInt32LE(data.length, 22);
-        header.writeUInt16LE(nameBuffer.length, 26);
-        return Buffer.concat([header, nameBuffer, data]);
-    }));
-    const file = path.join(dir, "asset.pet");
-    fs.writeFileSync(file, output);
-    return file;
-}
-function uint32LE(value) {
-    const buffer = Buffer.alloc(4);
-    buffer.writeUInt32LE(value);
-    return buffer;
-}
-function writeUInt24LE(buffer, value, offset) {
-    buffer[offset] = value & 0xff;
-    buffer[offset + 1] = (value >> 8) & 0xff;
-    buffer[offset + 2] = (value >> 16) & 0xff;
-}

package/dist/runtime/pet/petdex-forge-service.d.ts

@@ -1,19 +0,0 @@
-import { type PetdexForgeRequest, type PetdexForgeOutput, type GeneratePetdexImage, type UploadPetdexReferenceImage, type PetdexProductionOptions } from "@xiaozhiclaw/pet-core";
-export { PETDEX_PRODUCTION_SCHEMA, } from "@xiaozhiclaw/pet-core";
-export type { PetdexForgeRequest, PetdexImageGenerationRequest, PetdexImageGenerationResult, PetdexForgeOutput, PetdexProductionRun, PetdexProductionJob, PetdexProductionReferenceImage, GeneratePetdexImage, UploadPetdexReferenceImage, PetdexProductionOptions, } from "@xiaozhiclaw/pet-core";
-export interface PetdexForgePackageOutput extends PetdexForgeOutput {
-    packagePath: string;
-    assetDir: string;
-    manifestPath: string;
-    spritesheetPath: string;
-    validationPath: string;
-    productionRunPath: string;
-}
-export declare function forgePetdexAsset(input: PetdexForgeRequest, generateImage: GeneratePetdexImage, options?: PetdexProductionOptions): Promise<PetdexForgeOutput>;
-export declare function forgePetdexAssetPackage(params: {
-    input: PetdexForgeRequest;
-    outputDir: string;
-    generateImage: GeneratePetdexImage;
-    uploadReferenceImage?: UploadPetdexReferenceImage;
-}): Promise<PetdexForgePackageOutput>;
-export declare function readGeneratedPetdexImage(mediaUrl: string): Promise<Buffer>;