@neta-art/cohub 9.0.1 → 11.0.0

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

@@ -0,0 +1,421 @@
+import { boardScriptItems } from "../model/script-index.js";
+import { boardScriptScope } from "../model/script-scene.js";
+import { createBoardScriptModuleReader, loadBoardScriptSources } from "../../protocol/dist/board-script-modules.js";
+import { boardScriptFrameSource } from "./script-sandbox.js";
+import { Texture } from "pixi.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 layer = document.createElement("div");
+	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;
+	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);
+		entry.texture?.destroy(true);
+		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) 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) {
+			const previous = entry.texture;
+			entry.texture = Texture.from(data.bitmap);
+			previous?.destroy(true);
+		}
+		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 ?? 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, interactive, visibleIds) {
+			if (disposed) return;
+			const alive = /* @__PURE__ */ new Set();
+			const liveFocusTargets = /* @__PURE__ */ new Set();
+			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: null,
+						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);
+					if (!hits.length && entry.output.listens.length) hits.push([id, {
+						x: 0,
+						y: 0,
+						width: box.width,
+						height: box.height,
+						label: "text" in item.props && typeof item.props.text === "string" ? item.props.text : item.script.src
+					}]);
+					for (const [target, hit] of hits) {
+						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 (!current || current.error) return;
+								current.events.push({
+									type,
+									target,
+									key,
+									point: {
+										x: hit.x + hit.width / 2,
+										y: hit.y + hit.height / 2
+									}
+								});
+								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);
+						}
+						button.setAttribute("aria-label", hit.label ?? target);
+						button.tabIndex = interactive && visible ? 0 : -1;
+						const [a, b, c, d, x, y] = scene.layout.matrix(id);
+						button.style.cssText = `position:absolute;pointer-events:none;background:transparent;border:0;padding:0;transform-origin:0 0;width:${hit.width}px;height:${hit.height}px;transform:matrix(${a * camera.zoom},${b * camera.zoom},${c * camera.zoom},${d * camera.zoom},${(x + a * hit.x + c * hit.y) * camera.zoom + camera.x},${(y + b * hit.x + d * hit.y) * camera.zoom + camera.y})`;
+					}
+				}
+				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 === "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 };

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

@@ -0,0 +1,213 @@
+//#region src/board/render/script-runtime.ts
+/** Self-contained so browser workers and Node execute exactly the same kernel. */
+function createScriptRuntime(module, initial, host) {
+	if ("mount" in module) throw new Error("Board scripts do not support DOM mount(). Use draw() or native scene items.");
+	let input = initial;
+	let disposed = false;
+	let revision = 0;
+	let randomState = 2166136261;
+	for (const char of initial.item.script?.seed ?? initial.id) randomState = Math.imul(randomState ^ char.charCodeAt(0), 16777619) >>> 0;
+	const parameterDefaults = Object.fromEntries(Object.entries(module.parameters ?? {}).filter(([, spec]) => spec.default !== void 0).map(([key, spec]) => [key, spec.default]));
+	let params = {
+		...parameterDefaults,
+		...initial.item.script?.params
+	};
+	const state = structuredClone(initial.snapshot?.state ?? {});
+	if (initial.snapshot) randomState = initial.snapshot.random;
+	let time = initial.snapshot?.time ?? 0;
+	let started = Boolean(initial.snapshot);
+	const stepMs = 1e3 / 60;
+	let frame = {
+		t: time,
+		dt: 0,
+		width: initial.width,
+		height: initial.height,
+		seed: initial.item.script?.seed ?? initial.id,
+		params,
+		state
+	};
+	const handlers = /* @__PURE__ */ new Map();
+	const frames = /* @__PURE__ */ new Set();
+	const cleanups = [];
+	const effects = structuredClone(initial.snapshot?.effects);
+	let patches = effects?.patches ?? {};
+	let items = effects?.items ?? {};
+	let space = effects?.space ?? "world";
+	let hits = effects?.hits ?? {};
+	const invalidate = () => {
+		if (disposed) return;
+		revision++;
+		host.invalidate();
+	};
+	const present = (id, patch) => {
+		if (patch === null) delete patches[id];
+		else patches[id] = structuredClone(patch);
+		invalidate();
+	};
+	const context = {
+		self: {
+			id: initial.id,
+			get base() {
+				return input.item;
+			},
+			present: (patch) => present(initial.id, patch)
+		},
+		get params() {
+			return params;
+		},
+		get targets() {
+			return input.item.script?.targets ?? {};
+		},
+		async emit(target, type, data) {
+			await host.call("board.emit", {
+				target,
+				type,
+				data
+			});
+		},
+		state,
+		get frame() {
+			return frame;
+		},
+		random() {
+			randomState = Math.imul(randomState, 1664525) + 1013904223 >>> 0;
+			return randomState / 4294967296;
+		},
+		on(type, handler) {
+			let listeners = handlers.get(type);
+			if (!listeners) {
+				listeners = /* @__PURE__ */ new Set();
+				handlers.set(type, listeners);
+			}
+			listeners.add(handler);
+			invalidate();
+			return () => {
+				listeners.delete(handler);
+				invalidate();
+			};
+		},
+		onFrame(handler) {
+			frames.add(handler);
+			invalidate();
+			return () => {
+				frames.delete(handler);
+				invalidate();
+			};
+		},
+		onDispose: (handler) => cleanups.push(handler),
+		invalidate,
+		get: (id) => input.items[id],
+		present,
+		scene(next, options) {
+			items = structuredClone(next);
+			space = options?.space ?? "world";
+			invalidate();
+		},
+		hitRegions(next) {
+			hits = structuredClone(next);
+			invalidate();
+		},
+		async commit(patch) {
+			await host.call("board.commit", patch);
+		},
+		capabilities: {
+			has: (name) => (input.capabilities ?? []).includes(name),
+			call: (name, value) => host.call(name, value)
+		}
+	};
+	const setup = module.default?.(context);
+	if (typeof setup === "function") cleanups.push(setup);
+	return {
+		get animated() {
+			return frames.size > 0 || module.animated === true;
+		},
+		update(next) {
+			input = next;
+			params = {
+				...parameterDefaults,
+				...next.item.script?.params
+			};
+		},
+		step(t) {
+			if (disposed) return;
+			if (!Number.isFinite(t) || t < time - .001) throw new Error("Reset the instance before seeking backwards.");
+			const update = (at, dt) => {
+				frame = {
+					...frame,
+					t: at,
+					dt,
+					width: input.width,
+					height: input.height,
+					params: context.params
+				};
+				for (const handler of frames) handler(frame);
+			};
+			if (!started) {
+				started = true;
+				update(time, 0);
+			}
+			if (frames.size) while (time + stepMs <= t + 1e-6) {
+				time += stepMs;
+				update(time, stepMs);
+			}
+			else time = t;
+			frame = {
+				...frame,
+				t,
+				dt: 0,
+				width: input.width,
+				height: input.height,
+				params: context.params
+			};
+		},
+		event(event) {
+			if (disposed) return;
+			const listeners = handlers.get(event.type);
+			if (!listeners?.size) return;
+			for (const handler of listeners) handler(event);
+			invalidate();
+		},
+		draw(canvas) {
+			const result = module.draw?.(canvas, frame);
+			if (result && typeof result.then === "function") throw new Error("draw() must be synchronous.");
+		},
+		output() {
+			return {
+				parameters: module.parameters,
+				space,
+				patches,
+				items,
+				hits,
+				listens: [...handlers].filter(([, callbacks]) => callbacks.size).map(([type]) => type),
+				animated: this.animated,
+				updating: frames.size > 0,
+				version: revision
+			};
+		},
+		snapshot(includeEffects = true, clone = true) {
+			const snapshot = {
+				state,
+				time,
+				random: randomState,
+				effects: includeEffects ? {
+					patches,
+					items,
+					hits,
+					space
+				} : void 0
+			};
+			return clone ? structuredClone(snapshot) : snapshot;
+		},
+		destroy() {
+			disposed = true;
+			for (const cleanup of cleanups.reverse()) cleanup();
+			handlers.clear();
+			frames.clear();
+			patches = {};
+			items = {};
+			hits = {};
+		}
+	};
+}
+//#endregion
+export { createScriptRuntime };

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

@@ -0,0 +1,4 @@
+//#region src/board/render/script-sandbox.d.ts
+declare function boardScriptFrameSource(): string;
+//#endregion
+export { boardScriptFrameSource };