@neta-art/cohub 9.0.1 → 11.0.0

package/dist/board/stage/assets.js

@@ -0,0 +1,355 @@
+import { mediaPreviewCandidates } from "../../media.js";
+import { parseBoardMediaSource } from "../../protocol/dist/board-model.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") {
+		const source = parseBoardMediaSource(item.props.src);
+		if (!source) return null;
+		return source.kind === "url" ? `video-url:${encodeURIComponent(source.value)}` : `video:${encodeURIComponent(source.value)}:${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 };

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

@@ -0,0 +1,32 @@
+//#region src/board/stage/lru.d.ts
+/**
+ * Pure eviction policy for the board texture LRU cache.
+ *
+ * Textures whose cards have scrolled off-screen are not freed immediately:
+ * they enter a "cooling" pool (reference count zero but still on the GPU) so a
+ * quick pan back is instant instead of re-fetching. The pool is bounded by
+ * both entry count and approximate GPU bytes; when a budget is exceeded the least
+ * recently used entries are evicted first. Keeping this decision pure makes the
+ * release-vs-churn trade-off trivial to test.
+ */
+type LruEntry = {
+  key: string;
+  /** Timestamp (ms) the entry was last used; smaller = older = evict first. */
+  lastUsedAt: number;
+  /** Approximate GPU footprint in bytes. */
+  bytes: number;
+};
+type LruBudget = {
+  maxCount: number;
+  maxBytes: number;
+};
+/** Default cooling-pool ceiling: 64 images or ~128 MB of GPU memory. */
+declare const DEFAULT_LRU_BUDGET: LruBudget;
+/**
+ * Given the unreferenced (cooling) entries and a budget, return the keys to
+ * evict — oldest first — so the remaining pool fits within both limits. Returns
+ * an empty array when the pool already fits.
+ */
+declare function selectLruEvictions(entries: LruEntry[], budget: LruBudget): string[];
+//#endregion
+export { DEFAULT_LRU_BUDGET, LruBudget, LruEntry, selectLruEvictions };

package/dist/board/stage/lru.js

@@ -0,0 +1,29 @@
+//#region src/board/stage/lru.ts
+/** Default cooling-pool ceiling: 64 images or ~128 MB of GPU memory. */
+const DEFAULT_LRU_BUDGET = {
+	maxCount: 64,
+	maxBytes: 134217728
+};
+/**
+* Given the unreferenced (cooling) entries and a budget, return the keys to
+* evict — oldest first — so the remaining pool fits within both limits. Returns
+* an empty array when the pool already fits.
+*/
+function selectLruEvictions(entries, budget) {
+	if (entries.length === 0) return [];
+	let count = entries.length;
+	let bytes = 0;
+	for (const entry of entries) bytes += entry.bytes;
+	if (count <= budget.maxCount && bytes <= budget.maxBytes) return [];
+	const sorted = [...entries].sort((a, b) => a.lastUsedAt - b.lastUsedAt);
+	const evict = [];
+	for (const entry of sorted) {
+		if (count <= budget.maxCount && bytes <= budget.maxBytes) break;
+		evict.push(entry.key);
+		count -= 1;
+		bytes -= entry.bytes;
+	}
+	return evict;
+}
+//#endregion
+export { DEFAULT_LRU_BUDGET, selectLruEvictions };

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

@@ -0,0 +1,5 @@
+import { Renderer } from "pixi.js";
+//#region src/board/stage/maintenance.d.ts
+declare function scheduleBoardMaintenance(renderer: Renderer): () => void;
+//#endregion
+export { scheduleBoardMaintenance };

package/dist/board/stage/maintenance.js

@@ -0,0 +1,11 @@
+import { Ticker } from "pixi.js";
+//#region src/board/stage/maintenance.ts
+function scheduleBoardMaintenance(renderer) {
+	renderer.events.setTargetElement(null);
+	const scheduler = renderer.scheduler;
+	Ticker.system.remove(scheduler._update, scheduler);
+	const timer = setInterval(() => scheduler._update(), 1e3);
+	return () => clearInterval(timer);
+}
+//#endregion
+export { scheduleBoardMaintenance };

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

@@ -0,0 +1,8 @@
+import { BoardViewport } from "../model/geometry.js";
+import "../model/index.js";
+import { BoardPointerEvent } from "../editor/interaction.js";
+import "../editor/index.js";
+//#region src/board/stage/pointer.d.ts
+declare function toBoardPointerEvent(event: PointerEvent, rect: DOMRect, camera: BoardViewport, coalesce?: boolean): BoardPointerEvent;
+//#endregion
+export { toBoardPointerEvent };

package/dist/board/stage/pointer.js

@@ -0,0 +1,33 @@
+import { pointToWorld, screenPoint } from "../model/geometry.js";
+//#region src/board/stage/pointer.ts
+function pressureOf(event) {
+	return event.pointerType === "pen" && event.pressure > 0 ? event.pressure : .5;
+}
+function screenOf(event, rect) {
+	return screenPoint(event.clientX - rect.left, event.clientY - rect.top);
+}
+function toBoardPointerEvent(event, rect, camera, coalesce = false) {
+	const screen = screenOf(event, rect);
+	const coalesced = coalesce ? event.getCoalescedEvents?.() : void 0;
+	const samples = coalesced && coalesced.length > 1 ? coalesced.map((sample) => ({
+		world: pointToWorld(screenOf(sample, rect), camera),
+		pressure: pressureOf(sample)
+	})) : void 0;
+	return {
+		pointerId: event.pointerId,
+		screen,
+		world: pointToWorld(screen, camera),
+		shiftKey: event.shiftKey,
+		metaKey: event.metaKey,
+		ctrlKey: event.ctrlKey,
+		altKey: event.altKey,
+		button: event.button,
+		buttons: event.buttons,
+		pointerType: event.pointerType,
+		cancelled: event.type === "pointercancel" || event.type === "lostpointercapture",
+		pressure: pressureOf(event),
+		...samples ? { samples } : {}
+	};
+}
+//#endregion
+export { toBoardPointerEvent };

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

@@ -0,0 +1,85 @@
+import { BoardDrawPoint } from "../../protocol/dist/board-model.js";
+import { BoardFrame } from "../../protocol/dist/board-layout.js";
+import { Rect, WorldPoint } from "../model/geometry.js";
+import { BoardScene as BoardScene$1, BoardSceneItem } from "../model/scene.js";
+import "../model/index.js";
+import { BoardSelectionTransform, BoardTransformControl } from "../editor/selection-transform.js";
+import "../editor/index.js";
+import { BoardCardRendererResolver, BoardRenderContext, BoardRenderPalette } from "../render/renderers/board-renderer-registry.js";
+import "../render/index.js";
+import { Container, Graphics } from "pixi.js";
+//#region src/board/stage/scene.d.ts
+type BoardLiveStroke = {
+  id: string;
+  points: BoardDrawPoint[];
+  color: string;
+  size: number;
+};
+type SceneSyncInput = {
+  items: readonly BoardSceneItem[];
+  strokes: readonly BoardLiveStroke[];
+  scene: BoardScene$1;
+  context: BoardRenderContext;
+  getItem: (id: string) => BoardSceneItem | null;
+  visibleIds: Set<string> | null;
+  pinnedIds: Set<string>;
+  globalSig: string;
+  structureVersion: number;
+  geometryVersion: number;
+  gestureActive: boolean;
+};
+type SceneOverlayInput = {
+  zoom: number;
+  pointerType: string;
+  marquee: Rect | null;
+  selection: string[];
+  transform: BoardSelectionTransform | null;
+  controls: boolean;
+  hoveredControl: BoardTransformControl | null;
+  rotationPointer: WorldPoint | null;
+  arrowEndpoints?: Array<{
+    x: number;
+    y: number;
+  }>;
+  ports?: ReadonlyArray<{
+    x: number;
+    y: number;
+    radius: number;
+  }>;
+  hoveredPort?: {
+    x: number;
+    y: number;
+  } | null;
+  arrowDraft?: {
+    from: {
+      x: number;
+      y: number;
+    };
+    to: {
+      x: number;
+      y: number;
+    };
+    size: number;
+    targetFrame: BoardFrame | null;
+  } | null;
+  bindTarget?: BoardFrame | null;
+};
+type BoardSceneNode = {
+  item: BoardSceneItem;
+  container: Container;
+};
+type BoardScene = {
+  sync: (input: SceneSyncInput) => void;
+  getNode: (itemId: string) => BoardSceneNode | null;
+  readonly animated: boolean;
+  drawOverlay: (input: SceneOverlayInput, palette: BoardRenderPalette) => void;
+  destroy: (context: BoardRenderContext) => void;
+};
+declare function createBoardScene(options: {
+  world: Container;
+  overlay: Graphics;
+  getRenderer: BoardCardRendererResolver;
+  onFarLayerFrame?: () => void;
+}): BoardScene;
+//#endregion
+export { BoardLiveStroke, BoardScene, BoardSceneNode, SceneOverlayInput, SceneSyncInput, createBoardScene };