@moku-labs/game 0.15.2 → 0.15.4

package/dist/{src-Ca8W8Dvv.mjs → src-tkKl-oCn.mjs}

@@ -3753,7 +3753,7 @@ function featureProblems(flows, features) {
 * sceneIdOf("board"); // undefined: a scene is an object with an id
 * ```
 */
-function sceneIdOf(value) {
+function sceneIdOf$1(value) {
 	if (typeof value !== "object" || value === null || !("id" in value)) return void 0;
 	return typeof value.id === "string" ? value.id : void 0;
 }
@@ -3772,7 +3772,7 @@ function declaredScenes(features) {
 	for (const list of lists) {
 		if (!Array.isArray(list)) continue;
 		for (const scene of list) {
-			const id = sceneIdOf(scene);
+			const id = sceneIdOf$1(scene);
 			if (id !== void 0) ids.add(id);
 		}
 	}
@@ -8374,6 +8374,32 @@ const NO_ROWS = {
 	next: () => DONE
 };
 /**
+* Tells whether a system's query may match, before its run: every term has a store and none of them
+* is empty, which is the smallest store among the terms not being empty. A store met for the first
+* time is kept in the entry, so later checks only read sizes. An empty query may always match. An
+* entity that carries one term and not the others still passes: the walk finds nothing, as before.
+*
+* @param stores - Every component store of the world, by name.
+* @param entry - The registered system.
+* @returns False when a term has no entity: the system is skipped.
+*/
+function mayMatch(stores, entry) {
+	const names = entry.plan.names;
+	const kept = entry.stores;
+	const count = names.length;
+	for (let index = 0; index < count; index += 1) {
+		let store = kept[index];
+		if (store === void 0) {
+			const name = names[index];
+			store = name === void 0 ? void 0 : stores.get(name);
+			if (store === void 0) return false;
+			kept[index] = store;
+		}
+		if (store.size === 0) return false;
+	}
+	return true;
+}
+/**
 * The rows the runner hands a system's `run`: its walk, reset; none for an empty query. A system
 * entry made without a walk gets one here, once.
 *
@@ -8467,6 +8493,113 @@ function rememberPlan(ctx, key, terms) {
 	return plan;
 }
 //#endregion
+//#region src/plugins/world/ecs/scenes.ts
+/**
+* Creates the set of declared scene ids. Its own function: a collection is built outside the
+* exported declarations.
+*
+* @returns An empty set.
+*/
+function emptyIds() {
+	return /* @__PURE__ */ new Set();
+}
+/**
+* Reads the id of one entry of a feature's `scenes` list, without trusting the entry.
+*
+* @param entry - What the feature put in the list.
+* @returns The id, or `undefined` when the entry carries none.
+* @example
+* ```ts
+* sceneIdOf({ id: "board", layers: {} }); // "board"
+* ```
+*/
+function sceneIdOf(entry) {
+	if (typeof entry !== "object" || entry === null) return void 0;
+	const id = entry.id;
+	return typeof id === "string" ? id : void 0;
+}
+/**
+* Records the scene ids every feature declares, so the systems registered from now on have their
+* `scenes` checked. Called once at start, before the features' systems register.
+*
+* @param scene - The scene state.
+* @param features - The registered features.
+*/
+function declareScenes(scene, features) {
+	const declared = emptyIds();
+	for (const feature of features) {
+		const list = feature.description.scenes;
+		if (!Array.isArray(list)) continue;
+		for (const entry of list) {
+			const id = sceneIdOf(entry);
+			if (id !== void 0) declared.add(id);
+		}
+	}
+	scene.declared = declared;
+}
+/**
+* Throws for a name in a system's `scenes` that no feature declares as a scene: such a system
+* would never run. Nothing is checked before start, when the declared scenes are not known yet.
+* The caller guards it for dev builds.
+*
+* @param scene - The scene state.
+* @param definition - The system being registered.
+* @throws {Error} When a name in `scenes` is not a declared scene.
+*/
+function checkScenes(scene, definition) {
+	const declared = scene.declared;
+	if (declared === void 0 || definition.scenes === void 0) return;
+	for (const name of definition.scenes) {
+		if (declared.has(name)) continue;
+		const known = [...declared].join(", ") || "none";
+		throw new Error(`[game] System "${definition.name}" runs on the scene "${name}", which no feature declares.\n  Name a scene a feature lists in its scenes (declared: ${known}).`);
+	}
+}
+/**
+* Mounts a scene for the systems: the scene mounted before starts leaving. The same scene again
+* changes nothing.
+*
+* @param scene - The scene state.
+* @param id - The id of the scene now mounted.
+*/
+function mountScene(scene, id) {
+	const before = scene.mounted;
+	if (before === id) return;
+	if (before !== void 0 && !scene.leaving.includes(before)) scene.leaving.push(before);
+	scene.mounted = id;
+}
+/**
+* Ends the leave of every leaving scene once nothing carries `Exiting`: the elements of the JSX
+* views of the scenes before played their exit. Called at the start of a phase while a scene leaves.
+*
+* @param state - The ecs branch of the plugin state.
+*/
+function endLeaving(state) {
+	const exiting = state.stores.get(Exiting.componentName);
+	if (exiting !== void 0 && exiting.size > 0) return;
+	const leaving = state.scene.leaving;
+	while (leaving.length > 0) leaving.pop();
+}
+/**
+* Tells whether one of a system's scenes is mounted or leaving.
+*
+* @param scene - The scene state.
+* @param names - The system's `scenes`.
+* @returns True when the system may run.
+*/
+function onScene(scene, names) {
+	const { mounted, leaving } = scene;
+	const count = names.length;
+	const left = leaving.length;
+	for (let index = 0; index < count; index += 1) {
+		const name = names[index];
+		if (name === void 0) continue;
+		if (name === mounted) return true;
+		for (let at = 0; at < left; at += 1) if (leaving[at] === name) return true;
+	}
+	return false;
+}
+//#endregion
 //#region src/plugins/world/ecs/schema.ts
 const notJson = null;
 /**
@@ -8635,13 +8768,27 @@ function frameSnapshot(ctx, time) {
 	return snapshot;
 }
 /**
-* Registers a system at the end of its phase list and returns the remover. Its query is resolved
-* here, once: a later change to the definition's `query` array is not seen.
+* An empty slot for each term of a plan: the stores its check keeps, filled with `push`, so the
+* list is a packed array of its exact length from the start.
+*
+* @param count - The number of terms.
+* @returns The slots, all `undefined`.
+*/
+function storeSlots(count) {
+	const slots = [];
+	for (let index = 0; index < count; index += 1) slots.push(void 0);
+	return slots;
+}
+/**
+* Registers a system at the end of its phase list and returns the remover. Its query and its
+* `scenes` are read here, once: a later change to the definition is not seen. A dev build checks
+* the `scenes` against the scenes the features declare, once the world started.
 *
 * @param ctx - Domain context of the world plugin.
 * @param definition - The system.
 * @returns The remover; calling it twice is a no-op.
-* @throws {Error} When a system of that name is already registered.
+* @throws {Error} When a system of that name is already registered, and in a dev build for a
+*   name in `scenes` that no feature declares.
 */
 function registerSystem(ctx, definition) {
 	const state = ctx.state.ecs;
@@ -8651,11 +8798,15 @@ function registerSystem(ctx, definition) {
 		"layout",
 		"sync"
 	]) if (state.systems[phase].some((entry) => entry.definition.name === definition.name)) throw new Error(`[game] System "${definition.name}" is registered twice.\n  Give the second system another name, or remove the first one.`);
+	if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__) checkScenes(state.scene, definition);
 	const plan = planOf(ctx, definition.query);
 	const entry = {
 		definition,
 		frame: ctx.deps.time.snapshot().frame,
 		plan,
+		stores: storeSlots(plan.names.length),
+		scenes: definition.scenes === void 0 ? void 0 : [...definition.scenes],
+		skipped: false,
 		walk: plan.names.length === 0 ? void 0 : new SystemWalk(ctx, plan)
 	};
 	const list = state.systems[definition.phase];
@@ -8682,7 +8833,8 @@ function createPhaseContext(state, world, snapshot, time) {
 		world,
 		res: (resourceType) => resourceValue(state, resourceType),
 		snapshot,
-		time
+		time,
+		resumed: false
 	};
 	state.phaseContext = context;
 	return context;
@@ -8707,6 +8859,27 @@ function phaseContextOf(ctx, world, time) {
 	return known;
 }
 /**
+* Tells whether a system runs in this phase: one of its `scenes` is mounted or leaving, and no
+* term of its query has an empty store. A skipped system remembers it; one that runs is told in
+* `resumed` whether its last chance was skipped. No walk, no mark and no clock read happen for a
+* skipped system: the check comes before all three.
+*
+* @param state - The ecs branch of the plugin state.
+* @param entry - The system.
+* @param context - What its `run` receives; `resumed` is written here.
+* @returns True when the system runs.
+*/
+function wakes(state, entry, context) {
+	const scenes = entry.scenes;
+	if (scenes !== void 0 && !onScene(state.scene, scenes) || !mayMatch(state.stores, entry)) {
+		entry.skipped = true;
+		return false;
+	}
+	context.resumed = entry.skipped;
+	entry.skipped = false;
+	return true;
+}
+/**
 * Runs one system, reporting a throw: the try lives here, so the loop of a phase holds none.
 *
 * @param ctx - Domain context of the world plugin.
@@ -8726,7 +8899,9 @@ function guardedRun(ctx, entry, context, phase) {
 }
 /**
 * Runs the systems of one phase and flushes the commands they queued. A throwing system is
-* reported and skipped for this frame; the frame goes on.
+* reported and skipped for this frame; the frame goes on. A system whose query has no entity, or
+* none of whose `scenes` is mounted or leaving, is skipped in its slot. While a scene leaves, the
+* phase first ends the leave when nothing carries `Exiting` any more.
 *
 * @param ctx - Domain context of the world plugin.
 * @param world - The ecs API a system's `run` receives.
@@ -8736,21 +8911,24 @@ function guardedRun(ctx, entry, context, phase) {
 function runPhase(ctx, world, phase, time) {
 	const state = ctx.state.ecs;
 	if (phase !== ALWAYS && effectiveMode(ctx) !== "live") return;
+	if (state.scene.leaving.length > 0) endLeaving(state);
 	const context = phaseContextOf(ctx, world, time);
 	const entries = state.systems[phase];
 	state.running = phase;
 	if (state.timing === void 0) for (let index = 0; index < entries.length; index += 1) {
 		const entry = entries[index];
-		if (entry !== void 0 && entry.frame < time.frame) guardedRun(ctx, entry, context, phase);
+		if (entry === void 0 || entry.frame >= time.frame) continue;
+		if (wakes(state, entry, context)) guardedRun(ctx, entry, context, phase);
 	}
 	else runTimed(ctx, state.timing, entries, context, phase, time);
 	state.running = void 0;
 	flushCommands(ctx);
 }
 /**
-* Runs the systems of one phase as `runPhase` does, same order, same error isolation, and adds
-* each run's time to its row of the timing table: two clock reads per run, an indexed loop, no
-* closure. The rows were zeroed at the start of the frame, so after the frame they hold its time.
+* Runs the systems of one phase as `runPhase` does, same order, same error isolation, same skip,
+* and adds each run's time to its row of the timing table: two clock reads per run, an indexed
+* loop, no closure. The rows were zeroed at the start of the frame, so after the frame they hold
+* its time; a skipped system's row stays 0.
 *
 * @param ctx - Domain context of the world plugin.
 * @param timing - The timing table of the agent build.
@@ -8760,11 +8938,13 @@ function runPhase(ctx, world, phase, time) {
 * @param time - The frame's `Time`.
 */
 function runTimed(ctx, timing, entries, context, phase, time) {
+	const state = ctx.state.ecs;
 	const count = entries.length;
 	for (let index = 0; index < count; index += 1) {
 		const entry = entries[index];
 		if (entry === void 0 || entry.frame >= time.frame) continue;
-		const row = rowOf(ctx.state.ecs, entry.definition.name);
+		if (!wakes(state, entry, context)) continue;
+		const row = rowOf(state, entry.definition.name);
 		const started = timing.clock();
 		guardedRun(ctx, entry, context, phase);
 		timing.ms[row] = (timing.ms[row] ?? 0) + timing.clock() - started;
@@ -8774,7 +8954,8 @@ function runTimed(ctx, timing, entries, context, phase, time) {
 //#region src/plugins/world/ecs/api.ts
 /**
 * Empties the world in place: entities, components, resources, systems, hooks and the frame
-* history. The state object keeps its identity, so every view on it stays valid.
+* history. The mounted scene stays: `scenes` still shows it. The state object keeps its identity,
+* so every view on it stays valid.
 *
 * @param ctx - Domain context of the world plugin.
 */
@@ -8896,6 +9077,9 @@ function createEcsApi(ctx) {
 		setMode: (mode) => {
 			state.mode = mode;
 		},
+		setScene: (scene) => {
+			mountScene(state.scene, scene);
+		},
 		typeOf: (name) => asComponent$2(state.types.get(name)),
 		snapshot: () => snapshotWorld(state, effectiveMode(ctx)),
 		diff: (from, to) => diffHistory(state.history, from, to),
@@ -9033,14 +9217,17 @@ function registerEach(ctx, feature, key, accepts, register) {
 }
 /**
 * Registers what every feature brought, in feature order: components first, so their schema is
-* known, then systems, then projections.
+* known, then systems, then projections. The scene ids of every feature are read first, so a dev
+* build checks the `scenes` of each system as it registers.
 *
 * @param ctx - Domain context of the world plugin.
 * @param ecs - The ecs module.
 * @param projection - The projection module.
 */
 function registerFeatures(ctx, ecs, projection) {
-	for (const feature of ctx.deps.flow.features.all()) {
+	const features = ctx.deps.flow.features.all();
+	declareScenes(ctx.state.ecs.scene, features);
+	for (const feature of features) {
 		registerEach(ctx, feature, "components", isComponentEntry, (entry) => registerType(ctx, entry));
 		registerEach(ctx, feature, "systems", isSystemEntry, (entry) => ecs.system(entry));
 		registerEach(ctx, feature, "projections", isProjectionEntry, (entry) => projection.register(entry));
@@ -9086,7 +9273,8 @@ function connectWorld(ctx) {
 }
 /**
 * Empties the world in `onStop`: the frame callbacks and the hint listener are removed, then
-* every track, view, queued view, entity and resource is dropped and the frame history is reset.
+* every track, view, queued view, entity and resource is dropped, and the scenes and the frame
+* history are reset.
 * No `onRemoved` fires, because `renderer` stopped earlier and destroyed its own objects.
 *
 * @param state - The plugin state, the only thing a teardown context carries.
@@ -9137,6 +9325,9 @@ function clearWorld(state) {
 	state.ecs.mode = "live";
 	state.ecs.timing = void 0;
 	state.ecs.timingSlots.clear();
+	state.ecs.scene.mounted = void 0;
+	state.ecs.scene.leaving.length = 0;
+	state.ecs.scene.declared = void 0;
 	resetHistory(state.ecs);
 }
 //#endregion
@@ -11334,6 +11525,7 @@ function exposeEcs(ecs, projection) {
 			ecs.setMode(mode);
 			if (ecs.mode() === "fast") projection.flushAll();
 		},
+		setScene: ecs.setScene,
 		snapshot: ecs.snapshot,
 		diff: (from, to) => withKeys(ecs.diff(from, to), ecs, projection),
 		schema: ecs.schema
@@ -11432,6 +11624,19 @@ function emptyMap$10() {
 	return /* @__PURE__ */ new Map();
 }
 /**
+* Creates the scene state of a world no scene was mounted in: nothing mounted, nothing leaving, the
+* declared scenes unknown until start.
+*
+* @returns An empty scene state.
+*/
+function emptyScene() {
+	return {
+		mounted: void 0,
+		leaving: [],
+		declared: void 0
+	};
+}
+/**
 * Creates the initial ecs state: no entity, no type, no system, no resource and no frame history:
 * a dev build starts one on its first frame. Every collection is its own object, so two apps in
 * one process never share a world.
@@ -11473,7 +11678,8 @@ function createEcsState() {
 		walkReported: false,
 		queryPlans: emptyMap$10(),
 		walkLists: [],
-		despawns: 0
+		despawns: 0,
+		scene: emptyScene()
 	};
 }
 //#endregion
@@ -11585,7 +11791,7 @@ const worldPlugin = /*#__PURE__*/ createPlugin$1("world", {
 */
 function slotsPadding(slots) {
 	let pad = 0;
-	for (const slot of slots) pad += slot.filter.padding;
+	for (let index = 0; index < slots.length; index += 1) pad += slots[index]?.filter.padding ?? 0;
 	return pad;
 }
 /**
@@ -11745,8 +11951,9 @@ function checkMissedMarks(ctx, state, stage, views, shown) {
 //#endregion
 //#region src/plugins/renderer/demand/shown.ts
 /**
-* The paddings of every filter a node holds, enabled or not: a superset of what any of them could spill onto the
-* screen. Pixi answers `undefined` before the first write and `null` after a clear.
+* The paddings of every filter a node holds: what they could spill onto the screen. Pixi holds the enabled filters of
+* a view (E3), and a filter switched on reaches Pixi before the decision judges the marks again. Pixi answers
+* `undefined` before the first write and `null` after a clear.
 *
 * @param node - A display object on the chain of a view.
 * @returns The sum of the paddings; 0 without a filter.
@@ -11755,7 +11962,7 @@ function paddingOf$2(node) {
 	const filters = node.filters;
 	if (filters === null || filters === void 0) return 0;
 	let pad = 0;
-	for (const filter of filters) pad += filter.padding;
+	for (let index = 0; index < filters.length; index += 1) pad += filters[index]?.padding ?? 0;
 	return pad;
 }
 /** What `chainPadding` answers for a chain that is not drawn. */
@@ -11777,6 +11984,15 @@ function noAlpha() {
 	return false;
 }
 /**
+* The reader without the engine's records: Pixi's own `alpha`.
+*
+* @param node - A node on the chain of a view.
+* @returns True at alpha 0 or below.
+*/
+function alphaZero(node) {
+	return node.alpha <= 0;
+}
+/**
 * Walks from a node up to the stage: every node on the way is visible, renderable (or a kept top its quad draws) and
 * not fully transparent, and the chain reaches the stage. The paddings of the filters met on the way are summed; no
 * object is made.
@@ -11784,14 +12000,15 @@ function noAlpha() {
 * @param from - The first node of the walk.
 * @param stage - The stage of the application.
 * @param through - The kept reader: the padding of a kept top drawn through its quad, or `HIDDEN`.
+* @param transparent - Whether a node is drawn at alpha 0.
 * @param stop - Where the walk notes a visible node at alpha 0 it stopped at; left as it is for any other stop.
 * @returns The sum of the paddings of the chain, or `HIDDEN` when the chain is not drawn.
 */
-function chainPadding(from, stage, through, stop) {
+function chainPadding(from, stage, through, transparent, stop) {
 	let pad = 0;
 	for (let node = from; node !== stage; node = node.parent) {
 		if (node === null || !node.visible) return HIDDEN;
-		if (node.alpha <= 0) {
+		if (transparent(node)) {
 			if (stop !== void 0) stop.node = node;
 			return HIDDEN;
 		}
@@ -11861,15 +12078,16 @@ function alphaStop(node, top, alphaHidden) {
 * @param entity - The entity.
 * @param through - The kept reader: the padding of a kept top drawn through its quad, or `HIDDEN`; none by default.
 * @param alphaHidden - Sync's reader of the `"alpha"` reason; none by default.
+* @param transparent - Whether a node is drawn at alpha 0; Pixi's `alpha` by default.
 * @returns Where the walk stopped.
 */
-function unseenBy(state, host, views, entity, through = noneThrough, alphaHidden = noAlpha) {
+function unseenBy(state, host, views, entity, through = noneThrough, alphaHidden = noAlpha, transparent = alphaZero) {
 	const view = views.get(entity);
 	const stage = host.stage();
 	if (view === void 0 || stage === void 0) return "other";
 	const top = view.wrapper ?? view.object;
 	state.stop.node = void 0;
-	const pad = chainPadding(top, stage, through, state.stop);
+	const pad = chainPadding(top, stage, through, transparent, state.stop);
 	if (pad === HIDDEN) return alphaStop(state.stop.node, top, alphaHidden);
 	if (view.wrapper !== void 0 || top.children.length > 0) return "shown";
 	return onScreen(state, host, top, pad) ? "shown" : "off-screen";
@@ -11882,10 +12100,11 @@ function unseenBy(state, host, views, entity, through = noneThrough, alphaHidden
 * @param views - The views by entity.
 * @param entity - The marked entity.
 * @param through - The kept reader: the padding of a kept top drawn through its quad, or `HIDDEN`; none by default.
+* @param transparent - Whether a node is drawn at alpha 0; Pixi's `alpha` by default.
 * @returns True when the view is drawn.
 */
-function isShown$2(state, host, views, entity, through = noneThrough) {
-	return unseenBy(state, host, views, entity, through) === "shown";
+function isShown$2(state, host, views, entity, through = noneThrough, transparent = alphaZero) {
+	return unseenBy(state, host, views, entity, through, noAlpha, transparent) === "shown";
 }
 /**
 * The ancestor rule of loose marks: the walk of `isShown` from the parent of the view's top node, without bounds. A
@@ -11896,13 +12115,14 @@ function isShown$2(state, host, views, entity, through = noneThrough) {
 * @param views - The views by entity.
 * @param entity - The entity of a loose mark.
 * @param through - The kept reader: the padding of a kept top drawn through its quad, or `HIDDEN`; none by default.
+* @param transparent - Whether a node is drawn at alpha 0; Pixi's `alpha` by default.
 * @returns True when the ancestors of the view draw it.
 */
-function ancestorsShown(host, views, entity, through = noneThrough) {
+function ancestorsShown(host, views, entity, through = noneThrough, transparent = alphaZero) {
 	const view = views.get(entity);
 	const stage = host.stage();
 	if (view === void 0 || stage === void 0) return false;
-	return chainPadding((view.wrapper ?? view.object).parent, stage, through) !== HIDDEN;
+	return chainPadding((view.wrapper ?? view.object).parent, stage, through, transparent) !== HIDDEN;
 }
 //#endregion
 //#region src/plugins/renderer/pixels.ts
@@ -12025,6 +12245,15 @@ function firstWhole(wholes) {
 	return wholes.size === 0 ? void 0 : wholes.values().next().value;
 }
 /**
+* Whether a node is drawn at alpha 0, read from Pixi: the reader of a demand module built without sync's records.
+*
+* @param node - A node on the chain of a view.
+* @returns True at alpha 0 or below.
+*/
+function pixiTransparent(node) {
+	return node.alpha <= 0;
+}
+/**
 * Tells whether one entity of a mark list passes a test, walked by index: no iterator.
 *
 * @param entities - The marks.
@@ -12067,11 +12296,12 @@ function clearMarks(state) {
 * @param deps.host - The host module.
 * @param deps.views - The views by entity: `ctx.state.sync.views`, whose identity sync keeps.
 * @param deps.hiddenBy - Sync's `hiddenBy`: whether one reason hides a view (spec 26 R1.7.1).
+* @param deps.transparent - Sync's reader of a node drawn at alpha 0 from its records (E4); Pixi's `alpha` without it.
 * @returns The demand module.
 */
 function createDemandApi(ctx, deps) {
 	const state = ctx.state.demand;
-	const { host, views, hiddenBy } = deps;
+	const { host, views, hiddenBy, transparent = pixiTransparent } = deps;
 	/**
 	* Whether the render phase decides this frame: `onDemand` is on, or the pixel oracle runs in shadow.
 	*
@@ -12084,7 +12314,7 @@ function createDemandApi(ctx, deps) {
 	* @param entity - The entity.
 	* @returns True when its view is drawn as the frame stands.
 	*/
-	const shown = (entity) => isShown$2(state, host, views, entity, through);
+	const shown = (entity) => isShown$2(state, host, views, entity, through, transparent);
 	/**
 	* Whether a node is the top or the visual of a view hidden by `"alpha"` (spec 26 R1.7.1), read from sync's state.
 	*
@@ -12110,7 +12340,7 @@ function createDemandApi(ctx, deps) {
 	* @param entity - The entity of a loose mark.
 	* @returns True when it counts.
 	*/
-	const looseShown = (entity) => ancestorsShown(host, views, entity, through);
+	const looseShown = (entity) => ancestorsShown(host, views, entity, through, transparent);
 	/**
 	* Notes an entity in the record since the last drawn frame, in a dev or an agent build.
 	*
@@ -12226,7 +12456,7 @@ function createDemandApi(ctx, deps) {
 		settle,
 		frame: () => state.frame,
 		shown,
-		unseenBy: (entity) => unseenBy(state, host, views, entity, through, alphaHidden),
+		unseenBy: (entity) => unseenBy(state, host, views, entity, through, alphaHidden, transparent),
 		marked: () => state.marked,
 		loose: () => state.loose,
 		visual: () => state.visual,
@@ -12589,281 +12819,486 @@ function watchPixelRatio(ctx) {
 	state.cleanups.push(() => query?.removeEventListener("change", follow));
 }
 //#endregion
-//#region src/plugins/renderer/host/sdf-text.ts
+//#region src/plugins/renderer/host/sdf-batcher.ts
+/** The key of the glyph record on the proxy graphics of every bitmap text the renderer's pipe lays out. */
+const SDF = Symbol("moku-sdf-glyphs");
+/** The name the renderer's batcher of distance-field glyphs registers under, and the element's `batcherName`. */
+const SDF_BATCHER = "moku-sdf";
+/** The name of Pixi's default batcher, which an element goes back to. */
+const DEFAULT_BATCHER = "default";
+/** Floats of one vertex: position 2, uv 2, colour 1 (unorm8x4), texture id and rounding 1 (uint16x2), distance 1. */
+const VERTEX_SIZE = 7;
+/** Bytes of one vertex. */
+const STRIDE = 28;
+/** The name of the renderer's batched SDF program, on both backends. */
+const PROGRAM_NAME = "moku-sdf-batch";
+/**
+* The renderer's piece of the high shader: the glyph's edge width from the vertex, at the scale of the render group,
+* and the coverage with the alpha applied once. The template's `outColor * vColor` applies the colour and every alpha.
+*/
+const SDF_BIT = {
+	name: "moku-sdf-batch-bit",
+	vertex: {
+		header: `
+            @in aSdfDistance: f32;
+            @out @interpolate(flat) vSdfDistance: f32;
+        `,
+		main: `
+            let sdfWorld = globalUniforms.uWorldTransformMatrix;
+            vSdfDistance = aSdfDistance * (length(sdfWorld[0].xy) + length(sdfWorld[1].xy)) * 0.5;
+        `
+	},
+	fragment: {
+		header: `
+            @in @interpolate(flat) vSdfDistance: f32;
+        `,
+		main: `
+            outColor = vec4<f32>(calculateMSDFAlpha(outColor, vec4<f32>(vColor.rgb / max(vColor.a, 1e-4), 1.0), vSdfDistance));
+        `
+	}
+};
 /**
-* The fragment step of the renderer's WGSL SDF shader, in place of Pixi's
-* `calculateMSDFAlpha(outColor, vColor, …)`. The coverage is the glyph's alone and its gamma
-* leans on the true luma of the colour; the template's `outColor * vColor` applies the alpha.
-*/
-const SINGLE_ALPHA_STEP = `
-            outColor = vec4<f32>(calculateMSDFAlpha(outColor, vec4<f32>(vColor.rgb / max(vColor.a, 1e-4), 1.0), localUniforms.uDistance));
-        `;
-/** The same fragment step in GLSL, for the WebGL program. */
-const SINGLE_ALPHA_STEP_GL = `
-            outColor = vec4(calculateMSDFAlpha(outColor, vec4(vColor.rgb / max(vColor.a, 1e-4), 1.0), uDistance));
-        `;
-/** The name of the renderer's local-uniform piece, apart from Pixi's in its shader cache. */
-const TEXT_BIT_NAME = "local-uniform-msdf-single-alpha-bit";
-/** The name of the renderer's SDF program, on both backends. */
-const PROGRAM_NAME = "sdf-shader-single-alpha";
+* The same piece in GLSL, for the WebGL program. Pixi compiles its batch programs as GLSL ES 1.00 (its `in` and `out`
+* are macros), where `flat` is a reserved word: the distance is a plain varying, the same at the three vertices of a
+* glyph's triangle, as Pixi's own texture id is.
+*/
+const SDF_BIT_GL = {
+	name: "moku-sdf-batch-bit",
+	vertex: {
+		header: `
+            in float aSdfDistance;
+            out float vSdfDistance;
+        `,
+		main: `
+            vSdfDistance = aSdfDistance * (length(uWorldTransformMatrix[0].xy) + length(uWorldTransformMatrix[1].xy)) * 0.5;
+        `
+	},
+	fragment: {
+		header: `
+            in float vSdfDistance;
+        `,
+		main: `
+            outColor = vec4(calculateMSDFAlpha(outColor, vec4(vColor.rgb / max(vColor.a, 1e-4), 1.0), vSdfDistance));
+        `
+	}
+};
 /**
-* The scale of a transform as Pixi's `_updateDistanceField` measures it: the mean length of its two axes. Pure.
+* The edge width one vertex of an element carries: Pixi's distance at the element's scale in its render group, times
+* the resolution. A text's group transform is what Pixi scales by; the render group's own scale is the shader's.
 *
-* @param linear - The linear part of a transform.
-* @returns The scale.
-* @example
-* ```ts
-* scaleOf({ a: 0.25, b: 0, c: 0, d: 0.25 }); // 0.25
-* ```
+* @param element - The element.
+* @param a - `a` of its group transform.
+* @param b - `b` of its group transform.
+* @param c - `c` of its group transform.
+* @param d - `d` of its group transform.
+* @param density - Device pixels per CSS pixel.
+* @returns The distance, device px at the render group's scale 1; 0 for an element without glyphs.
 */
-function scaleOf$1(linear) {
-	return (Math.hypot(linear.a, linear.b) + Math.hypot(linear.c, linear.d)) / 2;
+function distanceOf(element, a, b, c, d, density) {
+	const glyphs = element.renderable?.[SDF];
+	if (glyphs === void 0) return 0;
+	return glyphs.perScale * (Math.sqrt(a * a + b * b) + Math.sqrt(c * c + d * d)) * density / 2;
 }
 /**
-* The local uniforms of one text, in the order of the WGSL struct, at Pixi's starting values. The
-* pipe writes `uDistance`, the graphics adaptor the rest, before every draw.
+* Keeps one shader per batch texture limit: made the first time a limit is asked for, shared by every batcher after.
+* Its own function, because lint rule L5 refuses a collection built inside an exported declaration.
 *
-* Pixi writes `uDistance` in CSS pixels (`AbstractBitmapTextPipe._updateDistanceField`: the scale
-* of the text's group transform times the font's range over its scale), while the shader measures
-* the glyph edge in device pixels, so at a resolution above 1 the edge is smeared over that many
-* more pixels. The group's `uDistance` is therefore an accessor: Pixi's write keeps the CSS value,
-* every read answers it times `density.resolution`, and Pixi reads the uniform by property each
-* time it uploads it, on both backends. The resolution is read at the draw, so a change of
-* resolution needs nothing more.
+* @param make - Makes the shader of one texture limit.
+* @returns The shader for a texture limit.
+*/
+function cachedBy(make) {
+	const shaders = /* @__PURE__ */ new Map();
+	return (maxTextures) => {
+		const known = shaders.get(maxTextures);
+		if (known !== void 0) return known;
+		const shader = make(maxTextures);
+		shaders.set(maxTextures, shader);
+		return shader;
+	};
+}
+/**
+* The shaders of the batcher: Pixi's five SDF bits on both backends with the local uniforms replaced by the
+* renderer's piece, and Pixi's batch sampler slots for WebGL, as Pixi's own `DefaultShader` carries them.
 *
-* The scale is the text's world scale, read at the draw as well. Pixi's group transform is the
-* text against its render group, which leaves out the group's own scale: a kept picture renders its
-* view as a render group of its own, so its labels would draw with other edges than live. And Pixi
-* writes the distance only when the group's instructions are built, so a label whose view scaled
-* since would keep the edge of the old scale. A write of Pixi made while the pipe names the text
-* keeps the distance per unit of the group scale it was made with; a read answers that times the
-* text's world scale. A write without a text, or at a group scale of 0, is answered as Pixi wrote it.
+* @param pixi - The loaded Pixi module.
+* @returns The shader for a texture limit.
+*/
+function sdfShaders(pixi) {
+	return cachedBy((maxTextures) => new pixi.Shader({
+		gpuProgram: pixi.compileHighShaderGpuProgram({
+			name: PROGRAM_NAME,
+			bits: [
+				pixi.colorBit,
+				pixi.generateTextureBatchBit(maxTextures),
+				SDF_BIT,
+				pixi.mSDFBit,
+				pixi.roundPixelsBit
+			]
+		}),
+		glProgram: pixi.compileHighShaderGlProgram({
+			name: PROGRAM_NAME,
+			bits: [
+				pixi.colorBitGl,
+				pixi.generateTextureBatchBitGl(maxTextures),
+				SDF_BIT_GL,
+				pixi.mSDFBitGl,
+				pixi.roundPixelsBitGl
+			]
+		}),
+		resources: { batchSamplers: pixi.getBatchSamplersUniformGroup(maxTextures) }
+	}));
+}
+/**
+* The geometry of one batcher: Pixi's batch geometry with the distance after the texture id, one buffer of 7 floats a
+* vertex.
 *
 * @param pixi - The loaded Pixi module.
-* @param density - What the device pixels per CSS pixel are read from at each draw: the renderer.
-* @param density.resolution - The renderer's resolution, read at each upload.
-* @param writing - The text whose distance Pixi writes now, held by the pipe.
-* @returns A new uniform group.
-*/
-function createLocalUniforms(pixi, density, writing) {
-	const group = new pixi.UniformGroup({
-		uColor: {
-			value: new Float32Array([
-				1,
-				1,
-				1,
-				1
-			]),
-			type: "vec4<f32>"
-		},
-		uTransformMatrix: {
-			value: new pixi.Matrix(),
-			type: "mat3x3<f32>"
-		},
-		uDistance: {
-			value: 4,
-			type: "f32"
-		},
-		uRound: {
-			value: 0,
-			type: "f32"
-		}
+* @returns A new geometry.
+*/
+function sdfGeometry(pixi) {
+	const buffer = new pixi.Buffer({
+		data: /* @__PURE__ */ new Float32Array(1),
+		label: "attribute-sdf-batch-buffer",
+		usage: pixi.BufferUsage.VERTEX | pixi.BufferUsage.COPY_DST,
+		shrinkToFit: false
 	});
-	let css = 4;
-	let text;
-	let perScale = 0;
-	Object.defineProperty(group.uniforms, "uDistance", {
-		enumerable: true,
-		get: () => {
-			return (text !== void 0 && perScale !== 0 && text !== void 0 ? perScale * scaleOf$1(text.worldTransform) : css) * density.resolution;
-		},
-		set: (value) => {
-			const scale = writing.text === void 0 ? 0 : scaleOf$1(writing.text.groupTransform);
-			css = value;
-			text = writing.text;
-			perScale = scale > 0 ? value / scale : 0;
-		}
+	const indexBuffer = new pixi.Buffer({
+		data: /* @__PURE__ */ new Uint32Array(1),
+		label: "index-sdf-batch-buffer",
+		usage: pixi.BufferUsage.INDEX | pixi.BufferUsage.COPY_DST,
+		shrinkToFit: false
+	});
+	return new pixi.Geometry({
+		attributes: {
+			aPosition: {
+				buffer,
+				format: "float32x2",
+				stride: STRIDE,
+				offset: 0
+			},
+			aUV: {
+				buffer,
+				format: "float32x2",
+				stride: STRIDE,
+				offset: 8
+			},
+			aColor: {
+				buffer,
+				format: "unorm8x4",
+				stride: STRIDE,
+				offset: 16
+			},
+			aTextureIdAndRound: {
+				buffer,
+				format: "uint16x2",
+				stride: STRIDE,
+				offset: 20
+			},
+			aSdfDistance: {
+				buffer,
+				format: "float32",
+				stride: STRIDE,
+				offset: 24
+			}
+		},
+		indexBuffer
 	});
-	return group;
 }
 /**
-* The shader a text already draws with on one renderer: the custom shader of its graphics context.
+* Builds the batcher of distance-field glyphs from the module object, at call time, because Pixi's `Batcher` arrives
+* with the lazily loaded module. Its packing is Pixi's `DefaultBatcher`'s loop with the distance written after the
+* texture id; the distances are packed at the resolution the batcher pipe last drew it at (`packAt`).
 *
-* @param text - The text.
-* @param renderer - The renderer's uid, the key of the text's GPU data.
-* @returns The shader, or `undefined` before the text was laid out on that renderer.
-*/
-function shaderOf(text, renderer) {
-	return text._gpuData[renderer]?.context.customShader ?? void 0;
+* @param pixi - The loaded Pixi module.
+* @returns The batcher class, with the extension Pixi's registry files it under.
+*/
+function createSdfBatcher(pixi) {
+	const shaderFor = sdfShaders(pixi);
+	/** Pixi's batcher, with a vertex that carries the edge width of its glyph. */
+	class SdfBatcher extends pixi.Batcher {
+		static extension = {
+			type: [pixi.ExtensionType.Batcher],
+			name: SDF_BATCHER
+		};
+		name = SDF_BATCHER;
+		geometry = sdfGeometry(pixi);
+		shader = shaderFor(this.maxTextures);
+		/** Device pixels per CSS pixel the distances are packed at; a double from the start, so writes box nothing. */
+		density = NaN;
+		vertexSize = VERTEX_SIZE;
+		/**
+		* Packs the vertices of a mesh element: Pixi's default vertex and the distance.
+		*
+		* @param element - The element.
+		* @param float32View - The attribute buffer as floats.
+		* @param uint32View - The attribute buffer as unsigned integers.
+		* @param index - The first float of the element.
+		* @param textureId - The element's slot in its batch's textures.
+		*/
+		packAttributes(element, float32View, uint32View, index, textureId) {
+			const textureIdAndRound = textureId << 16 | element.roundPixels & 65535;
+			const { a, b, c, d, tx, ty } = element.transform;
+			const distance = distanceOf(element, a, b, c, d, this.density);
+			const positions = element.positions;
+			const uvs = element.uvs;
+			const argb = element.color;
+			const end = element.attributeOffset + element.attributeSize;
+			let at = index;
+			for (let vertex = element.attributeOffset; vertex < end; vertex += 1) {
+				const x = positions[vertex * 2] ?? 0;
+				const y = positions[vertex * 2 + 1] ?? 0;
+				float32View[at] = a * x + c * y + tx;
+				float32View[at + 1] = d * y + b * x + ty;
+				float32View[at + 2] = uvs[vertex * 2] ?? 0;
+				float32View[at + 3] = uvs[vertex * 2 + 1] ?? 0;
+				uint32View[at + 4] = argb;
+				uint32View[at + 5] = textureIdAndRound;
+				float32View[at + 6] = distance;
+				at += VERTEX_SIZE;
+			}
+		}
+		/**
+		* Packs the four vertices of a quad element: Pixi's default quad and the distance.
+		*
+		* @param element - The element.
+		* @param float32View - The attribute buffer as floats.
+		* @param uint32View - The attribute buffer as unsigned integers.
+		* @param index - The first float of the element.
+		* @param textureId - The element's slot in its batch's textures.
+		*/
+		packQuadAttributes(element, float32View, uint32View, index, textureId) {
+			const { a, b, c, d, tx, ty } = element.transform;
+			const { minX, minY, maxX, maxY } = element.bounds;
+			const uvs = element.texture.uvs;
+			const argb = element.color;
+			const textureIdAndRound = textureId << 16 | element.roundPixels & 65535;
+			const distance = distanceOf(element, a, b, c, d, this.density);
+			float32View[index] = a * minX + c * minY + tx;
+			float32View[index + 1] = d * minY + b * minX + ty;
+			float32View[index + 2] = uvs.x0;
+			float32View[index + 3] = uvs.y0;
+			uint32View[index + 4] = argb;
+			uint32View[index + 5] = textureIdAndRound;
+			float32View[index + 6] = distance;
+			float32View[index + 7] = a * maxX + c * minY + tx;
+			float32View[index + 8] = d * minY + b * maxX + ty;
+			float32View[index + 9] = uvs.x1;
+			float32View[index + 10] = uvs.y1;
+			uint32View[index + 11] = argb;
+			uint32View[index + 12] = textureIdAndRound;
+			float32View[index + 13] = distance;
+			float32View[index + 14] = a * maxX + c * maxY + tx;
+			float32View[index + 15] = d * maxY + b * maxX + ty;
+			float32View[index + 16] = uvs.x2;
+			float32View[index + 17] = uvs.y2;
+			uint32View[index + 18] = argb;
+			uint32View[index + 19] = textureIdAndRound;
+			float32View[index + 20] = distance;
+			float32View[index + 21] = a * minX + c * maxY + tx;
+			float32View[index + 22] = d * maxY + b * minX + ty;
+			float32View[index + 23] = uvs.x3;
+			float32View[index + 24] = uvs.y3;
+			uint32View[index + 25] = argb;
+			uint32View[index + 26] = textureIdAndRound;
+			float32View[index + 27] = distance;
+		}
+		/**
+		* Packs every element of the drawn batches again at a resolution and hands the buffer to the GPU.
+		*
+		* @param density - Device pixels per CSS pixel.
+		*/
+		packAt(density) {
+			this.density = density;
+			for (let batch = 0; batch < this.batchIndex; batch += 1) {
+				const elements = this.batches[batch]?.elements;
+				if (elements === void 0) continue;
+				for (let at = 0; at < elements.length; at += 1) {
+					const element = elements[at];
+					if (element !== void 0) this.updateElement(element);
+				}
+			}
+			this.dirty = false;
+			this.geometry.buffers[0]?.update(this.attributeSize * 4);
+		}
+	}
+	return SdfBatcher;
 }
 /**
-* Keeps one compiled program per batch texture limit: compiled the first time a limit is asked
-* for, shared by every text after. Its own function, because lint rule L5 refuses a collection
-* built inside an exported declaration.
+* Tells whether a batch's batcher is the renderer's batcher of distance-field glyphs.
 *
-* @param compile - Compiles the program of one texture limit.
-* @returns The program for a texture limit.
+* @param batcher - The batcher of a batch.
+* @returns True for the SDF batcher.
 */
-function cachedBy(compile) {
-	const programs = /* @__PURE__ */ new Map();
-	return (maxTextures) => {
-		const known = programs.get(maxTextures);
-		if (known !== void 0) return known;
-		const program = compile(maxTextures);
-		programs.set(maxTextures, program);
-		return program;
-	};
+function isSdfBatcher(batcher) {
+	return batcher.name === SDF_BATCHER;
 }
 /**
-* The compile step of the renderer's WGSL SDF program: Pixi's `SdfShader` bits with the fragment
-* step of the local-uniform piece replaced.
+* Builds the renderer's batcher pipe from the module object, at call time. It keeps the base's `static extension`
+* object, so the registry files it under the same types and name, and Pixi's batcher registry, which `getBatcher`
+* reads. `addToBatch` names the batcher of an element before Pixi adds it: the glyphs of a distance-field text go to
+* `SDF_BATCHER`; a pooled element that carried that name before, now another graphics' or a plain font's, goes back to
+* Pixi's default. `execute` packs the distances of a batcher again when the renderer's resolution changed since it
+* last drew, before Pixi binds its geometry. The monitor's counting pipe of a dev build extends this pipe.
 *
 * @param pixi - The loaded Pixi module.
-* @returns The WebGPU program for a texture limit.
+* @returns The pipe class.
 */
-function gpuProgramCache(pixi) {
-	const base = pixi.localUniformMSDFBit;
-	const textBit = {
-		...base,
-		name: TEXT_BIT_NAME,
-		fragment: {
-			...base.fragment,
-			main: SINGLE_ALPHA_STEP
-		}
-	};
-	return cachedBy((maxTextures) => pixi.compileHighShaderGpuProgram({
-		name: PROGRAM_NAME,
-		bits: [
-			pixi.colorBit,
-			pixi.generateTextureBatchBit(maxTextures),
-			textBit,
-			pixi.mSDFBit,
-			pixi.roundPixelsBit
-		]
-	}));
+function createSdfBatcherPipe(pixi) {
+	/** Pixi's batcher pipe, which routes the glyphs of distance-field text to the renderer's batcher. */
+	class SdfRoutingBatcherPipe extends pixi.BatcherPipe {
+		static extension = pixi.BatcherPipe.extension;
+		/**
+		* Names the element's batcher, then adds it as Pixi does.
+		*
+		* @param element - The element.
+		* @param instructionSet - The instructions of its render group.
+		*/
+		addToBatch(element, instructionSet) {
+			routeElement(element);
+			super.addToBatch(element, instructionSet);
+		}
+		/**
+		* Draws a batch as Pixi does; the first batch of an SDF batcher's run first packs the distances again when the
+		* resolution moved.
+		*
+		* @param batch - The batch.
+		*/
+		execute(batch) {
+			const batcher = batch.batcher;
+			if (batch.action === "startBatch" && isSdfBatcher(batcher)) {
+				const resolution = this.renderer.resolution;
+				if (batcher.density !== resolution) batcher.packAt(resolution);
+			}
+			super.execute(batch);
+		}
+	}
+	return SdfRoutingBatcherPipe;
 }
 /**
-* The compile step of the renderer's GLSL SDF program: Pixi's `SdfShader` GL bits with the same
-* fragment step replaced.
+* Names the batcher of one element: `SDF_BATCHER` for a glyph of a distance-field text, Pixi's default again for an
+* element that carried that name from an earlier owner, as it was otherwise.
 *
-* @param pixi - The loaded Pixi module.
-* @returns The WebGL program for a texture limit.
+* @param element - The element.
 */
-function glProgramCache(pixi) {
-	const base = pixi.localUniformMSDFBitGl;
-	const textBit = {
-		...base,
-		name: TEXT_BIT_NAME,
-		fragment: {
-			...base.fragment,
-			main: SINGLE_ALPHA_STEP_GL
-		}
-	};
-	return cachedBy((maxTextures) => pixi.compileHighShaderGlProgram({
-		name: PROGRAM_NAME,
-		bits: [
-			pixi.colorBitGl,
-			pixi.generateTextureBatchBitGl(maxTextures),
-			textBit,
-			pixi.mSDFBitGl,
-			pixi.roundPixelsBitGl
-		]
-	}));
+function routeElement(element) {
+	const glyphs = element.renderable?.[SDF];
+	if (glyphs !== void 0 && glyphs.perScale > 0) element.batcherName = SDF_BATCHER;
+	else if (element.batcherName === "moku-sdf") element.batcherName = DEFAULT_BATCHER;
 }
+//#endregion
+//#region src/plugins/renderer/host/sdf-text.ts
+/** The suffix of a bitmap font's key in Pixi's cache, the one `_updateDistanceField` reads. */
+const CACHE_SUFFIX$1 = "-bitmap";
 /**
-* Builds the renderer's bitmap text pipe from the module object. It is made at call time, because
-* Pixi's pipe arrives with the lazily loaded module. It keeps the base's `static extension` object
-* as it is, so the registry files it under the same types and name. Every text gets a shader of its
-* own once, at its first layout, over the one shared program of its backend, and keeps it when it is laid out again
-* (Pixi asks for one at every layout); a WebGL shader also gets
-* Pixi's batch sampler slots, as Pixi's own `SdfShader` does. Its `uDistance` answers Pixi's CSS
-* distance at the text's world scale times the renderer's resolution: the pipe names the text
-* while Pixi's `addRenderable` and `updateRenderable`, the two that write the distance, run.
+* Measures the edge of a text's glyphs again when its font family or size changed since: Pixi's distance at scale 1
+* from the font in Pixi's cache, 0 for a font without a distance field or not in the cache.
+*
+* @param pixi - The loaded Pixi module.
+* @param glyphs - The text's glyph record.
+* @param style - The text's style.
+*/
+function measureGlyphs(pixi, glyphs, style) {
+	const family = style.fontFamily;
+	const size = style.fontSize;
+	if (family === glyphs.family && size === glyphs.size) return;
+	const key = `${String(family)}${CACHE_SUFFIX$1}`;
+	const font = pixi.Cache.has(key) ? pixi.Cache.get(key) : void 0;
+	const field = font?.distanceField;
+	glyphs.family = family;
+	glyphs.size = size;
+	glyphs.perScale = font === void 0 || field === void 0 || field.type === "none" ? 0 : field.range * (1 / (font.baseRenderedFontSize / size));
+}
+/**
+* Builds the renderer's bitmap text pipe from the module object, at call time, because Pixi's pipe arrives with the
+* lazily loaded module. It keeps the base's `static extension` object, so the registry files it under the same types
+* and name. Every text's proxy graphics gets a batchable context and its glyph record when Pixi makes it; the record is
+* brought up to date before Pixi adds or updates the text, so the batcher packs the edge of the text's font.
 *
 * @param pixi - The loaded Pixi module.
 * @returns The pipe class.
 */
 function createSdfTextPipe(pixi) {
-	const gpuProgramFor = gpuProgramCache(pixi);
-	const glProgramFor = glProgramCache(pixi);
-	/** Pixi's bitmap text pipe, with an SDF shader that applies the alpha once. */
-	class SingleAlphaBitmapTextPipe extends pixi.BitmapTextPipe {
+	/** Pixi's bitmap text pipe, with distance-field text drawn by the renderer's batcher. */
+	class SdfTextPipe extends pixi.BitmapTextPipe {
 		static extension = pixi.BitmapTextPipe.extension;
-		/** The text whose distance Pixi writes now, read by the uniforms of every text of this pipe. */
-		writing = { text: void 0 };
 		/**
-		* The text Pixi lays out now: `getSdfShader` hands its own shader back, read at the call, so the text keeps it and no
-		* shader is made. Pixi asks `getSdfShader()` at every layout of a text (twice for a new one) and keeps the answer
-		* only for a context without a shader: a new shader each time was garbage (about 22 KB a text update), and on WebGL
-		* it listened to the shared batch-sampler group for good, a leak.
+		* Makes a text's proxy graphics as Pixi does, batchable at any length, with the edge of its glyphs.
+		*
+		* @param text - The text.
+		* @returns The proxy.
 		*/
-		laying;
+		initGpuText(text) {
+			const proxy = super.initGpuText(text);
+			const glyphs = {
+				perScale: NaN,
+				family: void 0,
+				size: NaN
+			};
+			proxy.context.batchMode = "batch";
+			proxy[SDF] = glyphs;
+			measureGlyphs(pixi, glyphs, text._style);
+			return proxy;
+		}
 		/**
-		* Adds a text to the instructions as Pixi does, naming it while Pixi writes its distance and lays it out.
+		* Adds a text to the instructions as Pixi does, its glyph edge measured first.
 		*
 		* @param text - The text.
 		* @param instructionSet - The instructions of its render group.
 		*/
 		addRenderable(text, instructionSet) {
-			this.writing.text = text;
-			this.laying = text;
+			this.measure(text);
 			super.addRenderable(text, instructionSet);
-			this.laying = void 0;
-			this.writing.text = void 0;
 		}
 		/**
-		* Updates a text as Pixi does, naming it while Pixi writes its distance.
+		* Updates a text as Pixi does, its glyph edge measured first.
 		*
 		* @param text - The text.
 		*/
 		updateRenderable(text) {
-			this.writing.text = text;
+			this.measure(text);
 			super.updateRenderable(text);
-			this.writing.text = void 0;
 		}
 		/**
-		* The shader of one distance-field text, asked for each time Pixi lays the text out: the text's own when it has one,
-		* else a new one.
+		* No shader: Pixi then leaves the text's context without one, and batchable.
 		*
-		* @returns The text's shader, or a new shader with its own local uniforms on the program of the backend.
+		* @returns `null`.
 		*/
 		getSdfShader() {
-			const own = this.laying === void 0 ? void 0 : shaderOf(this.laying, this._renderer.uid);
-			if (own !== void 0) return own;
-			const maxTextures = this._renderer.limits.maxBatchableTextures;
-			const density = this._renderer;
-			if (this._renderer.name === "webgpu") return new pixi.Shader({
-				gpuProgram: gpuProgramFor(maxTextures),
-				resources: { localUniforms: createLocalUniforms(pixi, density, this.writing) }
-			});
-			return new pixi.Shader({
-				glProgram: glProgramFor(maxTextures),
-				resources: {
-					localUniforms: createLocalUniforms(pixi, density, this.writing),
-					batchSamplers: pixi.getBatchSamplersUniformGroup(maxTextures)
-				}
-			});
+			return null;
+		}
+		/**
+		* Measures the glyph edge of a text Pixi made a proxy for already; a new text's proxy measures its own.
+		*
+		* @param text - The text.
+		*/
+		measure(text) {
+			const proxy = text._gpuData[this._renderer.uid];
+			if (proxy !== void 0) measureGlyphs(pixi, proxy[SDF], text._style);
 		}
 	}
-	return SingleAlphaBitmapTextPipe;
+	return SdfTextPipe;
 }
 /**
-* Swaps Pixi's bitmap text pipe for the renderer's in the module's extension registry: `remove`
-* frees the name on both backends, `add` puts the subclass in under it. Every application made
-* afterwards draws its distance-field text with it. The registry is global to the module object,
-* so the remover matters: it swaps Pixi's own pipe back.
+* Installs the three pieces of batched distance-field text in the module's extension registry: the batcher under its
+* own name, and the bitmap text pipe and the batch pipe under Pixi's, on both backends. Every application made
+* afterwards draws distance-field text with them. Every class is built before the registry is touched, so a module
+* without the pieces throws with the registry as it was. The registry is global to the module object, so the remover
+* matters: it swaps Pixi's own pipes back and leaves the batcher, which a pooled element may still name. A counting batch pipe of the monitor, which extends the routing pipe, is
+* installed after this one, in its place.
 *
 * @param pixi - The loaded Pixi module.
 * @returns The remover.
-* @throws {TypeError} When the module has no `BitmapTextPipe` to subclass.
-*/
-function installSdfTextPipe(pixi) {
-	const pipe = createSdfTextPipe(pixi);
-	pixi.extensions.remove(pixi.BitmapTextPipe);
-	pixi.extensions.add(pipe);
+* @throws {TypeError} When the module has no `Batcher`, `BitmapTextPipe` or `BatcherPipe` to subclass.
+*/
+function installSdfText(pixi) {
+	const batcher = createSdfBatcher(pixi);
+	const textPipe = createSdfTextPipe(pixi);
+	const batchPipe = createSdfBatcherPipe(pixi);
+	pixi.extensions.remove(pixi.BitmapTextPipe, pixi.BatcherPipe);
+	pixi.extensions.add(batcher, textPipe, batchPipe);
 	return () => {
-		pixi.extensions.remove(pipe);
-		pixi.extensions.add(pixi.BitmapTextPipe);
+		pixi.extensions.remove(textPipe, batchPipe);
+		pixi.extensions.add(pixi.BitmapTextPipe, pixi.BatcherPipe);
 	};
 }
 //#endregion
@@ -13000,26 +13435,27 @@ function installCounting$1(ctx, pixi, deps) {
 	} else installPasses(ctx, pixi, deps.installPasses);
 }
 /**
-* Swaps Pixi's bitmap text pipe for the renderer's, whose SDF shader applies the alpha of
-* distance-field text once. Like the draw counter it runs before `new Application()`, because Pixi
-* builds its pipes inside `init`, and once per host state: a restore reuses the installed pipe.
-* Every build installs it. A Pixi without the pieces draws on with its own pipe, with a warning.
+* Installs the renderer's batched distance-field text: its batcher, its bitmap text pipe and its batch pipe, which draw
+* consecutive labels in one draw with the alpha applied once. It runs before `new Application()`, because Pixi builds
+* its pipes inside `init`, and before the draw counter, whose batch pipe extends the routing one and takes its place;
+* once per host state: a restore reuses the installed pieces. Every build installs it. A Pixi without the pieces draws
+* on with its own pipes, with a warning.
 *
 * @param ctx - Domain context of the renderer plugin.
 * @param pixi - The module the application is built from.
 */
-function installSdfText(ctx, pixi) {
+function installTextBatch(ctx, pixi) {
 	const state = ctx.state.host;
 	if (state.uninstallSdfText !== void 0) return;
 	try {
-		state.uninstallSdfText = installSdfTextPipe(pixi);
+		state.uninstallSdfText = installSdfText(pixi);
 	} catch (error) {
 		ctx.log.warn("renderer: distance-field text applies its alpha twice", { error });
 	}
 }
 /**
 * Swaps Pixi's render-group pipe for the renderer's, which binds a filter's input again after a group cached as a
-* texture was refreshed inside the filter (F10). Like the bitmap text pipe it runs before `new Application()`, once per
+* texture was refreshed inside the filter (F10). Like the batched text it runs before `new Application()`, once per
 * host state, in every build. A Pixi without the pieces draws on with its own pipe, with a warning.
 *
 * @param ctx - Domain context of the renderer plugin.
@@ -13053,8 +13489,8 @@ async function createApplication(ctx, mount, deps) {
 	const pixi = loaded ?? await ctx.config.loadPixi();
 	if (typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ && loaded === void 0) startupMark("moku:pixi-end");
 	state.pixi = pixi;
+	installTextBatch(ctx, pixi);
 	installCounting$1(ctx, pixi, deps);
-	installSdfText(ctx, pixi);
 	installRenderGroup(ctx, pixi);
 	state.resolution.dpr = devicePixels();
 	state.resolution.cap = ctx.config.maxResolution;
@@ -13099,7 +13535,7 @@ function destroyApplication(state) {
 /**
 * Undoes everything `init` created. Works on the state alone, because `onStop` has no context.
 * `ready` drops first, so a device that goes away during the teardown is ignored. The draw
-* counter, the bitmap text pipe and the render-group pipe swap Pixi's own classes back, so the next application on
+* counter, the batched text and the render-group pipe swap Pixi's own classes back, so the next application on
 * the page starts from them. The pool trim starts over and its listeners go; Pixi's pool itself is left.
 *
 * @param state - The host branch of the plugin state.
@@ -14018,8 +14454,9 @@ function endLoan(inputs) {
 * @returns The slot and its inputs, or `undefined`.
 */
 function firstInputs(slots) {
-	for (const slot of slots) {
-		if (!slot.filter.enabled) continue;
+	for (let index = 0; index < slots.length; index += 1) {
+		const slot = slots[index];
+		if (slot === void 0 || !slot.filter.enabled) continue;
 		return slot.inputs === void 0 ? void 0 : {
 			slot,
 			inputs: slot.inputs
@@ -14256,7 +14693,11 @@ function renderStage3(kctx, pixi, matrices, record, now) {
 	key[KEY.s3Tx] = now.tx;
 	key[KEY.s3Ty] = now.ty;
 	let passes = 1;
-	for (const slot of record.slots) if (slot.filter.enabled) passes += slot.passes;
+	const slots = record.slots;
+	for (let index = 0; index < slots.length; index += 1) {
+		const slot = slots[index];
+		if (slot?.filter.enabled === true) passes += slot.passes;
+	}
 	kctx.state.flushPasses += passes;
 	return true;
 }
@@ -14662,7 +15103,8 @@ function createKeptState(config) {
 		warnedBudget: false,
 		verifySkipped: 0,
 		bypassed: false,
-		flushPasses: 0
+		flushPasses: 0,
+		calm: false
 	};
 }
 /**
@@ -14798,11 +15240,12 @@ function readStack(slots, resolution, into) {
 	let enabled = 0;
 	let rs = Number.POSITIVE_INFINITY;
 	let padding = 0;
-	for (const slot of slots) {
-		if (!slot.filter.enabled) continue;
+	for (let index = 0; index < slots.length; index += 1) {
+		const filter = slots[index]?.filter;
+		if (filter === void 0 || !filter.enabled) continue;
 		enabled += 1;
-		rs = Math.min(rs, resolutionOf(slot.filter, resolution));
-		padding += slot.filter.padding;
+		rs = Math.min(rs, resolutionOf(filter, resolution));
+		padding += filter.padding;
 	}
 	into.enabled = enabled;
 	into.rs = enabled === 0 ? resolution : rs;
@@ -14834,8 +15277,9 @@ function holdsFilters(node) {
 * @returns True when they do.
 */
 function plainFilters(slots) {
-	for (const slot of slots) {
-		const { filter } = slot;
+	for (let index = 0; index < slots.length; index += 1) {
+		const filter = slots[index]?.filter;
+		if (filter === void 0) continue;
 		if (filter.enabled && (filter.blendRequired || !plainBlend(filter.blendMode))) return false;
 	}
 	return true;
@@ -15126,16 +15570,18 @@ function neededBytes(record, now, box) {
 	return bytes;
 }
 /**
-* Hands the filters of a live record from its top to its stand-in, before stage 1 renders the top without them.
+* Hands the filters of a live record from its top to its stand-in, before stage 1 renders the top without them: the
+* enabled ones, as `sync` hangs them (E3).
 *
 * @param kctx - The kept context.
 * @param pixi - The module that draws.
 * @param record - The record.
+* @param view - Its view.
 */
-function handFilters(kctx, pixi, record) {
+function handFilters(kctx, pixi, record, view) {
 	const standIn = standInOf(pixi, record);
 	kctx.sync.clearFilters(record.top);
-	standIn.filters = filtersOf$1(kctx.ctx.state.sync, record.entity).map((slot) => slot.filter);
+	kctx.sync.applyFilters(view, filtersOf$1(kctx.ctx.state.sync, record.entity), noMark$1, standIn);
 }
 /**
 * Writes the take keys of a record: the linear part, the stack resolution and the translation of this frame, and the
@@ -15240,7 +15686,7 @@ function isEmptyBounds(bounds) {
 */
 function renderStages(kctx, pixi, matrices, record, view, now) {
 	const live = record.mode === "live";
-	if (live) handFilters(kctx, pixi, record);
+	if (live) handFilters(kctx, pixi, record, view);
 	const first = firstInputs(record.slots);
 	let ok = renderStage1(kctx, pixi, matrices, record);
 	if (ok && first !== void 0) renderStage2(kctx, pixi, matrices, record, {
@@ -15538,6 +15984,23 @@ function drawingChanged(kctx, record, before) {
 	return before.mode !== record.mode || before.passes !== kctx.state.flushPasses || !Object.is(before.qtx, record.key[KEY.qtx]) || !Object.is(before.qty, record.key[KEY.qty]) || before.shown !== quadShown(record);
 }
 /**
+* The frame of a kept record in a calm frame (no mark, no whole-frame reason) that owes nothing: no dirty flag, no
+* settle retake, no churn, not bypassed. Its step would find every key as it stands and its quad where it is, so it is
+* counted as drawn from its picture and left alone (E5).
+*
+* @param kctx - The kept context.
+* @param record - The record.
+* @returns True when the record was drawn as it stands; false when it is to be stepped.
+*/
+function stepCalm(kctx, record) {
+	const { state } = kctx;
+	if (!state.calm || state.bypassed || record.mode !== "kept" || record.dirtyS1 || record.dirtyS2 || record.dirtyS3 || record.settle || record.churn !== 0) return false;
+	record.lastDrawn = state.frame;
+	state.drawnPictures += 1;
+	record.quiet += 1;
+	return true;
+}
+/**
 * One drawn frame of a record, inside the flush: eligibility, the keys of this frame, the policy of its life, the quad
 * of a kept one; the dirty flags are cleared.
 *
@@ -15639,7 +16102,7 @@ function bypassRecord(kctx, record, view, live) {
 		return;
 	}
 	kctx.sync.clearFilters(record.top);
-	if (record.standIn !== void 0) record.standIn.filters = filters.map((slot) => slot.filter);
+	if (record.standIn !== void 0) kctx.sync.applyFilters(view, filters, noMark$1, record.standIn);
 	kctx.sync.swapHidden(kctx.hidden, view, "kept", true);
 	if (record.quad !== void 0) record.quad.visible = record.top.visible && !kctx.sync.hiddenBy(view, "alpha") && !kctx.sync.hiddenBy(view, "cover");
 }
@@ -15849,7 +16312,7 @@ function stepRecords(kctx, pixi, matrices) {
 			continue;
 		}
 		const view = kctx.ctx.state.sync.views.get(record.entity);
-		if (view !== void 0) stepRecord(kctx, pixi, matrices, record, view);
+		if (view !== void 0 && !stepCalm(kctx, record)) stepRecord(kctx, pixi, matrices, record, view);
 	}
 }
 /**
@@ -15902,9 +16365,10 @@ function createKeptApi(ctx, deps) {
 	const bypass = (on) => {
 		if (state.bypassed === on) return;
 		state.bypassed = on;
-		for (const record of state.records) {
-			const view = viewOf(record);
-			if (record.mode === "kept" && view !== void 0) bypassRecord(kctx, record, view, on);
+		for (let index = 0; index < state.records.length; index += 1) {
+			const record = state.records[index];
+			const view = record === void 0 ? void 0 : viewOf(record);
+			if (record?.mode === "kept" && view !== void 0) bypassRecord(kctx, record, view, on);
 		}
 	};
 	/**
@@ -15913,7 +16377,9 @@ function createKeptApi(ctx, deps) {
 	*/
 	const sortRecords = () => {
 		let changed = state.unsorted;
-		for (const record of state.records) {
+		for (let index = 0; index < state.records.length; index += 1) {
+			const record = state.records[index];
+			if (record === void 0) continue;
 			const depth = depthOf(record.top);
 			if (depth !== record.depth) {
 				record.depth = depth;
@@ -15982,6 +16448,7 @@ function createKeptApi(ctx, deps) {
 			if (wholes.has("debug") || wholes.has("restore")) for (const record of state.records) record.dirtyS1 = true;
 			const marked = deps.demand.marked();
 			const loose = deps.demand.loose();
+			state.calm = wholes.size === 0 && marked.size === 0 && loose.size === 0;
 			for (let index = 0; index < marked.size; index += 1) collectOne(marked.at(index));
 			for (let index = 0; index < loose.size; index += 1) collectOne(loose.at(index));
 		},
@@ -15995,6 +16462,7 @@ function createKeptApi(ctx, deps) {
 			if (state.on) {
 				sortRecords();
 				stepRecords(kctx, pixi, matrices);
+				state.calm = false;
 			} else for (const record of state.records) if (record.mode === "kept") live(record);
 			flushRanges(kctx);
 		},
@@ -16379,7 +16847,7 @@ const ALL_SECTIONS = Object.freeze({
 * @param next - The switches asked for; `undefined` for none.
 * @returns The sections, frozen; `base` itself when nothing differs.
 */
-function switched(base, next) {
+function switched$1(base, next) {
 	if (next === void 0) return base;
 	const sections = { ...base };
 	let changed = false;
@@ -18211,7 +18679,7 @@ function createSinks(draws) {
 */
 function createPerfState(config, sinks) {
 	const events = createEventRing();
-	const sections = switched(ALL_SECTIONS, config.sections);
+	const sections = switched$1(ALL_SECTIONS, config.sections);
 	sinks.sections = bitsOf(sections);
 	sinks.sectionsNext = sinks.sections;
 	return {
@@ -20959,7 +21427,7 @@ function stopPerf(perf, sinks) {
 */
 function switchSections(pc, next) {
 	const { perf, sinks } = pc;
-	const sections = switched(perf.sections, next);
+	const sections = switched$1(perf.sections, next);
 	if (sections === perf.sections) return sections;
 	perf.sections = sections;
 	sinks.sectionsNext = bitsOf(sections);
@@ -20980,7 +21448,7 @@ const READ_ONLY_SECTIONS = "[game] monitor.sections switches the sections only o
 */
 function refuseSections(pc, next) {
 	const { sections } = pc.perf;
-	if (switched(sections, next) === sections) return sections;
+	if (switched$1(sections, next) === sections) return sections;
 	throw Object.assign(/* @__PURE__ */ new Error(READ_ONLY_SECTIONS), { reason: "read-only" });
 }
 //#endregion
@@ -21545,6 +22013,23 @@ function hiddenBy(view, reason) {
 	return (view[maskOf(view, reason)] & BITS[reason]) !== 0;
 }
 /**
+* Whether a node on the chain of a view is drawn at alpha 0, read from the engine's records (E4): Pixi's `alpha` getter
+* hands its double back boxed at every read of a walk of `shown`. The top of a built-in visual, its wrapper or its
+* object, draws at alpha 0 exactly when the `"alpha"` reason hides it, and so does an adapter's own object. A node of no
+* view on a chain is the engine's (a clip container, a layer, the root), never faded. A game's object and the wrapper
+* of an adapter carry an alpha the engine does not hold: Pixi's is read.
+*
+* @param state - The sync state.
+* @param node - A node on the chain of a view, below the stage.
+* @returns True at alpha 0.
+*/
+function transparentNode(state, node) {
+	const view = state.viewOfTop.get(node);
+	if (view === void 0) return false;
+	if (view.kind === "Display" || view.kind === "adapter" && node === view.wrapper) return node.alpha <= 0;
+	return hiddenBy(view, "alpha");
+}
+/**
 * Tells whether a node is hidden, and by these reasons alone: spec 23's eligibility of a picture whose ancestor is in
 * an overlay's range (`"freeze"`) or is itself a kept top drawn through its quad (`"kept"`).
 *
@@ -21678,6 +22163,8 @@ function clearAdapters(state) {
 }
 //#endregion
 //#region src/plugins/renderer/sync/filters.ts
+/** What a display object without filters holds: one shared list, plain, so a still frame's compare makes none. */
+const NO_FILTERS = [];
 /**
 * The filters a display object holds now. Pixi answers `undefined` before the first write and
 * `null` after a clear, which its getter type does not say.
@@ -21686,10 +22173,11 @@ function clearAdapters(state) {
 * @returns The filters, empty when there are none.
 */
 function heldFilters(target) {
-	return target.filters ?? [];
+	return target.filters ?? NO_FILTERS;
 }
 /**
-* Tells whether a display object holds exactly these filter instances, in this order.
+* Tells whether a display object holds exactly the enabled filters of these slots, in their order (E3): Pixi is handed
+* no disabled filter, which draws nothing but costs a filter push and pop, two batch breaks, every frame.
 *
 * @param target - The display object.
 * @param slots - The slots to compare with.
@@ -21697,7 +22185,37 @@ function heldFilters(target) {
 */
 function holds(target, slots) {
 	const held = heldFilters(target);
-	return held.length === slots.length && slots.every((slot, index) => held[index] === slot.filter);
+	let at = 0;
+	for (let index = 0; index < slots.length; index += 1) {
+		const filter = slots[index]?.filter;
+		if (filter === void 0 || !filter.enabled) continue;
+		if (held[at] !== filter) return false;
+		at += 1;
+	}
+	return at === held.length;
+}
+/**
+* The enabled filters of slots, in their order: what Pixi is handed.
+*
+* @param slots - The slots.
+* @returns A new list, or `undefined` when no filter is enabled.
+*/
+function enabledFilters(slots) {
+	let enabled;
+	for (const slot of slots) if (slot.filter.enabled) {
+		enabled ??= [];
+		enabled.push(slot.filter);
+	}
+	return enabled;
+}
+/**
+* Writes the enabled filters of slots onto a display object, or clears them when none is enabled.
+*
+* @param target - The display object.
+* @param slots - The slots.
+*/
+function writeFilters(target, slots) {
+	target.filters = enabledFilters(slots) ?? null;
 }
 /**
 * Takes every filter off a display object. Nothing is written when it holds none: Pixi copies the
@@ -21711,8 +22229,10 @@ function clearFilters(target) {
 /**
 * Hangs the filters on a view: on its wrapper when it has one, so they cover the entity's whole
 * subtree, otherwise on the object; on the stand-in of its kept picture while it has one
-* (`kept.filterTarget`, spec 23 P9.1). Written only when the instances differ from what the target
-* holds, and `before` runs once just before that write: the caller marks the entity there.
+* (`kept.filterTarget`, spec 23 P9.1). Only the enabled ones: a disabled filter draws nothing, and Pixi would push and
+* pop it around the view every frame (E3); a view whose filters are all disabled holds none. Written only when they
+* differ from what the target holds, and `before` runs once just before that write: the caller marks the entity there.
+* A filter switched on or off later is written by `applySwitched` in the frame it was switched.
 *
 * @param view - The view.
 * @param slots - The filters in draw order; empty clears them.
@@ -21722,7 +22242,7 @@ function clearFilters(target) {
 function applyFilters(view, slots, before, target = view.wrapper ?? view.object) {
 	if (holds(target, slots)) return;
 	before();
-	target.filters = slots.length === 0 ? null : slots.map((slot) => slot.filter);
+	writeFilters(target, slots);
 }
 /**
 * The filters kept for an entity.
@@ -21815,6 +22335,45 @@ function moveFilters(state, entity, view, before, kept) {
 	clearFilters(view.object);
 	applyFilters(view, slots, before);
 }
+/** What the walk of the switched filters reads, set before the walk: one at a time, no closure per frame. */
+const switched = {
+	sync: void 0,
+	kept: void 0,
+	wrote: false
+};
+/**
+* Writes the enabled filters of one view again when one of them was switched on or off since they were handed to Pixi.
+*
+* @param slots - The filters of the view.
+* @param entity - The entity.
+*/
+function applySwitchedOne(slots, entity) {
+	const { sync, kept } = switched;
+	const view = sync?.views.get(entity);
+	if (view === void 0 || kept === void 0) return;
+	const target = kept.filterTarget(view);
+	if (holds(target, slots)) return;
+	writeFilters(target, slots);
+	switched.wrote = true;
+}
+/**
+* Hands Pixi the filters of every view whose filters were switched on or off since they were written (E3), before the
+* frame is drawn, so a switch is drawn in the frame it was made. No mark: the writer of a switch tells the renderer
+* with `invalidate` first. A write moves `passesVersion` on: the paddings the walks of `shown` read changed (E4).
+*
+* @param state - The sync branch of the plugin state.
+* @param kept - The kept module: where each view's filters hang.
+*/
+function applySwitched(state, kept) {
+	if (state.filters.size === 0) return;
+	switched.sync = state;
+	switched.kept = kept;
+	switched.wrote = false;
+	state.filters.forEach(applySwitchedOne);
+	if (switched.wrote) state.passesVersion += 1;
+	switched.sync = void 0;
+	switched.kept = void 0;
+}
 /**
 * Forgets the filters and the filter area of an entity whose view left, only when the entity itself is gone. A live
 * entity keeps them for its next view, in this frame, as a `ui` element that swaps its shape for a
@@ -25057,6 +25616,7 @@ function applyHud(sctx, entity, view, factor) {
 	if (view.hud === factor) return;
 	markView(sctx, entity);
 	view.hud = factor;
+	sctx.ctx.state.sync.passesVersion += 1;
 	if (ownsAlpha(view)) {
 		applyAlpha(sctx, entity, view, componentAlpha(sctx, entity, view));
 		return;
@@ -25812,6 +26372,7 @@ function dropView(sctx, entity) {
 	state.views.delete(entity);
 	if (state.filters.has(entity) || state.areas.has(entity)) state.viewlessEntries = true;
 	state.orphans.delete(entity);
+	state.held.delete(entity);
 	state.entityOf.delete(view.object);
 	state.viewOfTop.delete(view.wrapper ?? view.object);
 	untrackKey(state, entity, view.textureKey);
@@ -26034,9 +26595,11 @@ function renderFrame(ctx, modules) {
 	if (modules.viewport.applyPending()) {
 		const root = modules.sync.root();
 		modules.monitor.changed("resize");
+		ctx.state.sync.passesVersion += 1;
 		if (root !== void 0) modules.viewport.apply(root);
 		modules.demand.whole("resize");
 	}
+	modules.sync.stepFilters();
 	modules.sync.stepOverlays();
 	modules.sync.drainOverlayEvents(modules.monitor);
 	modules.kept.collect();
@@ -26232,19 +26795,22 @@ function countUpload(sinks, source) {
 /**
 * Builds the seven counting subclasses from the module object. They are made at call time,
 * because the base classes arrive with the lazily loaded module. Each keeps the base's `static
-* extension` object as it is, so the registry files it under the same type and name.
+* extension` object as it is, so the registry files it under the same type and name. The batch pipe extends the one
+* it is given: the routing pipe of the renderer's batched text, which the plugin root injects, so the counting pipe
+* that takes its place routes the same.
 *
 * @param pixi - The loaded Pixi module.
 * @param sinks - What every instance counts into.
+* @param batcherPipe - The batch pipe the counting one extends; Pixi's own when none is given.
 * @returns The seven counting classes (BatcherPipe among them).
 */
-function createCountingClasses(pixi, sinks) {
+function createCountingClasses(pixi, sinks, batcherPipe = pixi.BatcherPipe) {
 	const counter = sinks.draws;
 	/**
 	* Counts every rebuild of a render group's instruction list: Pixi's render group system calls `buildStart` once per
 	* rebuild and nowhere else. It inherits the static batcher registry, so batchers resolve as before.
 	*/
-	class CountingBatcherPipe extends pixi.BatcherPipe {
+	class CountingBatcherPipe extends batcherPipe {
 		static extension = pixi.BatcherPipe.extension;
 		/**
 		* Counts the rebuild, in the frame's counter only inside a frame, then begins it.
@@ -26451,10 +27017,11 @@ function createCountingClasses(pixi, sinks) {
 *
 * @param pixi - The loaded Pixi module.
 * @param sinks - The sinks of the renderer that installs it.
+* @param batcherPipe - The batch pipe the counting one extends: the routing pipe of the batched text.
 * @returns The remover.
 */
-function installCounting(pixi, sinks) {
-	const counting = createCountingClasses(pixi, sinks);
+function installCounting(pixi, sinks, batcherPipe = pixi.BatcherPipe) {
+	const counting = createCountingClasses(pixi, sinks, batcherPipe);
 	const bases = [
 		pixi.BatcherPipe,
 		pixi.GpuBatchAdaptor,
@@ -27796,8 +28363,9 @@ function emptyEntitySet$1() {
 	return /* @__PURE__ */ new Set();
 }
 /**
-* Where the walk of `shown` stopped for an entity's view, walked once between two sync passes: an entity with several
-* endless loops asks once a frame (spec 26 R1.7.3). Nothing is allocated once the map has grown.
+* Where the walk of `shown` stopped for an entity's view, walked again only when `passesVersion` moved since (E4): an
+* entity with several endless loops is walked once, and the loops of a still board are answered from their records
+* (spec 26 R1.7.3). A record is made at an entity's first ask and written in place after.
 *
 * @param sctx - Domain context of the sync module.
 * @param entity - The entity a loop is about to write.
@@ -27807,9 +28375,16 @@ function unseenOf(sctx, entity) {
 	const state = sctx.ctx.state.sync;
 	if (state.root === void 0 || !state.views.has(entity)) return "other";
 	const known = state.held.get(entity);
-	if (known !== void 0) return known;
+	if (known !== void 0 && known.at === state.passesVersion) return known.answer;
 	const answer = sctx.deps.demand.unseenBy(entity);
-	state.held.set(entity, answer);
+	if (known === void 0) state.held.set(entity, {
+		answer,
+		at: state.passesVersion
+	});
+	else {
+		known.answer = answer;
+		known.at = state.passesVersion;
+	}
 	return answer;
 }
 /**
@@ -28200,7 +28775,6 @@ function createSyncApi(ctx, deps) {
 	* view. A still frame (nothing changed, nothing waits) returns before any work and makes nothing.
 	*/
 	const pass = () => {
-		if (state.held.size > 0) state.held.clear();
 		if (still()) return;
 		state.passesVersion += 1;
 		if (state.removed.size > 0) {
@@ -28347,6 +28921,7 @@ function createSyncApi(ctx, deps) {
 		layerContainer: (name) => layerContainer(state, name),
 		layerOf: (entity) => layerOf(sctx, entity),
 		stepOverlays: () => stepOverlays(sctx),
+		stepFilters: () => applySwitched(state, deps.kept),
 		drainOverlayEvents: (monitor) => drainOverlayEvents(sctx, monitor),
 		warmStep: () => warmStep(sctx),
 		onWarm: (fn) => {
@@ -28814,14 +29389,14 @@ function createViewportApi(ctx, deps) {
 /**
 * The counting `host` installs before `new Application()`: the seven counting classes (BatcherPipe among them) of
 * `monitor` in a dev build and in a debug build, bound to the sinks in the monitor branch of the
-* state, none in production. A production `define` folds the dev or agent guard, so the counting
-* module leaves the bundle.
+* state, none in production; the counting batch pipe extends the routing pipe of the batched text. A production
+* `define` folds the dev or agent guard, so the counting module leaves the bundle.
 *
 * @param ctx - Domain context of the renderer plugin.
 * @returns The bound installer, or `undefined` without the dev flag and the agent flag.
 */
 function countingOf(ctx) {
-	return typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? (pixi) => installCounting(pixi, ctx.state.monitor.sinks) : void 0;
+	return typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ || typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ ? (pixi) => installCounting(pixi, ctx.state.monitor.sinks, createSdfBatcherPipe(pixi)) : void 0;
 }
 /**
 * The writers of `sync` the kept cache draws through: the one owner of `renderable`, the one writer of a view's
@@ -28861,7 +29436,8 @@ function createModules$1(ctx) {
 	const demand = createDemandApi(ctx, {
 		host,
 		views: ctx.state.sync.views,
-		hiddenBy
+		hiddenBy,
+		transparent: (node) => transparentNode(ctx.state.sync, node)
 	});
 	const built = {};
 	const kept = createKeptApi(ctx, {
@@ -30994,7 +31570,8 @@ function same$1(stored, next) {
 * every frame all the same.
 *
 * A frame that moves every field writes the track's own patch, filled in place. A frame that
-* leaves a field alone builds the patch of the fields it moves, so no other field is written.
+* leaves a field alone writes the track's patch of the fields it moves, kept for the next such
+* frame and built again only when the moved fields change, so no other field is written.
 *
 * @param actx - Domain context of the anim plugin.
 * @param track - The track to write, its normalised time in `clock[1]`.
@@ -31009,7 +31586,7 @@ function writeFields(actx, track, final) {
 	}
 	beginTrack(actx, track, stored);
 	const owned = track.muted();
-	const { names, live, moved, values, seen, patch } = track;
+	const { names, live, moved, values, seen } = track;
 	let fields = 0;
 	let count = 0;
 	for (let slot = 0; slot < names.length; slot++) {
@@ -31029,27 +31606,57 @@ function writeFields(actx, track, final) {
 			continue;
 		}
 		seen[slot] = next;
-		patch[field] = next;
 		moved[slot] = 1;
 		count++;
 	}
 	if (count === 0) return;
-	ecs.set(track.entity, track.component, count === fields ? patch : movedPatch(track));
+	const written = count === fields ? track.patch : partialPatch(track);
+	fillPatch(track, written);
+	ecs.set(track.entity, track.component, written);
 }
 /**
-* The patch of a frame that moved only some of the fields of a track: those fields, at the values
-* the frame put into the track's patch.
+* Puts the values of the moved slots into a patch of the track: each moved field gets what the
+* frame left in `values` for it.
 *
 * @param track - The track that writes.
-* @returns A new patch of the moved fields only.
+* @param written - Its full patch, or its patch of the moved fields.
 */
-function movedPatch(track) {
-	const written = {};
+function fillPatch(track, written) {
+	const { names, moved, values } = track;
+	for (let slot = 0; slot < names.length; slot++) {
+		const field = names[slot];
+		if (moved[slot] === 1 && field !== void 0) written[field] = values[slot] ?? 0;
+	}
+}
+/**
+* The patch of a frame that moved only some of the fields of a track: the one the track keeps,
+* when the frame moved the same fields as the frame it was built for, otherwise a new one.
+*
+* @param track - The track that writes, its `moved` flags set by this frame.
+* @returns The patch of exactly the moved fields; their values are filled after.
+*/
+function partialPatch(track) {
+	const { moved, partialMoved, partial } = track;
+	if (partial === void 0) return keepPartial(track);
+	for (let slot = 0; slot < moved.length; slot++) if (moved[slot] !== partialMoved[slot]) return keepPartial(track);
+	return partial;
+}
+/**
+* Builds the patch of the fields the frame moved and keeps it on the track, with the `moved`
+* flags it was built for. Runs only when the moved fields change.
+*
+* @param track - The track that writes.
+* @returns The new patch, its values still to fill.
+*/
+function keepPartial(track) {
+	const built = {};
 	for (let slot = 0; slot < track.names.length; slot++) {
 		const field = track.names[slot];
-		if (track.moved[slot] === 1 && field !== void 0) written[field] = track.patch[field];
+		if (track.moved[slot] === 1 && field !== void 0) built[field] = 0;
 	}
-	return written;
+	track.partialMoved.set(track.moved);
+	track.partial = built;
+	return built;
 }
 /**
 * Releases the field bookkeeping of a track that is ending: the fields it owned, its own offsets
@@ -31289,7 +31896,9 @@ function startTrack$1(actx, entity, component, to, options, muted, driven = fals
 		masked: noMaskedFields(),
 		keep,
 		reveals: revealsOf(component, target),
-		patch: { ...target }
+		patch: { ...target },
+		partial: void 0,
+		partialMoved: new Uint8Array(names.length)
 	};
 	actx.state.nextId += 1;
 	if (track.ended) return track;
@@ -35124,8 +35733,8 @@ function overTargetOf(ctx, node, run) {
 }
 /**
 * Builds the scene in one synchronous block: the layers, then the projections of the old scene
-* out, then the ones of the new scene in, then the list the scene names to `assets`, then the
-* frame loop out of its idle cap, and only then the event.
+* out, then the ones of the new scene in, the new scene to the world's systems, then the list the
+* scene names to `assets`, then the frame loop out of its idle cap, and only then the event.
 *
 * @param ctx - Domain context of the plugin.
 * @param scene - The scene whose bundles are there.
@@ -35140,6 +35749,7 @@ function apply(ctx, scene, named) {
 	if (previous !== void 0) projection.unmount(previous.projections);
 	projection.mount(scene.projections, state.owner);
 	state.current = scene.id;
+	ctx.deps.world.ecs.setScene(scene.id);
 	state.named = named;
 	ctx.deps.assets.sceneBundles(named);
 	ctx.deps.time.wake();
@@ -41588,8 +42198,9 @@ function countParticles(ectx) {
 	state.over.particles = above;
 }
 /**
-* Builds the `animate` system of the particles. It returns at once while the renderer does not
-* draw. Time is the frame's `delta` only, so `time.step(dt)` drives every test.
+* Builds the `animate` system of the emitters. It runs while an entity carries `Emitter` (the world
+* skips a system whose query has no entity) and returns at once while the renderer does not draw.
+* Time is the frame's `delta` only, so `time.step(dt)` drives every test.
 *
 * @param ectx - Domain context of the effects plugin.
 * @returns The system `world.ecs.system` takes.
@@ -41605,6 +42216,26 @@ function createParticleSystem(ectx) {
 			if (pixi === void 0) return;
 			const reducedMotion = ectx.deps.anim.reducedMotion();
 			for (const [entity, emitter] of rows) runEmitter(ectx, pixi, entity, emitter, context.time, reducedMotion);
+		}
+	});
+}
+/**
+* Builds the `animate` system of the orphans, registered right after the emitters: the particles
+* of an emitter whose host left fly on after the last `Emitter` is gone, so this system has no
+* query and runs every frame. It returns at once while the renderer does not draw, then steps the
+* orphans and keeps the particle budget.
+*
+* @param ectx - Domain context of the effects plugin.
+* @returns The system `world.ecs.system` takes.
+*/
+function createOrphanSystem(ectx) {
+	return system({
+		name: "effects:orphans",
+		phase: "animate",
+		query: [],
+		run: (_rows, context) => {
+			const host = ectx.deps.renderer.host;
+			if (!host.ready() || host.pixi() === void 0) return;
 			runOrphans(ectx, context.time);
 			countParticles(ectx);
 		}
@@ -41932,7 +42563,7 @@ function warnScreenReads(ectx, entries) {
 	});
 }
 /**
-* Opens the world side: the two systems, the hook that retires an emitter's instance, and the two
+* Opens the world side: the three systems, the hook that retires an emitter's instance, and the two
 * hooks per filter kind; then records the filter components that are on entities already.
 *
 * @param ectx - Domain context of the effects plugin.
@@ -41940,7 +42571,7 @@ function warnScreenReads(ectx, entries) {
 */
 function openWorld(ectx, kinds) {
 	const ecs = ectx.deps.world.ecs;
-	ectx.state.removers.push(ecs.system(createParticleSystem(ectx)), ecs.system(createFilterSystem(ectx)), ecs.onRemoved(Emitter, (entity) => forgetEmitter(ectx, entity)), ...kinds.map((kind) => ecs.onRemoved(kind.component, (entity) => forgetFilter(ectx, kind, entity))), ...kinds.map((kind) => ecs.onAdded(kind.component, (entity) => trackFilter(ectx, kind, entity))));
+	ectx.state.removers.push(ecs.system(createParticleSystem(ectx)), ecs.system(createOrphanSystem(ectx)), ecs.system(createFilterSystem(ectx)), ecs.onRemoved(Emitter, (entity) => forgetEmitter(ectx, entity)), ...kinds.map((kind) => ecs.onRemoved(kind.component, (entity) => forgetFilter(ectx, kind, entity))), ...kinds.map((kind) => ecs.onAdded(kind.component, (entity) => trackFilter(ectx, kind, entity))));
 	for (const kind of kinds) for (const [entity] of ecs.query(kind.component)) trackFilter(ectx, kind, entity);
 }
 /**
@@ -57466,6 +58097,7 @@ function featurePluginOf(name, description, children) {
 */
 function defineFeature(name, description) {
 	if (takenNames().has(name)) throw new Error(`[game] Feature name "${name}" is reserved or already a plugin.\n  Choose another feature name.`);
+	assertNoSystemsRun(name, description);
 	const children = Object.freeze([...description.features ?? []]);
 	assertFeatures(name, children);
 	const logicOnly = Object.assign(featurePluginOf(name, logicKeysOf(description), children), { features: Object.freeze(children.map((child) => child.logicOnly)) });
@@ -57475,6 +58107,18 @@ function defineFeature(name, description) {
 	});
 }
 /**
+* Throws for a feature that still writes `systemsRun`, removed after 0.15.3: the type refuses it,
+* this catches a game in JavaScript or a factory that passes the key through.
+*
+* @param name - Feature name.
+* @param description - What the feature brings.
+* @throws {Error} When the description carries `systemsRun`.
+*/
+function assertNoSystemsRun(name, description) {
+	if (!("systemsRun" in description)) return;
+	throw new Error(`[game] Feature "${name}" sets systemsRun, which the engine no longer has.\n  Delete it: a system whose query has no entity is not run (world README, "When a system runs").`);
+}
+/**
 * Tells whether an entry of a feature tree carries its `features` list, as every plugin of
 * `defineFeature` does. A plain plugin, a cast object or a hole in the array does not.
 *
@@ -57947,6 +58591,168 @@ function defineEffect(kind, options = {}) {
 	});
 }
 //#endregion
+//#region src/plugins/anim/tween/bezier.ts
+/**
+* @file anim/tween — the CSS timing function `cubic-bezier(x1, y1, x2, y2)` as an easing. The
+* curve is solved once, into a table of its progress at 512 even steps of time; a frame reads two
+* cells and draws a line between them. Where a line strays from the curve (the curve leaves an end
+* vertically), that step is solved again at each call, inside the bracket the table keeps. Either
+* way a call allocates nothing.
+*/
+/**
+* How many even steps of time the table splits 0…1 into. With 512, a line strays at most 1e-5
+* from any curve that keeps a finite slope (the CSS keywords, an overshoot both ways), so only a
+* curve that leaves an end vertically solves any step at a call; 8 KB per curve.
+*/
+const STEPS = 512;
+/**
+* How far the line of a step may stray from the curve at the step's middle before that step is
+* solved at each call instead: a fifth of the 1e-4 the factory promises, so the rest of the step,
+* where the line may stray a little more, stays inside the promise too (2e-5 measured).
+*/
+const STRAY = 2e-5;
+/** Halvings of a solve: 2^-48 of the bracket, far below what a double of progress shows. */
+const HALVINGS = 48;
+/**
+* One coordinate of a cubic curve from 0 to 1 with the two inner control values. Pure.
+*
+* @param along - The curve parameter, 0 to 1.
+* @param first - The first control value.
+* @param second - The second control value.
+* @returns The coordinate at `along`.
+* @example
+* ```ts
+* coordinate(0.5, 1 / 3, 2 / 3); // 0.5: the middle of a straight line
+* ```
+*/
+function coordinate(along, first, second) {
+	const back = 1 - along;
+	return 3 * back * back * along * first + 3 * back * along * along * second + along * along * along;
+}
+/**
+* The curve parameter whose x is `time`, found by halving a bracket of parameters. The x of the
+* curve never falls while x1 and x2 lie in 0…1, so halving always finds it. Pure.
+*
+* @param time - The x to reach.
+* @param x1 - The x of the first control point.
+* @param x2 - The x of the second control point.
+* @param low - A parameter whose x is at most `time`.
+* @param high - A parameter whose x is at least `time`.
+* @returns The parameter.
+* @example
+* ```ts
+* parameterAt(0.25, 0, 1, 0, 1); // 0.25: on a straight line the parameter is the time
+* ```
+*/
+function parameterAt(time, x1, x2, low, high) {
+	let from = low;
+	let to = high;
+	for (let step = 0; step < HALVINGS; step++) {
+		const middle = (from + to) / 2;
+		if (coordinate(middle, x1, x2) < time) from = middle;
+		else to = middle;
+	}
+	return (from + to) / 2;
+}
+/**
+* Solves a curve into its table: the parameter and the progress at every even step of time, and
+* the steps whose line strays from the curve at their middle.
+*
+* @param points - `[x1, y1, x2, y2]`, x1 and x2 in 0…1.
+* @returns The table.
+*/
+function solveTable(points) {
+	const [x1 = 0, y1 = 0, x2 = 0, y2 = 0] = points;
+	const params = /* @__PURE__ */ new Float64Array(513);
+	const progress = /* @__PURE__ */ new Float64Array(513);
+	const solved = new Uint8Array(STEPS);
+	for (let index = 1; index < STEPS; index++) {
+		params[index] = parameterAt(index / STEPS, x1, x2, 0, 1);
+		progress[index] = coordinate(params[index] ?? 0, y1, y2);
+	}
+	params[STEPS] = 1;
+	progress[STEPS] = 1;
+	for (let index = 0; index < STEPS; index++) {
+		const middle = parameterAt((index + .5) / STEPS, x1, x2, params[index] ?? 0, params[index + 1] ?? 1);
+		const line = ((progress[index] ?? 0) + (progress[index + 1] ?? 0)) / 2;
+		if (Math.abs(coordinate(middle, y1, y2) - line) > STRAY) solved[index] = 1;
+	}
+	return {
+		points,
+		params,
+		progress,
+		solved
+	};
+}
+/**
+* The cell a solved step passes its time in and its progress out: a double handed to or returned
+* from a call V8 does not inline is boxed, a cell is not.
+*/
+const SOLVED = /* @__PURE__ */ new Float64Array(1);
+/**
+* The progress of a curve at one time: exactly 0 up to the start and 1 from the end on, a line
+* between two cells of the table in between, or the curve itself on a step whose line strays.
+*
+* @param table - The curve's table.
+* @param time - The time.
+* @returns The progress.
+*/
+function progressAt(table, time) {
+	if (time <= 0) return 0;
+	if (time >= 1) return 1;
+	const at = time * STEPS;
+	const index = Math.floor(at);
+	if (table.solved[index] === 1) {
+		SOLVED[0] = time;
+		solveStep(table, index);
+		return SOLVED[0] ?? 0;
+	}
+	const low = table.progress[index] ?? 0;
+	return low + ((table.progress[index + 1] ?? 1) - low) * (at - index);
+}
+/**
+* The progress on a step whose line strays from the curve: the curve solved inside the bracket of
+* parameters the table keeps for that step. It reads the time from `SOLVED[0]` and leaves the
+* progress there. Kept apart so the common call stays small.
+*
+* @param table - The curve's table.
+* @param index - The step.
+*/
+function solveStep(table, index) {
+	const points = table.points;
+	const along = parameterAt(SOLVED[0] ?? 0, points[0] ?? 0, points[2] ?? 0, table.params[index] ?? 0, table.params[index + 1] ?? 1);
+	SOLVED[0] = coordinate(along, points[1] ?? 0, points[3] ?? 0);
+}
+/**
+* The CSS timing function `cubic-bezier(x1, y1, x2, y2)` as an easing a tween, a keyframe segment
+* or a motion takes for `ease`. The curve is solved once, here, into a table; a frame reads it, so
+* an eased time costs a few reads and allocates nothing, and the progress stays within 1e-4 of the
+* exact curve. It is exactly 0 up to the start and exactly 1 from the end on, and may leave 0…1 on
+* the way (an overshoot). Make each curve once, at module level, and share it.
+*
+* @param x1 - The x of the first control point, 0 to 1.
+* @param y1 - The y of the first control point; below 0 or above 1 overshoots.
+* @param x2 - The x of the second control point, 0 to 1.
+* @param y2 - The y of the second control point; below 0 or above 1 overshoots.
+* @returns The curve: normalised time in, eased progress out.
+* @throws {Error} When x1 or x2 lies outside 0…1: the curve would be no function of time.
+* @example
+* ```ts
+* // The design's arrival curve, made once and named by every tween that arrives.
+* const arrive = cubicBezier(0.22, 0.61, 0.36, 1);
+* arrive(0.5); // 0.873 (to 1e-4)
+* const drop = defineAnimation("card.drop", {
+*   slots: { card: type<Target>() },
+*   build: ({ card }) => sequence(tween(card, Transform, { y: 40 }, { ms: 300, ease: arrive }))
+* });
+* ```
+*/
+function cubicBezier(x1, y1, x2, y2) {
+	if (!(x1 >= 0 && x1 <= 1 && x2 >= 0 && x2 <= 1)) throw new Error(`[game] cubicBezier needs x1 and x2 between 0 and 1, got ${x1} and ${x2}.\n  The x of a control point is a time; y1 and y2 may leave 0…1 for an overshoot.`);
+	const table = solveTable(Float64Array.of(x1, y1, x2, y2));
+	return (t) => progressAt(table, t);
+}
+//#endregion
 //#region src/index.ts
 /**
 * The `@moku-labs/game` package — 2D puzzle game engine on Moku Core.
@@ -58155,4 +58961,4 @@ const screen = [
 	uiPlugin
 ];
 //#endregion
-export { parallel as $, SHADER_WHATS as $t, types_exports$12 as A, Blur as At, DebugTrigger as B, assetsPlugin as Bt, types_exports$5 as C, Traced as Ct, types_exports$9 as D, effectsPlugin as Dt, types_exports$8 as E, messageDuration as Et, types_exports$17 as F, Outline as Ft, textPlugin as G, rendererPlugin as Gt, popup as H, AnimPlayer as Ht, uiPlugin as I, defineFilter as It, defineAnimation as J, MONITOR_SECTIONS as Jt, platformPlugin as K, PASS_KINDS as Kt, resolve as L, debugPlugin as Lt, types_exports$14 as M, Displacement as Mt, types_exports$15 as N, Glow as Nt, types_exports$10 as O, Emitter as Ot, types_exports$16 as P, Noise as Pt, mark as Q, PROBLEM_RULES as Qt, defineMotion as R, audioPlugin as Rt, types_exports$4 as S, Traceable as St, types_exports$7 as T, messageArgument as Tt, defineTokens as U, Animation as Ut, LocalWrite as V, animPlugin as Vt, defineStyle as W, Frames as Wt, frames as X, PERF_GAP_BUCKETS as Xt, external as Y, PERF_CAUSES as Yt, haptic as Z, PERF_LOG_VERSION as Zt, load as _, Pressable as _t, defineEffect as a, slot as an, spawned as at, types_exports$2 as b, Tappable as bt, schedule as c, modelPlugin as cn, use as ct, tr as d, timePlugin as dn, Draggable as dt, DEMAND_REASONS as en, play$1 as et, defineFeature as f, clockPlugin as fn, DropTarget as ft, defineBundles as g, PointerOver as gt, music as h, Pointer as ht, screen as i, exit as in, spawn as it, types_exports$13 as j, ColorMatrix as jt, types_exports$11 as k, Alpha as kt, projection as l, SaveUnreadableError as ln, wait as lt, defineEmitter as m, Hovered as mt, createPlugin as n, flowPlugin as nn, set as nt, guide as o, to as on, stagger as ot, flattenFeatures as p, Held as pt, HAPTIC_KINDS as q, frameAt as qt, defineGame as r, refuseStart as rn, sfx as rt, hint as s, type as sn, tween as st, createApp as t, worldPlugin as tn, sequence as tt, defineScene as u, lifecyclePlugin as un, inputPlugin as ut, types_exports as v, Pressed as vt, types_exports$6 as w, i18nPlugin as wt, types_exports$3 as x, Touchable as xt, types_exports$1 as y, Swipeable as yt, Box as z, scenesPlugin as zt };
+export { mark as $, PROBLEM_RULES as $t, types_exports$11 as A, Alpha as At, Box as B, scenesPlugin as Bt, types_exports$4 as C, Traceable as Ct, types_exports$8 as D, messageDuration as Dt, types_exports$7 as E, messageArgument as Et, types_exports$16 as F, Noise as Ft, defineStyle as G, Frames as Gt, LocalWrite as H, animPlugin as Ht, types_exports$17 as I, Outline as It, HAPTIC_KINDS as J, frameAt as Jt, textPlugin as K, rendererPlugin as Kt, uiPlugin as L, defineFilter as Lt, types_exports$13 as M, ColorMatrix as Mt, types_exports$14 as N, Displacement as Nt, types_exports$9 as O, effectsPlugin as Ot, types_exports$15 as P, Glow as Pt, haptic as Q, PERF_LOG_VERSION as Qt, resolve as R, debugPlugin as Rt, types_exports$3 as S, Touchable as St, types_exports$6 as T, i18nPlugin as Tt, popup as U, AnimPlayer as Ut, DebugTrigger as V, assetsPlugin as Vt, defineTokens as W, Animation as Wt, external as X, PERF_CAUSES as Xt, defineAnimation as Y, MONITOR_SECTIONS as Yt, frames as Z, PERF_GAP_BUCKETS as Zt, defineBundles as _, PointerOver as _t, cubicBezier as a, exit as an, spawn as at, types_exports$1 as b, Swipeable as bt, hint as c, type as cn, tween as ct, defineScene as d, lifecyclePlugin as dn, inputPlugin as dt, SHADER_WHATS as en, parallel as et, tr as f, timePlugin as fn, Draggable as ft, music as g, Pointer as gt, defineEmitter as h, Hovered as ht, screen as i, refuseStart as in, sfx as it, types_exports$12 as j, Blur as jt, types_exports$10 as k, Emitter as kt, schedule as l, modelPlugin as ln, use as lt, flattenFeatures as m, Held as mt, createPlugin as n, worldPlugin as nn, sequence as nt, defineEffect as o, slot as on, spawned as ot, defineFeature as p, clockPlugin as pn, DropTarget as pt, platformPlugin as q, PASS_KINDS as qt, defineGame as r, flowPlugin as rn, set as rt, guide as s, to as sn, stagger as st, createApp as t, DEMAND_REASONS as tn, play$1 as tt, projection as u, SaveUnreadableError as un, wait as ut, load as v, Pressable as vt, types_exports$5 as w, Traced as wt, types_exports$2 as x, Tappable as xt, types_exports as y, Pressed as yt, defineMotion as z, audioPlugin as zt };