@fungi.computer/sprite-zdog 0.0.0-stage → 0.0.1

package/dist/mushroom.d.ts

@@ -0,0 +1,4 @@
+import { type LocalCharacter } from "@fungi.computer/sprite";
+/** The retained mushroom as one portable character plus its native renderer. */
+declare const mushroomCharacter: LocalCharacter;
+export default mushroomCharacter;

package/dist/mushroom.js

@@ -0,0 +1,9 @@
+import { characterSchema } from "@fungi.computer/sprite";
+import document from "./mushroom.character.json" with { type: "json" };
+import renderZdog from "./renderer.js";
+/** The retained mushroom as one portable character plus its native renderer. */
+const mushroomCharacter = {
+    document: characterSchema.parse(document),
+    render: renderZdog,
+};
+export default mushroomCharacter;

package/dist/palette.d.ts

@@ -0,0 +1,3 @@
+/** Author palette references remain plain strings in portable Zdog scene data. */
+export declare const COLOR_PREFIX = "\0sprite-color:";
+export declare const colorKeyFromValue: (value: string | undefined) => string | undefined;

package/dist/palette.js

@@ -0,0 +1,5 @@
+/** Author palette references remain plain strings in portable Zdog scene data. */
+export const COLOR_PREFIX = "\u0000sprite-color:";
+export const colorKeyFromValue = (value) => value?.startsWith(COLOR_PREFIX)
+    ? value.slice(COLOR_PREFIX.length)
+    : undefined;

package/dist/portable.d.ts

@@ -0,0 +1,4 @@
+import { type CharacterDocument } from "@fungi.computer/sprite";
+import type { SpriteDefinition } from "./author.js";
+/** Compile trusted scene-authoring code into a document that contains no code. */
+export declare function toCharacter(definition: SpriteDefinition): CharacterDocument;

package/dist/portable.js

@@ -0,0 +1,61 @@
+import { characterSchema, } from "@fungi.computer/sprite";
+import { getDefinitionInternals } from "./internal.js";
+import { zdogDocumentSchema, zdogNodeSchema, } from "./document.js";
+/** Compile trusted scene-authoring code into a document that contains no code. */
+export function toCharacter(definition) {
+    const internals = getDefinitionInternals(definition);
+    const ids = new Map();
+    const nodes = [];
+    const visit = (node, parent) => {
+        const id = `node-${String(ids.size)}`;
+        ids.set(node, id);
+        const candidate = parent === undefined
+            ? { id, kind: node.kind, options: node.options }
+            : { id, parent, kind: node.kind, options: node.options };
+        nodes.push(zdogNodeSchema.parse(candidate));
+        for (const child of node.children)
+            visit(child, id);
+    };
+    visit(internals.root);
+    const variants = Object.fromEntries([...internals.variants].map(([channel, values]) => [
+        channel,
+        Object.fromEntries([...values].map(([name, node]) => {
+            const id = ids.get(node);
+            if (!id)
+                throw new Error("Cannot export a variant outside the scene root");
+            return [name, id];
+        })),
+    ]));
+    const data = zdogDocumentSchema.parse({
+        root: ids.get(internals.root),
+        nodes,
+        variants,
+        palette: internals.palette,
+        expressions: internals.expressions,
+        activities: internals.activities,
+        defaultPresentation: {
+            activity: internals.defaultActivity,
+            expression: internals.defaultExpression,
+        },
+    });
+    return characterSchema.parse(JSON.parse(JSON.stringify({
+        version: 1,
+        name: definition.name,
+        renderer: "zdog",
+        controls: Object.fromEntries(Object.entries(internals.palette).map(([name, value]) => [
+            name,
+            {
+                type: "color",
+                label: name,
+                default: value.length === 4
+                    ? `#${value
+                        .slice(1)
+                        .split("")
+                        .map((digit) => digit + digit)
+                        .join("")}`
+                    : value,
+            },
+        ])),
+        data,
+    })));
+}

package/dist/renderer.d.ts

@@ -0,0 +1,4 @@
+import type { Renderer } from "@fungi.computer/sprite";
+/** Optional native Zdog adapter. Scene data is decoded before creating the canvas. */
+declare const renderZdog: Renderer;
+export default renderZdog;

package/dist/renderer.js

@@ -0,0 +1,106 @@
+import * as Effect from "effect/Effect";
+import * as z from "zod";
+import { zdogDocumentSchema } from "./document.js";
+import { createZdogRenderer } from "./zdog-runtime.js";
+/** Optional native Zdog adapter. Scene data is decoded before creating the canvas. */
+const renderZdog = (context) => Effect.gen(function* () {
+    const scene = zdogDocumentSchema.parse(context.document.data);
+    const canvas = yield* Effect.acquireRelease(Effect.sync(() => context.target.ownerDocument.createElement("canvas")), (canvas) => Effect.sync(() => {
+        canvas.remove();
+    }));
+    canvas.style.cssText = "width:100%;height:100%;display:block";
+    context.target.replaceChildren(canvas);
+    const view = context.target.ownerDocument.defaultView;
+    if (!view)
+        throw new Error("Zdog avatar requires a browser window");
+    let frame;
+    let paused = true;
+    let destroyed = false;
+    const schedule = () => {
+        if (paused || destroyed || frame !== undefined)
+            return;
+        frame = view.requestAnimationFrame((time) => {
+            frame = undefined;
+            if (native.tick(time))
+                schedule();
+        });
+    };
+    // A paused player (reduced motion, hidden page, host pause) runs no frame
+    // loop, so every change it must show, including the canvas clear that a
+    // resize causes, is drawn at once as one still frame.
+    const invalidate = () => {
+        if (destroyed)
+            return;
+        if (paused)
+            native.renderStill();
+        else
+            schedule();
+    };
+    const native = yield* Effect.acquireRelease(Effect.sync(() => createZdogRenderer({
+        target: canvas,
+        scene,
+        onInvalidate: invalidate,
+        maxPixels: context.maxPixels,
+    })), (native) => Effect.sync(() => {
+        native.destroy();
+    }));
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+        destroyed = true;
+        if (frame !== undefined)
+            view.cancelAnimationFrame(frame);
+    }));
+    native.pause(true);
+    let presentationKey;
+    let paletteKey;
+    return {
+        activities: [
+            "idle",
+            "listening",
+            "processing",
+            "speaking",
+            "thinking",
+            "error",
+            ...Object.keys(scene.activities),
+        ],
+        expressions: [
+            scene.defaultPresentation.expression,
+            ...Object.keys(scene.expressions),
+        ].filter((value, index, values) => values.indexOf(value) === index),
+        set(presentation) {
+            const palette = {};
+            for (const [key, value] of Object.entries(presentation.appearance)) {
+                const color = z.string().safeParse(value);
+                if (!color.success)
+                    throw new Error(`Zdog palette value must be a color: ${key}`);
+                palette[key] = color.data;
+            }
+            const nextPalette = JSON.stringify(palette);
+            if (nextPalette !== paletteKey) {
+                native.setPalette(palette);
+                paletteKey = nextPalette;
+            }
+            const expression = presentation.expression ?? scene.defaultPresentation.expression;
+            if (!expression)
+                throw new Error("Zdog avatar needs an expression");
+            const nextPresentation = JSON.stringify([
+                presentation.activity,
+                expression,
+            ]);
+            if (nextPresentation !== presentationKey) {
+                native.present({ activity: presentation.activity, expression });
+                presentationKey = nextPresentation;
+            }
+            invalidate();
+        },
+        pause(value) {
+            paused = value;
+            native.pause(value);
+            if (paused && frame !== undefined) {
+                view.cancelAnimationFrame(frame);
+                frame = undefined;
+            }
+            invalidate();
+        },
+    };
+});
+export default renderZdog;

package/dist/zdog-runtime.d.ts

@@ -0,0 +1,21 @@
+import type { ZdogDocument } from "./document.js";
+export type SpriteRenderer = {
+    present(presentation: {
+        readonly activity: string;
+        readonly expression: string;
+    }): void;
+    setPalette(palette: Readonly<Record<string, string>>): void;
+    pause(paused: boolean): void;
+    tick(timestamp: number): boolean;
+    /** Draw pending changes now, unthrottled, as a paused player's still frame. */
+    renderStill(): void;
+    resize(): void;
+    destroy(): void;
+};
+export declare const createZdogRenderer: (options: {
+    readonly target: HTMLCanvasElement;
+    readonly scene: ZdogDocument;
+    readonly onInvalidate: () => void;
+    readonly maxPixels: number;
+    readonly palette?: Partial<Record<string, string>>;
+}) => SpriteRenderer;