@fungi.computer/sprite 0.0.0-stage → 0.0.1

package/dist/video.js

@@ -0,0 +1,141 @@
+import { z } from "zod";
+import * as Effect from "effect/Effect";
+const videoSchema = z
+    .strictObject({
+    clips: z.record(z.string().min(1), z.string().min(1)),
+})
+    .refine((data) => Object.hasOwn(data.clips, "idle"), {
+    message: "Video avatar needs an idle clip",
+});
+const awaitFirstFrame = (video, signal) => new Promise((resolve, reject) => {
+    const cleanup = () => {
+        video.removeEventListener("loadeddata", loaded);
+        video.removeEventListener("error", failed);
+        signal.removeEventListener("abort", aborted);
+    };
+    const loaded = () => {
+        cleanup();
+        resolve();
+    };
+    const failed = () => {
+        cleanup();
+        reject(new Error("Avatar video could not be decoded"));
+    };
+    const aborted = () => {
+        cleanup();
+        reject(new Error("Avatar video load was cancelled"));
+    };
+    video.addEventListener("loadeddata", loaded, { once: true });
+    video.addEventListener("error", failed, { once: true });
+    signal.addEventListener("abort", aborted, { once: true });
+    if (signal.aborted)
+        aborted();
+});
+/** One character, with browser-native MP4 clips selected by semantic activity. */
+const renderVideo = (context) => Effect.gen(function* () {
+    const data = videoSchema.parse(context.document.data);
+    const posterURL = context.document.poster
+        ? yield* context.assetURL(context.document.poster)
+        : undefined;
+    if (posterURL) {
+        const poster = yield* Effect.acquireRelease(Effect.sync(() => context.target.ownerDocument.createElement("img")), (image) => Effect.sync(() => {
+            image.remove();
+        }));
+        poster.alt = "";
+        poster.src = posterURL;
+        poster.style.cssText =
+            "width:100%;height:100%;object-fit:contain;display:block";
+        context.target.replaceChildren(poster);
+    }
+    const videos = new Map();
+    let decodedPixels = 0;
+    for (const reference of new Set(Object.values(data.clips))) {
+        const src = yield* context.assetURL(reference);
+        const video = yield* Effect.acquireRelease(Effect.sync(() => context.target.ownerDocument.createElement("video")), (element) => Effect.sync(() => {
+            element.pause();
+            element.removeAttribute("src");
+            element.removeAttribute("poster");
+            element.remove();
+        }));
+        video.muted = true;
+        video.defaultMuted = true;
+        video.loop = true;
+        video.playsInline = true;
+        video.preload = "auto";
+        video.style.cssText =
+            "width:100%;height:100%;object-fit:contain;display:none";
+        if (posterURL)
+            video.poster = posterURL;
+        context.target.append(video);
+        const frame = awaitFirstFrame(video, context.signal);
+        video.src = src;
+        yield* Effect.tryPromise({
+            try: () => frame,
+            catch: (error) => error instanceof Error ? error : new Error(String(error)),
+        });
+        context.signal.throwIfAborted();
+        decodedPixels += video.videoWidth * video.videoHeight;
+        if (video.videoWidth <= 0 ||
+            video.videoHeight <= 0 ||
+            decodedPixels > context.maxPixels)
+            throw new Error("Avatar videos exceed the pixel limit or have no frame");
+        videos.set(reference, video);
+    }
+    const idleReference = data.clips.idle;
+    const idle = idleReference ? videos.get(idleReference) : undefined;
+    if (!idle)
+        throw new Error("Video avatar has no decoded idle clip");
+    let current = idle;
+    let paused = true;
+    const play = (video) => {
+        void video.play().then(() => {
+            if (paused || current !== video)
+                video.pause();
+        }, (error) => {
+            if (!paused && current === video && !context.signal.aborted)
+                context.reportError(error instanceof Error ? error : new Error(String(error)));
+        });
+    };
+    for (const video of videos.values()) {
+        const failed = () => {
+            if (current === video)
+                context.reportError(new Error("Avatar video playback failed"));
+        };
+        yield* Effect.acquireRelease(Effect.sync(() => {
+            video.addEventListener("error", failed);
+        }), () => Effect.sync(() => {
+            video.removeEventListener("error", failed);
+        }));
+    }
+    idle.style.display = "block";
+    context.target.replaceChildren(idle);
+    return {
+        activities: Object.keys(data.clips),
+        expressions: [],
+        set(presentation) {
+            const reference = data.clips[presentation.activity];
+            const next = reference ? videos.get(reference) : undefined;
+            if (!next)
+                throw new Error(`Unknown video activity: ${presentation.activity}`);
+            if (next === current)
+                return;
+            current.pause();
+            current.style.display = "none";
+            current = next;
+            current.style.display = "block";
+            context.target.replaceChildren(current);
+            if (!paused)
+                play(current);
+        },
+        pause(value) {
+            if (paused === value)
+                return;
+            paused = value;
+            if (value)
+                current.pause();
+            else
+                play(current);
+        },
+    };
+});
+export default renderVideo;

package/package.json

@@ -1,6 +1,96 @@
 {
   "name": "@fungi.computer/sprite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.1",
+  "author": "Levi <levi@technomancy.dev>",
+  "description": "Typed renderer-bounded presentation for Fungi agents",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react.d.ts",
+      "import": "./dist/react.js"
+    },
+    "./video": {
+      "types": "./dist/video.d.ts",
+      "import": "./dist/video.js"
+    },
+    "./mycelium": {
+      "types": "./dist/mycelium.d.ts",
+      "import": "./dist/mycelium.js"
+    },
+    "./ink": {
+      "types": "./dist/ink.d.ts",
+      "import": "./dist/ink.js"
+    },
+    "./avatar": {
+      "types": "./dist/avatar.d.ts",
+      "import": "./dist/avatar.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "effect": "4.0.2",
+    "zod": "4.4.3",
+    "@fungi.computer/cairn": "0.0.1"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ladle/react": "5.1.1",
+    "@types/node": "24.13.3",
+    "@types/react": "18.3.3",
+    "@types/react-dom": "18.3.0",
+    "jsdom": "29.0.1",
+    "playwright": "1.62.1",
+    "react": "18.3.1",
+    "react-dom": "18.3.1",
+    "typescript": "5.9.3",
+    "vitest": "4.1.11"
+  },
+  "botanical": {
+    "role": "package",
+    "operations": {
+      "lint": "required",
+      "typecheck": "required",
+      "build": "required",
+      "test": "required",
+      "docs": "required",
+      "pack": "required",
+      "smoke": "required",
+      "stranger": "required"
+    }
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fungi-computer/sprite.git"
+  },
+  "scripts": {
+    "clean": "node --input-type=module --eval \"import { rm } from 'node:fs/promises'; await rm('dist', { recursive: true, force: true });\"",
+    "lint": "eslint src test vitest.config.ts --max-warnings=0 && ../../node_modules/.bin/oxlint --config ../../oxlint.config.ts --deny-warnings src test vitest.config.ts",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "build": "pnpm run clean && tsc -p tsconfig.build.json",
+    "test": "vitest run --config vitest.config.ts",
+    "docs": "tsx ../../tooling/repository/src/docs/cli.ts check --root ../..",
+    "docs:write": "tsx ../../tooling/repository/src/docs/cli.ts write --root ../..",
+    "pack": "mkdir -p ../../.botanical/sprite-pack && pnpm pack --pack-destination ../../.botanical/sprite-pack",
+    "smoke": "node --input-type=module -e \"import('./dist/index.js').then(({ createSprite }) => { if (typeof createSprite !== 'function') process.exit(1); })\"",
+    "stranger": "tsx ../../tooling/repository/src/artifacts/cli.ts --repo-root ../.. .",
+    "workbench:contract": "node scripts/workbench-contract.mjs",
+    "workbench:build": "ladle build",
+    "format:check": "node ../../tooling/repository/scripts/format-package-check.mjs",
+    "lint:anti-slop": "node ../../tooling/repository/scripts/lint-package-anti-slop.mjs"
+  }
 }