@neta-art/cohub 12.4.0 → 12.6.0

package/README.md

@@ -95,6 +95,14 @@ await session.messages.send({
 });
 ```
 
+## Space files
+
+`space.files.read(path)` and `space.files.resolveUrl(path)` share requests: reads
+made in the same task become one batched read, and concurrent reads of a file
+share one request. In browsers with realtime, resolved URLs are remembered per
+user across reloads, confirmed in the background and dropped when the file
+changes; call `clearFileUrlCache()` on sign-out.
+
 ## Boards
 
 A Board is one document of `board` settings, `items` and `animations`. Bind
@@ -197,16 +205,14 @@ editor.addMedia("https://cdn.example.com/media?id=42", worldPoint(400, 0), {
   snapshot: { title: "Launch", naturalWidth: 1920, naturalHeight: 1080 },
 });
 
-// Media URLs load directly; these callbacks only receive Space paths.
-// A published copy can resolve paths against captured artifacts instead.
-const source = {
-  resolveFileUrl: (path: string) => space.files.resolveUrl(path, { purpose: "preview" }),
-  resolvePlaybackUrl: (path: string) => space.files.resolveUrl(path, { purpose: "playback" }),
-};
+// Media URLs load directly; Space paths resolve through the Space's file URLs,
+// which reload pictures when their file changes. A published copy can resolve
+// paths against captured artifacts instead.
+const source = space.boards.assetSource();
 const stage = mountBoardStage(element, {
   editor,
   source,
-  assets: createBoardAssetManager({ resolveFileUrl: source.resolveFileUrl }),
+  assets: createBoardAssetManager(source),
   views: [{
     type: "acme.order",
     // Mount anything: a React root, a Vue app, plain DOM.
@@ -245,9 +251,10 @@ Pictures your own items show go through `itemAsset`. They share the built-in
 loader: CDN variants sized to the screen, loads ordered by where the view is
 heading, prefetch, compact copies when panned away, device budgets, one cache
 and exports. `src` is a Space path, resolved like an image item's, or a URL;
-`fit: "cover"` sizes pictures cropped to fill their box by the short edge. Call
-`invalidateItemAssets()` when the data it reads changes, and `invalidatePath`
-when a file changes:
+`fit: "cover"` sizes pictures cropped to fill their box by the short edge. When
+the data it reads changes for some items, call `invalidateItemAssets(ids)` and
+`stage.invalidate({ items: ids })` (omit `ids` when everything changed); call
+`invalidatePath` when a file changes:
 
 ```ts
 const assets = createBoardAssetManager({

package/dist/board/model/media-playback.d.ts

@@ -6,6 +6,7 @@ type BoardAssetUrlOptions = {
 type BoardAssetSource = {
   resolveFileUrl: (path: string, options?: BoardAssetUrlOptions) => Promise<string | null>;
   resolvePlaybackUrl?: (path: string, options?: BoardAssetUrlOptions) => Promise<string | null>;
+  subscribe?: (listener: (path: string) => void) => () => void;
 };
 declare function resolveBoardMediaUrl(src: string, source: BoardAssetSource, purpose?: "preview" | "playback"): Promise<string | null>;
 type BoardPlayableMedia = {

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>;
+  /** `only: []` reads metadata only; remotes may return the full Board. */
+  get(read?: Pick<BoardReadInput, "only">): Promise<BoardReadResult>;
   apply(patch: BoardPatch, options: {
     mutationId: string;
     clientId?: string;

package/dist/board/replica/index.js

@@ -57,7 +57,7 @@ function createBoardReplica(options) {
 			return remote.subscribe({
 				changed: (event) => receive(event.payload),
 				playback: (event) => receivePlayback(event.payload.playback),
-				resync: () => void retry()
+				resync: () => void resync()
 			});
 		} catch {
 			return null;
@@ -220,7 +220,7 @@ function createBoardReplica(options) {
 		}
 		emit();
 	}
-	function retry() {
+	function retry(read = true) {
 		if (disposed) return Promise.resolve();
 		if (retryTimer) clearTimeout(retryTimer);
 		retryTimer = null;
@@ -228,7 +228,18 @@ function createBoardReplica(options) {
 		readError = null;
 		writeError = null;
 		emit();
-		return refresh().then(flush);
+		return (read ? refresh() : Promise.resolve()).then(flush);
+	}
+	async function resync() {
+		await refreshing;
+		if (disposed) return;
+		if (!loaded || readError) return retry();
+		const revision = playbackRevision;
+		const head = await remote.get({ only: [] }).catch(() => null);
+		if (disposed) return;
+		if (!head || head.version > version) return retry();
+		if (revision === playbackRevision) playback = head.playback;
+		return retry(false);
 	}
 	function onOnline() {
 		if (pending.length || readError || writeError) retry();
@@ -276,7 +287,7 @@ function createBoardReplica(options) {
 		receive,
 		receivePlayback,
 		refresh,
-		retry,
+		retry: () => retry(),
 		dispose() {
 			disposed = true;
 			globalThis.removeEventListener?.("online", onOnline);

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, BoardAssetUrlOptions } 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: {
@@ -61,6 +61,7 @@ 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>;
+  subscribe?: BoardAssetSource["subscribe"];
   /** undefined keeps the built-in rule, null shows none; cached until `invalidateItemAssets`. */
   itemAsset?: (item: BoardSceneItem) => BoardAssetRef | null | undefined;
   concurrency?: number;

package/dist/board/stage/assets.js

@@ -80,6 +80,7 @@ function createBoardAssetManager(options) {
 	}
 	const resolveFileUrl = options.resolveFileUrl;
 	const entries = /* @__PURE__ */ new Map();
+	const keysByPath = /* @__PURE__ */ new Map();
 	const pathVersions = /* @__PURE__ */ new Map();
 	const starters = /* @__PURE__ */ new Map();
 	const failedModels = /* @__PURE__ */ new Set();
@@ -92,6 +93,7 @@ function createBoardAssetManager(options) {
 		model: 0
 	};
 	let disposed = false;
+	let stopSource = null;
 	let focus = null;
 	let trimTimer = null;
 	let trimSince = 0;
@@ -131,16 +133,33 @@ function createBoardAssetManager(options) {
 		cancelTone = toneQueue.size > 0 ? scheduleBoardIdle(readNextTone, 0) : null;
 	}
 	const keys = /* @__PURE__ */ new WeakMap();
+	const itemEpochs = /* @__PURE__ */ new Map();
 	let keyEpoch = 0;
 	function managedAssetKey(item) {
-		const cached = keys.get(item);
-		if (cached?.epoch === keyEpoch) return cached.key;
-		const key = resolveAssetKey(item);
-		keys.set(item, {
-			epoch: keyEpoch,
-			key
-		});
-		return key;
+		const itemEpoch = itemEpochs.get(item.id) ?? 0;
+		let record = keys.get(item);
+		if (record?.epoch !== keyEpoch || record.itemEpoch !== itemEpoch) {
+			const base = resolveAssetKey(item);
+			const source = base ? boardAssetKeySource(base) : null;
+			const path = source?.kind === "file" ? source.value : null;
+			record = {
+				epoch: keyEpoch,
+				itemEpoch,
+				base,
+				path,
+				version: 0,
+				key: base
+			};
+			keys.set(item, record);
+		}
+		if (record.path !== null) {
+			const version = pathVersions.get(record.path) ?? 0;
+			if (version !== record.version) {
+				record.version = version;
+				record.key = `local:${version}:${record.base}`;
+			}
+		}
+		return record.key;
 	}
 	function resolveAssetKey(item) {
 		const asset = options.itemAsset?.(item);
@@ -149,9 +168,7 @@ function createBoardAssetManager(options) {
 		const source = boardAssetKeySource(key);
 		if (source?.media === "video" && options.loadVideoPreviews === false) return null;
 		if (source?.media === "model" && !modelPreviewable(item)) return null;
-		if (source?.kind !== "file") return key;
-		const version = pathVersions.get(source.value) ?? 0;
-		return version > 0 ? `local:${version}:${key}` : key;
+		return key;
 	}
 	function clearRetry(entry) {
 		if (entry.retryTimer) {
@@ -163,9 +180,11 @@ function createBoardAssetManager(options) {
 		let entry = entries.get(key);
 		if (!entry) {
 			const source = boardAssetKeySource(key);
+			const path = source?.kind === "file" ? source.value : null;
 			entry = {
 				media: source?.media ?? "image",
 				cover: source?.fit === "cover",
+				path,
 				source: null,
 				url: null,
 				texture: null,
@@ -182,6 +201,11 @@ function createBoardAssetManager(options) {
 				lastUsedAt: now()
 			};
 			entries.set(key, entry);
+			if (path !== null) {
+				const keyed = keysByPath.get(path);
+				if (keyed) keyed.add(key);
+				else keysByPath.set(path, /* @__PURE__ */ new Set([key]));
+			}
 		}
 		return entry;
 	}
@@ -203,6 +227,10 @@ function createBoardAssetManager(options) {
 		starters.delete(key);
 		if (entry.url || entry.texture) releaseTexture(entry.media, entry.url ?? "", entry.texture);
 		entries.delete(key);
+		if (entry.path === null) return;
+		const keyed = keysByPath.get(entry.path);
+		keyed?.delete(key);
+		if (keyed?.size === 0) keysByPath.delete(entry.path);
 	}
 	function scheduleTrim() {
 		const at = now();
@@ -464,18 +492,19 @@ function createBoardAssetManager(options) {
 	const manager = {
 		assetKey: managedAssetKey,
 		invalidatePath(path) {
-			if (disposed) return;
-			const stale = [...entries.keys()].filter((key) => {
-				const source = boardAssetKeySource(key);
-				return source?.kind === "file" && source.value === path;
-			});
-			if (stale.length === 0) return;
+			const stale = keysByPath.get(path);
+			if (disposed || !stale) return;
 			pathVersions.set(path, (pathVersions.get(path) ?? 0) + 1);
-			keyEpoch += 1;
-			for (const key of stale) notify(key);
+			for (const key of [...stale]) notify(key);
 		},
-		invalidateItemAssets() {
-			if (options.itemAsset) keyEpoch += 1;
+		invalidateItemAssets(ids) {
+			if (!options.itemAsset) return;
+			if (!ids) {
+				keyEpoch += 1;
+				itemEpochs.clear();
+				return;
+			}
+			for (const id of ids) itemEpochs.set(id, (itemEpochs.get(id) ?? 0) + 1);
 		},
 		requestItem(item, edge = Number.POSITIVE_INFINITY) {
 			if (disposed) return;
@@ -659,6 +688,7 @@ function createBoardAssetManager(options) {
 		},
 		destroy() {
 			disposed = true;
+			stopSource?.();
 			if (trimTimer !== null) clearTimeout(trimTimer);
 			trimTimer = null;
 			cancelTone?.();
@@ -669,6 +699,7 @@ function createBoardAssetManager(options) {
 			unwarmable.clear();
 			listeners.clear();
 			pathVersions.clear();
+			itemEpochs.clear();
 			starters.clear();
 			failedModels.clear();
 			for (const [key, entry] of entries) evict(key, entry);
@@ -676,6 +707,7 @@ function createBoardAssetManager(options) {
 			for (const release of [...retiring]) release();
 		}
 	};
+	stopSource = options.subscribe?.((path) => manager.invalidatePath(path)) ?? null;
 	return manager;
 }
 //#endregion

package/dist/board/stage/scene.js

@@ -14,6 +14,7 @@ const Z_LIVE_STROKE = Number.MAX_SAFE_INTEGER - 1;
 const Z_OVERLAY = Number.MAX_SAFE_INTEGER;
 const POOL_LIMIT_PER_RENDERER = 48;
 const EMPTY_IDS = /* @__PURE__ */ new Set();
+const NO_PLATES = /* @__PURE__ */ new Map();
 function idSetSignature(ids) {
 	let hash = ids.size;
 	for (const id of ids) {
@@ -257,13 +258,19 @@ function createBoardScene(options) {
 	let paintedPlan = null;
 	let paintedSig = "";
 	let platesPending = false;
-	let covered = EMPTY_IDS;
+	let covered = NO_PLATES;
 	/**
 	* Repaint the plates whose cards changed, within a per-frame budget. A card
 	* is covered once a plate draws it; until then it stays live if it already is.
 	*/
 	function paintPlates(input, current) {
 		const { context, globalSig, scene } = input;
+		for (const id of input.staleIds ?? EMPTY_IDS) {
+			const plate = covered.get(id);
+			if (!plate) continue;
+			plate.sig = "";
+			paintedPlan = null;
+		}
 		if (current === paintedPlan && globalSig === paintedSig) return false;
 		const start = performance.now();
 		const allowance = budget.allow("plate");
@@ -303,8 +310,8 @@ function createBoardScene(options) {
 			plate.graphics.destroy();
 			changed = true;
 		}
-		const next = /* @__PURE__ */ new Set();
-		for (const plate of plates.values()) for (const item of plate.items) next.add(item.id);
+		const next = /* @__PURE__ */ new Map();
+		for (const plate of plates.values()) for (const item of plate.items) next.set(item.id, plate);
 		covered = next;
 		budget.spend("plate", painted, paintMs);
 		platesPending = pending;
@@ -328,7 +335,7 @@ function createBoardScene(options) {
 		paintedPlan = null;
 		paintedSig = "";
 		platesPending = false;
-		covered = EMPTY_IDS;
+		covered = NO_PLATES;
 		plan = null;
 		planInputs = [];
 		nearIds = EMPTY_IDS;

package/dist/chunks/app-realtime.js

@@ -1,4 +1,4 @@
-import { O as readRtcTransportStats, k as waitForIceGathering } from "./http.js";
+import { A as readRtcTransportStats, j as waitForIceGathering } from "./http.js";
 import { c as HttpError, p as REALTIME_ROOM_EVENT_NAME_PATTERN } from "./http-error.js";
 import { z } from "zod";
 //#region \0rolldown/runtime.js