@neta-art/cohub 10.0.0 → 11.1.0

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

@@ -0,0 +1,223 @@
+//#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 anchor = effects?.anchor;
+	let view = null;
+	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;
+		},
+		get view() {
+			return view;
+		},
+		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);
+			}
+			const listener = (event) => handler(event);
+			listeners.add(listener);
+			invalidate();
+			return () => {
+				listeners.delete(listener);
+				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";
+			anchor = options?.anchor ? structuredClone(options.anchor) : void 0;
+			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;
+			if (event.type === "viewchange") view = event.data;
+			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,
+				anchor,
+				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,
+					anchor
+				} : 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 };

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

@@ -0,0 +1,173 @@
+import { scriptModuleUrls } from "../../protocol/dist/board-script-modules.js";
+import { createScriptRuntime } from "./script-runtime.js";
+//#region src/board/render/script-sandbox.ts
+function scriptAgent(runtimeFactory, moduleUrls, load) {
+	let runtime = null;
+	let input = null;
+	let module = null;
+	let urls = null;
+	let outputVersion = -1;
+	let canvas = null;
+	let callId = 0;
+	const calls = /* @__PURE__ */ new Map();
+	const send = (data, transfer = []) => {
+		self.postMessage(data, transfer);
+	};
+	const call = (name, input) => new Promise((resolve, reject) => {
+		const id = ++callId;
+		calls.set(id, {
+			resolve,
+			reject
+		});
+		send({
+			kind: "call",
+			call: id,
+			name,
+			input
+		});
+	});
+	let processing = false;
+	const queue = [];
+	async function process(data) {
+		try {
+			if (data.input) input = data.input;
+			if (!input) throw new Error("Missing script input.");
+			if (!runtime) {
+				if (!data.sources) throw new Error("Missing script modules.");
+				urls = moduleUrls(data.sources);
+				const src = input.item.script?.src;
+				const url = src ? urls.urls[src] : void 0;
+				if (!url) throw new Error("Missing entry module.");
+				module = await load(url);
+				runtime = runtimeFactory(module, input, {
+					call,
+					invalidate: () => {
+						if (!processing) send({ kind: "dirty" });
+					}
+				});
+			}
+			if (data.input) runtime.update(input);
+			for (const event of data.events ?? []) runtime.event(event);
+			runtime.step(data.t);
+			let bitmap;
+			if (module?.draw && data.draw !== false) {
+				const width = Math.max(1, Math.round(input.width * data.scale));
+				const height = Math.max(1, Math.round(input.height * data.scale));
+				canvas ??= new OffscreenCanvas(width, height);
+				if (canvas.width !== width) canvas.width = width;
+				if (canvas.height !== height) canvas.height = height;
+				const context = canvas.getContext("2d");
+				if (!context) throw new Error("Canvas 2D is unavailable.");
+				context.reset();
+				context.scale(data.scale, data.scale);
+				runtime.draw(context);
+				bitmap = canvas.transferToImageBitmap();
+			}
+			const output = runtime.output();
+			const changed = output.version !== outputVersion;
+			outputVersion = output.version;
+			send({
+				kind: "frame",
+				request: data.request,
+				output: changed ? output : void 0,
+				bitmap
+			}, bitmap ? [bitmap] : []);
+		} catch (error) {
+			send({
+				kind: "error",
+				request: data.request,
+				error: error instanceof Error ? error.stack ?? error.message : String(error)
+			});
+		}
+	}
+	async function drain() {
+		if (processing) return;
+		processing = true;
+		while (queue.length) {
+			const request = queue.shift();
+			if (request) await process(request);
+		}
+		processing = false;
+	}
+	self.addEventListener("message", (event) => {
+		const data = event.data;
+		if (data.kind === "snapshot") {
+			try {
+				for (const event of data.events ?? []) runtime?.event(event);
+				send({
+					kind: "snapshot",
+					snapshot: runtime?.snapshot(true, false) ?? null
+				});
+			} catch (error) {
+				send({
+					kind: "snapshot",
+					error: String(error)
+				});
+			}
+			return;
+		}
+		if (data.kind === "dispose") {
+			try {
+				runtime?.destroy();
+				urls?.dispose();
+			} finally {
+				send({ kind: "disposed" });
+			}
+			return;
+		}
+		if (data.kind === "result" && data.call !== void 0) {
+			const pending = calls.get(data.call);
+			calls.delete(data.call);
+			if (data.error) pending?.reject(new Error(data.error));
+			else pending?.resolve(data.value);
+			return;
+		}
+		queue.push(data);
+		drain();
+	});
+	self.addEventListener("unhandledrejection", (event) => {
+		send({
+			kind: "error",
+			error: String(event.reason)
+		});
+	});
+}
+function boardScriptFrameSource() {
+	const runtime = createScriptRuntime.toString();
+	const urls = scriptModuleUrls.toString();
+	const agent = scriptAgent.toString();
+	const prelude = "const __name = (value, name) => Object.defineProperty(value, 'name', { value: name, configurable: true });";
+	const worker = `${prelude} (${agent})(${runtime}, ${urls}, url => import(url));`;
+	return `<!doctype html><meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline' blob:; worker-src blob:; connect-src 'none'; form-action 'none'; base-uri 'none'"><script>
+${prelude}
+const workerUrl = URL.createObjectURL(new Blob([${JSON.stringify(worker)}], {type:'text/javascript'}));
+const workers = new Map();
+addEventListener('message', event => {
+ if(event.source !== parent) return;
+ const {token, data} = event.data;
+ if(typeof token !== 'number' || !data) return;
+ let entry = workers.get(token);
+ if(data.kind === 'terminate') {
+  if(entry) { clearTimeout(entry.timer); entry.worker.terminate(); workers.delete(token); }
+  return;
+ }
+ if(!entry) {
+  if(!data.sources) return;
+  const worker = new Worker(workerUrl);
+  entry = {worker}; workers.set(token, entry);
+  worker.onmessage = event => {
+   parent.postMessage({...event.data, token}, '*', event.data.bitmap ? [event.data.bitmap] : []);
+   if(event.data.kind === 'disposed') {
+    clearTimeout(entry.timer); worker.terminate(); workers.delete(token);
+   }
+  };
+  worker.onerror = event => parent.postMessage({token,kind:'error',error:event.message || 'Script worker failed to start.'}, '*');
+ }
+ entry.worker.postMessage(data);
+ if(data.kind === 'dispose') entry.timer = setTimeout(() => {entry.worker.terminate(); workers.delete(token);},100);
+});
+parent.postMessage({kind:'ready'}, '*');
+<\/script>`;
+}
+//#endregion
+export { boardScriptFrameSource };

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

@@ -0,0 +1,11 @@
+import { Texture } from "pixi.js";
+//#region src/board/render/script-texture.d.ts
+declare class BoardScriptTexture {
+  private texture;
+  private bitmap;
+  get current(): Texture | null;
+  update(bitmap: ImageBitmap): void;
+  destroy(): void;
+}
+//#endregion
+export { BoardScriptTexture };

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

@@ -0,0 +1,33 @@
+import { ImageSource, Texture } from "pixi.js";
+//#region src/board/render/script-texture.ts
+var BoardScriptTexture = class {
+	texture = null;
+	bitmap = null;
+	get current() {
+		return this.texture;
+	}
+	update(bitmap) {
+		const previous = this.bitmap;
+		this.bitmap = bitmap;
+		if (!this.texture) {
+			this.texture = new Texture({
+				source: new ImageSource({ resource: bitmap }),
+				dynamic: true
+			});
+			return;
+		}
+		const source = this.texture.source;
+		source.resource = bitmap;
+		source.update();
+		if (previous !== bitmap) previous?.close();
+	}
+	destroy() {
+		if (!this.texture) return;
+		this.texture.destroy(true);
+		this.bitmap?.close();
+		this.bitmap = null;
+		this.texture = null;
+	}
+};
+//#endregion
+export { BoardScriptTexture };

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

@@ -8,5 +8,6 @@ declare function trimPolyline(path: readonly WorldPoint[], trim: number | undefi
 declare function tracePolyline(graphics: Graphics, path: readonly WorldPoint[], pattern: [number, number] | null, closed?: boolean): void;
 declare function traceArrowhead(graphics: Graphics, tip: WorldPoint, angle: number, size: number): void;
 declare function endAngle(path: readonly WorldPoint[], atStart: boolean): number | null;
+declare function roundRectPoints(width: number, height: number, radius: number): WorldPoint[];
 //#endregion
-export { dashPattern, endAngle, traceArrowhead, tracePolyline, trimPolyline };
+export { dashPattern, endAngle, roundRectPoints, traceArrowhead, tracePolyline, trimPolyline };

package/dist/board/render/stroke.js

@@ -86,5 +86,26 @@ function endAngle(path, atStart) {
 	}
 	return null;
 }
+function roundRectPoints(width, height, radius) {
+	const r = Math.min(radius, width / 2, height / 2);
+	if (r <= 0) return [
+		worldPoint(0, 0),
+		worldPoint(width, 0),
+		worldPoint(width, height),
+		worldPoint(0, height),
+		worldPoint(0, 0)
+	];
+	const corner = (cx, cy, from) => Array.from({ length: 9 }, (_, index) => {
+		const angle = from + index / 8 * (Math.PI / 2);
+		return worldPoint(cx + Math.cos(angle) * r, cy + Math.sin(angle) * r);
+	});
+	return [
+		...corner(width - r, r, -Math.PI / 2),
+		...corner(width - r, height - r, 0),
+		...corner(r, height - r, Math.PI / 2),
+		...corner(r, r, Math.PI),
+		worldPoint(width - r, 0)
+	];
+}
 //#endregion
-export { dashPattern, endAngle, traceArrowhead, tracePolyline, trimPolyline };
+export { dashPattern, endAngle, roundRectPoints, traceArrowhead, tracePolyline, trimPolyline };

package/dist/board/render/text-measurement.js

@@ -5,7 +5,7 @@ import { DOMAdapter } from "pixi.js";
 //#region src/board/render/text-measurement.ts
 const BOARD_FONT_STACKS = {
 	sans: BOARD_FONT_STACK,
-	serif: "ui-serif, Georgia, \"Noto Serif CJK SC\", \"Songti SC\", serif",
+	serif: "ui-serif, Georgia, \"Noto Serif CJK SC\", \"Songti SC\", \"Noto Sans Math\", \"DejaVu Sans\", \"Noto Sans CJK SC\", \"FreeSans\", \"FreeSerif\", sans-serif",
 	mono: BOARD_MONO_FONT_STACK
 };
 let measureContext;

package/dist/board/stage/assets.js

@@ -1,5 +1,6 @@
 import { mediaPreviewCandidates } from "../../media.js";
-import { featuredTaskArtifact } from "../model/task.js";
+import { parseBoardMediaSource } from "../../protocol/dist/board-model.js";
+import { featuredTaskArtifact } from "../../protocol/dist/board-task.js";
 import { boardImageKeySource, imageAssetKey } from "../model/image-key.js";
 import { loadVideoThumbnailTexture, videoTextureNaturalSize } from "../render/video-thumbnail.js";
 import { DEFAULT_LRU_BUDGET, selectLruEvictions } from "./lru.js";
@@ -14,7 +15,11 @@ function taskPreviewKey(artifact) {
 }
 function boardAssetKey(item) {
 	if (item.type === "task") return taskPreviewKey(featuredTaskArtifact(item.props.snapshot.artifacts));
-	if (item.type === "video") return `video:${encodeURIComponent(item.props.src)}:${item.props.snapshot?.mtimeMs ?? "unknown"}`;
+	if (item.type === "video") {
+		const source = parseBoardMediaSource(item.props.src);
+		if (!source) return null;
+		return source.kind === "url" ? `video-url:${encodeURIComponent(source.value)}` : `video:${encodeURIComponent(source.value)}:${item.props.snapshot?.mtimeMs ?? "unknown"}`;
+	}
 	return imageAssetKey(item);
 }
 function keySource(key) {

package/dist/board/stage/maintenance.d.ts

@@ -0,0 +1,5 @@
+import { Renderer } from "pixi.js";
+//#region src/board/stage/maintenance.d.ts
+declare function scheduleBoardMaintenance(renderer: Renderer): () => void;
+//#endregion
+export { scheduleBoardMaintenance };

package/dist/board/stage/maintenance.js

@@ -0,0 +1,11 @@
+import { Ticker } from "pixi.js";
+//#region src/board/stage/maintenance.ts
+function scheduleBoardMaintenance(renderer) {
+	renderer.events.setTargetElement(null);
+	const scheduler = renderer.scheduler;
+	Ticker.system.remove(scheduler._update, scheduler);
+	const timer = setInterval(() => scheduler._update(), 1e3);
+	return () => clearInterval(timer);
+}
+//#endregion
+export { scheduleBoardMaintenance };

package/dist/board/stage/scene.d.ts

@@ -24,6 +24,7 @@ type SceneSyncInput = {
   visibleIds: Set<string> | null;
   pinnedIds: Set<string>;
   globalSig: string;
+  staleIds?: ReadonlySet<string>;
   structureVersion: number;
   geometryVersion: number;
   gestureActive: boolean;
@@ -72,6 +73,7 @@ type BoardScene = {
   sync: (input: SceneSyncInput) => void;
   getNode: (itemId: string) => BoardSceneNode | null;
   readonly animated: boolean;
+  tick: (clock: number) => number | null;
   drawOverlay: (input: SceneOverlayInput, palette: BoardRenderPalette) => void;
   destroy: (context: BoardRenderContext) => void;
 };

package/dist/board/stage/scene.js

@@ -48,6 +48,7 @@ function createBoardScene(options) {
 	const cards = /* @__PURE__ */ new Map();
 	const clips = /* @__PURE__ */ new Map();
 	const animatedIds = /* @__PURE__ */ new Set();
+	const tickingIds = /* @__PURE__ */ new Set();
 	const pools = /* @__PURE__ */ new Map();
 	const heldKeys = /* @__PURE__ */ new Map();
 	let orderById = /* @__PURE__ */ new Map();
@@ -72,6 +73,7 @@ function createBoardScene(options) {
 		setHeldKey(context, id, null);
 		cards.delete(id);
 		animatedIds.delete(id);
+		tickingIds.delete(id);
 		if (destroyed) return;
 		entry.container.parent?.removeChild(entry.container);
 		entry.container.visible = false;
@@ -123,6 +125,7 @@ function createBoardScene(options) {
 		container.alpha = scene.opacity(item.id);
 		hostFor(item, scene).addChild(container);
 		if (renderer.animated) animatedIds.add(item.id);
+		if (renderer.tick) tickingIds.add(item.id);
 		const entry = {
 			item,
 			container,
@@ -130,7 +133,8 @@ function createBoardScene(options) {
 			selected: context.selectedIds.has(item.id),
 			hovered: context.hoveredId === item.id,
 			resizing: context.resizingIds.has(item.id),
-			globalSig
+			globalSig,
+			scriptRevision: context.scripts?.revision?.(item.id) ?? 0
 		};
 		cards.set(item.id, entry);
 		setHeldKey(context, item.id, context.assetKey(item));
@@ -350,7 +354,9 @@ function createBoardScene(options) {
 			const selected = context.selectedIds.has(id);
 			const hovered = context.hoveredId === id;
 			const resizing = context.resizingIds.has(id);
-			const changed = item !== entry.item || entry.renderer.animated || selected !== entry.selected || hovered !== entry.hovered || resizing !== entry.resizing || globalSig !== entry.globalSig;
+			const scriptRevision = context.scripts?.revision?.(id) ?? 0;
+			const changed = input.staleIds?.has(id) || scriptRevision !== entry.scriptRevision || item !== entry.item || entry.renderer.animated || selected !== entry.selected || hovered !== entry.hovered || resizing !== entry.resizing || globalSig !== entry.globalSig;
+			entry.scriptRevision = scriptRevision;
 			entry.item = item;
 			entry.selected = selected;
 			entry.hovered = hovered;
@@ -360,12 +366,23 @@ function createBoardScene(options) {
 			if (changed) {
 				entry.renderer.update(entry.container, item, context);
 				entry.container.alpha = scene.opacity(id);
+				if (entry.renderer.tick) tickingIds.add(id);
 			}
 		}
 		if (structureChanged || liveSetChanged) syncClips(scene);
 		if (structureChanged || farModeChanged || liveSetChanged) applyChildOrder();
 		syncLiveStrokes(input);
 	}
+	function tick(clock) {
+		let next = null;
+		for (const id of tickingIds) {
+			const entry = cards.get(id);
+			const wait = entry?.container.visible ? entry.renderer.tick?.(entry.container, clock) ?? null : null;
+			if (wait === null) tickingIds.delete(id);
+			else next = next === null ? wait : Math.min(next, wait);
+		}
+		return next;
+	}
 	function applyChildOrder() {
 		for (const [id, entry] of cards) entry.container.zIndex = orderById.get(id) ?? 0;
 		world.sortableChildren = true;
@@ -486,6 +503,7 @@ function createBoardScene(options) {
 		for (const entry of clips.values()) entry.group.destroy({ children: true });
 		clips.clear();
 		animatedIds.clear();
+		tickingIds.clear();
 		for (const id of [...liveStrokes.keys()]) removeLiveStroke(id, context);
 		resetFarLayer();
 		farActive = false;
@@ -504,6 +522,7 @@ function createBoardScene(options) {
 		get animated() {
 			return animatedIds.size > 0;
 		},
+		tick,
 		drawOverlay,
 		destroy
 	};

package/dist/board/stage/script-pointer.d.ts

@@ -0,0 +1,20 @@
+//#region src/board/stage/script-pointer.d.ts
+type BoardScriptPointerTarget = {
+  owner: string;
+  target: string;
+};
+declare function createBoardScriptPointerRouter(): {
+  needsRouting(pointerId: number, scriptsEnabled: boolean): boolean;
+  owner(pointerId: number): "editor" | "script" | null;
+  route(phase: "down" | "move" | "up" | "leave", pointerId: number, target: BoardScriptPointerTarget | null, point: {
+    x: number;
+    y: number;
+  }, cancelled?: boolean): {
+    recipient: BoardScriptPointerTarget | null;
+    click: BoardScriptPointerTarget | null;
+  };
+  cancelScripts(cancel: (pointerId: number, target: BoardScriptPointerTarget) => void, owner?: string, retained?: Readonly<Record<string, unknown>>): void;
+  clear(): void;
+};
+//#endregion
+export { BoardScriptPointerTarget, createBoardScriptPointerRouter };