@neta-art/cohub 9.0.1 → 10.0.0

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 };

package/dist/board/stage/assets.js

@@ -0,0 +1,350 @@
+import { mediaPreviewCandidates } from "../../media.js";
+import { featuredTaskArtifact } from "../model/task.js";
+import { boardImageKeySource, imageAssetKey } from "../model/image-key.js";
+import { loadVideoThumbnailTexture, videoTextureNaturalSize } from "../render/video-thumbnail.js";
+import { DEFAULT_LRU_BUDGET, selectLruEvictions } from "./lru.js";
+import { boardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture } from "./texture-pool.js";
+//#region src/board/stage/assets.ts
+const TASK_TEXTURE_SIZE = 1536;
+function taskPreviewKey(artifact) {
+	if (!artifact || artifact.type === "text") return null;
+	const [still] = mediaPreviewCandidates(artifact, { size: TASK_TEXTURE_SIZE });
+	if (still) return `url:${still}`;
+	return artifact.type === "video" ? `video-url:${encodeURIComponent(artifact.url)}` : null;
+}
+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"}`;
+	return imageAssetKey(item);
+}
+function keySource(key) {
+	let baseKey = key;
+	if (key.startsWith("local:")) {
+		const separator = key.indexOf(":", 6);
+		if (separator < 0) return null;
+		baseKey = key.slice(separator + 1);
+	}
+	if (baseKey.startsWith("video-url:")) try {
+		return {
+			kind: "url",
+			media: "video",
+			value: decodeURIComponent(baseKey.slice(10))
+		};
+	} catch {
+		return null;
+	}
+	if (baseKey.startsWith("video:")) {
+		const separator = baseKey.lastIndexOf(":");
+		if (separator <= 6) return null;
+		try {
+			return {
+				kind: "file",
+				media: "video",
+				value: decodeURIComponent(baseKey.slice(6, separator))
+			};
+		} catch {
+			return null;
+		}
+	}
+	const image = boardImageKeySource(baseKey);
+	return image ? {
+		...image,
+		media: "image"
+	} : null;
+}
+const MAX_RETRY_DELAY = 3e4;
+function footprintOf(texture) {
+	if (!texture) return 0;
+	return (texture.width || 0) * (texture.height || 0) * 4;
+}
+function createBoardAssetManager(options) {
+	const concurrency = Math.max(1, options.concurrency ?? 4);
+	const videoConcurrency = Math.max(1, Math.min(options.videoConcurrency ?? 2, concurrency));
+	const budget = options.lruBudget ?? DEFAULT_LRU_BUDGET;
+	const now = options.now ?? (() => Date.now());
+	const imagePool = options.imageTexturePool ?? boardImageTexturePool;
+	const useSharedImagePool = !options.loadTexture && !options.unloadTexture;
+	const loadTexture = options.loadTexture ?? ((url, media) => media === "video" ? loadVideoThumbnailTexture(url) : useSharedImagePool ? imagePool.acquire(url) : loadBoardImageTexture(url));
+	const pendingUnloads = /* @__PURE__ */ new Map();
+	const unloadTexture = options.unloadTexture ?? (async (url, texture, media) => {
+		if (media === "video" || !url) {
+			texture?.destroy(true);
+			return;
+		}
+		if (useSharedImagePool) {
+			await imagePool.release(url);
+			return;
+		}
+		await unloadBoardImageTexture(url, texture);
+	});
+	function releaseTexture(key, url, texture) {
+		const media = keySource(key)?.media ?? "image";
+		const pendingKey = `${media}:${url}`;
+		const promise = unloadTexture(url, texture, media).catch(() => {}).then(() => {
+			if (url && pendingUnloads.get(pendingKey) === promise) pendingUnloads.delete(pendingKey);
+		});
+		if (url) pendingUnloads.set(pendingKey, promise);
+	}
+	const resolveFileUrl = options.resolveFileUrl;
+	const entries = /* @__PURE__ */ new Map();
+	const pathVersions = /* @__PURE__ */ new Map();
+	const resolvers = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Set();
+	const queue = [];
+	const listeners = /* @__PURE__ */ new Set();
+	let active = 0;
+	let activeVideos = 0;
+	let disposed = false;
+	function notify() {
+		for (const listener of listeners) listener();
+	}
+	function managedAssetKey(item) {
+		const key = boardAssetKey(item);
+		if (!key) return null;
+		const source = keySource(key);
+		if (source?.media === "video" && options.loadVideoPreviews === false) return null;
+		if (source?.kind !== "file") return key;
+		const version = pathVersions.get(source.value) ?? 0;
+		return version > 0 ? `local:${version}:${key}` : key;
+	}
+	function clearRetry(entry) {
+		if (entry.retryTimer) {
+			clearTimeout(entry.retryTimer);
+			entry.retryTimer = null;
+		}
+	}
+	function ensureEntry(key) {
+		let entry = entries.get(key);
+		if (!entry) {
+			entry = {
+				url: null,
+				texture: null,
+				refs: 0,
+				loading: false,
+				error: false,
+				attempts: 0,
+				retryAt: 0,
+				retryTimer: null,
+				lastUsedAt: now()
+			};
+			entries.set(key, entry);
+		}
+		return entry;
+	}
+	function scheduleRetry(key, entry) {
+		clearRetry(entry);
+		const delay = Math.max(0, entry.retryAt - now());
+		entry.retryTimer = setTimeout(() => {
+			entry.retryTimer = null;
+			if (disposed || entries.get(key) !== entry) return;
+			if (entry.refs <= 0 || entry.texture || entry.loading) return;
+			const getUrl = resolvers.get(key);
+			if (!getUrl) return;
+			entry.error = false;
+			if (!queue.some((task) => task.key === key)) {
+				queue.push({
+					key,
+					getUrl
+				});
+				pump();
+			}
+		}, delay);
+	}
+	function evict(key, entry) {
+		clearRetry(entry);
+		resolvers.delete(key);
+		if (entry.url || entry.texture) releaseTexture(key, entry.url ?? "", entry.texture);
+		entries.delete(key);
+	}
+	function trim() {
+		const cooling = [];
+		for (const [key, entry] of entries) if (entry.refs <= 0 && entry.texture && !entry.loading) cooling.push({
+			key,
+			lastUsedAt: entry.lastUsedAt,
+			bytes: footprintOf(entry.texture)
+		});
+		const evictions = selectLruEvictions(cooling, budget);
+		for (const key of evictions) {
+			const entry = entries.get(key);
+			if (entry) evict(key, entry);
+		}
+	}
+	function settle(key, entry, texture, error) {
+		entry.loading = false;
+		inflight.delete(key);
+		active -= 1;
+		if (keySource(key)?.media === "video") activeVideos -= 1;
+		if (entries.get(key) !== entry) {
+			if (texture) releaseTexture(key, entry.url ?? "", texture);
+			if (!disposed) pump();
+			return;
+		}
+		if (texture) {
+			entry.error = false;
+			entry.attempts = 0;
+			entry.texture = texture;
+			entry.lastUsedAt = now();
+			if (entry.refs <= 0) trim();
+			else notify();
+		} else {
+			entry.error = true;
+			entry.attempts += 1;
+			entry.retryAt = now() + Math.min(1e3 * 2 ** entry.attempts, MAX_RETRY_DELAY);
+			console.warn(`[board] failed to load preview for ${key}`, error);
+			if (entry.refs <= 0) evict(key, entry);
+			else {
+				scheduleRetry(key, entry);
+				notify();
+			}
+		}
+		if (!disposed) pump();
+	}
+	function pump() {
+		while (!disposed && active < concurrency && queue.length > 0) {
+			const taskIndex = queue.findIndex(({ key }) => {
+				return keySource(key)?.media !== "video" || activeVideos < videoConcurrency;
+			});
+			if (taskIndex < 0) return;
+			const [task] = queue.splice(taskIndex, 1);
+			if (!task) continue;
+			const entry = entries.get(task.key);
+			const source = keySource(task.key);
+			if (!entry || !source || entry.texture || entry.loading) continue;
+			entry.loading = true;
+			inflight.add(task.key);
+			active += 1;
+			if (source.media === "video") activeVideos += 1;
+			task.getUrl().then(async (url) => {
+				if (!url || disposed) return null;
+				entry.url = url;
+				const pendingKey = `${source.media}:${url}`;
+				const pending = pendingUnloads.get(pendingKey);
+				if (pending) await pending;
+				if (disposed) return null;
+				return loadTexture(url, source.media);
+			}).then((texture) => settle(task.key, entry, texture ?? null), (error) => settle(task.key, entry, null, error));
+		}
+	}
+	const manager = {
+		assetKey: managedAssetKey,
+		invalidatePath(path) {
+			if (disposed) return;
+			if (![...entries.keys()].some((key) => {
+				const source = keySource(key);
+				return source?.kind === "file" && source.value === path;
+			})) return;
+			pathVersions.set(path, (pathVersions.get(path) ?? 0) + 1);
+			notify();
+		},
+		requestItem(item) {
+			if (disposed) return;
+			const key = managedAssetKey(item);
+			if (!key) return;
+			const source = keySource(key);
+			if (!source) return;
+			const entry = ensureEntry(key);
+			entry.lastUsedAt = now();
+			if (entry.texture || entry.loading) return;
+			if (entry.error && now() < entry.retryAt) return;
+			entry.error = false;
+			clearRetry(entry);
+			if (queue.some((queued) => queued.key === key)) return;
+			const getUrl = source.kind === "url" ? () => Promise.resolve(source.value) : () => resolveFileUrl(source.value);
+			resolvers.set(key, getUrl);
+			queue.push({
+				key,
+				getUrl
+			});
+			pump();
+		},
+		getTexture(key) {
+			const entry = entries.get(key);
+			if (!entry?.texture) return null;
+			entry.lastUsedAt = now();
+			return entry.texture;
+		},
+		getNaturalSize(key) {
+			const texture = manager.getTexture(key);
+			if (!texture) return null;
+			return videoTextureNaturalSize(texture) ?? {
+				width: texture.width,
+				height: texture.height
+			};
+		},
+		hasError(key) {
+			return entries.get(key)?.error ?? false;
+		},
+		acquire(key) {
+			const entry = ensureEntry(key);
+			entry.refs += 1;
+			entry.lastUsedAt = now();
+		},
+		release(key) {
+			const entry = entries.get(key);
+			if (!entry) return;
+			entry.refs -= 1;
+			if (entry.refs > 0) return;
+			entry.lastUsedAt = now();
+			clearRetry(entry);
+			if (entry.loading) return;
+			if (!entry.texture) evict(key, entry);
+			else trim();
+		},
+		async withTextures(items, use, loadOptions) {
+			const keys = /* @__PURE__ */ new Set();
+			if (!disposed) for (const item of items) {
+				const key = managedAssetKey(item);
+				if (key) keys.add(key);
+			}
+			const textures = /* @__PURE__ */ new Map();
+			if (keys.size === 0) return use(textures);
+			for (const key of keys) manager.acquire(key);
+			try {
+				for (const item of items) manager.requestItem(item);
+				const settled = () => [...keys].every((key) => {
+					const entry = entries.get(key);
+					return Boolean(entry?.texture) || Boolean(entry?.error);
+				});
+				if (!settled()) {
+					const timeoutMs = loadOptions?.timeoutMs ?? 15e3;
+					await new Promise((resolve) => {
+						const timer = setTimeout(finish, timeoutMs);
+						const unsubscribe = manager.subscribe(() => {
+							if (settled()) finish();
+						});
+						function finish() {
+							clearTimeout(timer);
+							unsubscribe();
+							resolve();
+						}
+					});
+				}
+				for (const key of keys) {
+					const texture = entries.get(key)?.texture;
+					if (texture) textures.set(key, texture);
+				}
+				return await use(textures);
+			} finally {
+				for (const key of keys) manager.release(key);
+			}
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		destroy() {
+			disposed = true;
+			queue.length = 0;
+			listeners.clear();
+			pathVersions.clear();
+			resolvers.clear();
+			for (const [key, entry] of entries) evict(key, entry);
+			entries.clear();
+		}
+	};
+	return manager;
+}
+//#endregion
+export { boardAssetKey, createBoardAssetManager };

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

@@ -0,0 +1,8 @@
+import { DEFAULT_LRU_BUDGET, LruBudget, LruEntry, selectLruEvictions } from "./lru.js";
+import { BoardImageTexturePool, boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture } from "./texture-pool.js";
+import { BoardAssetManager, BoardAssetManagerOptions, boardAssetKey, createBoardAssetManager } from "./assets.js";
+import { toBoardPointerEvent } from "./pointer.js";
+import { BoardLiveStroke, BoardScene, BoardSceneNode, SceneOverlayInput, SceneSyncInput, createBoardScene } from "./scene.js";
+import { BoardItemView, BoardItemViewContext, BoardItemViewInstance, BoardItemViewLayer, createBoardItemViewLayer } from "./views.js";
+import { BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageTheme, mountBoardStage } from "./stage.js";
+export { BoardAssetManager, BoardAssetManagerOptions, BoardImageTexturePool, BoardItemView, BoardItemViewContext, BoardItemViewInstance, BoardItemViewLayer, BoardLiveStroke, BoardScene, BoardSceneNode, BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageTheme, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, SceneOverlayInput, SceneSyncInput, boardAssetKey, boardImageTexturePool, createBoardAssetManager, createBoardImageTexturePool, createBoardItemViewLayer, createBoardScene, loadBoardImageTexture, mountBoardStage, selectLruEvictions, toBoardPointerEvent, unloadBoardImageTexture };

package/dist/board/stage/index.js

@@ -0,0 +1,8 @@
+import { DEFAULT_LRU_BUDGET, selectLruEvictions } from "./lru.js";
+import { boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture } from "./texture-pool.js";
+import { boardAssetKey, createBoardAssetManager } from "./assets.js";
+import { toBoardPointerEvent } from "./pointer.js";
+import { createBoardScene } from "./scene.js";
+import { createBoardItemViewLayer } from "./views.js";
+import { mountBoardStage } from "./stage.js";
+export { DEFAULT_LRU_BUDGET, boardAssetKey, boardImageTexturePool, createBoardAssetManager, createBoardImageTexturePool, createBoardItemViewLayer, createBoardScene, loadBoardImageTexture, mountBoardStage, selectLruEvictions, toBoardPointerEvent, unloadBoardImageTexture };