@neta-art/cohub 10.0.0 → 11.1.0

package/dist/board/render/renderers/video-card-renderer.js

@@ -1,4 +1,5 @@
 import { BOARD_FONT_STACK } from "../../../protocol/dist/board-constants.js";
+import { getMediaResourceTitle } from "../../model/media.js";
 import { syncTextResolution, syncTextWrapWidth, textResolutionForZoom } from "../text-resolution.js";
 import { positionShell } from "./base-card-renderer.js";
 import { drawFarPlate } from "./far-plate.js";
@@ -23,7 +24,7 @@ function sync(container, item, context) {
 	const selected = context.selectedIds.has(item.id);
 	const hovered = context.hoveredId === item.id;
 	const resizing = context.resizingIds.has(item.id);
-	const title = item.props.snapshot?.title ?? item.props.src.split("/").pop() ?? "Video";
+	const title = item.props.snapshot?.title ?? getMediaResourceTitle(item.props.src);
 	const key = context.assetKey(item);
 	const texture = key ? context.getTexture(key) : null;
 	const failed = Boolean(key && !texture && context.hasError(key));

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

@@ -0,0 +1,22 @@
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import { BoardFrame } from "../../protocol/dist/board-layout.js";
+import "../../protocol/dist/index.js";
+import { BoardScene } from "../model/scene.js";
+import { BoardEvaluation } from "../model/animation.js";
+import { BoardShapeColors } from "../model/palette.js";
+import { BoardRenderPalette } from "./renderers/board-renderer-registry.js";
+//#region src/board/render/sampling.d.ts
+declare function createBoardRenderSampler(document: BoardDocument, animation: string | null, options?: {
+  colorScheme?: "dark" | "light";
+  colors?: BoardShapeColors;
+  palette?: Partial<BoardRenderPalette>;
+}): {
+  frameAt(id: string, time: number): BoardFrame | undefined;
+  at(time: number): {
+    document: BoardDocument;
+    evaluation: BoardEvaluation;
+    scene: BoardScene;
+  };
+};
+//#endregion
+export { createBoardRenderSampler };

package/dist/board/render/sampling.js

@@ -0,0 +1,21 @@
+import { createBoardAnimationSampler } from "../model/sampling.js";
+import { buildFallbackShapeColors } from "../model/palette.js";
+import { defaultBoardPalette, itemAlpha, itemColor } from "./palette.js";
+//#region src/board/render/sampling.ts
+function createBoardRenderSampler(document, animation, options = {}) {
+	const colorScheme = options.colorScheme ?? "dark";
+	const context = {
+		colorScheme,
+		colors: options.colors ?? buildFallbackShapeColors(colorScheme),
+		palette: {
+			...defaultBoardPalette(colorScheme),
+			...options.palette
+		}
+	};
+	return createBoardAnimationSampler(document, animation, { resolveColor: (color) => ({
+		color: itemColor(context, color, "brand", "fill"),
+		alpha: itemAlpha(context, color)
+	}) });
+}
+//#endregion
+export { createBoardRenderSampler };

package/dist/board/render/script-export.d.ts

@@ -0,0 +1,11 @@
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { BoardScriptSnapshot } from "../model/script.js";
+import { BoardScriptHost } from "./renderers/board-renderer-registry.js";
+//#region src/board/render/script-export.d.ts
+declare function prepareBrowserBoardScripts(document: BoardDocument, time: number, readModule: (path: string) => Promise<string>, snapshots?: Readonly<Record<string, BoardScriptSnapshot>>): Promise<{
+  host: BoardScriptHost;
+  dispose(): void;
+}>;
+//#endregion
+export { prepareBrowserBoardScripts };

package/dist/board/render/script-export.js

@@ -0,0 +1,86 @@
+import { composeBoardScriptItems } from "../model/script-scene.js";
+import { buildBoardScene } from "../model/scene.js";
+import { createBoardScriptHost } from "./script-host.js";
+//#region src/board/render/script-export.ts
+async function prepareBrowserBoardScripts(document, time, readModule, snapshots) {
+	if (!Number.isFinite(time) || time < 0 || time > 6e5) throw new Error("Script export time must be between 0 and 600000 ms.");
+	const element = globalThis.document.createElement("div");
+	element.style.cssText = "position:fixed;left:-10000px;top:0;width:1px;height:1px;visibility:hidden;pointer-events:none";
+	globalThis.document.body.appendChild(element);
+	const outputs = /* @__PURE__ */ new Map();
+	const scene = buildBoardScene(document);
+	const ids = Object.entries(document.items).filter(([, item]) => item.script?.enabled).map(([id]) => id);
+	let schedule = () => {};
+	const host = createBoardScriptHost({
+		host: element,
+		readModule,
+		export: true,
+		snapshots,
+		timeoutMs: 15e3,
+		onFrame: () => schedule(),
+		onOutput(id, output) {
+			if (output) outputs.set(id, output);
+			else outputs.delete(id);
+		}
+	});
+	const dispose = () => {
+		schedule = () => {};
+		host.destroy();
+		element.remove();
+	};
+	try {
+		await new Promise((resolve, reject) => {
+			const timer = setTimeout(() => reject(/* @__PURE__ */ new Error("Script export preparation timed out.")), 2e4);
+			let queued = false;
+			const sync = () => {
+				queued = false;
+				try {
+					host.sync(document, scene, {
+						x: 0,
+						y: 0,
+						zoom: 1
+					}, time, false);
+					for (const id of ids) {
+						const error = host.error(id);
+						if (error) throw new Error(error);
+					}
+					if (ids.every((id) => host.ready?.(id))) {
+						clearTimeout(timer);
+						schedule = () => {};
+						resolve();
+					}
+				} catch (error) {
+					clearTimeout(timer);
+					schedule = () => {};
+					reject(error);
+				}
+			};
+			schedule = () => {
+				if (!queued) {
+					queued = true;
+					queueMicrotask(sync);
+				}
+			};
+			schedule();
+		});
+		return {
+			host: {
+				...host,
+				document(input) {
+					const items = { ...input.items };
+					for (const [id, item] of composeBoardScriptItems(input, buildBoardScene(input), outputs)) items[id] = item;
+					return {
+						...input,
+						items
+					};
+				}
+			},
+			dispose
+		};
+	} catch (error) {
+		dispose();
+		throw error;
+	}
+}
+//#endregion
+export { prepareBrowserBoardScripts };

package/dist/board/render/script-host.d.ts

@@ -0,0 +1,31 @@
+import { BoardDocument } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { BoardViewport } from "../model/geometry.js";
+import { BoardScriptEvent, BoardScriptOutput, BoardScriptSnapshot } from "../model/script.js";
+import { BoardScene } from "../model/scene.js";
+import { BoardScriptHost } from "./renderers/board-renderer-registry.js";
+//#region src/board/render/script-host.d.ts
+type BoardScriptHostOptions = {
+  readModule(path: string): Promise<string>;
+  host: HTMLElement;
+  onFrame(): void;
+  onOutput(id: string, output: BoardScriptOutput | null): void;
+  capabilities?: Record<string, (id: string, input: unknown) => Promise<unknown>>;
+  timeoutMs?: number;
+  export?: boolean;
+  snapshots?: Readonly<Record<string, BoardScriptSnapshot>>;
+};
+type BrowserBoardScriptHost = BoardScriptHost & {
+  sync(document: BoardDocument, scene: BoardScene, camera: BoardViewport, time: number, interactive: boolean, visibleIds?: ReadonlySet<string> | null): void;
+  event(id: string, event: BoardScriptEvent): void;
+  output(id: string): BoardScriptOutput | null;
+  snapshot(id: string): Promise<BoardScriptSnapshot | null>;
+  restore(id: string, snapshot: BoardScriptSnapshot): void;
+  fault(id: string, message: string): void;
+  readonly animated: boolean;
+  invalidate(src?: string): void;
+  destroy(): void;
+};
+declare function createBoardScriptHost(options: BoardScriptHostOptions): BrowserBoardScriptHost;
+//#endregion
+export { BoardScriptHostOptions, BrowserBoardScriptHost, createBoardScriptHost };

package/dist/board/render/script-host.js

@@ -0,0 +1,446 @@
+import { boardScriptItems } from "../model/script-index.js";
+import { boardScriptScope } from "../model/script-scene.js";
+import { boardScriptHitVisible, resolveBoardScriptHit } from "../model/script-hit.js";
+import { BoardScriptTexture } from "./script-texture.js";
+import { createBoardScriptModuleReader, loadBoardScriptSources } from "../../protocol/dist/board-script-modules.js";
+import { boardScriptFrameSource } from "./script-sandbox.js";
+//#region src/board/render/script-host.ts
+function createBoardScriptHost(options) {
+	const revisions = /* @__PURE__ */ new Map();
+	const entries = /* @__PURE__ */ new Map();
+	const restored = new Map(Object.entries(options.snapshots ?? {}));
+	const sources = /* @__PURE__ */ new Map();
+	const dependencies = /* @__PURE__ */ new Map();
+	const modules = createBoardScriptModuleReader(options.readModule);
+	const tokens = /* @__PURE__ */ new Map();
+	let nextToken = 0;
+	let brokerReady = false;
+	let broker = null;
+	const signatures = /* @__PURE__ */ new WeakMap();
+	function entrySignature(item) {
+		let value = signatures.get(item);
+		if (value === void 0) {
+			value = JSON.stringify(item.script);
+			signatures.set(item, value);
+		}
+		return value;
+	}
+	const focusTargets = /* @__PURE__ */ new Map();
+	const focusStyles = /* @__PURE__ */ new WeakMap();
+	const layer = document.createElement("div");
+	let interactive = false;
+	layer.style.cssText = "position:absolute;inset:0;pointer-events:none;overflow:hidden;z-index:2";
+	layer.dataset.boardScripts = "";
+	options.host.appendChild(layer);
+	let disposed = false;
+	const retiredTextures = /* @__PURE__ */ new Set();
+	let retirementFrame = 0;
+	function retireTexture(texture) {
+		if (!texture.current) return;
+		retiredTextures.add(texture);
+		if (retirementFrame) return;
+		retirementFrame = requestAnimationFrame(() => {
+			retirementFrame = requestAnimationFrame(() => {
+				retirementFrame = 0;
+				for (const retired of retiredTextures) retired.destroy();
+				retiredTextures.clear();
+			});
+		});
+	}
+	function ensureBroker() {
+		if (broker) return;
+		broker = document.createElement("iframe");
+		broker.setAttribute("sandbox", "allow-scripts");
+		broker.setAttribute("aria-hidden", "true");
+		broker.tabIndex = -1;
+		broker.style.cssText = "position:absolute;visibility:hidden;width:0;height:0;border:0";
+		broker.srcdoc = boardScriptFrameSource();
+		layer.appendChild(broker);
+	}
+	function removeFrame(entry) {
+		if (entry.capture) {
+			clearTimeout(entry.capture.timer);
+			entry.capture.reject(/* @__PURE__ */ new Error("Script stopped before its snapshot completed."));
+			entry.capture = void 0;
+		}
+		tokens.delete(entry.token);
+		broker?.contentWindow?.postMessage({
+			token: entry.token,
+			data: { kind: "terminate" }
+		}, "*");
+	}
+	function release(entry) {
+		clearTimeout(entry.timer);
+		if (entry.ready && !entry.error) {
+			post(entry, { kind: "dispose" });
+			entry.timer = setTimeout(() => removeFrame(entry), 100);
+		} else removeFrame(entry);
+		retireTexture(entry.texture);
+		entries.delete(entry.id);
+		revisions.set(entry.id, (revisions.get(entry.id) ?? 0) + 1);
+		options.onOutput(entry.id, null);
+	}
+	function fail(entry, error) {
+		clearTimeout(entry.timer);
+		entry.error = error;
+		revisions.set(entry.id, (revisions.get(entry.id) ?? 0) + 1);
+		entry.pending = false;
+		removeFrame(entry);
+		options.onOutput(entry.id, null);
+		options.onFrame();
+	}
+	function post(entry, data) {
+		broker?.contentWindow?.postMessage({
+			token: entry.token,
+			data
+		}, "*");
+	}
+	const onMessage = (event) => {
+		const data = event.data;
+		if (!data || typeof data !== "object") return;
+		const fromBroker = broker !== null && event.source === broker.contentWindow;
+		if (fromBroker && data.kind === "ready" && data.token === void 0) {
+			brokerReady = true;
+			for (const entry of tokens.values()) entry.ready = true;
+			options.onFrame();
+			return;
+		}
+		if (!fromBroker) return;
+		const entry = tokens.get(data.token);
+		if (!entry || entry.error) {
+			if (fromBroker || entry) data.bitmap?.close?.();
+			return;
+		}
+		if (data.kind === "disposed") {
+			clearTimeout(entry.timer);
+			removeFrame(entry);
+			return;
+		}
+		if (entries.get(entry.id) !== entry) {
+			data.bitmap?.close?.();
+			return;
+		}
+		if (data.kind === "ready") {
+			entry.ready = true;
+			options.onFrame();
+			return;
+		}
+		if (data.kind === "dirty") {
+			entry.dirty = true;
+			options.onFrame();
+			return;
+		}
+		if (data.kind === "call") {
+			const capability = typeof data.name === "string" && options.capabilities && Object.hasOwn(options.capabilities, data.name) ? options.capabilities[data.name] : void 0;
+			Promise.resolve().then(() => {
+				if (!capability) throw new Error(`Capability unavailable: ${data.name}`);
+				return capability(entry.id, data.input);
+			}).then((value) => post(entry, {
+				kind: "result",
+				call: data.call,
+				value
+			}), (error) => post(entry, {
+				kind: "result",
+				call: data.call,
+				error: error instanceof Error ? error.message : String(error)
+			}));
+			return;
+		}
+		if (data.kind === "snapshot") {
+			const capture = entry.capture;
+			if (!capture) return;
+			clearTimeout(capture.timer);
+			entry.capture = void 0;
+			if (data.error) capture.reject(new Error(String(data.error)));
+			else capture.resolve(data.snapshot ? {
+				...data.snapshot,
+				configuration: entry.signature
+			} : null);
+			return;
+		}
+		if (data.kind === "error") {
+			fail(entry, String(data.error));
+			return;
+		}
+		if (data.kind !== "frame" || data.request !== entry.request) {
+			data.bitmap?.close?.();
+			return;
+		}
+		clearTimeout(entry.timer);
+		entry.pending = false;
+		revisions.set(entry.id, (revisions.get(entry.id) ?? 0) + 1);
+		if (data.bitmap) entry.texture.update(data.bitmap);
+		try {
+			const output = data.output;
+			if (output) {
+				options.onOutput(entry.id, output);
+				entry.output = output;
+			}
+		} catch (error) {
+			fail(entry, error instanceof Error ? error.message : String(error));
+			return;
+		}
+		options.onFrame();
+	};
+	window.addEventListener("message", onMessage);
+	return {
+		revision: (id) => revisions.get(id) ?? 0,
+		ready: (id) => entries.get(id)?.output !== null && entries.get(id)?.output !== void 0,
+		frame: (item) => entries.get(item.id)?.texture.current ?? null,
+		error: (id) => entries.get(id)?.error ?? null,
+		release: () => {},
+		fault(id, message) {
+			const entry = entries.get(id);
+			if (entry) fail(entry, message);
+		},
+		snapshot(id) {
+			const entry = entries.get(id);
+			if (!entry?.output || entry.error) return Promise.resolve(null);
+			if (entry.capture) return entry.capture.promise;
+			let resolve = () => {};
+			let reject = () => {};
+			const promise = new Promise((yes, no) => {
+				resolve = yes;
+				reject = no;
+			});
+			const timer = setTimeout(() => {
+				entry.capture = void 0;
+				reject(/* @__PURE__ */ new Error("Script snapshot timed out."));
+			}, options.timeoutMs ?? 2e3);
+			entry.capture = {
+				promise,
+				resolve,
+				reject,
+				timer
+			};
+			post(entry, {
+				kind: "snapshot",
+				events: entry.events.splice(0)
+			});
+			return promise;
+		},
+		restore(id, snapshot) {
+			const entry = entries.get(id);
+			if (entry && snapshot.configuration && snapshot.configuration !== entry.signature) throw new Error("Snapshot configuration does not match the script.");
+			if (!Number.isFinite(snapshot.time) || snapshot.time < 0 || !Number.isInteger(snapshot.random)) throw new Error("Invalid script snapshot.");
+			restored.set(id, structuredClone(snapshot));
+			if (entry) release(entry);
+			options.onFrame();
+		},
+		output: (id) => entries.get(id)?.output ?? null,
+		get animated() {
+			return [...entries.values()].some((entry) => !entry.error && entry.output?.animated && (entry.visible || entry.output.updating) && !entry.pending);
+		},
+		sync(board, scene, camera, time, inputEnabled, visibleIds) {
+			if (disposed) return;
+			interactive = inputEnabled;
+			const alive = /* @__PURE__ */ new Set();
+			const liveFocusTargets = /* @__PURE__ */ new Set();
+			let focusSurface;
+			for (const [id, item] of boardScriptItems(board)) {
+				if (!item.script?.enabled) continue;
+				alive.add(id);
+				const signature = entrySignature(item);
+				let entry = entries.get(id);
+				if (entry && entry.signature !== signature) {
+					release(entry);
+					entry = void 0;
+				}
+				const box = scene.layout.box(id);
+				const scoped = entry?.inputDocument === board ? entry.input.items : { [id]: item };
+				if (entry?.inputDocument !== board) for (const child of boardScriptScope(board, id)) {
+					const value = board.items[child];
+					if (value) scoped[child] = value;
+				}
+				const input = entry?.inputDocument === board && entry.input.width === box.width && entry.input.height === box.height ? entry.input : {
+					id,
+					item,
+					items: scoped,
+					width: box.width,
+					height: box.height,
+					capabilities: Object.keys(options.capabilities ?? {}),
+					snapshot: restored.get(id)
+				};
+				if (!entry) {
+					ensureBroker();
+					entry = {
+						id,
+						signature,
+						token: ++nextToken,
+						ready: brokerReady,
+						sources: null,
+						input,
+						inputKey: "",
+						inputDocument: null,
+						startedAt: (options.export ? 0 : time) - (input.snapshot?.time ?? 0),
+						texture: new BoardScriptTexture(),
+						error: null,
+						output: null,
+						events: [],
+						dirty: true,
+						request: 0,
+						pending: false,
+						time: -1,
+						sentSources: false,
+						visible: true
+					};
+					entries.set(id, entry);
+					restored.delete(id);
+					tokens.set(entry.token, entry);
+					const current = entry;
+					let loading = sources.get(item.script.src);
+					if (!loading) {
+						const paths = /* @__PURE__ */ new Set([item.script.src]);
+						dependencies.set(item.script.src, paths);
+						loading = loadBoardScriptSources(item.script.src, (path) => {
+							paths.add(path);
+							return modules.read(path);
+						});
+						sources.set(item.script.src, loading);
+					}
+					current.timer = setTimeout(() => fail(current, "Script loading timed out."), 15e3);
+					loading.then((value) => {
+						if (disposed || entries.get(id) !== current) return;
+						current.sources = value;
+						options.onFrame();
+					}, (error) => {
+						if (!disposed && entries.get(id) === current) fail(current, String(error));
+					});
+				}
+				if (entry.error) continue;
+				const visible = !visibleIds || visibleIds.has(id);
+				if (entry.visible !== visible) {
+					entry.visible = visible;
+					if (visible) entry.dirty = true;
+				}
+				if (entry.input !== input || entry.inputDocument !== board) {
+					const inputKey = JSON.stringify(input);
+					if (entry.inputKey !== inputKey) {
+						entry.inputKey = inputKey;
+						entry.input = input;
+						entry.dirty = true;
+					}
+					entry.inputDocument = board;
+				}
+				if (entry.output && !options.export) {
+					const hits = Object.entries(entry.output.hits).filter(([, hit]) => hit.label);
+					for (const [target, hit] of hits) {
+						const resolved = resolveBoardScriptHit(scene, id, hit);
+						if (!resolved) continue;
+						const { rect } = resolved;
+						if (interactive) focusSurface ??= {
+							width: options.host.clientWidth,
+							height: options.host.clientHeight
+						};
+						const focusable = Boolean(focusSurface && interactive && boardScriptHitVisible(scene, resolved, camera, focusSurface));
+						const key = `${id}/${target}`;
+						liveFocusTargets.add(key);
+						let button = focusTargets.get(key);
+						if (!button) {
+							button = document.createElement("button");
+							button.type = "button";
+							const emit = (type, key) => {
+								const current = entries.get(id);
+								if (!interactive || !current || current.error || !current.output?.listens.includes(type)) return;
+								current.events.push({
+									type,
+									target,
+									key
+								});
+								current.dirty = true;
+								options.onFrame();
+							};
+							button.onfocus = () => emit("focus");
+							button.onblur = () => emit("blur");
+							button.onclick = () => emit("click");
+							button.onkeydown = (event) => emit("keydown", event.key);
+							button.onkeyup = (event) => emit("keyup", event.key);
+							focusTargets.set(key, button);
+							layer.appendChild(button);
+						}
+						const label = hit.label ?? target;
+						if (button.getAttribute("aria-label") !== label) button.setAttribute("aria-label", label);
+						const tabIndex = focusable ? 0 : -1;
+						if (button.tabIndex !== tabIndex) button.tabIndex = tabIndex;
+						const [a, b, c, d, x, y] = scene.layout.matrix(resolved.id);
+						const style = `position:absolute;pointer-events:none;background:transparent;border:0;padding:0;transform-origin:0 0;width:${rect.width}px;height:${rect.height}px;transform:matrix(${a * camera.zoom},${b * camera.zoom},${c * camera.zoom},${d * camera.zoom},${(x + a * rect.x + c * rect.y) * camera.zoom + camera.x},${(y + b * rect.x + d * rect.y) * camera.zoom + camera.y})`;
+						if (focusStyles.get(button) !== style) {
+							button.style.cssText = style;
+							focusStyles.set(button, style);
+						}
+					}
+				}
+				if (!entry.ready || !entry.sources || entry.pending || !entry.dirty && (!entry.output?.animated || !visible && !entry.output.updating || entry.time === time)) continue;
+				entry.pending = true;
+				entry.dirty = false;
+				entry.time = time;
+				entry.request++;
+				const current = entry;
+				clearTimeout(entry.timer);
+				entry.timer = setTimeout(() => fail(current, "Script execution timed out."), options.timeoutMs ?? 2e3);
+				post(entry, {
+					request: entry.request,
+					input: entry.sentInput === entry.input ? void 0 : entry.input,
+					sources: entry.sentSources ? void 0 : entry.sources,
+					draw: visible,
+					t: time - entry.startedAt,
+					scale: Math.min(2, 2048 / Math.max(1, box.width, box.height)),
+					events: entry.events.splice(0)
+				});
+				entry.sentInput = entry.input;
+				entry.sentSources = true;
+			}
+			for (const [key, button] of focusTargets) if (!liveFocusTargets.has(key)) {
+				button.remove();
+				focusTargets.delete(key);
+			}
+			for (const entry of entries.values()) if (!alive.has(entry.id)) release(entry);
+		},
+		event(id, event) {
+			const entry = entries.get(id);
+			if (!entry || entry.error || entry.output && !entry.output.listens.includes(event.type)) return;
+			if (event.type === "viewchange" || event.type === "selectionchange") {
+				const queued = entry.events.findIndex((pending) => pending.type === event.type);
+				if (queued >= 0) entry.events.splice(queued, 1);
+			}
+			if (event.type === "pointermove" && entry.events.at(-1)?.type === "pointermove") entry.events.pop();
+			if (entry.events.length >= 128) return;
+			entry.events.push(event);
+			entry.dirty = true;
+			options.onFrame();
+		},
+		invalidate(path) {
+			modules.invalidate(path);
+			const affected = new Set([...sources.keys()].filter((src) => !path || src === path || dependencies.get(src)?.has(path)));
+			for (const src of affected) {
+				sources.delete(src);
+				dependencies.delete(src);
+			}
+			let changed = false;
+			for (const entry of entries.values()) {
+				if (path && !affected.has(entry.input.item.script?.src ?? "")) continue;
+				restored.delete(entry.id);
+				release(entry);
+				changed = true;
+			}
+			if (!path) restored.clear();
+			if (changed) options.onFrame();
+		},
+		destroy() {
+			disposed = true;
+			window.removeEventListener("message", onMessage);
+			for (const entry of entries.values()) release(entry);
+			layer.remove();
+			sources.clear();
+			dependencies.clear();
+			modules.destroy();
+			focusTargets.clear();
+			restored.clear();
+			tokens.clear();
+			revisions.clear();
+			broker = null;
+		}
+	};
+}
+//#endregion
+export { createBoardScriptHost };

package/dist/board/render/script-modules.d.ts

@@ -0,0 +1,2 @@
+import { BOARD_SCRIPT_MAX_BYTES, BoardScriptSource, BoardScriptSources, createBoardScriptModuleReader, loadBoardScriptSources, resolveScriptImport, scriptModuleUrls } from "../../protocol/dist/board-script-modules.js";
+export { BOARD_SCRIPT_MAX_BYTES, BoardScriptSource, BoardScriptSources, createBoardScriptModuleReader, loadBoardScriptSources, resolveScriptImport, scriptModuleUrls };

package/dist/board/render/script-modules.js

@@ -0,0 +1,2 @@
+import { BOARD_SCRIPT_MAX_BYTES, createBoardScriptModuleReader, loadBoardScriptSources, resolveScriptImport, scriptModuleUrls } from "../../protocol/dist/board-script-modules.js";
+export { BOARD_SCRIPT_MAX_BYTES, createBoardScriptModuleReader, loadBoardScriptSources, resolveScriptImport, scriptModuleUrls };

package/dist/board/render/script-runtime.d.ts

@@ -0,0 +1,29 @@
+import { BoardItem } from "../../protocol/dist/board-model.js";
+import "../../protocol/dist/index.js";
+import { BoardScriptEvent, BoardScriptModule, BoardScriptOutput, BoardScriptSnapshot } from "../model/script.js";
+//#region src/board/render/script-runtime.d.ts
+type ScriptRuntimeInput = {
+  id: string;
+  item: BoardItem;
+  items: Record<string, BoardItem>;
+  width: number;
+  height: number;
+  capabilities?: string[];
+  snapshot?: BoardScriptSnapshot;
+};
+/** Self-contained so browser workers and Node execute exactly the same kernel. */
+declare function createScriptRuntime(module: BoardScriptModule, initial: ScriptRuntimeInput, host: {
+  call(name: string, input: unknown): Promise<unknown>;
+  invalidate(): void;
+}): {
+  readonly animated: boolean;
+  update(next: ScriptRuntimeInput): void;
+  step(t: number): void;
+  event(event: BoardScriptEvent): void;
+  draw(canvas: CanvasRenderingContext2D): void;
+  output(): BoardScriptOutput;
+  snapshot(includeEffects?: boolean, clone?: boolean): BoardScriptSnapshot;
+  destroy(): void;
+};
+//#endregion
+export { ScriptRuntimeInput, createScriptRuntime };