@neta-art/cohub 10.0.0 → 11.0.0

package/dist/board/model/media.js

@@ -59,9 +59,15 @@ function inferBoardMediaKind(value, mimeType) {
 	return "file";
 }
 function getMediaResourceTitle(value) {
+	if (!/^[a-z][a-z\d+.-]*:/i.test(value)) return value.split("/").filter(Boolean).pop() || value;
 	try {
 		const url = new URL(value);
-		return decodeURIComponent(url.pathname.split("/").filter(Boolean).pop() || url.hostname);
+		const title = url.pathname.split("/").filter(Boolean).pop() || url.hostname;
+		try {
+			return decodeURIComponent(title);
+		} catch {
+			return title;
+		}
 	} catch {
 		return value.split("/").filter(Boolean).pop() || value;
 	}

package/dist/board/model/sampling.d.ts

@@ -0,0 +1,19 @@
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import { BoardFrame } from "../../protocol/dist/board-layout.js";
+import "../../protocol/dist/index.js";
+import { BoardViewport, Size } from "./geometry.js";
+import { BoardScene } from "./scene.js";
+import { BoardCameraOverride, BoardEvaluateOptions, BoardEvaluation } from "./animation.js";
+//#region src/board/model/sampling.d.ts
+declare function createBoardAnimationSampler(document: BoardDocument, animation: string | null, options?: BoardEvaluateOptions): {
+  frameAt(id: string, time: number): BoardFrame | undefined;
+  at(time: number): {
+    document: BoardDocument;
+    evaluation: BoardEvaluation;
+    scene: BoardScene;
+  };
+};
+type BoardAnimationSampler = ReturnType<typeof createBoardAnimationSampler>;
+declare function resolveBoardAnimationCamera(override: BoardCameraOverride, bounds: (id: string) => BoardFrame | undefined, surface: Size, time: number, base?: BoardViewport): BoardViewport;
+//#endregion
+export { BoardAnimationSampler, createBoardAnimationSampler, resolveBoardAnimationCamera };

package/dist/board/model/sampling.js

@@ -0,0 +1,96 @@
+import { arrowBindings } from "../../protocol/dist/board-layout.js";
+import { cameraForFocus, cameraForState } from "./geometry.js";
+import { applyBoardEvaluation, boardAnimationTime, compileBoardAnimations, evaluateBoardAnimations } from "./animation.js";
+import { buildBoardScene } from "./scene.js";
+//#region src/board/model/sampling.ts
+function createBoardAnimationSampler(document, animation, options = {}) {
+	const selected = animation ? document.animations[animation] : void 0;
+	if (animation && !selected) throw new Error(`Animation ${animation} does not exist.`);
+	const compiled = compileBoardAnimations(document);
+	const cache = /* @__PURE__ */ new Map();
+	const geometry = /* @__PURE__ */ new Map();
+	function sample(time) {
+		const times = /* @__PURE__ */ new Map();
+		for (const [id, entry] of compiled.animations) if (entry.header.play === "always") times.set(id, boardAnimationTime(entry.header, time) ?? 0);
+		if (animation && selected) times.set(animation, Math.min(time, selected.duration));
+		const evaluation = evaluateBoardAnimations(compiled, times, options);
+		return {
+			document: applyBoardEvaluation(document, evaluation),
+			evaluation
+		};
+	}
+	function stateAt(time) {
+		if (!Number.isFinite(time) || time < 0) throw new Error("Animation time must be finite and non-negative.");
+		let value = cache.get(time);
+		if (!value) {
+			value = sample(time);
+			const oldest = cache.keys().next().value;
+			if (cache.size >= 64 && oldest !== void 0) cache.delete(oldest);
+			cache.set(time, value);
+		}
+		return value;
+	}
+	let current;
+	return {
+		frameAt(id, time) {
+			const key = `${time}:${id}`;
+			if (geometry.has(key)) return geometry.get(key);
+			const sampled = stateAt(time).document;
+			const items = {};
+			const pending = [id];
+			while (pending.length) {
+				const next = pending.pop();
+				if (!next || items[next]) continue;
+				const item = sampled.items[next];
+				if (!item) continue;
+				items[next] = item;
+				if (item.parent) pending.push(item.parent);
+				pending.push(...arrowBindings(item));
+			}
+			const frame = buildBoardScene({
+				...sampled,
+				items
+			}).get(id)?.frame;
+			if (geometry.size >= 2048) geometry.clear();
+			geometry.set(key, frame);
+			return frame;
+		},
+		at(time) {
+			if (current?.time === time) return current.value;
+			const sampled = stateAt(time);
+			const value = {
+				...sampled,
+				scene: buildBoardScene(sampled.document)
+			};
+			current = {
+				time,
+				value
+			};
+			return value;
+		}
+	};
+}
+function resolveBoardAnimationCamera(override, bounds, surface, time, base = {
+	x: 0,
+	y: 0,
+	zoom: 1
+}) {
+	let camera = override.focus === void 0 ? base : cameraForFocus(override.focus, bounds, surface, { padding: 48 }) ?? base;
+	if (override.zoom !== void 0) camera = {
+		...camera,
+		zoom: override.zoom
+	};
+	if (override.center) camera = cameraForState({
+		centerX: override.center.x,
+		centerY: override.center.y,
+		zoom: camera.zoom
+	}, surface);
+	if (override.shake) camera = {
+		...camera,
+		x: camera.x + Math.sin(time / 1e3 * 91.3) * override.shake,
+		y: camera.y + Math.cos(time / 1e3 * 77.9) * override.shake
+	};
+	return camera;
+}
+//#endregion
+export { createBoardAnimationSampler, resolveBoardAnimationCamera };

package/dist/board/model/script-example.d.ts

@@ -0,0 +1,4 @@
+//#region src/board/model/script-example.d.ts
+declare const BOARD_SCRIPT_DRAWING_EXAMPLE = "export const animated = true;\n\nexport const parameters = {\n  amplitude: { type: \"number\", label: \"Amplitude\", default: 40, min: 0, max: 120 }\n};\n\nexport function draw(ctx, { t, width, height, params }) {\n  ctx.strokeStyle = \"#e67845\";\n  ctx.lineWidth = 3;\n  ctx.beginPath();\n  for (let x = 0; x <= width; x += 2) {\n    const y = height / 2 + Math.sin(x / 40 - t / 800) * params.amplitude;\n    if (x === 0) ctx.moveTo(x, y);\n    else ctx.lineTo(x, y);\n  }\n  ctx.stroke();\n}\n";
+//#endregion
+export { BOARD_SCRIPT_DRAWING_EXAMPLE };

package/dist/board/model/script-example.js

@@ -0,0 +1,21 @@
+//#region src/board/model/script-example.ts
+const BOARD_SCRIPT_DRAWING_EXAMPLE = `export const animated = true;
+
+export const parameters = {
+  amplitude: { type: "number", label: "Amplitude", default: 40, min: 0, max: 120 }
+};
+
+export function draw(ctx, { t, width, height, params }) {
+  ctx.strokeStyle = "#e67845";
+  ctx.lineWidth = 3;
+  ctx.beginPath();
+  for (let x = 0; x <= width; x += 2) {
+    const y = height / 2 + Math.sin(x / 40 - t / 800) * params.amplitude;
+    if (x === 0) ctx.moveTo(x, y);
+    else ctx.lineTo(x, y);
+  }
+  ctx.stroke();
+}
+`;
+//#endregion
+export { BOARD_SCRIPT_DRAWING_EXAMPLE };

package/dist/board/model/script-hit.d.ts

@@ -0,0 +1,10 @@
+import { BoardScriptOutput } from "./script.js";
+import { WorldPoint } from "./geometry.js";
+import { BoardScene, BoardSceneItem } from "./scene.js";
+//#region src/board/model/script-hit.d.ts
+declare function boardScriptTarget(scene: BoardScene, candidates: readonly string[], point: WorldPoint, outputs: ReadonlyMap<string, BoardScriptOutput>, hitTest: (item: BoardSceneItem, point: WorldPoint) => boolean): {
+  owner: string;
+  target: string;
+} | null;
+//#endregion
+export { boardScriptTarget };

package/dist/board/model/script-hit.js

@@ -0,0 +1,52 @@
+import { applyMatrix, invertMatrix } from "../../protocol/dist/board-layout.js";
+import { frameContainsPoint } from "./geometry.js";
+import { scriptTemporaryPrefix } from "./script-scene.js";
+//#region src/board/model/script-hit.ts
+function boardScriptTarget(scene, candidates, point, outputs, hitTest) {
+	const owners = new Map([...outputs.keys()].map((id) => [scriptTemporaryPrefix(id), id]));
+	for (const id of [...candidates].sort((a, b) => scene.indexOf(b) - scene.indexOf(a))) {
+		const item = scene.get(id);
+		if (!item || scene.opacity(id) <= 0 || id.endsWith("root") && owners.has(id.slice(0, -4))) continue;
+		let parent = item.parent;
+		let clipped = false;
+		for (let depth = 0; parent && depth < 64; depth++) {
+			const ancestor = scene.get(parent);
+			if (!ancestor) break;
+			if (ancestor.type === "frame" && ancestor.props.clip && !frameContainsPoint(ancestor.frame, point)) {
+				clipped = true;
+				break;
+			}
+			parent = ancestor.parent;
+		}
+		if (clipped) continue;
+		const output = outputs.get(id);
+		if (output) {
+			const local = applyMatrix(invertMatrix(scene.layout.matrix(id)), point);
+			for (const [target, region] of Object.entries(output.hits).reverse()) if (local.x >= region.x && local.y >= region.y && local.x <= region.x + region.width && local.y <= region.y + region.height) return {
+				owner: id,
+				target
+			};
+		}
+		if (!hitTest(item, point)) continue;
+		let current = item;
+		for (let depth = 0; current && depth < 64; depth++) {
+			if (outputs.has(current.id)) return {
+				owner: current.id,
+				target: id
+			};
+			for (const [prefix, owner] of owners) {
+				if (current.id === `${prefix}root`) break;
+				if (current.id.startsWith(prefix)) return {
+					owner,
+					target: current.id.slice(prefix.length)
+				};
+			}
+			current = current.parent ? scene.get(current.parent) : void 0;
+		}
+		if (item.type === "frame" && item.props.decoration === "none") continue;
+		return null;
+	}
+	return null;
+}
+//#endregion
+export { boardScriptTarget };

package/dist/board/model/script-index.d.ts

@@ -0,0 +1,7 @@
+import { BoardDocument, BoardItem } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+//#region src/board/model/script-index.d.ts
+declare function boardScriptItems(document: Pick<BoardDocument, "items">): readonly (readonly [string, BoardItem])[];
+declare function hasBoardScripts(document: Pick<BoardDocument, "items">): boolean;
+//#endregion
+export { boardScriptItems, hasBoardScripts };

package/dist/board/model/script-index.js

@@ -0,0 +1,15 @@
+//#region src/board/model/script-index.ts
+const scriptsByItems = /* @__PURE__ */ new WeakMap();
+function boardScriptItems(document) {
+	let scripts = scriptsByItems.get(document.items);
+	if (!scripts) {
+		scripts = Object.entries(document.items).filter(([, item]) => item.script?.enabled);
+		scriptsByItems.set(document.items, scripts);
+	}
+	return scripts;
+}
+function hasBoardScripts(document) {
+	return boardScriptItems(document).length > 0;
+}
+//#endregion
+export { boardScriptItems, hasBoardScripts };

package/dist/board/model/script-scene.d.ts

@@ -0,0 +1,24 @@
+import { BoardDocument, BoardItem, BoardPatch } from "../../protocol/dist/board-model.js";
+import { BoardScriptOutput } from "./script.js";
+import { BoardScene } from "./scene.js";
+//#region src/board/model/script-scene.d.ts
+declare function boardScriptScope(document: Pick<BoardDocument, "items">, id: string): Set<string>;
+declare function validateBoardScriptOutput(output: BoardScriptOutput, scope: ReadonlySet<string>): void;
+declare function validateBoardScriptCommit(document: BoardDocument, id: string, patch: BoardPatch): void;
+declare function scriptTemporaryPrefix(owner: string): string;
+type PreparedOutput = {
+  document: BoardDocument;
+  owner: string;
+  rootId: string;
+  items: Map<string, BoardItem>;
+  presented: Map<string, {
+    base: BoardItem;
+    item: BoardItem;
+  }>;
+};
+declare function prepareBoardScriptOutput(document: BoardDocument, owner: string, output: BoardScriptOutput): PreparedOutput;
+declare function composeBoardScriptItems(document: BoardDocument, scene: BoardScene, outputs: ReadonlyMap<string, BoardScriptOutput>, incoming?: ReadonlyMap<string, BoardItem>, screen?: {
+  zoom: number;
+}, onError?: (owner: string, error: unknown) => void): Map<string, BoardItem>;
+//#endregion
+export { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput };

package/dist/board/model/script-scene.js

@@ -0,0 +1,267 @@
+import { parseBoardItem as parseBoardItem$1 } from "../../protocol/dist/board-model.js";
+import { applyMatrix, createBoardLayout } from "../../protocol/dist/board-layout.js";
+import { applyBoardPatchToDocument, mergePatch } from "../../protocol/dist/board-patch.js";
+//#region src/board/model/script-scene.ts
+function parseBoardItem(value) {
+	const parsed = parseBoardItem$1(value);
+	if (!parsed.ok) throw new Error(parsed.diagnostics[0]?.message ?? "Invalid script item.");
+	return parsed.item;
+}
+const DISPLAY_FIELDS = /* @__PURE__ */ new Set([
+	"position",
+	"size",
+	"rotation",
+	"scale",
+	"opacity",
+	"style",
+	"props"
+]);
+function boardScriptScope(document, id) {
+	const scope = /* @__PURE__ */ new Set([id, ...Object.values(document.items[id]?.script?.targets ?? {}).filter((target) => Boolean(document.items[target]))]);
+	if (document.items[id]?.type !== "frame") return scope;
+	for (const candidate of Object.keys(document.items)) {
+		let parent = document.items[candidate]?.parent;
+		for (let depth = 0; parent && depth < 64; depth++) {
+			if (parent === id) {
+				scope.add(candidate);
+				break;
+			}
+			parent = document.items[parent]?.parent;
+		}
+	}
+	return scope;
+}
+function validateBoardScriptOutput(output, scope) {
+	if (!output || typeof output !== "object" || !output.patches || !output.items || !output.hits || !Array.isArray(output.listens)) throw new Error("Invalid script output.");
+	if (JSON.stringify(output).length > 1e6) throw new Error("Script output exceeds the 1 MB limit.");
+	if (output.space !== void 0 && output.space !== "world" && output.space !== "screen") throw new Error("Invalid script scene space.");
+	if (output.parameters) {
+		if (Object.keys(output.parameters).length > 64) throw new Error("A script may declare at most 64 parameters.");
+		for (const spec of Object.values(output.parameters)) {
+			if (!spec || ![
+				"number",
+				"boolean",
+				"string",
+				"color"
+			].includes(spec.type)) throw new Error("Invalid script parameter type.");
+			if (spec.label !== void 0 && typeof spec.label !== "string") throw new Error("Invalid script parameter label.");
+			if ([
+				spec.min,
+				spec.max,
+				spec.step
+			].some((value) => value !== void 0 && !Number.isFinite(value))) throw new Error("Invalid script parameter range.");
+		}
+	}
+	if (Object.keys(output.items).length > 1e3 || Object.keys(output.hits).length > 1e3) throw new Error("A script may create at most 1000 temporary items or hit regions.");
+	for (const [id, patch] of Object.entries(output.patches)) {
+		if (!scope.has(id)) throw new Error(`Item is outside the script scope: ${id}`);
+		if (!patch || typeof patch !== "object" || Object.keys(patch).some((key) => !DISPLAY_FIELDS.has(key))) throw new Error("Scripts may only present display properties.");
+	}
+	for (const hit of Object.values(output.hits)) {
+		if (hit.cursor && ![
+			"default",
+			"pointer",
+			"grab",
+			"grabbing",
+			"crosshair",
+			"text",
+			"move",
+			"ew-resize",
+			"ns-resize",
+			"not-allowed"
+		].includes(hit.cursor)) throw new Error("Invalid script cursor.");
+		if (![
+			hit.x,
+			hit.y,
+			hit.width,
+			hit.height
+		].every(Number.isFinite) || hit.width < 0 || hit.height < 0) throw new Error("Invalid script hit region.");
+	}
+}
+function validateBoardScriptCommit(document, id, patch) {
+	if (!patch || typeof patch !== "object" || Object.keys(patch).some((key) => key !== "items")) throw new Error("Scripts may only commit items in their scope.");
+	const scope = boardScriptScope(document, id);
+	for (const [target, value] of Object.entries(patch.items ?? {})) {
+		if (!scope.has(target)) {
+			if (document.items[target]) throw new Error(`Item is outside the script scope: ${target}`);
+			if (!value || typeof value !== "object" || !("parent" in value) || typeof value.parent !== "string" || !scope.has(value.parent) || document.items[value.parent]?.type !== "frame") throw new Error("New items must belong to a frame in the script scope.");
+			if ("script" in value) throw new Error("Scripts cannot start other scripts.");
+			continue;
+		}
+		if (value && typeof value === "object" && ("script" in value || "parent" in value || "type" in value)) throw new Error("A script cannot replace scripts, types, or parent relationships.");
+	}
+	const result = applyBoardPatchToDocument(document, patch);
+	if (!result.ok) throw new Error(result.diagnostics[0]?.message ?? "Invalid script commit.");
+}
+function scriptTemporaryPrefix(owner) {
+	let hash = 2166136261;
+	for (const char of owner) hash = Math.imul(hash ^ char.charCodeAt(0), 16777619) >>> 0;
+	return `~script-${hash.toString(36)}-`;
+}
+const preparedOutputs = /* @__PURE__ */ new WeakMap();
+const preparedScopes = /* @__PURE__ */ new WeakMap();
+function prepareBoardScriptOutput(document, owner, output) {
+	const previous = preparedOutputs.get(output);
+	if (previous?.document === document && previous.owner === owner) return previous;
+	let scopes = preparedScopes.get(document);
+	if (!scopes) {
+		scopes = /* @__PURE__ */ new Map();
+		preparedScopes.set(document, scopes);
+	}
+	let scope = scopes.get(owner);
+	if (!scope) {
+		scope = boardScriptScope(document, owner);
+		scopes.set(owner, scope);
+	}
+	validateBoardScriptOutput(output, scope);
+	const presented = /* @__PURE__ */ new Map();
+	for (const [id, patch] of Object.entries(output.patches)) {
+		const base = document.items[id];
+		if (base) presented.set(id, {
+			base,
+			item: parseBoardItem(mergePatch(base, patch))
+		});
+	}
+	const prefix = scriptTemporaryPrefix(owner);
+	const rootId = `${prefix}root`;
+	if (document.items[rootId]) throw new Error("Temporary item ID conflicts with the document.");
+	const items = /* @__PURE__ */ new Map();
+	const parsed = new Map(Object.entries(output.items).map(([id, value]) => [id, parseBoardItem(value)]));
+	for (const [local, value] of parsed) {
+		if (!/^[a-zA-Z0-9_-]{1,80}$/.test(local) || local === "root") throw new Error("Temporary IDs must be 1–80 letters, digits, underscores or hyphens; root is reserved.");
+		if (value.script) throw new Error("Temporary items cannot start scripts.");
+		if (value.parent && !(value.parent in output.items)) throw new Error("Temporary parents must belong to the same instance.");
+		let cursor = value.parent;
+		const visited = /* @__PURE__ */ new Set([local]);
+		while (cursor) {
+			if (visited.has(cursor)) throw new Error("Temporary parents must not form a cycle.");
+			visited.add(cursor);
+			const parentItem = parsed.get(cursor);
+			if (!parentItem) throw new Error("Temporary parent is missing.");
+			if (parentItem.type !== "frame") throw new Error("Only frames can contain temporary items.");
+			cursor = parentItem.parent;
+		}
+		const id = `${prefix}${local}`;
+		if (document.items[id]) throw new Error("Temporary item ID conflicts with the document.");
+		const parent = value.parent ? `${prefix}${value.parent}` : rootId;
+		if (value.type === "arrow") {
+			const remap = (endpoint) => {
+				if (!("item" in endpoint)) return endpoint;
+				if (!(endpoint.item in output.items) && !scope.has(endpoint.item)) throw new Error("Arrow target is outside the script scope.");
+				return endpoint.item in output.items ? {
+					...endpoint,
+					item: `${prefix}${endpoint.item}`
+				} : endpoint;
+			};
+			items.set(id, {
+				...value,
+				parent,
+				props: {
+					...value.props,
+					start: remap(value.props.start),
+					end: remap(value.props.end)
+				}
+			});
+		} else items.set(id, {
+			...value,
+			parent
+		});
+	}
+	const prepared = {
+		document,
+		owner,
+		rootId,
+		items,
+		presented
+	};
+	preparedOutputs.set(output, prepared);
+	return prepared;
+}
+function composeBoardScriptItems(document, scene, outputs, incoming = /* @__PURE__ */ new Map(), screen, onError) {
+	const result = new Map(incoming);
+	const screenAnchors = /* @__PURE__ */ new Map();
+	if (outputs.size === 0) return result;
+	for (const owner of Object.keys(document.items)) {
+		const output = outputs.get(owner);
+		if (!output) continue;
+		try {
+			const changes = /* @__PURE__ */ new Map();
+			const prepared = prepareBoardScriptOutput(document, owner, output);
+			for (const [id, patch] of Object.entries(output.patches)) {
+				const base = result.get(id) ?? document.items[id];
+				if (!base) continue;
+				let cached = prepared.presented.get(id);
+				if (cached?.base !== base) {
+					cached = {
+						base,
+						item: parseBoardItem(mergePatch(base, patch))
+					};
+					prepared.presented.set(id, cached);
+				}
+				changes.set(id, cached.item);
+			}
+			if (!prepared.items.size || output.space === "screen" && !screen) {
+				for (const [id, item] of changes) result.set(id, item);
+				continue;
+			}
+			const rootId = prepared.rootId;
+			const item = changes.get(owner) ?? result.get(owner) ?? document.items[owner];
+			if (!item) continue;
+			const box = scene.layout.box(owner);
+			const overlay = output.space === "screen" && screen ? {
+				parent: void 0,
+				position: {
+					x: 0,
+					y: 0
+				},
+				scale: 1 / screen.zoom,
+				rotation: 0,
+				origin: {
+					x: 0,
+					y: 0
+				}
+			} : {};
+			changes.set(rootId, parseBoardItem({
+				type: "frame",
+				parent: item.parent,
+				position: item.position,
+				rotation: item.rotation,
+				scale: item.scale,
+				origin: item.origin,
+				opacity: item.opacity,
+				size: {
+					width: Math.max(1, box.width),
+					height: Math.max(1, box.height)
+				},
+				z: (item.z ?? 0) + .001,
+				props: {
+					decoration: "none",
+					clip: false
+				},
+				...overlay
+			}));
+			for (const [id, value] of prepared.items) changes.set(id, value);
+			for (const [id, item] of changes) result.set(id, item);
+			if (output.space === "screen") screenAnchors.set(owner, rootId);
+		} catch (error) {
+			if (!onError) throw error;
+			onError(owner, error);
+		}
+	}
+	if (screenAnchors.size) {
+		const layout = createBoardLayout((id) => result.get(id) ?? document.items[id]);
+		for (const [owner, rootId] of screenAnchors) {
+			const root = result.get(rootId);
+			if (root) result.set(rootId, {
+				...root,
+				position: applyMatrix(layout.matrix(owner), {
+					x: 0,
+					y: 0
+				})
+			});
+		}
+	}
+	return result;
+}
+//#endregion
+export { boardScriptScope, composeBoardScriptItems, prepareBoardScriptOutput, scriptTemporaryPrefix, validateBoardScriptCommit, validateBoardScriptOutput };

package/dist/board/model/script.d.ts

@@ -0,0 +1,105 @@
+import { BoardItem, BoardPatch, BoardScript, BoardVec2 } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+//#region src/board/model/script.d.ts
+type BoardScriptEvent = {
+  type: string;
+  target?: string;
+  relatedTarget?: string;
+  relatedOwner?: string;
+  point?: BoardVec2;
+  pointerId?: number;
+  pointerType?: string;
+  buttons?: number;
+  key?: string;
+  shiftKey?: boolean;
+  altKey?: boolean;
+  ctrlKey?: boolean;
+  metaKey?: boolean;
+  data?: unknown;
+};
+type BoardScriptFrame = {
+  t: number;
+  dt: number;
+  width: number;
+  height: number;
+  seed: string;
+  params: BoardScript["params"];
+  state: Record<string, unknown>;
+};
+type BoardScriptItemPatch = Partial<Pick<BoardItem, "position" | "scale" | "rotation" | "opacity" | "style">> & {
+  size?: {
+    width?: number;
+    height?: number;
+  };
+  props?: Record<string, unknown>;
+};
+type BoardScriptHit = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  label?: string;
+  cursor?: string;
+};
+type BoardScriptSnapshot = {
+  state: Record<string, unknown>;
+  time: number;
+  random: number;
+  configuration?: string;
+  effects?: Pick<BoardScriptOutput, "patches" | "items" | "hits" | "space">;
+};
+type BoardScriptParameter = {
+  type: "number" | "boolean" | "string" | "color";
+  label?: string;
+  default?: string | number | boolean;
+  min?: number;
+  max?: number;
+  step?: number;
+};
+type BoardScriptOutput = {
+  parameters?: Record<string, BoardScriptParameter>;
+  space?: "world" | "screen";
+  patches: Record<string, Record<string, unknown>>;
+  items: Record<string, unknown>;
+  hits: Record<string, BoardScriptHit>;
+  listens: string[];
+  animated: boolean;
+  updating?: boolean;
+  version: number;
+};
+type BoardScriptContext = {
+  readonly self: {
+    readonly id: string;
+    readonly base: BoardItem;
+    present(patch: BoardScriptItemPatch | null): void;
+  };
+  readonly params: BoardScript["params"];
+  readonly targets: Readonly<Record<string, string>>;
+  emit(target: string, type: string, data?: unknown): Promise<void>;
+  readonly state: Record<string, unknown>;
+  readonly frame: BoardScriptFrame;
+  random(): number;
+  on(type: string, handler: (event: BoardScriptEvent) => void): () => void;
+  onFrame(handler: (frame: BoardScriptFrame) => void): () => void;
+  onDispose(handler: () => void): void;
+  invalidate(): void;
+  get(id: string): BoardItem | undefined;
+  present(id: string, patch: BoardScriptItemPatch | null): void;
+  scene(items: Record<string, unknown>, options?: {
+    space?: "world" | "screen";
+  }): void;
+  hitRegions(hits: Record<string, BoardScriptHit>): void;
+  commit(patch: BoardPatch): Promise<void>;
+  capabilities: {
+    has(name: string): boolean;
+    call(name: string, input?: unknown): Promise<unknown>;
+  };
+};
+type BoardScriptModule = {
+  parameters?: Record<string, BoardScriptParameter>;
+  default?: ((context: BoardScriptContext) => void) | ((context: BoardScriptContext) => () => void);
+  draw?: (context: CanvasRenderingContext2D, frame: BoardScriptFrame) => void;
+  animated?: boolean;
+};
+//#endregion
+export { BoardScriptContext, BoardScriptEvent, BoardScriptFrame, BoardScriptHit, BoardScriptItemPatch, BoardScriptModule, BoardScriptOutput, BoardScriptParameter, BoardScriptSnapshot };

package/dist/board/model/script.js

@@ -0,0 +1 @@
+export {};

package/dist/board/render/css-color.d.ts

@@ -1,4 +1,9 @@
 //#region src/board/render/css-color.d.ts
+type BoardCssPaint = {
+  color: number;
+  alpha: number;
+};
+declare function parseBoardCssPaint(value: string): BoardCssPaint | null;
 declare function parseBoardCssColor(value: string): number | null;
 //#endregion
-export { parseBoardCssColor };
+export { BoardCssPaint, parseBoardCssColor, parseBoardCssPaint };