@neta-art/cohub 12.2.0 → 12.4.0

package/dist/board/stage/assets.js

@@ -1,43 +1,53 @@
 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 { boardAssetKey, boardAssetKeySource, boardAssetRefKey } from "../model/asset-key.js";
 import { loadVideoThumbnailTexture, videoTextureNaturalSize } from "../render/video-thumbnail.js";
-import { DEFAULT_LRU_BUDGET, planLruTrim } from "./lru.js";
-import { boardImageTexturePool, loadBoardImageTexture, loadFittedImageTexture, shrinkBoardTexture, unloadBoardImageTexture } from "./texture-pool.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 variantUrl(source, edge) {
+function variantUrl(source, edge, cover) {
 	if (!(edge <= 1536)) return null;
-	const url = imageVariantUrl(source, edge);
+	const url = imageVariantUrl(source, edge, cover ? "cover" : "contain");
 	return url && url !== source ? url : 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;
+function boundEdge({ width, height }, cover) {
+	return cover ? Math.min(width, height) : Math.max(width, height);
+}
+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) {
@@ -86,8 +96,39 @@ function createBoardAssetManager(options) {
 	let trimTimer = null;
 	let trimSince = 0;
 	let shrinking = 0;
-	function notify(key) {
-		for (const listener of listeners) listener(key);
+	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;
@@ -102,7 +143,8 @@ function createBoardAssetManager(options) {
 		return key;
 	}
 	function resolveAssetKey(item) {
-		const key = boardAssetKey(item);
+		const asset = options.itemAsset?.(item);
+		const key = asset === void 0 ? boardAssetKey(item) : asset && boardAssetRefKey(asset);
 		if (!key) return null;
 		const source = boardAssetKeySource(key);
 		if (source?.media === "video" && options.loadVideoPreviews === false) return null;
@@ -120,8 +162,10 @@ function createBoardAssetManager(options) {
 	function ensureEntry(key) {
 		let entry = entries.get(key);
 		if (!entry) {
+			const source = boardAssetKeySource(key);
 			entry = {
-				media: boardAssetKeySource(key)?.media ?? "image",
+				media: source?.media ?? "image",
+				cover: source?.fit === "cover",
 				source: null,
 				url: null,
 				texture: null,
@@ -221,6 +265,7 @@ function createBoardAssetManager(options) {
 			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 ?? "";
@@ -238,6 +283,7 @@ function createBoardAssetManager(options) {
 			if (entry.refs <= 0) scheduleTrim();
 			else notify(key);
 			if (replaced) retire(entry.media, replacedUrl, replaced);
+			queueTone(key);
 			refine(key, entry);
 			return;
 		}
@@ -258,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;
@@ -275,16 +321,20 @@ function createBoardAssetManager(options) {
 	}
 	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;
-			if (!focus || !center) return index;
-			const distance = (center.x - focus.x) ** 2 + (center.y - focus.y) ** 2;
-			if (distance < nearest) {
+			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;
@@ -296,13 +346,16 @@ function createBoardAssetManager(options) {
 			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();
 			};
@@ -312,24 +365,26 @@ function createBoardAssetManager(options) {
 	function textureLoad(media, source) {
 		return async (entry) => {
 			entry.source = source;
-			const edge = entry.want;
-			const variant = media === "image" ? variantUrl(source, Math.max(edge, SMALLEST_VARIANT)) : 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).catch(() => null);
+				const fitted = await loadFittedImageTexture(url, edge, cover).catch(() => null);
 				if (fitted) return {
 					texture: fitted,
 					url: "",
-					edge: sharpEdge(fitted, edge, true)
+					edge: sharpEdge(fitted, edge, true, cover)
 				};
 			}
 			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);
+			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 {
@@ -342,7 +397,7 @@ function createBoardAssetManager(options) {
 			return {
 				texture,
 				url,
-				edge: sharpEdge(texture, edge, Boolean(variant))
+				edge: sharpEdge(texture, edge, Boolean(variant), cover)
 			};
 		};
 	}
@@ -352,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));
@@ -419,6 +474,9 @@ function createBoardAssetManager(options) {
 			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);
@@ -457,10 +515,14 @@ 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;
@@ -477,6 +539,55 @@ function createBoardAssetManager(options) {
 			if (!entry.texture) evict(key, entry);
 			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();
 			if (!disposed) for (const item of items) {
@@ -490,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;
@@ -525,10 +636,19 @@ function createBoardAssetManager(options) {
 				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
+				bytes,
+				loading,
+				prefetching
 			};
 		},
 		subscribe(listener) {
@@ -541,7 +661,12 @@ function createBoardAssetManager(options) {
 			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();

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

package/dist/board/stage/bench.js

@@ -0,0 +1,153 @@
+//#region src/board/stage/bench.ts
+const STEP = {
+	name: "step",
+	frames: 1,
+	rest: 3e3,
+	wheel: { deltaY: 960 }
+};
+const BOARD_BENCH_PHASES = [
+	{
+		name: "zoom in",
+		frames: 15,
+		wheel: {
+			deltaY: -10,
+			ctrlKey: true
+		}
+	},
+	{
+		name: "close",
+		frames: 12,
+		wheel: {
+			deltaY: -10,
+			ctrlKey: true
+		}
+	},
+	STEP,
+	STEP,
+	STEP,
+	{
+		name: "pan close",
+		frames: 60,
+		wheel: {
+			deltaX: -24,
+			deltaY: 16
+		}
+	},
+	{
+		name: "zoom out",
+		frames: 12,
+		wheel: {
+			deltaY: 10,
+			ctrlKey: true
+		}
+	},
+	{
+		name: "pan",
+		frames: 120,
+		wheel: { deltaX: 24 }
+	},
+	{
+		name: "overview",
+		frames: 16,
+		wheel: {
+			deltaY: 10,
+			ctrlKey: true
+		}
+	}
+];
+const SETTLE_LIMIT_MS = 2e4;
+const LONG_FRAME_MS = 50;
+function percentiles(values) {
+	const sorted = [...values].sort((a, b) => a - b);
+	const at = (ratio) => sorted[Math.min(sorted.length - 1, Math.floor(sorted.length * ratio))] ?? 0;
+	return {
+		p50: at(.5),
+		p95: at(.95),
+		max: sorted[sorted.length - 1] ?? 0
+	};
+}
+const nextFrame = () => new Promise((resolve) => requestAnimationFrame(resolve));
+async function settle(stage, since) {
+	const times = {};
+	for (;;) {
+		const now = await nextFrame();
+		const { waiting, settling, loading } = stage.stats();
+		const at = now - since;
+		if (times.shown === void 0 && waiting === 0) times.shown = at;
+		if (times.ready === void 0 && !settling) times.ready = at;
+		if (times.loaded === void 0 && !settling && loading === 0) times.loaded = at;
+		if (times.loaded !== void 0 || at >= SETTLE_LIMIT_MS) return {
+			shown: times.shown ?? SETTLE_LIMIT_MS,
+			ready: times.ready ?? SETTLE_LIMIT_MS,
+			loaded: times.loaded ?? SETTLE_LIMIT_MS
+		};
+	}
+}
+function measureFrameWork() {
+	const original = globalThis.requestAnimationFrame;
+	let work = 0;
+	globalThis.requestAnimationFrame = (callback) => original((time) => {
+		const start = performance.now();
+		try {
+			callback(time);
+		} finally {
+			work += performance.now() - start;
+		}
+	});
+	return {
+		take: () => {
+			const taken = work;
+			work = 0;
+			return taken;
+		},
+		stop: () => {
+			globalThis.requestAnimationFrame = original;
+		}
+	};
+}
+async function runBoardStageBench(stage, { since = performance.now(), phases = BOARD_BENCH_PHASES } = {}) {
+	await stage.ready;
+	const canvas = stage.renderer?.canvas;
+	if (!canvas) throw new Error("Board stage has no canvas.");
+	const open = await settle(stage, since);
+	const rect = canvas.getBoundingClientRect();
+	const work = measureFrameWork();
+	try {
+		const reports = [];
+		for (const phase of phases) {
+			if (phase.rest) await new Promise((resolve) => setTimeout(resolve, phase.rest));
+			const intervals = [];
+			const costs = [];
+			let previous = await nextFrame();
+			for (let frame = 0; frame < phase.frames; frame += 1) {
+				canvas.dispatchEvent(new WheelEvent("wheel", {
+					bubbles: true,
+					cancelable: true,
+					clientX: rect.left + rect.width / 2,
+					clientY: rect.top + rect.height / 2,
+					...phase.wheel
+				}));
+				work.take();
+				const now = await nextFrame();
+				costs.push(work.take());
+				intervals.push(now - previous);
+				previous = now;
+			}
+			reports.push({
+				name: phase.name,
+				frame: percentiles(intervals),
+				work: percentiles(costs),
+				long: intervals.filter((interval) => interval > LONG_FRAME_MS).length,
+				...await settle(stage, previous)
+			});
+		}
+		return {
+			open,
+			phases: reports
+		};
+	} finally {
+		work.stop();
+	}
+}
+//#endregion
+export { BOARD_BENCH_PHASES, runBoardStageBench };

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

@@ -0,0 +1,41 @@
+import { BoardLod } from "../render/lod.js";
+import { LruBudget } from "./lru.js";
+//#region src/board/stage/device.d.ts
+type BoardDeviceTier = "low" | "standard" | "high";
+type BoardDeviceSignals = {
+  phone?: boolean;
+  memory?: number;
+  cores?: number;
+  saveData?: boolean;
+  slowNetwork?: boolean;
+};
+type BoardDeviceBudget = {
+  tier: BoardDeviceTier;
+  lod: BoardLod;
+  lru: LruBudget;
+  concurrency: number;
+  prefetch: number;
+};
+declare const BOARD_DEVICE_TIERS: readonly BoardDeviceTier[];
+type BoardDeviceEnvironment = {
+  navigator?: Navigator & {
+    deviceMemory?: number;
+    connection?: {
+      saveData?: boolean;
+      effectiveType?: string;
+    };
+  };
+  matchMedia?: (query: string) => {
+    matches: boolean;
+  };
+  screen?: {
+    width: number;
+    height: number;
+  };
+};
+declare function readBoardDeviceSignals(environment?: BoardDeviceEnvironment): BoardDeviceSignals;
+declare function boardDeviceTier({ phone, memory, cores }: BoardDeviceSignals): BoardDeviceTier;
+declare function boardDeviceBudget(signals: BoardDeviceSignals, tier?: BoardDeviceTier): BoardDeviceBudget;
+declare function defaultBoardDeviceBudget(): BoardDeviceBudget;
+//#endregion
+export { BOARD_DEVICE_TIERS, BoardDeviceBudget, BoardDeviceEnvironment, BoardDeviceSignals, BoardDeviceTier, boardDeviceBudget, boardDeviceTier, defaultBoardDeviceBudget, readBoardDeviceSignals };

package/dist/board/stage/device.js

@@ -0,0 +1,62 @@
+import { COMPACT_BOARD_LOD, DEFAULT_BOARD_LOD } from "../render/lod.js";
+import { COMPACT_LRU_BUDGET, DEFAULT_LRU_BUDGET } from "./lru.js";
+//#region src/board/stage/device.ts
+const BUDGETS = {
+	low: {
+		lod: COMPACT_BOARD_LOD,
+		lru: COMPACT_LRU_BUDGET,
+		concurrency: 4,
+		prefetch: 0
+	},
+	standard: {
+		lod: DEFAULT_BOARD_LOD,
+		lru: DEFAULT_LRU_BUDGET,
+		concurrency: 6,
+		prefetch: .5
+	},
+	high: {
+		lod: DEFAULT_BOARD_LOD,
+		lru: {
+			maxCount: 4096,
+			maxBytes: 402653184
+		},
+		concurrency: 8,
+		prefetch: 1
+	}
+};
+const BOARD_DEVICE_TIERS = Object.keys(BUDGETS);
+const PHONE_SHORT_SIDE = 600;
+function readBoardDeviceSignals(environment = globalThis) {
+	const { navigator: device, matchMedia, screen } = environment;
+	if (!device || !matchMedia || !screen) return {};
+	const connection = device.connection;
+	return {
+		phone: matchMedia("(pointer: coarse)").matches && !matchMedia("(any-pointer: fine)").matches && Math.min(screen.width, screen.height) < PHONE_SHORT_SIDE,
+		memory: device.deviceMemory,
+		cores: device.hardwareConcurrency,
+		saveData: Boolean(connection?.saveData),
+		slowNetwork: /^(slow-2g|2g|3g)$/.test(connection?.effectiveType ?? "")
+	};
+}
+function boardDeviceTier({ phone, memory, cores }) {
+	if (memory !== void 0 && memory <= 2 || cores !== void 0 && cores <= 2) return "low";
+	if (phone) return memory !== void 0 && memory >= 8 ? "standard" : "low";
+	if (memory !== void 0 && memory <= 4 && cores !== void 0 && cores <= 4) return "low";
+	if (memory !== void 0 && memory >= 8 && cores !== void 0 && cores >= 8) return "high";
+	return "standard";
+}
+function boardDeviceBudget(signals, tier = boardDeviceTier(signals)) {
+	const budget = BUDGETS[tier];
+	return {
+		tier,
+		...budget,
+		prefetch: signals.saveData || signals.slowNetwork ? 0 : budget.prefetch
+	};
+}
+let detected;
+function defaultBoardDeviceBudget() {
+	detected ??= boardDeviceBudget(readBoardDeviceSignals());
+	return detected;
+}
+//#endregion
+export { BOARD_DEVICE_TIERS, boardDeviceBudget, boardDeviceTier, defaultBoardDeviceBudget, readBoardDeviceSignals };

package/dist/board/stage/frame-budget.d.ts

@@ -0,0 +1,19 @@
+//#region src/board/stage/frame-budget.d.ts
+type BoardFrameWork = "materialize" | "plate" | "resolution";
+type BoardFrameBudget = {
+  allow(kind: BoardFrameWork): number;
+  spend(kind: BoardFrameWork, units: number, ms: number): void;
+};
+type BoardFrameClock = BoardFrameBudget & {
+  begin(frameTime: number, options: {
+    moving: boolean;
+    chained: boolean;
+  }): void;
+  readonly interval: number;
+};
+declare function fixedBoardFrameBudget(): BoardFrameBudget & {
+  reset(): void;
+};
+declare function createBoardFrameClock(now?: () => number): BoardFrameClock;
+//#endregion
+export { BoardFrameBudget, BoardFrameClock, BoardFrameWork, createBoardFrameClock, fixedBoardFrameBudget };