@neta-art/cohub 10.0.0 → 11.0.0

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/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,4 +1,5 @@
 import { mediaPreviewCandidates } from "../../media.js";
+import { parseBoardMediaSource } from "../../protocol/dist/board-model.js";
 import { featuredTaskArtifact } from "../model/task.js";
 import { boardImageKeySource, imageAssetKey } from "../model/image-key.js";
 import { loadVideoThumbnailTexture, videoTextureNaturalSize } from "../render/video-thumbnail.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.js

@@ -130,7 +130,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 +351,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 = 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;

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

@@ -0,0 +1,19 @@
+//#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;
+  };
+  clear(): void;
+};
+//#endregion
+export { BoardScriptPointerTarget, createBoardScriptPointerRouter };

package/dist/board/stage/script-pointer.js

@@ -0,0 +1,35 @@
+//#region src/board/stage/script-pointer.ts
+function createBoardScriptPointerRouter() {
+	const gestures = /* @__PURE__ */ new Map();
+	return {
+		needsRouting(pointerId, scriptsEnabled) {
+			return scriptsEnabled || gestures.has(pointerId);
+		},
+		owner(pointerId) {
+			const gesture = gestures.get(pointerId);
+			return gesture ? gesture.target ? "script" : "editor" : null;
+		},
+		route(phase, pointerId, target, point, cancelled = false) {
+			if (phase === "down") gestures.set(pointerId, {
+				target,
+				...point
+			});
+			const gesture = gestures.get(pointerId);
+			const recipient = gesture ? gesture.target : phase === "move" ? target : null;
+			let click = null;
+			if (phase === "up") {
+				gestures.delete(pointerId);
+				if (!cancelled && gesture?.target && target?.owner === gesture.target.owner && target.target === gesture.target.target && Math.hypot(point.x - gesture.x, point.y - gesture.y) < 5) click = gesture.target;
+			}
+			return {
+				recipient,
+				click
+			};
+		},
+		clear() {
+			gestures.clear();
+		}
+	};
+}
+//#endregion
+export { createBoardScriptPointerRouter };

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

@@ -1,6 +1,7 @@
 import { BoardItem } from "../../protocol/dist/board-model.js";
 import { BoardPlaybackSnapshot } from "../../protocol/dist/board.js";
 import "../../protocol/dist/index.js";
+import { BoardScriptOutput, BoardScriptSnapshot } from "../model/script.js";
 import { BoardViewport, WorldPoint } from "../model/geometry.js";
 import { BoardScene, BoardSceneItem } from "../model/scene.js";
 import { BoardShapeColors } from "../model/palette.js";
@@ -47,6 +48,7 @@ type BoardStageOptions = {
     height: number;
   }) => void;
   onVisibleChange?: (ids: ReadonlySet<string> | null) => void;
+  scriptCapabilities?: Record<string, (id: string, input: unknown) => Promise<unknown>>;
 };
 type BoardStage = {
   readonly ready: Promise<boolean>;
@@ -54,6 +56,14 @@ type BoardStage = {
   readonly camera: BoardViewport;
   readonly theme: BoardStageTheme;
   setActive(active: boolean): void;
+  setScriptMode(mode: "edit" | "interact" | "paused"): void;
+  resetScripts(): void;
+  invalidateScript(path: string): void;
+  scriptError(id: string): string | null;
+  scriptOutput(id: string): BoardScriptOutput | null;
+  snapshotScripts(): Promise<Record<string, BoardScriptSnapshot>>;
+  restoreScript(id: string, snapshot: BoardScriptSnapshot): void;
+  subscribeScripts(listener: () => void): () => void;
   invalidate(options?: {
     cards?: boolean;
   }): void;