@neta-art/cohub 12.1.1 → 12.3.0

package/dist/board/stage/scene.js

@@ -1,15 +1,14 @@
 import { parseBoardItem } from "../../protocol/dist/board-model.js";
 import { drawPointsBounds } from "../../protocol/dist/board-layout.js";
+import { itemBounds, rectsIntersect } from "../model/geometry.js";
+import { DEFAULT_BOARD_LOD, boardCardDetailed, boardLodRatio, boardLodSize } from "../render/lod.js";
 import { textZoomBucket } from "../render/text-resolution.js";
 import { clippingAncestor, isClippingFrame, syncClipGroup } from "../render/clip.js";
-import { Graphics } from "pixi.js";
+import { fixedBoardFrameBudget } from "./frame-budget.js";
+import { Graphics, Text } from "pixi.js";
 //#region src/board/stage/scene.ts
-const FAR_LAYER_ENTER = 450;
-const FAR_LAYER_EXIT = 350;
-const FAR_PASS_BATCH = 240;
-const FAR_LIVE_LIMIT = 64;
-const RESOLUTION_BATCH = 32;
-const Z_FAR_LAYER = -1;
+const FAR_CHUNK = 256;
+const LOD_ZOOM_STEPS = 8;
 const Z_LIFTED = 1e9;
 const Z_LIVE_STROKE = Number.MAX_SAFE_INTEGER - 1;
 const Z_OVERLAY = Number.MAX_SAFE_INTEGER;
@@ -24,6 +23,9 @@ function idSetSignature(ids) {
 	}
 	return hash;
 }
+function sameItems(a, b) {
+	return a.length === b.length && a.every((item, index) => item === b[index]);
+}
 function createBoardScene(options) {
 	const { world, overlay, getRenderer } = options;
 	world.sortableChildren = true;
@@ -36,14 +38,15 @@ function createBoardScene(options) {
 	const heldKeys = /* @__PURE__ */ new Map();
 	const holders = /* @__PURE__ */ new Map();
 	let orderById = /* @__PURE__ */ new Map();
-	let farSig = null;
-	let farActive = false;
+	let idsByOrder = [];
 	let lastStructureVersion = -1;
 	let lastZoom = NaN;
 	let lastResolution = "";
 	const pendingResolution = /* @__PURE__ */ new Set();
 	let liveVersion = 0;
 	let lifted = /* @__PURE__ */ new Set();
+	const fixedBudget = fixedBoardFrameBudget();
+	let budget = fixedBudget;
 	const liveStrokes = /* @__PURE__ */ new Map();
 	function setHeldKey(context, cardId, item) {
 		const desiredKey = item ? context.assetKey(item) : null;
@@ -105,6 +108,11 @@ function createBoardScene(options) {
 			const host = hostFor(entry.item, scene);
 			if (entry.container.parent !== host) host.addChild(entry.container);
 		}
+		for (const plate of plates.values()) {
+			const first = plate.items[0];
+			const host = first && hostFor(first, scene);
+			if (host && plate.graphics.parent !== host) host.addChild(plate.graphics);
+		}
 		for (const [id, entry] of clips) {
 			const frame = scene.get(id);
 			if (!frame || !isClippingFrame(frame) || entry.group.children.length <= 1) {
@@ -121,6 +129,7 @@ function createBoardScene(options) {
 		const pooled = takeFromPool(renderer.id);
 		const container = pooled ?? renderer.create(item, context);
 		container.visible = true;
+		container.culled = false;
 		if (pooled) renderer.update(container, item, context);
 		container.alpha = scene.opacity(item.id);
 		hostFor(item, scene).addChild(container);
@@ -141,79 +150,188 @@ function createBoardScene(options) {
 		renderer.zoom?.(container, context.zoom);
 		return entry;
 	}
-	let farFront = createFarLayer();
-	let farBack = createFarLayer();
-	let farPainted = false;
-	let farCovered = /* @__PURE__ */ new Set();
-	let farInput = null;
-	let farRunning = false;
-	let farQueued = false;
-	let farFrame = 0;
-	function createFarLayer() {
-		const layer = new Graphics({ label: "board-far-layer" });
-		layer.zIndex = Z_FAR_LAYER;
-		layer.visible = false;
-		world.addChild(layer);
-		return layer;
+	const lodSizes = /* @__PURE__ */ new WeakMap();
+	let nearIds = EMPTY_IDS;
+	let plan = null;
+	let planInputs = [];
+	/** Visible ids in z-order; sorting indices beats comparing ids through the map. */
+	function orderedIds(visibleIds) {
+		if (visibleIds === null) return idsByOrder;
+		const order = new Int32Array(visibleIds.size);
+		let length = 0;
+		for (const id of visibleIds) {
+			const index = orderById.get(id);
+			if (index !== void 0) order[length++] = index;
+		}
+		return Array.from(order.subarray(0, length).sort(), (index) => idsByOrder[index]);
 	}
-	function requestFarPass(signature) {
-		farSig = signature;
-		if (farRunning) farQueued = true;
-		else runFarPass();
+	function lodSize(renderer, item) {
+		let size = lodSizes.get(item);
+		if (size === void 0) {
+			size = boardLodSize(renderer, item);
+			lodSizes.set(item, size);
+		}
+		return size;
 	}
-	function runFarPass() {
-		if (!farInput) return;
-		farRunning = true;
-		farQueued = false;
-		const { context, getItem, pinnedIds } = farInput;
-		const ids = visibleFacts(farInput).orderedIds;
-		const target = farPainted ? farBack : farFront;
-		const painted = /* @__PURE__ */ new Set();
-		target.clear();
-		if (target === farFront) farCovered = painted;
-		let index = 0;
-		const step = () => {
-			farFrame = 0;
-			const end = Math.min(ids.length, index + FAR_PASS_BATCH);
-			for (; index < end; index += 1) {
-				const id = ids[index];
-				if (pinnedIds.has(id)) continue;
-				const item = getItem(id);
-				if (!item) continue;
-				getRenderer(item, context).renderFar?.(target, item, context);
-				painted.add(id);
+	/**
+	* Split the visible cards into live ones and z-ordered chunks of far stand-ins.
+	* A card is live while it is legible on screen, until the live budget keeps
+	* the on-screen ones nearest the focus; pinned cards and cards without a far
+	* stand-in stay live.
+	*/
+	function lodPlan(input) {
+		const { visibleIds, context, getItem, pinnedIds, scene } = input;
+		const lod = input.lod ?? DEFAULT_BOARD_LOD;
+		const step = Math.round(Math.log2(Math.max(context.zoom, 1e-4)) * LOD_ZOOM_STEPS);
+		const cell = input.view && input.focus && plan?.limited ? input.view.width / 8 : 0;
+		const at = cell ? `${Math.round((input.focus?.x ?? 0) / cell)},${Math.round((input.focus?.y ?? 0) / cell)}` : "";
+		const inputs = [
+			visibleIds,
+			input.structureVersion,
+			idSetSignature(pinnedIds),
+			step,
+			at,
+			lod.media,
+			lod.text,
+			lod.card,
+			lod.live
+		];
+		const reusable = plan && inputs.every((value, index) => value === planInputs[index]);
+		if (plan && reusable && !plan.deferred && (input.gestureActive || plan.scene === scene)) return plan;
+		planInputs = inputs;
+		const ids = orderedIds(visibleIds);
+		const live = /* @__PURE__ */ new Set();
+		const near = [];
+		for (const id of ids) {
+			const item = getItem(id);
+			if (!item) continue;
+			const renderer = getRenderer(item, context);
+			if (pinnedIds.has(id) || !renderer.renderFar) {
+				live.add(id);
+				continue;
 			}
-			if (index < ids.length) {
-				farFrame = requestAnimationFrame(step);
-				if (target === farFront) options.requestFrame?.();
-				return;
+			if (boardLodRatio(renderer, lodSize(renderer, item), context.zoom, lod) >= (nearIds.has(id) ? .8 : 1)) near.push(item);
+		}
+		const room = Math.max(0, lod.live - live.size);
+		const limited = near.length > room;
+		const allowance = budget.allow("materialize");
+		const { focus, view } = input;
+		const ranked = focus && (limited || near.length > allowance) ? near.map(({ id, frame }) => ({
+			id,
+			offscreen: view && !rectsIntersect(itemBounds(frame), view) ? 1 : 0,
+			distance: (frame.x + frame.width / 2 - focus.x) ** 2 + (frame.y + frame.height / 2 - focus.y) ** 2
+		})).sort((a, b) => a.offscreen - b.offscreen || a.distance - b.distance) : near;
+		let admitted = 0;
+		let deferred = false;
+		for (const { id } of ranked.slice(0, room)) if (!cards.has(id) && admitted++ >= allowance) deferred = true;
+		else live.add(id);
+		if (deferred) options.requestFrame?.();
+		nearIds = live;
+		const runs = /* @__PURE__ */ new Map();
+		const far = /* @__PURE__ */ new Set();
+		for (const id of ids) {
+			const item = getItem(id);
+			if (!item || live.has(id)) continue;
+			const order = orderById.get(id) ?? 0;
+			const key = `${Math.floor(order / FAR_CHUNK)}:${clippingAncestor(scene, item) ?? ""}`;
+			const run = runs.get(key);
+			if (run) run.items.push(item);
+			else runs.set(key, {
+				key,
+				order,
+				items: [item]
+			});
+			far.add(id);
+		}
+		plan = {
+			scene,
+			live,
+			far,
+			runs,
+			limited,
+			deferred
+		};
+		return plan;
+	}
+	const plates = /* @__PURE__ */ new Map();
+	let paintedPlan = null;
+	let paintedSig = "";
+	let platesPending = false;
+	let covered = EMPTY_IDS;
+	/**
+	* Repaint the plates whose cards changed, within a per-frame budget. A card
+	* is covered once a plate draws it; until then it stays live if it already is.
+	*/
+	function paintPlates(input, current) {
+		const { context, globalSig, scene } = input;
+		if (current === paintedPlan && globalSig === paintedSig) return false;
+		const start = performance.now();
+		const allowance = budget.allow("plate");
+		let painted = 0;
+		let pending = false;
+		let changed = false;
+		for (const run of current.runs.values()) {
+			let plate = plates.get(run.key);
+			if (plate?.sig === globalSig && sameItems(plate.items, run.items)) continue;
+			if (painted >= allowance) {
+				pending = true;
+				continue;
 			}
-			if (target === farBack) {
-				farBack = farFront;
-				farFront = target;
-				farBack.visible = false;
-				farBack.clear();
-				farCovered = painted;
+			painted += run.items.length;
+			if (!plate) {
+				plate = {
+					graphics: new Graphics({ label: "board-far-plate" }),
+					items: [],
+					sig: ""
+				};
+				plates.set(run.key, plate);
+				changed = true;
 			}
-			farFront.visible = farActive;
-			farPainted = true;
-			farRunning = false;
-			options.requestFrame?.();
-			if (farQueued) runFarPass();
-		};
-		step();
+			const { graphics } = plate;
+			graphics.clear();
+			for (const item of run.items) getRenderer(item, context).renderFar?.(graphics, item, context);
+			plate.items = run.items;
+			plate.sig = globalSig;
+			graphics.zIndex = run.order;
+			const host = hostFor(run.items[0], scene);
+			if (graphics.parent !== host) host.addChild(graphics);
+		}
+		const paintMs = performance.now() - start;
+		for (const [key, plate] of plates) {
+			if (current.runs.has(key)) continue;
+			plates.delete(key);
+			plate.graphics.destroy();
+			changed = true;
+		}
+		const next = /* @__PURE__ */ new Set();
+		for (const plate of plates.values()) for (const item of plate.items) next.add(item.id);
+		covered = next;
+		budget.spend("plate", painted, paintMs);
+		platesPending = pending;
+		if (pending) options.requestFrame?.();
+		else {
+			paintedPlan = current;
+			paintedSig = globalSig;
+		}
+		return changed;
+	}
+	function repaintFar(keys, assetKey) {
+		for (const plate of plates.values()) {
+			if (!plate.items.some((item) => keys.has(assetKey(item) ?? ""))) continue;
+			plate.sig = "";
+			paintedPlan = null;
+		}
 	}
-	function resetFarLayer() {
-		cancelAnimationFrame(farFrame);
-		farFrame = 0;
-		farRunning = false;
-		farQueued = false;
-		farInput = null;
-		farPainted = false;
-		farCovered = /* @__PURE__ */ new Set();
-		farSig = null;
-		farFront.clear();
-		farBack.clear();
+	function clearPlates() {
+		for (const plate of plates.values()) plate.graphics.destroy();
+		plates.clear();
+		paintedPlan = null;
+		paintedSig = "";
+		platesPending = false;
+		covered = EMPTY_IDS;
+		plan = null;
+		planInputs = [];
+		nearIds = EMPTY_IDS;
 	}
 	function syncLiveStrokes(input) {
 		const { strokes, context, getItem } = input;
@@ -274,28 +392,11 @@ function createBoardScene(options) {
 		world.removeChild(entry.container);
 		entry.renderer.destroy?.(entry.container, context);
 	}
-	let visibleMemo = null;
-	function visibleFacts(input) {
-		const { items, visibleIds, structureVersion, context, getItem } = input;
-		if (visibleMemo?.ids === visibleIds && visibleMemo.structureVersion === structureVersion) return visibleMemo;
-		const orderedIds = visibleIds === null ? items.map((item) => item.id) : [...visibleIds].sort((a, b) => (orderById.get(a) ?? 0) - (orderById.get(b) ?? 0));
-		const unbatched = /* @__PURE__ */ new Set();
-		for (const id of orderedIds) {
-			const item = getItem(id);
-			if (item && !getRenderer(item, context).renderFar) unbatched.add(id);
-		}
-		visibleMemo = {
-			ids: visibleIds,
-			structureVersion,
-			signature: visibleIds === null ? 0 : idSetSignature(visibleIds),
-			orderedIds,
-			unbatched
-		};
-		return visibleMemo;
-	}
 	function sync(input) {
-		const { items, scene, context, getItem, visibleIds, pinnedIds, globalSig, structureVersion, geometryVersion, gestureActive } = input;
-		const resolution = `${textZoomBucket(context.zoom)}:${context.textResolution}`;
+		const { items, scene, context, getItem, pinnedIds, globalSig, structureVersion } = input;
+		fixedBudget.reset();
+		budget = input.budget ?? fixedBudget;
+		const resolution = `${textZoomBucket(context.zoom)}:${boardCardDetailed(context.zoom)}:${context.textResolution}`;
 		if (resolution !== lastResolution) {
 			lastResolution = resolution;
 			queueResolution(input.focus);
@@ -305,45 +406,17 @@ function createBoardScene(options) {
 			lastStructureVersion = structureVersion;
 			const liveIds = new Set(items.map((item) => item.id));
 			for (const [id, entry] of [...cards]) if (!liveIds.has(id)) recycle(id, entry, context, false);
-			orderById = new Map(items.map((item, index) => [item.id, index]));
+			idsByOrder = items.map((item) => item.id);
+			orderById = new Map(idsByOrder.map((id, index) => [id, index]));
 		}
-		const visibleCount = visibleIds === null ? items.length : visibleIds.size;
-		const nextFarActive = farActive ? visibleCount > FAR_LAYER_EXIT : visibleCount > FAR_LAYER_ENTER;
-		const farModeChanged = nextFarActive !== farActive;
-		farActive = nextFarActive;
-		farFront.visible = farActive;
-		if (farActive) {
-			farInput = input;
-			const nextFarSig = [
-				structureVersion,
-				geometryVersion,
-				globalSig,
-				idSetSignature(pinnedIds),
-				visibleIds === null ? "all" : visibleFacts(input).signature
-			].join("|");
-			if (farSig === null || nextFarSig !== farSig && !gestureActive) requestFarPass(nextFarSig);
-		} else if (farModeChanged) resetFarLayer();
+		const current = lodPlan(input);
+		const platesChanged = paintPlates(input, current);
 		const wanted = new Set(pinnedIds);
-		if (farActive) {
-			const { orderedIds, unbatched } = visibleFacts(input);
-			for (const id of unbatched) wanted.add(id);
-			let retained = 0;
-			if (!farPainted) {
-				for (const id of cards.keys()) if ((!visibleIds || visibleIds.has(id)) && !farCovered.has(id) && !wanted.has(id)) {
-					wanted.add(id);
-					retained++;
-				}
-			}
-			let budget = Math.max(0, FAR_LIVE_LIMIT - retained);
-			for (const id of orderedIds) {
-				if (budget === 0) break;
-				if (farCovered.has(id) || wanted.has(id)) continue;
-				wanted.add(id);
-				budget -= 1;
-			}
-		} else if (visibleIds === null) for (const item of items) wanted.add(item.id);
-		else for (const id of visibleIds) wanted.add(id);
+		for (const id of current.live) wanted.add(id);
+		for (const id of cards.keys()) if (current.far.has(id) && !covered.has(id)) wanted.add(id);
 		let liveSetChanged = false;
+		let made = 0;
+		let making = 0;
 		for (const [id, entry] of [...cards]) if (!wanted.has(id)) {
 			recycle(id, entry, context, false);
 			liveSetChanged = true;
@@ -360,7 +433,10 @@ function createBoardScene(options) {
 				entry = void 0;
 			}
 			if (!entry) {
+				const start = performance.now();
 				materialize(item, context, globalSig, scene);
+				making += performance.now() - start;
+				made += 1;
 				liveSetChanged = true;
 				continue;
 			}
@@ -384,18 +460,28 @@ function createBoardScene(options) {
 				pendingResolution.delete(id);
 			}
 		}
+		budget.spend("materialize", made, making);
+		if (input.view) cullCards(input.view, pinnedIds);
 		refreshResolution(context);
 		if (liveSetChanged) liveVersion += 1;
-		if (structureChanged || liveSetChanged) syncClips(scene);
+		if (structureChanged || liveSetChanged || platesChanged) syncClips(scene);
 		if (context.zoom !== lastZoom) {
 			lastZoom = context.zoom;
 			for (const entry of cards.values()) entry.renderer.zoom?.(entry.container, lastZoom);
 		}
 		const liftChanged = context.liftedIds !== lifted;
 		lifted = context.liftedIds;
-		if (structureChanged || farModeChanged || liveSetChanged || liftChanged) applyChildOrder(scene);
+		if (structureChanged || liveSetChanged || liftChanged) applyChildOrder(scene);
 		syncLiveStrokes(input);
 	}
+	function cullCards(view, pinnedIds) {
+		for (const [id, entry] of cards) {
+			const culled = !pinnedIds.has(id) && !rectsIntersect(itemBounds(entry.item.frame), view);
+			if (entry.container.culled === culled) continue;
+			entry.container.culled = culled;
+			if (!culled && entry.renderer.tick) tickingIds.add(id);
+		}
+	}
 	function queueResolution(focus) {
 		const ids = [...cards].filter(([, entry]) => entry.renderer.resolution);
 		if (focus) {
@@ -406,22 +492,27 @@ function createBoardScene(options) {
 		for (const [id] of ids) pendingResolution.add(id);
 	}
 	function refreshResolution(context) {
-		let budget = RESOLUTION_BATCH;
+		if (pendingResolution.size === 0) return;
+		const start = performance.now();
+		const allowance = budget.allow("resolution");
+		let refreshed = 0;
 		for (const id of pendingResolution) {
-			if (budget-- === 0) break;
+			if (refreshed === allowance) break;
 			pendingResolution.delete(id);
 			const entry = cards.get(id);
 			if (!entry) continue;
 			entry.renderer.resolution?.(entry.container, entry.item, context);
 			if (entry.renderer.tick) tickingIds.add(id);
+			refreshed += 1;
 		}
+		budget.spend("resolution", refreshed, performance.now() - start);
 		if (pendingResolution.size) options.requestFrame?.();
 	}
 	function tick(clock) {
 		let next = null;
 		for (const id of tickingIds) {
 			const entry = cards.get(id);
-			const wait = entry?.container.visible ? entry.renderer.tick?.(entry.container, clock) ?? null : null;
+			const wait = entry?.container.visible && !entry.container.culled ? entry.renderer.tick?.(entry.container, clock) ?? null : null;
 			if (wait === null) tickingIds.delete(id);
 			else next = next === null ? wait : Math.min(next, wait);
 		}
@@ -438,6 +529,14 @@ function createBoardScene(options) {
 		}
 		world.sortChildren();
 	}
+	function redrawText() {
+		const redraw = (container) => {
+			for (const child of container.children) if (child instanceof Text) child.style.update();
+			else redraw(child);
+		};
+		for (const entry of cards.values()) redraw(entry.container);
+		for (const pool of pools.values()) for (const container of pool) redraw(container);
+	}
 	function destroy(context) {
 		for (const entry of cards.values()) entry.renderer.destroy?.(entry.container, context);
 		cards.clear();
@@ -447,14 +546,13 @@ function createBoardScene(options) {
 		heldKeys.clear();
 		holders.clear();
 		orderById = /* @__PURE__ */ new Map();
+		idsByOrder = [];
+		clearPlates();
 		for (const entry of clips.values()) entry.group.destroy({ children: true });
 		clips.clear();
 		animatedIds.clear();
 		tickingIds.clear();
 		for (const id of [...liveStrokes.keys()]) removeLiveStroke(id, context);
-		resetFarLayer();
-		farActive = false;
-		visibleMemo = null;
 		lastStructureVersion = -1;
 		lastZoom = NaN;
 		lastResolution = "";
@@ -470,14 +568,23 @@ function createBoardScene(options) {
 			} : null;
 		},
 		holders: (key) => holders.get(key) ?? EMPTY_IDS,
+		repaintFar,
 		get liveVersion() {
 			return liveVersion;
 		},
 		liveIds: () => new Set(cards.keys()),
+		counts: () => ({
+			live: cards.size,
+			far: covered.size
+		}),
+		get settling() {
+			return Boolean(plan?.deferred) || platesPending || pendingResolution.size > 0;
+		},
 		get animated() {
 			return animatedIds.size > 0;
 		},
 		tick,
+		redrawText,
 		destroy
 	};
 }

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

@@ -7,13 +7,15 @@ import { BoardScene, BoardSceneItem } from "../model/scene.js";
 import { BoardShapeColors } from "../model/palette.js";
 import { BoardAssetSource } from "../model/media-playback.js";
 import "../model/index.js";
-import { BoardPointerEvent } from "../editor/interaction.js";
+import { BoardActivation, BoardPointerEvent } from "../editor/interaction.js";
 import { BoardEditor } from "../editor/editor.js";
 import "../editor/index.js";
 import { BoardRenderStyle } from "../render/style.js";
+import { BoardLod } from "../render/lod.js";
 import { BoardCardRendererResolver, BoardRenderLabels, BoardRenderPalette } from "../render/renderers/board-renderer-registry.js";
 import "../render/index.js";
 import { BoardAssetManager } from "./assets.js";
+import { BoardStagePress } from "./presses.js";
 import { BoardLiveStroke } from "./scene.js";
 import { BoardItemView } from "./views.js";
 import { Graphics, Renderer } from "pixi.js";
@@ -50,6 +52,10 @@ type BoardStageOptions = {
     scene: BoardScene;
   }) => void;
   onPointer?: (phase: BoardStagePointerPhase, event: PointerEvent, input: BoardPointerEvent) => boolean | undefined;
+  onActivate?: (item: BoardSceneItem, activation: BoardActivation) => void;
+  onLongPress?: (item: BoardSceneItem, press: BoardStagePress) => void;
+  /** A press on a card key (`BoardCardRenderer.hitAt`); return false to leave it to the editor. */
+  onHit?: (item: BoardSceneItem, action: string, press: BoardStagePress) => boolean | undefined;
   onDoubleClick?: (item: BoardSceneItem | null, point: WorldPoint) => boolean | undefined;
   onSurfaceChange?: (size: {
     width: number;
@@ -59,6 +65,8 @@ type BoardStageOptions = {
   onLiveChange?: (ids: ReadonlySet<string>) => void;
   safeRect?: () => Rect;
   scriptCapabilities?: Record<string, (id: string, input: unknown) => Promise<unknown>>;
+  lod?: () => BoardLod | undefined;
+  prefetch?: number;
 };
 type BoardStage = {
   readonly ready: Promise<boolean>;
@@ -80,8 +88,26 @@ type BoardStage = {
   }): void;
   isMaterialized(id: string): boolean;
   toWorld(clientX: number, clientY: number): WorldPoint;
+  stats(): BoardStageStats;
   destroy(): void;
 };
+type BoardStageStats = {
+  live: number;
+  far: number;
+  textures: number;
+  cooling: number;
+  textureBytes: number;
+  loading: number;
+  prefetching: number;
+  waiting: number;
+  settling: boolean;
+  frame: {
+    p50: number;
+    p95: number;
+    max: number;
+  };
+  interval: number;
+};
 declare function mountBoardStage(host: HTMLElement, options: BoardStageOptions): BoardStage;
 //#endregion
-export { BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageTheme, mountBoardStage };
+export { BoardStage, BoardStageOptions, BoardStagePointerPhase, BoardStageStats, BoardStageTheme, mountBoardStage };