@neta-art/cohub 12.1.1 → 12.3.0

package/dist/board/stage/assets.js

@@ -1,97 +1,53 @@
-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 { loadVideoThumbnailTexture, videoTextureNaturalSize } from "../render/video-thumbnail.js";
-import { DEFAULT_LRU_BUDGET, selectLruEvictions } from "./lru.js";
-import { boardImageTexturePool, loadBoardImageTexture, unloadBoardImageTexture } from "./texture-pool.js";
+import { boardAssetKey, boardAssetKeySource, boardAssetRefKey } from "../model/asset-key.js";
+import { planLruTrim } from "./lru.js";
+import { defaultBoardDeviceBudget } from "./device.js";
+import { scheduleBoardIdle } from "./idle.js";
+import { boardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, readTextureTone, 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;
-	const url = imageVariantUrl(source, edge);
+function variantUrl(source, edge, cover) {
+	if (!(edge <= 1536)) return null;
+	const url = imageVariantUrl(source, edge, cover ? "cover" : "contain");
 	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"}`;
+const SMALLEST_VARIANT = MEDIA_VARIANT_SIZES[0];
+function boundEdge({ width, height }, cover) {
+	return cover ? Math.min(width, height) : Math.max(width, height);
 }
-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;
+function sharpEdge(texture, edge, resized, cover) {
+	return resized && boundEdge(texture, cover) >= edge ? edge : Number.POSITIVE_INFINITY;
 }
 const MAX_RETRY_DELAY = 3e4;
+const PREFETCH_CONCURRENCY = 2;
+const PREFETCH_POOL_SHARE = .5;
+const SHRINK_EDGE = 256;
+const SHRINK_CONCURRENCY = 4;
+const TRIM_DELAY = 400;
+const TRIM_MAX_DELAY = 2e3;
+const TONE_LIMIT = 8192;
 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 ?? 6);
+	const concurrency = Math.max(1, options.concurrency ?? defaultBoardDeviceBudget().concurrency);
 	const limits = {
 		image: concurrency,
 		video: Math.max(1, Math.min(options.videoConcurrency ?? 2, concurrency)),
 		model: 1
 	};
-	const budget = options.lruBudget ?? DEFAULT_LRU_BUDGET;
+	const budget = options.lruBudget ?? defaultBoardDeviceBudget().lru;
+	const prefetchLimit = Math.min(PREFETCH_CONCURRENCY, concurrency - 1);
 	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 shrinkTexture = options.shrinkTexture ?? (useSharedImagePool ? shrinkBoardTexture : null);
+	const readTone = options.readTone === void 0 ? typeof createImageBitmap === "function" ? readTextureTone : null : options.readTone;
 	const pendingUnloads = /* @__PURE__ */ new Map();
 	const unloadTexture = options.unloadTexture ?? (async (url, texture, media) => {
 		if (media !== "image" || !url) {
@@ -106,8 +62,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 +70,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 +92,61 @@ function createBoardAssetManager(options) {
 		model: 0
 	};
 	let disposed = false;
-	function notify(key) {
-		for (const listener of listeners) listener(key);
+	let focus = null;
+	let trimTimer = null;
+	let trimSince = 0;
+	let shrinking = 0;
+	let warm = /* @__PURE__ */ new Set();
+	let warming = 0;
+	const unwarmable = /* @__PURE__ */ new Set();
+	function isWarm(key) {
+		return warm.has(key) && (entries.get(key)?.refs ?? 0) <= 0;
+	}
+	function notify(key, change = "texture") {
+		for (const listener of listeners) listener(key, change);
+	}
+	const tones = /* @__PURE__ */ new Map();
+	const toneQueue = /* @__PURE__ */ new Set();
+	let cancelTone = null;
+	function queueTone(key) {
+		if (!readTone || tones.has(key)) return;
+		toneQueue.add(key);
+		cancelTone ??= scheduleBoardIdle(readNextTone, 0);
 	}
+	async function readNextTone() {
+		const [key] = toneQueue;
+		if (key === void 0) {
+			cancelTone = null;
+			return;
+		}
+		toneQueue.delete(key);
+		const texture = entries.get(key)?.texture;
+		const tone = texture && readTone ? await readTone(texture).catch(() => null) : null;
+		if (disposed) return;
+		if (tone !== null) {
+			if (tones.size >= TONE_LIMIT) tones.delete(tones.keys().next().value);
+			tones.set(key, tone);
+			notify(key, "tone");
+		}
+		cancelTone = toneQueue.size > 0 ? scheduleBoardIdle(readNextTone, 0) : null;
+	}
+	const keys = /* @__PURE__ */ new WeakMap();
+	let keyEpoch = 0;
 	function managedAssetKey(item) {
-		const key = boardAssetKey(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 asset = options.itemAsset?.(item);
+		const key = asset === void 0 ? boardAssetKey(item) : asset && boardAssetRefKey(asset);
 		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;
@@ -159,13 +162,16 @@ function createBoardAssetManager(options) {
 	function ensureEntry(key) {
 		let entry = entries.get(key);
 		if (!entry) {
+			const source = boardAssetKeySource(key);
 			entry = {
-				media: keySource(key)?.media ?? "image",
+				media: source?.media ?? "image",
+				cover: source?.fit === "cover",
 				source: null,
 				url: null,
 				texture: null,
 				edge: 0,
 				want: 0,
+				center: null,
 				natural: void 0,
 				refs: 0,
 				loading: false,
@@ -195,28 +201,71 @@ 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 (warm.delete(key) && !loaded && !entry.texture && entry.refs <= 0) unwarmable.add(key);
 		if (loaded) {
 			const replaced = entry.texture;
 			const replacedUrl = entry.url ?? "";
@@ -231,9 +280,10 @@ 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);
+			queueTone(key);
 			refine(key, entry);
 			return;
 		}
@@ -254,11 +304,11 @@ function createBoardAssetManager(options) {
 			notify(key);
 		}
 	}
-	function refinable(entry) {
-		return entry.media === "image" && entry.refs > 0 && entry.texture !== null && entry.source !== null && entry.want > entry.edge;
+	function refinable(key, entry) {
+		return entry.media === "image" && (entry.refs > 0 || warm.has(key)) && entry.texture !== null && entry.source !== null && entry.want > entry.edge;
 	}
 	function refine(key, entry) {
-		if (refinable(entry) && !entry.loading && entry.source) enqueue(key, "image", textureLoad("image", entry.source));
+		if (refinable(key, entry) && !entry.loading && entry.source) enqueue(key, "image", textureLoad("image", entry.source));
 	}
 	function enqueue(key, media, load) {
 		if (queue.some((task) => task.key === key)) return;
@@ -269,20 +319,43 @@ function createBoardAssetManager(options) {
 		});
 		pump();
 	}
+	function nextTask() {
+		let best = -1;
+		let bestWarm = true;
+		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 prefetching = isWarm(task.key);
+			if (prefetching && (!bestWarm || warming >= prefetchLimit)) continue;
+			const center = entries.get(task.key)?.center;
+			const distance = focus && center ? (center.x - focus.x) ** 2 + (center.y - focus.y) ** 2 : 0;
+			if (best < 0 || bestWarm && !prefetching || distance < nearest) {
+				nearest = distance;
+				best = index;
+				bestWarm = prefetching;
+				if (!focus && !prefetching) return 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;
 			const entry = entries.get(task.key);
-			if (!entry || entry.loading || entry.texture && !refinable(entry)) continue;
+			if (!entry || entry.loading || entry.texture && !refinable(task.key, entry)) continue;
+			const prefetching = isWarm(task.key);
 			entry.loading = true;
 			active += 1;
 			activeByMedia[task.media] += 1;
+			if (prefetching) warming += 1;
 			const done = (loaded, error) => {
 				active -= 1;
 				activeByMedia[task.media] -= 1;
+				if (prefetching) warming -= 1;
 				adopt(task.key, entry, loaded, error);
 				if (!disposed) pump();
 			};
@@ -292,18 +365,39 @@ function createBoardAssetManager(options) {
 	function textureLoad(media, source) {
 		return async (entry) => {
 			entry.source = source;
-			const edge = entry.want;
-			const variant = media === "image" ? variantUrl(source, edge) : null;
+			const { cover, want: edge } = entry;
+			const variant = media === "image" ? variantUrl(source, Math.max(edge, SMALLEST_VARIANT), cover) : 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, cover).catch(() => null);
+				if (fitted) return {
+					texture: fitted,
+					url: "",
+					edge: sharpEdge(fitted, edge, true, cover)
+				};
+			}
 			const texture = await loadTexture(url, media);
 			if (!texture) return null;
+			const bound = boundEdge(texture, cover);
+			if (media === "image" && shrinkTexture && edge < bound / 2) {
+				const longEdge = Math.round(edge * Math.max(texture.width, texture.height) / bound);
+				const small = await shrinkTexture(texture, longEdge).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), cover)
 			};
 		};
 	}
@@ -313,7 +407,7 @@ function createBoardAssetManager(options) {
 			entry.loading = true;
 			resolveFileUrl(path, fresh ? { fresh } : void 0).then((url) => {
 				if (disposed || entries.get(key) !== entry) return;
-				if (entry.refs <= 0) return evict(key, entry);
+				if (entry.refs <= 0 && !warm.has(key)) return evict(key, entry);
 				if (!url) return adopt(key, entry, null, /* @__PURE__ */ new Error(`Unavailable file: ${path}`));
 				entry.loading = false;
 				enqueue(key, media, textureLoad(media, url));
@@ -372,21 +466,29 @@ 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);
 		},
+		invalidateItemAssets() {
+			if (options.itemAsset) keyEpoch += 1;
+		},
 		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 +515,16 @@ function createBoardAssetManager(options) {
 		hasError(key) {
 			return entries.get(key)?.error ?? false;
 		},
+		getTone(key) {
+			return tones.get(key) ?? null;
+		},
+		focus(point) {
+			focus = point;
+		},
 		acquire(key) {
+			unwarmable.delete(key);
 			const entry = ensureEntry(key);
+			if (entry.refs <= 0) entry.want = 0;
 			entry.refs += 1;
 			entry.lastUsedAt = now();
 		},
@@ -427,7 +537,56 @@ function createBoardAssetManager(options) {
 			clearRetry(entry);
 			if (entry.loading) return;
 			if (!entry.texture) evict(key, entry);
-			else trim();
+			else scheduleTrim();
+		},
+		prefetch(requests) {
+			if (disposed) return;
+			const next = /* @__PURE__ */ new Set();
+			let room = budget.maxBytes * PREFETCH_POOL_SHARE;
+			for (const entry of entries.values()) if (entry.refs <= 0) room -= footprintOf(entry.texture);
+			for (const { item, edge } of requests) {
+				const key = managedAssetKey(item);
+				if (!key || !Number.isFinite(edge) || unwarmable.has(key) || boardAssetKeySource(key)?.media !== "image") continue;
+				const entry = entries.get(key);
+				const sharp = entry?.texture && entry.edge >= edge;
+				if (entry && (entry.refs > 0 || sharp || entry.error || entry.loading && !warm.has(key))) continue;
+				room -= edge * edge * 4;
+				if (room < 0) break;
+				next.add(key);
+			}
+			for (const key of warm) {
+				if (next.has(key)) continue;
+				const entry = entries.get(key);
+				if (!entry || entry.refs > 0 || entry.loading) continue;
+				const index = queue.findIndex((task) => task.key === key);
+				if (index >= 0) queue.splice(index, 1);
+				if (!entry.texture) evict(key, entry);
+			}
+			const fresh = new Set([...next].filter((key) => !warm.has(key)));
+			warm = next;
+			for (const { item, edge } of requests) {
+				const key = managedAssetKey(item);
+				if (!key || !next.has(key)) continue;
+				const entry = ensureEntry(key);
+				entry.want = edge;
+				entry.center = {
+					x: item.frame.x + item.frame.width / 2,
+					y: item.frame.y + item.frame.height / 2
+				};
+				if (!fresh.delete(key)) continue;
+				if (entry.texture) {
+					refine(key, entry);
+					continue;
+				}
+				const start = starter(item, key, boardAssetKeySource(key));
+				if (!start) {
+					warm.delete(key);
+					evict(key, entry);
+					continue;
+				}
+				starters.set(key, start);
+				start(entry);
+			}
 		},
 		async withTextures(items, use, loadOptions) {
 			const keys = /* @__PURE__ */ new Set();
@@ -442,7 +601,7 @@ function createBoardAssetManager(options) {
 				for (const item of items) manager.requestItem(item, loadOptions?.edge?.(item));
 				const settled = () => [...keys].every((key) => {
 					const entry = entries.get(key);
-					return Boolean(entry?.error) || Boolean(entry?.texture && !refinable(entry));
+					return Boolean(entry?.error) || Boolean(entry?.texture && !refinable(key, entry));
 				});
 				if (!settled()) {
 					const timeoutMs = loadOptions?.timeoutMs ?? 15e3;
@@ -467,6 +626,31 @@ 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);
+			}
+			let loading = active - warming;
+			let prefetching = warming;
+			for (const task of queue) {
+				if (!entries.has(task.key)) continue;
+				if (isWarm(task.key)) prefetching += 1;
+				else loading += 1;
+			}
+			return {
+				textures,
+				cooling,
+				bytes,
+				loading,
+				prefetching
+			};
+		},
 		subscribe(listener) {
 			listeners.add(listener);
 			return () => {
@@ -475,7 +659,14 @@ function createBoardAssetManager(options) {
 		},
 		destroy() {
 			disposed = true;
+			if (trimTimer !== null) clearTimeout(trimTimer);
+			trimTimer = null;
+			cancelTone?.();
+			toneQueue.clear();
+			tones.clear();
 			queue.length = 0;
+			warm.clear();
+			unwarmable.clear();
 			listeners.clear();
 			pathVersions.clear();
 			starters.clear();
@@ -488,4 +679,4 @@ function createBoardAssetManager(options) {
 	return manager;
 }
 //#endregion
-export { boardAssetKey, boardTextureEdge, createBoardAssetManager };
+export { createBoardAssetManager };

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

@@ -0,0 +1,35 @@
+import { BoardStage } from "./stage.js";
+//#region src/board/stage/bench.d.ts
+type BoardBenchPhase = {
+  name: string;
+  frames: number;
+  wheel: Pick<WheelEventInit, "deltaX" | "deltaY" | "ctrlKey">;
+  rest?: number;
+};
+type BoardBenchPercentiles = {
+  p50: number;
+  p95: number;
+  max: number;
+};
+type BoardBenchSettle = {
+  shown: number;
+  ready: number;
+  loaded: number;
+};
+type BoardBenchPhaseReport = BoardBenchSettle & {
+  name: string;
+  frame: BoardBenchPercentiles;
+  work: BoardBenchPercentiles;
+  long: number;
+};
+type BoardBenchReport = {
+  open: BoardBenchSettle;
+  phases: BoardBenchPhaseReport[];
+};
+declare const BOARD_BENCH_PHASES: readonly BoardBenchPhase[];
+declare function runBoardStageBench(stage: BoardStage, { since, phases }?: {
+  since?: number;
+  phases?: readonly BoardBenchPhase[];
+}): Promise<BoardBenchReport>;
+//#endregion
+export { BOARD_BENCH_PHASES, BoardBenchPercentiles, BoardBenchPhase, BoardBenchPhaseReport, BoardBenchReport, BoardBenchSettle, runBoardStageBench };