@neta-art/cohub 9.0.1 → 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

@@ -1,6 +1,6 @@
 import { BoardDash } from "../../protocol/dist/board-model.js";
 import "../../protocol/dist/index.js";
-import { WorldPoint } from "../geometry.js";
+import { WorldPoint } from "../model/geometry.js";
 import { Graphics } from "pixi.js";
 //#region src/board/render/stroke.d.ts
 declare function dashPattern(dash: BoardDash | undefined, width: number): [number, number] | null;
@@ -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

@@ -1,4 +1,4 @@
-import { worldPoint } from "../geometry.js";
+import { worldPoint } from "../model/geometry.js";
 //#region src/board/render/stroke.ts
 const HEAD_SPREAD = Math.PI / 6;
 function dashPattern(dash, width) {
@@ -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

@@ -1,11 +1,11 @@
 import { BOARD_FONT_STACK, BOARD_MONO_FONT_STACK } from "../../protocol/dist/board-constants.js";
 import { setBoardTextMeasurer } from "../../protocol/dist/board-layout.js";
-import { boardFontFamily } from "../core/text-metrics.js";
+import { boardFontFamily } from "../model/text-metrics.js";
 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/replica/index.d.ts

@@ -0,0 +1,70 @@
+import { BoardDelta, BoardDocument, BoardPatch } from "../../protocol/dist/board-model.js";
+import { BoardApplyResult, BoardPlaybackSnapshot, BoardReadResult } from "../../protocol/dist/board.js";
+import "../../protocol/dist/index.js";
+//#region src/board/replica/index.d.ts
+type BoardPendingPatch = {
+  mutationId: string;
+  patch: BoardPatch;
+};
+type BoardChangedPayload = {
+  mutationId: string;
+  baseVersion: number;
+  version: number;
+  after?: BoardDelta;
+};
+type BoardRemote = {
+  get(): Promise<BoardReadResult>;
+  apply(patch: BoardPatch, options: {
+    mutationId: string;
+    clientId?: string;
+  }): Promise<BoardApplyResult>;
+  subscribe?(handlers: {
+    changed?: (event: {
+      payload: BoardChangedPayload;
+    }) => void;
+    playback?: (event: {
+      payload: {
+        playback: BoardPlaybackSnapshot | null;
+      };
+    }) => void;
+  }): () => void;
+};
+type BoardReplicaStorage = {
+  listPending(): Promise<BoardPendingPatch[]>;
+  putPending(entry: BoardPendingPatch): Promise<void>;
+  deletePending(mutationId: string): Promise<void>;
+  readDocument(): Promise<{
+    version: number;
+    document: Record<string, unknown>;
+  } | null>;
+  writeDocument(version: number, document: BoardDocument): Promise<void>;
+};
+type BoardReplicaState = {
+  document: BoardDocument | null;
+  version: number;
+  title: string | null;
+  playback: BoardPlaybackSnapshot | null;
+  loaded: boolean;
+  pending: number;
+  error: string | null;
+};
+type BoardReplicaOptions = {
+  remote: BoardRemote;
+  storage?: BoardReplicaStorage;
+  clientId?: string;
+  persistIntervalMs?: number;
+};
+declare function createBoardReplica(options: BoardReplicaOptions): {
+  readonly state: BoardReplicaState;
+  subscribe(listener: (state: BoardReplicaState) => void): () => void;
+  start(): Promise<void>;
+  apply(patch: BoardPatch): Promise<void>;
+  receive: (payload: BoardChangedPayload) => void;
+  receivePlayback: (next: BoardPlaybackSnapshot | null) => void;
+  refresh: () => Promise<void>;
+  retry(): Promise<void>;
+  dispose(): void;
+};
+type BoardReplica = ReturnType<typeof createBoardReplica>;
+//#endregion
+export { BoardChangedPayload, BoardPendingPatch, BoardRemote, BoardReplica, BoardReplicaOptions, BoardReplicaState, BoardReplicaStorage, createBoardReplica };

package/dist/board/replica/index.js

@@ -0,0 +1,276 @@
+import { applyBoardDelta, applyBoardPatchToDocument, parseBoardDocument } from "../../protocol/dist/board-patch.js";
+import { createBoardEntityId } from "../model/items/id.js";
+//#region src/board/replica/index.ts
+function memoryStorage() {
+	return {
+		listPending: async () => [],
+		putPending: async () => void 0,
+		deletePending: async () => void 0,
+		readDocument: async () => null,
+		writeDocument: async () => void 0
+	};
+}
+const RETRY_BASE_MS = 1e3;
+const RETRY_MAX_MS = 3e4;
+const PERSIST_INTERVAL_MS = 500;
+function isRejection(error) {
+	const status = error.status;
+	return typeof status === "number" && status >= 400 && status < 500 && ![
+		401,
+		403,
+		408,
+		429
+	].includes(status);
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : "Board sync failed.";
+}
+function createBoardReplica(options) {
+	const remote = options.remote;
+	const storage = options.storage ?? memoryStorage();
+	const listeners = /* @__PURE__ */ new Set();
+	let unsubscribeRemote = null;
+	let server = null;
+	let version = 0;
+	let title = null;
+	let playback = null;
+	let playbackRevision = 0;
+	let loaded = false;
+	let readError = null;
+	let writeError = null;
+	let pending = [];
+	let document = null;
+	let sending = false;
+	let refreshing = null;
+	let refreshAgain = false;
+	let retryTimer = null;
+	let retryDelay = RETRY_BASE_MS;
+	let disposed = false;
+	let unpersisted = null;
+	let persistTimer = null;
+	function subscribeRemote() {
+		if (!remote.subscribe) return null;
+		try {
+			return remote.subscribe({
+				changed: (event) => receive(event.payload),
+				playback: (event) => receivePlayback(event.payload.playback)
+			});
+		} catch {
+			return null;
+		}
+	}
+	function recompute() {
+		if (!server) {
+			document = null;
+			return;
+		}
+		let next = server;
+		for (const entry of pending) {
+			const result = applyBoardPatchToDocument(next, entry.patch);
+			if (result.ok) next = result.document;
+		}
+		document = next;
+	}
+	function snapshot() {
+		return {
+			document,
+			version,
+			title,
+			playback,
+			loaded,
+			pending: pending.length,
+			error: writeError ?? readError
+		};
+	}
+	let current = snapshot();
+	function emit() {
+		if (disposed) return;
+		current = snapshot();
+		for (const listener of [...listeners]) listener(current);
+	}
+	function adoptServer(next, nextVersion, persist) {
+		server = next;
+		version = nextVersion;
+		recompute();
+		if (persist) schedulePersist(nextVersion, next);
+	}
+	function schedulePersist(nextVersion, next) {
+		unpersisted = {
+			version: nextVersion,
+			document: next
+		};
+		persistTimer ??= setTimeout(persistNow, options.persistIntervalMs ?? PERSIST_INTERVAL_MS);
+	}
+	function persistNow() {
+		if (persistTimer) clearTimeout(persistTimer);
+		persistTimer = null;
+		const entry = unpersisted;
+		unpersisted = null;
+		if (entry) storage.writeDocument(entry.version, entry.document).catch(() => void 0);
+	}
+	function adoptRead(result, readPlaybackRevision) {
+		const parsed = parseBoardDocument({
+			board: result.board,
+			items: result.items ?? {},
+			animations: result.animations ?? {}
+		});
+		if (!parsed.ok) throw new Error(`Board ${result.id} could not be read.`);
+		title = result.title;
+		if (readPlaybackRevision === playbackRevision) playback = result.playback;
+		loaded = true;
+		adoptServer(parsed.document, result.version, true);
+	}
+	function refresh() {
+		if (refreshing) {
+			refreshAgain = true;
+			return refreshing;
+		}
+		refreshing = (async () => {
+			try {
+				do {
+					refreshAgain = false;
+					const readPlaybackRevision = playbackRevision;
+					const result = await remote.get();
+					if (disposed) return;
+					if (result.version >= version || !loaded) adoptRead(result, readPlaybackRevision);
+					readError = null;
+					emit();
+				} while (refreshAgain && !disposed);
+			} catch (cause) {
+				readError = errorMessage(cause);
+				emit();
+			} finally {
+				refreshing = null;
+			}
+		})();
+		return refreshing;
+	}
+	function scheduleRetry() {
+		if (retryTimer || disposed) return;
+		retryTimer = setTimeout(() => {
+			retryTimer = null;
+			flush();
+		}, retryDelay);
+		retryDelay = Math.min(RETRY_MAX_MS, retryDelay * 2);
+	}
+	async function flush() {
+		if (sending || disposed || !loaded) return;
+		sending = true;
+		try {
+			while (pending.length && !disposed) {
+				const entry = pending[0];
+				try {
+					const result = await remote.apply(entry.patch, {
+						mutationId: entry.mutationId,
+						...options.clientId ? { clientId: options.clientId } : {}
+					});
+					const stillPending = pending.some((item) => item.mutationId === entry.mutationId);
+					pending = pending.filter((item) => item.mutationId !== entry.mutationId);
+					storage.deletePending(entry.mutationId).catch(() => void 0);
+					if (stillPending && server && !result.replayed && result.status === "applied" && result.version === version + 1) {
+						const next = applyBoardPatchToDocument(server, entry.patch);
+						if (next.ok) adoptServer(next.document, result.version, true);
+						else refresh();
+					} else if (result.version > version) refresh();
+					else recompute();
+					retryDelay = RETRY_BASE_MS;
+					writeError = null;
+					emit();
+				} catch (cause) {
+					if (isRejection(cause)) {
+						pending = pending.filter((item) => item.mutationId !== entry.mutationId);
+						storage.deletePending(entry.mutationId).catch(() => void 0);
+						writeError = errorMessage(cause);
+						recompute();
+						emit();
+						refresh();
+						continue;
+					}
+					writeError = errorMessage(cause);
+					emit();
+					scheduleRetry();
+					return;
+				}
+			}
+		} finally {
+			sending = false;
+		}
+	}
+	function receive(payload) {
+		if (!loaded) {
+			refresh();
+			return;
+		}
+		if (payload.version <= version) return;
+		if (payload.baseVersion !== version || !payload.after || !server) {
+			refresh();
+			return;
+		}
+		adoptServer(applyBoardDelta(server, payload.after), payload.version, true);
+		if (pending.some((entry) => entry.mutationId === payload.mutationId)) {
+			pending = pending.filter((entry) => entry.mutationId !== payload.mutationId);
+			storage.deletePending(payload.mutationId).catch(() => void 0);
+			recompute();
+		}
+		emit();
+	}
+	function receivePlayback(next) {
+		playbackRevision += 1;
+		playback = next;
+		emit();
+	}
+	return {
+		get state() {
+			return current;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		async start() {
+			unsubscribeRemote ??= subscribeRemote();
+			const [cached, stored] = await Promise.all([storage.readDocument().catch(() => null), storage.listPending().catch(() => [])]);
+			if (disposed) return;
+			pending = stored;
+			if (cached && !server) {
+				const parsed = parseBoardDocument(cached.document);
+				if (parsed.ok) adoptServer(parsed.document, cached.version, false);
+			}
+			emit();
+			await refresh();
+			await flush();
+		},
+		apply(patch) {
+			const entry = {
+				mutationId: createBoardEntityId(),
+				patch
+			};
+			pending = [...pending, entry];
+			recompute();
+			emit();
+			return storage.putPending(entry).catch(() => void 0).then(() => flush());
+		},
+		receive,
+		receivePlayback,
+		refresh,
+		retry() {
+			if (retryTimer) clearTimeout(retryTimer);
+			retryTimer = null;
+			retryDelay = RETRY_BASE_MS;
+			readError = null;
+			writeError = null;
+			emit();
+			return refresh().then(flush);
+		},
+		dispose() {
+			disposed = true;
+			unsubscribeRemote?.();
+			unsubscribeRemote = null;
+			listeners.clear();
+			if (retryTimer) clearTimeout(retryTimer);
+			persistNow();
+		}
+	};
+}
+//#endregion
+export { createBoardReplica };

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

@@ -0,0 +1,41 @@
+import { BoardSceneItem } from "../model/scene.js";
+import "../model/index.js";
+import { LruBudget } from "./lru.js";
+import { BoardImageTexturePool } from "./texture-pool.js";
+import { Texture } from "pixi.js";
+//#region src/board/stage/assets.d.ts
+type BoardAssetMedia = "image" | "video";
+declare function boardAssetKey(item: BoardSceneItem): string | null;
+type BoardAssetManager = {
+  assetKey: (item: BoardSceneItem) => string | null;
+  invalidatePath: (path: string) => void;
+  requestItem: (item: BoardSceneItem) => void;
+  getTexture: (key: string) => Texture | null;
+  getNaturalSize: (key: string) => {
+    width: number;
+    height: number;
+  } | null;
+  hasError: (key: string) => boolean;
+  acquire: (key: string) => void;
+  release: (key: string) => void;
+  withTextures: <T>(items: BoardSceneItem[], use: (textures: Map<string, Texture>) => T | Promise<T>, options?: {
+    timeoutMs?: number;
+  }) => Promise<T>;
+  subscribe: (listener: () => void) => () => void;
+  destroy: () => void;
+};
+type BoardAssetManagerOptions = {
+  /** Resolve a Space file path to a URL a texture can load from; null when unavailable. */
+  resolveFileUrl: (path: string) => Promise<string | null>;
+  concurrency?: number;
+  videoConcurrency?: number;
+  loadVideoPreviews?: boolean;
+  lruBudget?: LruBudget;
+  imageTexturePool?: BoardImageTexturePool;
+  loadTexture?: (url: string, media: BoardAssetMedia) => Promise<Texture | null>;
+  unloadTexture?: (url: string, texture: Texture | null, media: BoardAssetMedia) => Promise<void>;
+  now?: () => number;
+};
+declare function createBoardAssetManager(options: BoardAssetManagerOptions): BoardAssetManager;
+//#endregion
+export { BoardAssetManager, BoardAssetManagerOptions, boardAssetKey, createBoardAssetManager };