@neta-art/cohub 12.2.0 → 12.4.0

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

@@ -1,6 +1,7 @@
 import { BoardDelta, BoardDocument, BoardPatch } from "../../protocol/dist/board-model.js";
 import { BoardApplyResult, BoardPlaybackSnapshot, 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
 type BoardPendingPatch = {
   mutationId: string;
@@ -27,6 +28,7 @@ type BoardRemote = {
         playback: BoardPlaybackSnapshot | null;
       };
     }) => void;
+    resync?: () => void;
   }): () => void;
 };
 type BoardReplicaStorage = {
@@ -62,9 +64,9 @@ declare function createBoardReplica(options: BoardReplicaOptions): {
   receive: (payload: BoardChangedPayload) => void;
   receivePlayback: (next: BoardPlaybackSnapshot | null) => void;
   refresh: () => Promise<void>;
-  retry(): Promise<void>;
+  retry: () => Promise<void>;
   dispose(): void;
 };
 type BoardReplica = ReturnType<typeof createBoardReplica>;
 //#endregion
-export { BoardChangedPayload, BoardPendingPatch, BoardRemote, BoardReplica, BoardReplicaOptions, BoardReplicaState, BoardReplicaStorage, createBoardReplica };
+export { BoardChangedPayload, BoardPendingPatch, BoardRemote, BoardReplica, type BoardReplicaDatabaseOptions, BoardReplicaOptions, type BoardReplicaScope, BoardReplicaState, BoardReplicaStorage, clearBoardReplicaStorage, createBoardReplica, createIndexedDbBoardReplicaStorage };

package/dist/board/replica/index.js

@@ -1,6 +1,7 @@
 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 { clearBoardReplicaStorage, createIndexedDbBoardReplicaStorage } from "./indexeddb.js";
 //#region src/board/replica/index.ts
 function memoryStorage() {
 	return {
@@ -47,6 +48,7 @@ function createBoardReplica(options) {
 	let retryTimer = null;
 	let retryDelay = RETRY_BASE_MS;
 	let disposed = false;
+	let restored = false;
 	let unpersisted = null;
 	let persistTimer = null;
 	function subscribeRemote() {
@@ -54,7 +56,8 @@ function createBoardReplica(options) {
 		try {
 			return remote.subscribe({
 				changed: (event) => receive(event.payload),
-				playback: (event) => receivePlayback(event.payload.playback)
+				playback: (event) => receivePlayback(event.payload.playback),
+				resync: () => void retry()
 			});
 		} catch {
 			return null;
@@ -157,7 +160,7 @@ function createBoardReplica(options) {
 		retryDelay = Math.min(RETRY_MAX_MS, retryDelay * 2);
 	}
 	async function flush() {
-		if (sending || disposed || !loaded) return;
+		if (sending || disposed || !loaded || !restored) return;
 		sending = true;
 		try {
 			while (pending.length && !disposed) {
@@ -217,6 +220,30 @@ function createBoardReplica(options) {
 		}
 		emit();
 	}
+	function retry() {
+		if (disposed) return Promise.resolve();
+		if (retryTimer) clearTimeout(retryTimer);
+		retryTimer = null;
+		retryDelay = RETRY_BASE_MS;
+		readError = null;
+		writeError = null;
+		emit();
+		return refresh().then(flush);
+	}
+	function onOnline() {
+		if (pending.length || readError || writeError) retry();
+	}
+	async function restore() {
+		const [cached, stored] = await Promise.all([storage.readDocument().catch(() => null), 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();
+		emit();
+	}
 	function receivePlayback(next) {
 		playbackRevision += 1;
 		playback = next;
@@ -232,15 +259,8 @@ function createBoardReplica(options) {
 		},
 		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();
+			globalThis.addEventListener?.("online", onOnline);
+			await Promise.all([restore(), refresh()]);
 			await flush();
 		},
 		apply(patch) {
@@ -256,17 +276,10 @@ function createBoardReplica(options) {
 		receive,
 		receivePlayback,
 		refresh,
-		retry() {
-			if (retryTimer) clearTimeout(retryTimer);
-			retryTimer = null;
-			retryDelay = RETRY_BASE_MS;
-			readError = null;
-			writeError = null;
-			emit();
-			return refresh().then(flush);
-		},
+		retry,
 		dispose() {
 			disposed = true;
+			globalThis.removeEventListener?.("online", onOnline);
 			unsubscribeRemote?.();
 			unsubscribeRemote = null;
 			listeners.clear();
@@ -276,4 +289,4 @@ function createBoardReplica(options) {
 	};
 }
 //#endregion
-export { createBoardReplica };
+export { clearBoardReplicaStorage, createBoardReplica, createIndexedDbBoardReplicaStorage };

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

@@ -0,0 +1,16 @@
+import { BoardReplicaStorage } from "./index.js";
+//#region src/board/replica/indexeddb.d.ts
+type BoardReplicaScope = {
+  userKey: string;
+  spaceId: string;
+  boardId: string;
+};
+type BoardReplicaDatabaseOptions = {
+  database?: string;
+};
+declare function createIndexedDbBoardReplicaStorage(scope: BoardReplicaScope, options?: BoardReplicaDatabaseOptions): BoardReplicaStorage;
+declare function clearBoardReplicaStorage(options?: BoardReplicaDatabaseOptions & {
+  userKey?: string;
+}): Promise<void>;
+//#endregion
+export { BoardReplicaDatabaseOptions, BoardReplicaScope, clearBoardReplicaStorage, createIndexedDbBoardReplicaStorage };

package/dist/board/replica/indexeddb.js

@@ -0,0 +1,155 @@
+//#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();
+	};
+}
+let lastOrder = 0;
+function createIndexedDbBoardReplicaStorage(scope, options = {}) {
+	const name = options.database ?? DATABASE;
+	const board = JSON.stringify([
+		scope.userKey,
+		scope.spaceId,
+		scope.boardId
+	]);
+	return {
+		listPending: () => transact(name, ["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) => {
+			lastOrder = Math.max(Date.now(), lastOrder + 1);
+			const record = {
+				board,
+				mutationId,
+				userKey: scope.userKey,
+				order: lastOrder,
+				patch
+			};
+			tx.objectStore("pending").put(record);
+			return () => void 0;
+		}),
+		deletePending: (mutationId) => transact(name, ["pending"], "readwrite", (tx) => {
+			tx.objectStore("pending").delete([board, mutationId]);
+			return () => void 0;
+		}),
+		readDocument: () => transact(name, ["documents"], "readonly", (tx) => {
+			const request = tx.objectStore("documents").get(board);
+			return () => {
+				const record = request.result;
+				return record ? {
+					version: record.version,
+					document: record.document
+				} : null;
+			};
+		}),
+		writeDocument: (version, document) => transact(name, ["documents"], "readwrite", (tx) => {
+			const store = tx.objectStore("documents");
+			const request = store.get(board);
+			request.onsuccess = () => {
+				const current = request.result;
+				if (current && current.version > version) return;
+				const record = {
+					board,
+					userKey: scope.userKey,
+					version,
+					document
+				};
+				store.put(record);
+			};
+			return () => void 0;
+		})
+	};
+}
+async function clearBoardReplicaStorage(options = {}) {
+	const { userKey } = options;
+	await transact(options.database ?? DATABASE, ["documents", "pending"], "readwrite", (tx) => {
+		for (const name of ["documents", "pending"]) {
+			const store = tx.objectStore(name);
+			if (userKey === void 0) store.clear();
+			else deleteByIndex(store, "user", userKey);
+		}
+		return () => void 0;
+	});
+}
+//#endregion
+export { clearBoardReplicaStorage, createIndexedDbBoardReplicaStorage };

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

@@ -1,6 +1,6 @@
 import { ModelFormat } from "../../protocol/dist/fs/mime.js";
 import { BoardSceneItem } from "../model/scene.js";
-import { BoardAssetMedia } from "../model/asset-key.js";
+import { BoardAssetMedia, BoardAssetRef } from "../model/asset-key.js";
 import { BoardAssetUrlOptions } from "../model/media-playback.js";
 import "../model/index.js";
 import { LruBudget } from "./lru.js";
@@ -25,6 +25,7 @@ type BoardModelPreviews = {
 type BoardAssetManager = {
   assetKey: (item: BoardSceneItem) => string | null;
   invalidatePath: (path: string) => void;
+  invalidateItemAssets: () => void;
   requestItem: (item: BoardSceneItem, edge?: number) => void;
   /** World point used to prioritize queued loads. */
   focus: (point: {
@@ -33,25 +34,35 @@ type BoardAssetManager = {
   } | null) => void;
   getTexture: (key: string) => Texture | null;
   getNaturalSize: (key: string) => Size | null;
+  getTone: (key: string) => number | null;
   hasError: (key: string) => boolean;
   acquire: (key: string) => void;
   release: (key: string) => void;
+  prefetch?: (requests: readonly BoardAssetPrefetch[]) => void;
   withTextures: <T>(items: BoardSceneItem[], use: (textures: Map<string, Texture>) => T | Promise<T>, options?: {
     timeoutMs?: number;
     edge?: (item: BoardSceneItem) => number;
   }) => Promise<T>;
-  subscribe: (listener: (key: string) => void) => () => void;
-  /** Current texture and cooling-cache usage. */
+  subscribe: (listener: (key: string, change: BoardAssetChange) => void) => () => void;
   stats: () => {
     textures: number;
     cooling: number;
     bytes: number;
+    loading?: number;
+    prefetching?: number;
   };
   destroy: () => void;
 };
+type BoardAssetPrefetch = {
+  item: BoardSceneItem;
+  edge: number;
+};
+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>;
+  /** undefined keeps the built-in rule, null shows none; cached until `invalidateItemAssets`. */
+  itemAsset?: (item: BoardSceneItem) => BoardAssetRef | null | undefined;
   concurrency?: number;
   videoConcurrency?: number;
   loadVideoPreviews?: boolean;
@@ -62,8 +73,9 @@ type BoardAssetManagerOptions = {
   unloadTexture?: (url: string, texture: Texture | null, media: BoardAssetMedia) => Promise<void>;
   /** An unshared copy of an image texture at `edge`; null keeps evicting outright. */
   shrinkTexture?: (texture: Texture, edge: number) => Promise<Texture | null>;
+  readTone?: ((texture: Texture) => Promise<number | null>) | null;
   now?: () => number;
 };
 declare function createBoardAssetManager(options: BoardAssetManagerOptions): BoardAssetManager;
 //#endregion
-export { BoardAssetManager, BoardAssetManagerOptions, BoardModelPreviewRequest, BoardModelPreviews, createBoardAssetManager };
+export { BoardAssetChange, BoardAssetManager, BoardAssetManagerOptions, BoardAssetPrefetch, BoardModelPreviewRequest, BoardModelPreviews, createBoardAssetManager };