@neta-art/cohub 12.1.0 → 12.2.0

package/dist/board/stage/assets.js

@@ -1,81 +1,26 @@
-import { MEDIA_VARIANT_SIZES, imageVariantUrl, mediaVariantSize, probeMediaInfo, variantSource, videoFrameUrl } from "../../media.js";
-import { parseBoardMediaSource } from "../../protocol/dist/board-model.js";
-import { featuredTaskArtifact, taskArtifactPreviewUrl } from "../../protocol/dist/board-task.js";
-import { boardModelFormat, isBoardModelItem } from "../model/media.js";
-import { boardImageKeySource, imageAssetKey } from "../model/image-key.js";
+import { probeMediaInfo } from "../../protocol/dist/core/media.js";
+import { MEDIA_VARIANT_SIZES, imageVariantUrl, variantSource } from "../../media.js";
+import { boardModelFormat } from "../model/media.js";
+import { boardAssetKey, boardAssetKeySource } from "../model/asset-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";
+import { DEFAULT_LRU_BUDGET, planLruTrim } from "./lru.js";
+import { boardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, shrinkBoardTexture, unloadBoardImageTexture } from "./texture-pool.js";
 import { Texture } from "pixi.js";
 //#region src/board/stage/assets.ts
-function taskPreviewKey(artifact) {
-	const cover = taskArtifactPreviewUrl(artifact);
-	if (cover) return `url:${cover}`;
-	if (artifact?.type !== "video") return null;
-	const frame = videoFrameUrl(artifact.url, 768);
-	return frame ? `url:${frame}` : `video-url:${encodeURIComponent(artifact.url)}`;
-}
-const LARGEST_VARIANT = MEDIA_VARIANT_SIZES[MEDIA_VARIANT_SIZES.length - 1];
-function boardTextureEdge(item, scale) {
-	const crop = item.type === "image" ? item.props.crop : void 0;
-	const pixels = Math.max(item.frame.width / (crop?.w || 1), item.frame.height / (crop?.h || 1)) * scale;
-	return pixels > LARGEST_VARIANT ? Number.POSITIVE_INFINITY : mediaVariantSize(pixels);
-}
 function variantUrl(source, edge) {
-	if (!(edge <= LARGEST_VARIANT)) return null;
+	if (!(edge <= 1536)) return null;
 	const url = imageVariantUrl(source, edge);
 	return url && url !== source ? url : null;
 }
-const STILL_MEDIA = ["video", "model"];
-function stillKey(media, src, mtimeMs) {
-	const source = parseBoardMediaSource(src);
-	if (!source) return null;
-	return source.kind === "url" ? `${media}-url:${encodeURIComponent(source.value)}` : `${media}:${encodeURIComponent(source.value)}:${mtimeMs ?? "unknown"}`;
-}
-function boardAssetKey(item) {
-	if (item.type === "task") return taskPreviewKey(featuredTaskArtifact(item.props.snapshot.artifacts));
-	if (item.type === "video") return stillKey("video", item.props.src, item.props.snapshot?.mtimeMs);
-	if (item.type === "file" && isBoardModelItem(item)) return stillKey("model", item.props.src, item.props.snapshot?.mtimeMs);
-	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);
-	}
-	for (const media of STILL_MEDIA) {
-		if (baseKey.startsWith(`${media}-url:`)) try {
-			return {
-				kind: "url",
-				media,
-				value: decodeURIComponent(baseKey.slice(media.length + 5))
-			};
-		} catch {
-			return null;
-		}
-		if (baseKey.startsWith(`${media}:`)) {
-			const separator = baseKey.lastIndexOf(":");
-			if (separator <= media.length) return null;
-			try {
-				return {
-					kind: "file",
-					media,
-					value: decodeURIComponent(baseKey.slice(media.length + 1, separator))
-				};
-			} catch {
-				return null;
-			}
-		}
-	}
-	const image = boardImageKeySource(baseKey);
-	return image ? {
-		...image,
-		media: "image"
-	} : null;
+const SMALLEST_VARIANT = MEDIA_VARIANT_SIZES[0];
+function sharpEdge(texture, edge, resized) {
+	return resized && Math.max(texture.width, texture.height) >= edge ? edge : Number.POSITIVE_INFINITY;
 }
 const MAX_RETRY_DELAY = 3e4;
+const SHRINK_EDGE = 256;
+const SHRINK_CONCURRENCY = 4;
+const TRIM_DELAY = 400;
+const TRIM_MAX_DELAY = 2e3;
 function footprintOf(texture) {
 	if (!texture) return 0;
 	return (texture.width || 0) * (texture.height || 0) * 4;
@@ -92,6 +37,7 @@ function createBoardAssetManager(options) {
 	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 shrinkTexture = options.shrinkTexture ?? (useSharedImagePool ? shrinkBoardTexture : null);
 	const pendingUnloads = /* @__PURE__ */ new Map();
 	const unloadTexture = options.unloadTexture ?? (async (url, texture, media) => {
 		if (media !== "image" || !url) {
@@ -106,8 +52,7 @@ function createBoardAssetManager(options) {
 		}
 		await unloadBoardImageTexture(url, texture);
 	});
-	function releaseTexture(key, url, texture) {
-		const media = keySource(key)?.media ?? "image";
+	function releaseTexture(media, url, texture) {
 		const pendingKey = `${media}:${url}`;
 		const promise = unloadTexture(url, texture, media).catch(() => {}).then(() => {
 			if (url && pendingUnloads.get(pendingKey) === promise) pendingUnloads.delete(pendingKey);
@@ -115,9 +60,9 @@ function createBoardAssetManager(options) {
 		if (url) pendingUnloads.set(pendingKey, promise);
 	}
 	const retiring = /* @__PURE__ */ new Set();
-	function retire(key, url, texture) {
+	function retire(media, url, texture) {
 		const release = () => {
-			if (retiring.delete(release)) releaseTexture(key, url, texture);
+			if (retiring.delete(release)) releaseTexture(media, url, texture);
 		};
 		retiring.add(release);
 		if (typeof requestAnimationFrame === "function") requestAnimationFrame(release);
@@ -137,13 +82,29 @@ function createBoardAssetManager(options) {
 		model: 0
 	};
 	let disposed = false;
+	let focus = null;
+	let trimTimer = null;
+	let trimSince = 0;
+	let shrinking = 0;
 	function notify(key) {
 		for (const listener of listeners) listener(key);
 	}
+	const keys = /* @__PURE__ */ new WeakMap();
+	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;
+	}
+	function resolveAssetKey(item) {
 		const key = boardAssetKey(item);
 		if (!key) return null;
-		const source = keySource(key);
+		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;
@@ -160,12 +121,13 @@ function createBoardAssetManager(options) {
 		let entry = entries.get(key);
 		if (!entry) {
 			entry = {
-				media: keySource(key)?.media ?? "image",
+				media: boardAssetKeySource(key)?.media ?? "image",
 				source: null,
 				url: null,
 				texture: null,
 				edge: 0,
 				want: 0,
+				center: null,
 				natural: void 0,
 				refs: 0,
 				loading: false,
@@ -195,26 +157,68 @@ function createBoardAssetManager(options) {
 	function evict(key, entry) {
 		clearRetry(entry);
 		starters.delete(key);
-		if (entry.url || entry.texture) releaseTexture(key, entry.url ?? "", entry.texture);
+		if (entry.url || entry.texture) releaseTexture(entry.media, entry.url ?? "", entry.texture);
 		entries.delete(key);
 	}
+	function scheduleTrim() {
+		const at = now();
+		if (trimTimer === null) trimSince = at;
+		else if (at - trimSince >= TRIM_MAX_DELAY) return;
+		else clearTimeout(trimTimer);
+		trimTimer = setTimeout(() => {
+			trimTimer = null;
+			if (!disposed) trim();
+		}, TRIM_DELAY);
+	}
+	function shrunkFootprint({ media, texture }) {
+		if (!shrinkTexture || media !== "image" || !texture) return void 0;
+		const scale = SHRINK_EDGE / Math.max(texture.width, texture.height);
+		return scale < 1 ? Math.round(texture.width * scale) * Math.round(texture.height * scale) * 4 : void 0;
+	}
 	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)
+			bytes: footprintOf(entry.texture),
+			shrunkBytes: shrunkFootprint(entry)
 		});
-		const evictions = selectLruEvictions(cooling, budget);
-		for (const key of evictions) {
+		const plan = planLruTrim(cooling, budget);
+		for (const key of plan.evict) {
 			const entry = entries.get(key);
 			if (entry) evict(key, entry);
 		}
+		for (const key of plan.shrink.slice(0, Math.max(0, SHRINK_CONCURRENCY - shrinking))) {
+			const entry = entries.get(key);
+			if (entry) shrink(key, entry);
+		}
+	}
+	function shrink(key, entry) {
+		const { texture, url } = entry;
+		if (!shrinkTexture || !texture) return;
+		entry.loading = true;
+		shrinking += 1;
+		shrinkTexture(texture, SHRINK_EDGE).catch(() => null).then((small) => {
+			shrinking -= 1;
+			entry.loading = false;
+			const current = entries.get(key) === entry;
+			if (small && current && entry.refs <= 0) {
+				entry.texture = small;
+				entry.url = "";
+				entry.edge = SHRINK_EDGE;
+				releaseTexture(entry.media, url ?? "", texture);
+			} else {
+				if (small) releaseTexture(entry.media, "", small);
+				if (current && entry.refs > 0) refine(key, entry);
+				else if (current) evict(key, entry);
+			}
+			if (!disposed) trim();
+		});
 	}
 	function adopt(key, entry, loaded, error) {
 		entry.loading = false;
 		if (entries.get(key) !== entry) {
-			if (loaded) releaseTexture(key, loaded.url, loaded.texture);
+			if (loaded) releaseTexture(entry.media, loaded.url, loaded.texture);
 			return;
 		}
 		if (loaded) {
@@ -231,9 +235,9 @@ function createBoardAssetManager(options) {
 				height: texture.height
 			};
 			entry.lastUsedAt = now();
-			if (entry.refs <= 0) trim();
+			if (entry.refs <= 0) scheduleTrim();
 			else notify(key);
-			if (replaced) retire(key, replacedUrl, replaced);
+			if (replaced) retire(entry.media, replacedUrl, replaced);
 			refine(key, entry);
 			return;
 		}
@@ -269,9 +273,25 @@ function createBoardAssetManager(options) {
 		});
 		pump();
 	}
+	function nextTask() {
+		let best = -1;
+		let nearest = Number.POSITIVE_INFINITY;
+		for (let index = 0; index < queue.length; index += 1) {
+			const task = queue[index];
+			if (activeByMedia[task.media] >= limits[task.media]) continue;
+			const center = entries.get(task.key)?.center;
+			if (!focus || !center) return index;
+			const distance = (center.x - focus.x) ** 2 + (center.y - focus.y) ** 2;
+			if (distance < nearest) {
+				nearest = distance;
+				best = index;
+			}
+		}
+		return best;
+	}
 	function pump() {
 		while (!disposed && active < concurrency && queue.length > 0) {
-			const taskIndex = queue.findIndex(({ media }) => activeByMedia[media] < limits[media]);
+			const taskIndex = nextTask();
 			if (taskIndex < 0) return;
 			const [task] = queue.splice(taskIndex, 1);
 			if (!task) continue;
@@ -293,17 +313,36 @@ function createBoardAssetManager(options) {
 		return async (entry) => {
 			entry.source = source;
 			const edge = entry.want;
-			const variant = media === "image" ? variantUrl(source, edge) : null;
+			const variant = media === "image" ? variantUrl(source, Math.max(edge, SMALLEST_VARIANT)) : null;
 			const url = variant ?? source;
 			const pending = pendingUnloads.get(`${media}:${url}`);
 			if (pending) await pending;
 			if (disposed) return null;
+			if (media === "image" && !variant && useSharedImagePool && Number.isFinite(edge)) {
+				const fitted = await loadFittedImageTexture(url, edge).catch(() => null);
+				if (fitted) return {
+					texture: fitted,
+					url: "",
+					edge: sharpEdge(fitted, edge, true)
+				};
+			}
 			const texture = await loadTexture(url, media);
 			if (!texture) return null;
+			if (media === "image" && shrinkTexture && edge < Math.max(texture.width, texture.height) / 2) {
+				const small = await shrinkTexture(texture, edge).catch(() => null);
+				if (small) {
+					releaseTexture(media, url, texture);
+					return {
+						texture: small,
+						url: "",
+						edge
+					};
+				}
+			}
 			return {
 				texture,
 				url,
-				edge: !variant || Math.max(texture.width, texture.height) < edge ? Number.POSITIVE_INFINITY : edge
+				edge: sharpEdge(texture, edge, Boolean(variant))
 			};
 		};
 	}
@@ -372,21 +411,26 @@ function createBoardAssetManager(options) {
 		invalidatePath(path) {
 			if (disposed) return;
 			const stale = [...entries.keys()].filter((key) => {
-				const source = keySource(key);
+				const source = boardAssetKeySource(key);
 				return source?.kind === "file" && source.value === path;
 			});
 			if (stale.length === 0) return;
 			pathVersions.set(path, (pathVersions.get(path) ?? 0) + 1);
+			keyEpoch += 1;
 			for (const key of stale) notify(key);
 		},
 		requestItem(item, edge = Number.POSITIVE_INFINITY) {
 			if (disposed) return;
 			const key = managedAssetKey(item);
 			if (!key || failedModels.has(key)) return;
-			const source = keySource(key);
+			const source = boardAssetKeySource(key);
 			if (!source) return;
 			const entry = ensureEntry(key);
 			entry.lastUsedAt = now();
+			entry.center = {
+				x: item.frame.x + item.frame.width / 2,
+				y: item.frame.y + item.frame.height / 2
+			};
 			if (edge > entry.want) entry.want = edge;
 			if (entry.texture) return refine(key, entry);
 			if (entry.loading || entry.retryTimer) return;
@@ -413,8 +457,12 @@ function createBoardAssetManager(options) {
 		hasError(key) {
 			return entries.get(key)?.error ?? false;
 		},
+		focus(point) {
+			focus = point;
+		},
 		acquire(key) {
 			const entry = ensureEntry(key);
+			if (entry.refs <= 0) entry.want = 0;
 			entry.refs += 1;
 			entry.lastUsedAt = now();
 		},
@@ -427,7 +475,7 @@ function createBoardAssetManager(options) {
 			clearRetry(entry);
 			if (entry.loading) return;
 			if (!entry.texture) evict(key, entry);
-			else trim();
+			else scheduleTrim();
 		},
 		async withTextures(items, use, loadOptions) {
 			const keys = /* @__PURE__ */ new Set();
@@ -467,6 +515,22 @@ function createBoardAssetManager(options) {
 				for (const key of keys) manager.release(key);
 			}
 		},
+		stats() {
+			let textures = 0;
+			let cooling = 0;
+			let bytes = 0;
+			for (const entry of entries.values()) {
+				if (!entry.texture) continue;
+				textures += 1;
+				if (entry.refs <= 0) cooling += 1;
+				bytes += footprintOf(entry.texture);
+			}
+			return {
+				textures,
+				cooling,
+				bytes
+			};
+		},
 		subscribe(listener) {
 			listeners.add(listener);
 			return () => {
@@ -475,6 +539,8 @@ function createBoardAssetManager(options) {
 		},
 		destroy() {
 			disposed = true;
+			if (trimTimer !== null) clearTimeout(trimTimer);
+			trimTimer = null;
 			queue.length = 0;
 			listeners.clear();
 			pathVersions.clear();
@@ -488,4 +554,4 @@ function createBoardAssetManager(options) {
 	return manager;
 }
 //#endregion
-export { boardAssetKey, boardTextureEdge, createBoardAssetManager };
+export { createBoardAssetManager };

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

@@ -1,10 +1,10 @@
-import { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, selectLruEvictions } from "./lru.js";
-import { BoardImageTexturePool, boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture } from "./texture-pool.js";
-import { BoardAssetManager, BoardAssetManagerOptions, BoardModelPreviewRequest, BoardModelPreviews, boardAssetKey, boardTextureEdge, createBoardAssetManager } from "./assets.js";
+import { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, LruTrim, planLruTrim, selectLruEvictions } from "./lru.js";
+import { BoardImageTexturePool, boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, shrinkBoardTexture, unloadBoardImageTexture } from "./texture-pool.js";
+import { BoardAssetManager, BoardAssetManagerOptions, BoardModelPreviewRequest, BoardModelPreviews, createBoardAssetManager } from "./assets.js";
 import { toBoardPointerEvent } from "./pointer.js";
 import { createBoardPointerGestures } from "./pointer-gestures.js";
 import { BoardLiveStroke, BoardScene, BoardSceneNode, SceneSyncInput, createBoardScene } from "./scene.js";
 import { BoardItemView, BoardItemViewContext, BoardItemViewInstance, BoardItemViewLayer, createBoardItemViewLayer } from "./views.js";
-import { BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageTheme, mountBoardStage } from "./stage.js";
+import { BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageStats, BoardStageTheme, mountBoardStage } from "./stage.js";
 import { BoardOverlayInput, drawBoardOverlay, expandFrame } from "./overlay.js";
-export { BoardAssetManager, BoardAssetManagerOptions, BoardImageTexturePool, BoardItemView, BoardItemViewContext, BoardItemViewInstance, BoardItemViewLayer, BoardLiveStroke, BoardModelPreviewRequest, BoardModelPreviews, BoardOverlayInput, BoardScene, BoardSceneNode, BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageTheme, COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, SceneSyncInput, boardAssetKey, boardImageTexturePool, boardTextureEdge, createBoardAssetManager, createBoardImageTexturePool, createBoardItemViewLayer, createBoardPointerGestures, createBoardScene, drawBoardOverlay, expandFrame, loadBoardImageTexture, mountBoardStage, selectLruEvictions, toBoardPointerEvent, unloadBoardImageTexture };
+export { BoardAssetManager, BoardAssetManagerOptions, BoardImageTexturePool, BoardItemView, BoardItemViewContext, BoardItemViewInstance, BoardItemViewLayer, BoardLiveStroke, BoardModelPreviewRequest, BoardModelPreviews, BoardOverlayInput, BoardScene, BoardSceneNode, BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageStats, BoardStageTheme, COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, LruTrim, SceneSyncInput, boardImageTexturePool, createBoardAssetManager, createBoardImageTexturePool, createBoardItemViewLayer, createBoardPointerGestures, createBoardScene, drawBoardOverlay, expandFrame, loadBoardImageTexture, loadFittedImageTexture, mountBoardStage, planLruTrim, selectLruEvictions, shrinkBoardTexture, toBoardPointerEvent, unloadBoardImageTexture };

package/dist/board/stage/index.js

@@ -1,10 +1,10 @@
-import { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, selectLruEvictions } from "./lru.js";
-import { boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture } from "./texture-pool.js";
-import { boardAssetKey, boardTextureEdge, createBoardAssetManager } from "./assets.js";
+import { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, planLruTrim, selectLruEvictions } from "./lru.js";
+import { boardImageTexturePool, createBoardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, shrinkBoardTexture, unloadBoardImageTexture } from "./texture-pool.js";
+import { createBoardAssetManager } from "./assets.js";
 import { toBoardPointerEvent } from "./pointer.js";
 import { createBoardPointerGestures } from "./pointer-gestures.js";
 import { createBoardScene } from "./scene.js";
 import { drawBoardOverlay, expandFrame } from "./overlay.js";
 import { createBoardItemViewLayer } from "./views.js";
 import { mountBoardStage } from "./stage.js";
-export { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, boardAssetKey, boardImageTexturePool, boardTextureEdge, createBoardAssetManager, createBoardImageTexturePool, createBoardItemViewLayer, createBoardPointerGestures, createBoardScene, drawBoardOverlay, expandFrame, loadBoardImageTexture, mountBoardStage, selectLruEvictions, toBoardPointerEvent, unloadBoardImageTexture };
+export { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, boardImageTexturePool, createBoardAssetManager, createBoardImageTexturePool, createBoardItemViewLayer, createBoardPointerGestures, createBoardScene, drawBoardOverlay, expandFrame, loadBoardImageTexture, loadFittedImageTexture, mountBoardStage, planLruTrim, selectLruEvictions, shrinkBoardTexture, toBoardPointerEvent, unloadBoardImageTexture };

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

@@ -6,8 +6,8 @@
  * 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.
+ * recently used entries shrink or leave first. Keeping this decision pure makes
+ * the release-vs-churn trade-off trivial to test.
  */
 type LruEntry = {
   key: string;
@@ -15,19 +15,23 @@ type LruEntry = {
   lastUsedAt: number;
   /** Approximate GPU footprint in bytes. */
   bytes: number;
+  shrunkBytes?: number;
 };
 type LruBudget = {
   maxCount: number;
   maxBytes: number;
 };
-/** Default cooling-pool ceiling: 512 images or ~192 MB of GPU memory. */
-declare const DEFAULT_LRU_BUDGET: LruBudget;
-declare const COMPACT_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.
+ * Default cooling-pool ceiling: 2048 images or ~192 MB of GPU memory. Bytes
+ * bind first for full-size textures; shrunk copies let many more stay warm.
  */
+declare const DEFAULT_LRU_BUDGET: LruBudget;
+declare const COMPACT_LRU_BUDGET: LruBudget;
+type LruTrim = {
+  shrink: string[];
+  evict: string[];
+};
+declare function planLruTrim(entries: LruEntry[], budget: LruBudget): LruTrim;
 declare function selectLruEvictions(entries: LruEntry[], budget: LruBudget): string[];
 //#endregion
-export { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, selectLruEvictions };
+export { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, LruBudget, LruEntry, LruTrim, planLruTrim, selectLruEvictions };

package/dist/board/stage/lru.js

@@ -1,33 +1,51 @@
 //#region src/board/stage/lru.ts
-/** Default cooling-pool ceiling: 512 images or ~192 MB of GPU memory. */
+/**
+* Default cooling-pool ceiling: 2048 images or ~192 MB of GPU memory. Bytes
+* bind first for full-size textures; shrunk copies let many more stay warm.
+*/
 const DEFAULT_LRU_BUDGET = {
-	maxCount: 512,
+	maxCount: 2048,
 	maxBytes: 201326592
 };
 const COMPACT_LRU_BUDGET = {
-	maxCount: 256,
+	maxCount: 1024,
 	maxBytes: 100663296
 };
-/**
-* 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;
+function planLruTrim(entries, budget) {
 	let bytes = 0;
 	for (const entry of entries) bytes += entry.bytes;
-	if (count <= budget.maxCount && bytes <= budget.maxBytes) return [];
+	const over = entries.length - budget.maxCount;
+	if (over <= 0 && bytes <= budget.maxBytes) return {
+		shrink: [],
+		evict: []
+	};
 	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;
+	const evict = sorted.slice(0, Math.max(0, over));
+	const kept = sorted.slice(evict.length);
+	for (const entry of evict) bytes -= entry.bytes;
+	const shrink = /* @__PURE__ */ new Set();
+	for (const entry of kept) {
+		if (bytes <= budget.maxBytes) break;
+		if (entry.shrunkBytes === void 0 || entry.shrunkBytes >= entry.bytes) continue;
+		shrink.add(entry);
+		bytes -= entry.bytes - entry.shrunkBytes;
+	}
+	for (const entry of kept) {
+		if (bytes <= budget.maxBytes) break;
+		bytes -= shrink.delete(entry) ? entry.shrunkBytes : entry.bytes;
+		evict.push(entry);
 	}
-	return evict;
+	return {
+		shrink: [...shrink].map(({ key }) => key),
+		evict: evict.map(({ key }) => key)
+	};
+}
+function selectLruEvictions(entries, budget) {
+	return planLruTrim(entries.map(({ key, lastUsedAt, bytes }) => ({
+		key,
+		lastUsedAt,
+		bytes
+	})), budget).evict;
 }
 //#endregion
-export { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, selectLruEvictions };
+export { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET, planLruTrim, selectLruEvictions };

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

@@ -1,6 +1,8 @@
 import { BoardDrawPoint } from "../../protocol/dist/board-model.js";
+import { Rect } from "../model/geometry.js";
 import { BoardScene as BoardScene$1, BoardSceneItem } from "../model/scene.js";
 import "../model/index.js";
+import { BoardLod } from "../render/lod.js";
 import { BoardCardRendererResolver, BoardRenderContext } from "../render/renderers/board-renderer-registry.js";
 import "../render/index.js";
 import { Container, Graphics } from "pixi.js";
@@ -22,12 +24,14 @@ type SceneSyncInput = {
   globalSig: string;
   staleIds?: ReadonlySet<string>;
   structureVersion: number;
-  geometryVersion: number;
   gestureActive: boolean;
   focus?: {
     x: number;
     y: number;
   };
+  /** The world area on screen; live cards outside it skip rendering. */
+  view?: Rect;
+  lod?: BoardLod;
 };
 type BoardSceneNode = {
   item: BoardSceneItem;
@@ -39,8 +43,14 @@ type BoardScene = {
   holders: (key: string) => ReadonlySet<string>;
   readonly liveVersion: number;
   liveIds: () => ReadonlySet<string>;
+  /** Live cards and cards drawn on far plates. */
+  counts: () => {
+    live: number;
+    far: number;
+  };
   readonly animated: boolean;
   tick: (clock: number) => number | null;
+  redrawText: () => void;
   destroy: (context: BoardRenderContext) => void;
 };
 declare function createBoardScene(options: {