@neta-art/cohub 12.5.0 → 13.0.0

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

@@ -1,10 +1,10 @@
 import { BOARD_FONT_STACK, BOARD_MONO_FONT_STACK } from "../../../protocol/dist/board-constants.js";
 import { featuredTaskArtifact } from "../../../protocol/dist/board-task.js";
-import { boardCardDetailed } from "../lod.js";
+import { drawAudioWaveform } from "../audio-waveform.js";
 import { fitTextToLines, fitTextToWidth } from "../text-fit.js";
 import { syncTextResolution } from "../text-resolution.js";
 import { createCardTag, formatBoardDuration, syncCardTag, zoomCardTag } from "../card-tag.js";
-import { drawAudioWaveform } from "../audio-waveform.js";
+import { boardCardDetailed } from "../lod.js";
 import { cardElevation, containRect, drawCardSurface, traceCardOutline } from "../surface.js";
 import { positionShell } from "./base-card-renderer.js";
 import { drawFarPlate, farPictureTone } from "./far-plate.js";

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

@@ -1,8 +1,8 @@
 import { estimateTextWidth, layoutBoardText } from "../../../protocol/dist/board-layout.js";
-import { itemAlpha, itemColor } from "../palette.js";
 import { boardTextStyle, canvasFont, cssBaselineShift, layoutTextLines } from "../text-measurement.js";
-import { boardTextSize } from "../lod.js";
 import { syncTextResolution } from "../text-resolution.js";
+import { itemAlpha, itemColor } from "../palette.js";
+import { boardTextSize } from "../lod.js";
 import { positionShell } from "./base-card-renderer.js";
 import { drawFarBars } from "./far-plate.js";
 import { Container, Graphics, Text } from "pixi.js";

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

@@ -1,6 +1,6 @@
 import { getMediaResourceTitle } from "../../model/media.js";
-import { boardCardDetailed } from "../lod.js";
 import { createCardTag, formatBoardDuration, syncCardTag, zoomCardTag } from "../card-tag.js";
+import { boardCardDetailed } from "../lod.js";
 import { cardElevation, containRect, drawCardSurface, fillCardPicture } from "../surface.js";
 import { positionShell } from "./base-card-renderer.js";
 import { drawFarPlate, farPictureTone } from "./far-plate.js";

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

@@ -2,12 +2,14 @@ import { BoardShapeColors } from "../model/palette.js";
 import { BoardThemeId } from "../model/themes.js";
 import { BoardRenderStyle } from "./style.js";
 import { BoardRenderPalette } from "./renderers/board-renderer-registry.js";
+import { BoardThemeBackdrop } from "./backdrop.js";
 //#region src/board/render/theme.d.ts
 type BoardRenderTheme = {
   colorScheme: "dark" | "light";
   palette: BoardRenderPalette;
   colors: BoardShapeColors;
   style: BoardRenderStyle;
+  backdrop?: BoardThemeBackdrop;
 };
 /** A built-in Cohub theme as the app draws it; spread it into export or sampler options. */
 declare function boardRenderTheme(id: BoardThemeId): BoardRenderTheme;

package/dist/board/render/theme.js

@@ -3,12 +3,14 @@ import { resolveBoardRenderStyle } from "./style.js";
 //#region src/board/render/theme.ts
 /** A built-in Cohub theme as the app draws it; spread it into export or sampler options. */
 function boardRenderTheme(id) {
-	const { colorScheme, palette, colors, style } = BOARD_THEME_DATA[id];
+	const data = BOARD_THEME_DATA[id];
+	const { colorScheme, palette, colors, style } = data;
 	return {
 		colorScheme,
 		palette: { ...palette },
 		colors: Object.fromEntries(Object.entries(colors).map(([key, value]) => [key, { ...value }])),
-		style: resolveBoardRenderStyle(colorScheme, style)
+		style: resolveBoardRenderStyle(colorScheme, style),
+		..."backdrop" in data ? { backdrop: structuredClone(data.backdrop) } : {}
 	};
 }
 //#endregion

package/dist/board/replica/index.d.ts

@@ -1,5 +1,5 @@
 import { BoardDelta, BoardDocument, BoardPatch } from "../../protocol/dist/board-model.js";
-import { BoardApplyResult, BoardPlaybackSnapshot, BoardReadResult } from "../../protocol/dist/board.js";
+import { BoardApplyResult, BoardPlaybackSnapshot, BoardReadInput, BoardReadResult } from "../../protocol/dist/board.js";
 import "../../protocol/dist/index.js";
 import { BoardReplicaDatabaseOptions, BoardReplicaScope, clearBoardReplicaStorage, createIndexedDbBoardReplicaStorage } from "./indexeddb.js";
 //#region src/board/replica/index.d.ts
@@ -14,7 +14,8 @@ type BoardChangedPayload = {
   after?: BoardDelta;
 };
 type BoardRemote = {
-  get(): Promise<BoardReadResult>;
+  /** `since` asks only for the changes after that version; remotes may return the full Board. */
+  get(read?: Pick<BoardReadInput, "since">): Promise<BoardReadResult>;
   apply(patch: BoardPatch, options: {
     mutationId: string;
     clientId?: string;

package/dist/board/replica/index.js

@@ -1,6 +1,6 @@
 import { applyBoardDelta, applyBoardPatchToDocument, parseBoardDocument } from "../../protocol/dist/board-patch.js";
 import { createBoardEntityId } from "../model/items/id.js";
-import { shareBoardDocument } from "../model/document-share.js";
+import { readBoardDocument } from "../model/read.js";
 import { clearBoardReplicaStorage, createIndexedDbBoardReplicaStorage } from "./indexeddb.js";
 //#region src/board/replica/index.ts
 function memoryStorage() {
@@ -15,6 +15,7 @@ function memoryStorage() {
 const RETRY_BASE_MS = 1e3;
 const RETRY_MAX_MS = 3e4;
 const PERSIST_INTERVAL_MS = 500;
+const CACHE_WAIT_MS = 250;
 function isRejection(error) {
 	const status = error.status;
 	return typeof status === "number" && status >= 400 && status < 500 && ![
@@ -34,6 +35,7 @@ function createBoardReplica(options) {
 	let unsubscribeRemote = null;
 	let server = null;
 	let version = 0;
+	let sent = [];
 	let title = null;
 	let playback = null;
 	let playbackRevision = 0;
@@ -69,7 +71,7 @@ function createBoardReplica(options) {
 			return;
 		}
 		let next = server;
-		for (const entry of pending) {
+		for (const entry of [...sent, ...pending]) {
 			const result = applyBoardPatchToDocument(next, entry.patch);
 			if (result.ok) next = result.document;
 		}
@@ -95,6 +97,7 @@ function createBoardReplica(options) {
 	function adoptServer(next, nextVersion, persist) {
 		server = next;
 		version = nextVersion;
+		sent = sent.filter((entry) => entry.version > nextVersion);
 		recompute();
 		if (persist) schedulePersist(nextVersion, next);
 	}
@@ -112,21 +115,16 @@ function createBoardReplica(options) {
 		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.`);
+	function adoptRead(result, base, readPlaybackRevision) {
+		const next = readBoardDocument(result, result.changes ? base : server);
 		title = result.title;
 		if (readPlaybackRevision === playbackRevision) playback = result.playback;
 		loaded = true;
-		const next = shareBoardDocument(server, parsed.document);
 		if (next === server && result.version === version) return;
 		adoptServer(next, result.version, true);
 	}
 	function refresh() {
+		if (disposed) return Promise.resolve();
 		if (refreshing) {
 			refreshAgain = true;
 			return refreshing;
@@ -136,9 +134,10 @@ function createBoardReplica(options) {
 				do {
 					refreshAgain = false;
 					const readPlaybackRevision = playbackRevision;
-					const result = await remote.get();
+					const base = server;
+					const result = await remote.get(base ? { since: version } : void 0);
 					if (disposed) return;
-					if (result.version >= version || !loaded) adoptRead(result, readPlaybackRevision);
+					if (result.version >= version || !loaded) adoptRead(result, base, readPlaybackRevision);
 					readError = null;
 					emit();
 				} while (refreshAgain && !disposed);
@@ -162,6 +161,7 @@ function createBoardReplica(options) {
 	async function flush() {
 		if (sending || disposed || !loaded || !restored) return;
 		sending = true;
+		let latest = 0;
 		try {
 			while (pending.length && !disposed) {
 				const entry = pending[0];
@@ -173,12 +173,12 @@ function createBoardReplica(options) {
 					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();
+					if (stillPending && result.status === "applied" && result.version > version) sent = [...sent, {
+						version: result.version,
+						patch: entry.patch
+					}];
+					latest = Math.max(latest, result.version);
+					recompute();
 					retryDelay = RETRY_BASE_MS;
 					writeError = null;
 					emit();
@@ -198,6 +198,7 @@ function createBoardReplica(options) {
 					return;
 				}
 			}
+			if (latest > version && !disposed) refresh();
 		} finally {
 			sending = false;
 		}
@@ -233,15 +234,19 @@ function createBoardReplica(options) {
 	function onOnline() {
 		if (pending.length || readError || writeError) retry();
 	}
-	async function restore() {
-		const [cached, stored] = await Promise.all([storage.readDocument().catch(() => null), storage.listPending().catch(() => [])]);
+	async function restoreDocument() {
+		const cached = await storage.readDocument().catch(() => null);
+		if (disposed || server || !cached) return;
+		const parsed = parseBoardDocument(cached.document);
+		if (parsed.ok) adoptServer(parsed.document, cached.version, false);
+	}
+	async function restore(document) {
+		const [, stored] = await Promise.all([document, storage.listPending().catch(() => [])]);
 		if (disposed) return;
 		const known = new Set(stored.map((entry) => entry.mutationId));
 		pending = [...stored, ...pending.filter((entry) => !known.has(entry.mutationId))];
 		restored = true;
-		const parsed = cached && !server ? parseBoardDocument(cached.document) : null;
-		if (cached && parsed?.ok) adoptServer(parsed.document, cached.version, false);
-		else recompute();
+		recompute();
 		emit();
 	}
 	function receivePlayback(next) {
@@ -260,7 +265,12 @@ function createBoardReplica(options) {
 		async start() {
 			unsubscribeRemote ??= subscribeRemote();
 			globalThis.addEventListener?.("online", onOnline);
-			await Promise.all([restore(), refresh()]);
+			const document = restoreDocument();
+			const cacheWait = new Promise((resolve) => {
+				const timer = setTimeout(resolve, CACHE_WAIT_MS);
+				document.then(() => clearTimeout(timer));
+			});
+			await Promise.all([restore(document), Promise.race([document, cacheWait]).then(refresh)]);
 			await flush();
 		},
 		apply(patch) {

package/dist/board/replica/indexeddb.js

@@ -1,102 +1,31 @@
+import { deleteByIndex, indexedDb } from "../../indexeddb.js";
 //#region src/board/replica/indexeddb.ts
 const DATABASE = "cohub-board";
 const VERSION = 1;
-const OPEN_TIMEOUT_MS = 3e3;
-const connections = /* @__PURE__ */ new Map();
-function open(name) {
-	const existing = connections.get(name);
-	if (existing) return existing;
-	const opening = new Promise((resolve, reject) => {
-		const factory = globalThis.indexedDB;
-		if (!factory) {
-			reject(/* @__PURE__ */ new Error("IndexedDB is unavailable."));
-			return;
-		}
-		let late = false;
-		const timer = setTimeout(() => {
-			late = true;
-			reject(/* @__PURE__ */ new Error("IndexedDB did not open in time."));
-		}, OPEN_TIMEOUT_MS);
-		const request = factory.open(name, VERSION);
-		request.onupgradeneeded = () => {
-			const db = request.result;
-			db.createObjectStore("documents", { keyPath: "board" }).createIndex("user", "userKey");
-			const pending = db.createObjectStore("pending", { keyPath: ["board", "mutationId"] });
-			pending.createIndex("board", "board");
-			pending.createIndex("user", "userKey");
-		};
-		request.onsuccess = () => {
-			clearTimeout(timer);
-			const db = request.result;
-			if (late) {
-				db.close();
-				return;
-			}
-			const forget = () => {
-				if (connections.get(name) === opening) connections.delete(name);
-			};
-			db.onversionchange = () => {
-				db.close();
-				forget();
-			};
-			db.onclose = forget;
-			resolve(db);
-		};
-		request.onerror = () => {
-			clearTimeout(timer);
-			reject(request.error ?? /* @__PURE__ */ new Error("IndexedDB failed to open."));
-		};
-	});
-	connections.set(name, opening);
-	opening.catch(() => {
-		if (connections.get(name) === opening) connections.delete(name);
-	});
-	return opening;
-}
-async function transact(name, stores, mode, work, retry = true) {
-	const db = await open(name);
-	let tx;
-	try {
-		tx = db.transaction(stores, mode);
-	} catch (error) {
-		if (!retry) throw error;
-		db.close();
-		connections.delete(name);
-		return transact(name, stores, mode, work, false);
-	}
-	return new Promise((resolve, reject) => {
-		const result = work(tx);
-		tx.oncomplete = () => resolve(result());
-		tx.onerror = () => reject(tx.error ?? /* @__PURE__ */ new Error("IndexedDB transaction failed."));
-		tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("IndexedDB transaction aborted."));
-	});
-}
-function deleteByIndex(store, index, key) {
-	const request = store.index(index).openKeyCursor(IDBKeyRange.only(key));
-	request.onsuccess = () => {
-		const cursor = request.result;
-		if (!cursor) return;
-		store.delete(cursor.primaryKey);
-		cursor.continue();
-	};
+function upgrade(db) {
+	db.createObjectStore("documents", { keyPath: "board" }).createIndex("user", "userKey");
+	const pending = db.createObjectStore("pending", { keyPath: ["board", "mutationId"] });
+	pending.createIndex("board", "board");
+	pending.createIndex("user", "userKey");
 }
+const database = (name) => indexedDb(name, VERSION, upgrade);
 let lastOrder = 0;
 function createIndexedDbBoardReplicaStorage(scope, options = {}) {
-	const name = options.database ?? DATABASE;
+	const { transact } = database(options.database ?? DATABASE);
 	const board = JSON.stringify([
 		scope.userKey,
 		scope.spaceId,
 		scope.boardId
 	]);
 	return {
-		listPending: () => transact(name, ["pending"], "readonly", (tx) => {
+		listPending: () => transact(["pending"], "readonly", (tx) => {
 			const request = tx.objectStore("pending").index("board").getAll(IDBKeyRange.only(board));
 			return () => request.result.sort((a, b) => a.order - b.order).map(({ mutationId, patch }) => ({
 				mutationId,
 				patch
 			}));
 		}),
-		putPending: ({ mutationId, patch }) => transact(name, ["pending"], "readwrite", (tx) => {
+		putPending: ({ mutationId, patch }) => transact(["pending"], "readwrite", (tx) => {
 			lastOrder = Math.max(Date.now(), lastOrder + 1);
 			const record = {
 				board,
@@ -108,11 +37,11 @@ function createIndexedDbBoardReplicaStorage(scope, options = {}) {
 			tx.objectStore("pending").put(record);
 			return () => void 0;
 		}),
-		deletePending: (mutationId) => transact(name, ["pending"], "readwrite", (tx) => {
+		deletePending: (mutationId) => transact(["pending"], "readwrite", (tx) => {
 			tx.objectStore("pending").delete([board, mutationId]);
 			return () => void 0;
 		}),
-		readDocument: () => transact(name, ["documents"], "readonly", (tx) => {
+		readDocument: () => transact(["documents"], "readonly", (tx) => {
 			const request = tx.objectStore("documents").get(board);
 			return () => {
 				const record = request.result;
@@ -122,7 +51,7 @@ function createIndexedDbBoardReplicaStorage(scope, options = {}) {
 				} : null;
 			};
 		}),
-		writeDocument: (version, document) => transact(name, ["documents"], "readwrite", (tx) => {
+		writeDocument: (version, document) => transact(["documents"], "readwrite", (tx) => {
 			const store = tx.objectStore("documents");
 			const request = store.get(board);
 			request.onsuccess = () => {
@@ -142,7 +71,7 @@ function createIndexedDbBoardReplicaStorage(scope, options = {}) {
 }
 async function clearBoardReplicaStorage(options = {}) {
 	const { userKey } = options;
-	await transact(options.database ?? DATABASE, ["documents", "pending"], "readwrite", (tx) => {
+	await database(options.database ?? DATABASE).transact(["documents", "pending"], "readwrite", (tx) => {
 		for (const name of ["documents", "pending"]) {
 			const store = tx.objectStore(name);
 			if (userKey === void 0) store.clear();

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

@@ -1,7 +1,7 @@
 import { ModelFormat } from "../../protocol/dist/fs/mime.js";
 import { BoardSceneItem } from "../model/scene.js";
 import { BoardAssetMedia, BoardAssetRef } from "../model/asset-key.js";
-import { BoardAssetUrlOptions } from "../model/media-playback.js";
+import { BoardAssetSource } from "../model/media-playback.js";
 import "../model/index.js";
 import { LruBudget } from "./lru.js";
 import { BoardImageTexturePool } from "./texture-pool.js";
@@ -25,7 +25,7 @@ type BoardModelPreviews = {
 type BoardAssetManager = {
   assetKey: (item: BoardSceneItem) => string | null;
   invalidatePath: (path: string) => void;
-  invalidateItemAssets: () => void;
+  invalidateItemAssets: (ids?: Iterable<string>) => void;
   requestItem: (item: BoardSceneItem, edge?: number) => void;
   /** World point used to prioritize queued loads. */
   focus: (point: {
@@ -60,7 +60,8 @@ type BoardAssetPrefetch = {
 type BoardAssetChange = "texture" | "tone";
 type BoardAssetManagerOptions = {
   /** Resolve a Space file path to a URL a texture can load from; null when unavailable. */
-  resolveFileUrl: (path: string, options?: BoardAssetUrlOptions) => Promise<string | null>;
+  resolveFile: BoardAssetSource["resolveFile"];
+  subscribe?: BoardAssetSource["subscribe"];
   /** undefined keeps the built-in rule, null shows none; cached until `invalidateItemAssets`. */
   itemAsset?: (item: BoardSceneItem) => BoardAssetRef | null | undefined;
   concurrency?: number;