@moku-labs/game 0.15.3 → 0.15.4

package/dist/{src-xChMXzwH.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;
 /**
@@ -8546,294 +8679,6 @@ function schemaOf(types) {
 	return [...types].map((type) => schemaOfType(type)).toSorted((left, right) => left.name.localeCompare(right.name));
 }
 //#endregion
-//#region src/plugins/world/ecs/scope.ts
-/** The keys of a description whose entries can make a feature active. */
-const SOURCES = [
-	"nodes",
-	"flows",
-	"scenes",
-	"projections",
-	"ui"
-];
-/** The release of a hold that holds nothing. */
-const RELEASE_NOTHING = () => {};
-/**
-* Creates an empty table of owners. Its own function: a collection is built outside the exported
-* declarations.
-*
-* @returns An empty map.
-*/
-function emptyOwners$2() {
-	return /* @__PURE__ */ new Map();
-}
-/**
-* Sizes the scope to the features of the game, in registration order: the only allocation of the
-* scope, once per start. Whatever an earlier start left is dropped first.
-*
-* @param ctx - Domain context of the world plugin.
-*/
-function openScope(ctx) {
-	const scope = ctx.state.ecs.scope;
-	const features = ctx.deps.flow.features.all();
-	const count = features.length;
-	resetScope(scope);
-	for (const [at, feature] of features.entries()) {
-		scope.names.push(feature.name);
-		scope.index.set(feature.name, at);
-	}
-	scope.onStack = new Uint8Array(count);
-	scope.active = new Uint8Array(count);
-	scope.holds = new Int32Array(count);
-	scope.views = new Int32Array(count);
-	scope.dirty = true;
-}
-/**
-* Empties the scope in place, as a world that never started has it, and moves its generation on:
-* a release kept past this changes nothing, also once the world started again.
-*
-* @param scope - The scope.
-*/
-function resetScope(scope) {
-	scope.generation += 1;
-	scope.names.length = 0;
-	scope.index.clear();
-	scope.projections.clear();
-	scope.owners = void 0;
-	scope.ownersFailed = false;
-	scope.flow = void 0;
-	scope.onStack = /* @__PURE__ */ new Uint8Array(0);
-	scope.active = /* @__PURE__ */ new Uint8Array(0);
-	scope.holds = /* @__PURE__ */ new Int32Array(0);
-	scope.views = /* @__PURE__ */ new Int32Array(0);
-	scope.dirty = false;
-	scope.scoped = false;
-}
-/**
-* The scope the systems of one feature register with: its index for `systemsRun: "active"`, -1
-* otherwise. A value outside the type (a hand-written `features.register`) is reported and its
-* systems always run.
-*
-* @param ctx - Domain context of the world plugin.
-* @param at - The feature's index.
-* @param feature - The feature and what it registered.
-* @param feature.name - Feature name, for the log entry.
-* @param feature.description - What the feature brought.
-* @returns The scope of its systems.
-*/
-function scopeOf(ctx, at, feature) {
-	const run = feature.description.systemsRun;
-	if (run === "active") return at;
-	if (run !== void 0 && run !== "always") ctx.log.warn("world:bad-feature-entry", {
-		feature: feature.name,
-		key: "systemsRun"
-	});
-	return -1;
-}
-/**
-* Warns about a feature whose systems wait for it to be active while nothing can make it active:
-* it has systems and `systemsRun: "active"`, and no node, flow, scene, projection or ui component.
-* The caller guards it for dev builds.
-*
-* @param ctx - Domain context of the world plugin.
-* @param feature - The feature and what it registered.
-* @param feature.name - Feature name, for the warning.
-* @param feature.description - What the feature brought.
-*/
-function reportNeverActive(ctx, feature) {
-	const { name, description } = feature;
-	const systems = description.systems;
-	if (description.systemsRun !== "active") return;
-	if (!Array.isArray(systems) || systems.length === 0) return;
-	for (const key of SOURCES) {
-		const list = description[key];
-		if (Array.isArray(list) && list.length > 0) return;
-	}
-	ctx.log.warn("world:feature-never-active", {
-		feature: name,
-		message: `Feature "${name}" runs its systems only while it is active, but it has no node, flow, scene, projection or ui component, so nothing makes it active and its systems never run. Remove systemsRun: "active" from it.`
-	});
-}
-/**
-* Builds the owner table of rule N from one `describe()`: flow id to node name to the index of the
-* feature that owns the node. A node without an owner, or owned by a name that is not a feature,
-* is left out.
-*
-* @param graph - The described graph.
-* @param index - Feature name to index.
-* @returns The owner table.
-*/
-function ownersOf$1(graph, index) {
-	const owners = emptyOwners$2();
-	for (const [id, flow] of Object.entries(graph.flows)) {
-		const nodes = emptyOwners$2();
-		for (const [node, info] of Object.entries(flow.nodes)) {
-			const at = info.owner === void 0 ? void 0 : index.get(info.owner);
-			if (at !== void 0) nodes.set(node, at);
-		}
-		if (nodes.size > 0) owners.set(id, nodes);
-	}
-	return owners;
-}
-/**
-* Builds the owner table once, at the first stack that is not empty: the graph is sealed by
-* `flow.run()`. A `describe()` that throws is logged once and makes every feature count as on the
-* stack (fail-safe).
-*
-* @param ctx - Domain context of the world plugin.
-* @param scope - The scope.
-*/
-function buildOwners(ctx, scope) {
-	try {
-		scope.owners = ownersOf$1(ctx.deps.flow.describe(), scope.index);
-	} catch (error) {
-		scope.ownersFailed = true;
-		ctx.log.error("world:scope-owners-failed", {}, asError$3(error));
-	}
-}
-/**
-* Sets the stack flags of rule N from the frames of one flow state, every frame counted, the
-* outer frames of sub-flows included.
-*
-* @param ctx - Domain context of the world plugin.
-* @param scope - The scope.
-* @param stack - The frames of the flow state.
-*/
-function readStack$1(ctx, scope, stack) {
-	const onStack = scope.onStack;
-	const depth = stack.length;
-	onStack.fill(0);
-	if (depth === 0) return;
-	if (scope.owners === void 0 && !scope.ownersFailed) buildOwners(ctx, scope);
-	const owners = scope.owners;
-	if (owners === void 0) {
-		onStack.fill(1);
-		return;
-	}
-	for (let index = 0; index < depth; index += 1) {
-		const frame = stack[index];
-		const at = frame === void 0 ? void 0 : owners.get(frame.flow)?.get(frame.node);
-		if (at !== void 0) onStack[at] = 1;
-	}
-}
-/**
-* Reads the flow stack again when `flow.state()` answers a new object. The state is memoised, so a
-* frame in which the graph did not move costs one call and one comparison.
-*
-* @param ctx - Domain context of the world plugin.
-* @param scope - The scope.
-*/
-function readSources(ctx, scope) {
-	const flowState = ctx.deps.flow.state();
-	if (flowState === scope.flow) return;
-	scope.flow = flowState;
-	readStack$1(ctx, scope, flowState.stack);
-	scope.dirty = true;
-}
-/**
-* Evaluates the active set at the start of a phase that runs systems: a feature is active while it
-* is on the stack, held, or has a view. Nothing moved: one call, one comparison and one flag test.
-*
-* @param ctx - Domain context of the world plugin.
-*/
-function refreshScope(ctx) {
-	const scope = ctx.state.ecs.scope;
-	readSources(ctx, scope);
-	if (!scope.dirty) return;
-	const { onStack, holds, views, active } = scope;
-	const count = scope.names.length;
-	for (let at = 0; at < count; at += 1) active[at] = onStack[at] === 1 || (holds[at] ?? 0) > 0 || (views[at] ?? 0) > 0 ? 1 : 0;
-	scope.dirty = false;
-}
-/**
-* The release of one hold: it takes the hold back once, never below 0, and only in the run it was
-* taken in. A release kept across a stop and a start finds a newer generation and changes nothing
-* (spec 28 W7.1).
-*
-* @param scope - The scope.
-* @param at - The held feature's index.
-* @returns The idempotent release.
-*/
-function releaseOf(scope, at) {
-	const hold = {
-		released: false,
-		generation: scope.generation
-	};
-	return () => {
-		if (hold.released || hold.generation !== scope.generation) return;
-		hold.released = true;
-		scope.holds[at] = Math.max(0, (scope.holds[at] ?? 0) - 1);
-		scope.dirty = true;
-	};
-}
-/**
-* Takes one hold on a feature. A name that is not a feature holds nothing; a dev build warns.
-*
-* @param ctx - Domain context of the world plugin.
-* @param feature - The feature to keep active.
-* @returns The release.
-*/
-function holdFeature(ctx, feature) {
-	const scope = ctx.state.ecs.scope;
-	const at = scope.index.get(feature);
-	if (at === void 0) {
-		if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__) ctx.log.warn("world:hold-unknown-feature", { feature });
-		return RELEASE_NOTHING;
-	}
-	scope.holds[at] = (scope.holds[at] ?? 0) + 1;
-	scope.dirty = true;
-	return releaseOf(scope, at);
-}
-/**
-* Whether a feature is active now, from the sources as they are at this moment. It leaves the
-* active set of the running phase alone: a source that moves inside a phase counts for the
-* systems from the next phase.
-*
-* @param ctx - Domain context of the world plugin.
-* @param feature - The feature name.
-* @returns True while it is on the stack, held or has a view; false for a name that is not a feature.
-*/
-function isFeatureActive(ctx, feature) {
-	const scope = ctx.state.ecs.scope;
-	const at = scope.index.get(feature);
-	if (at === void 0) return false;
-	readSources(ctx, scope);
-	return scope.onStack[at] === 1 || (scope.holds[at] ?? 0) > 0 || (scope.views[at] ?? 0) > 0;
-}
-/**
-* Counts a new view of a projection for the feature that registered it. A projection no feature
-* registered counts for nobody.
-*
-* @param scope - The scope.
-* @param projection - The projection name.
-*/
-function viewCame(scope, projection) {
-	const at = scope.projections.get(projection);
-	if (at === void 0) return;
-	scope.views[at] = (scope.views[at] ?? 0) + 1;
-	scope.dirty = true;
-}
-/**
-* Takes back the count of a despawned view, never below 0.
-*
-* @param scope - The scope.
-* @param projection - The projection name.
-*/
-function viewLeft(scope, projection) {
-	const at = scope.projections.get(projection);
-	if (at === void 0) return;
-	scope.views[at] = Math.max(0, (scope.views[at] ?? 0) - 1);
-	scope.dirty = true;
-}
-/**
-* Drops every view count: the projections were cleared.
-*
-* @param scope - The scope.
-*/
-function viewsCleared(scope) {
-	scope.views.fill(0);
-	scope.dirty = true;
-}
-//#endregion
 //#region src/plugins/world/ecs/systems.ts
 /** The one phase that runs in every mode, because `renderer.sync` lives in it. */
 const ALWAYS = "sync";
@@ -8923,18 +8768,29 @@ 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. A system of a feature
-* with `systemsRun: "active"` carries the feature's index as its scope and runs only while the
-* feature is active; `ecs.system` passes none, so a system registered by hand always runs.
+* 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.
-* @param scope - The index of its feature in the scope, or -1 for a system that always runs.
 * @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, scope = -1) {
+function registerSystem(ctx, definition) {
 	const state = ctx.state.ecs;
 	for (const phase of [
 		"input",
@@ -8942,18 +8798,19 @@ function registerSystem(ctx, definition, scope = -1) {
 		"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,
-		scope,
+		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];
 	list.push(entry);
-	if (scope !== -1) state.scope.scoped = true;
 	if (state.timing !== void 0) giveRow(state, state.timing, definition.name);
 	return () => {
 		const at = list.indexOf(entry);
@@ -9002,19 +8859,19 @@ function phaseContextOf(ctx, world, time) {
 	return known;
 }
 /**
-* Tells whether a system of a scoped feature runs in this phase. One whose feature is not active is
-* skipped in its slot and remembers it; one that runs is told whether its runs before were
-* skipped. No walk, no mark and no clock read happen for a skipped system: the check comes before
-* all three. The caller sets `resumed` back to false after the run, so a system that always runs
-* reads false without a write of its own.
+* 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 active - The active flags of the features, evaluated at the start of the phase.
-* @param entry - The system, whose scope is a feature index.
+* @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(active, entry, context) {
-	if (active[entry.scope] === 0) {
+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;
 	}
@@ -9023,21 +8880,6 @@ function wakes(active, entry, context) {
 	return true;
 }
 /**
-* Runs one system of a scoped feature when its feature is active, and leaves `resumed` false for
-* the systems after it.
-*
-* @param ctx - Domain context of the world plugin.
-* @param active - The active flags of the features.
-* @param entry - The system.
-* @param context - What its `run` receives.
-* @param phase - The phase, for the report of a throw.
-*/
-function runScoped(ctx, active, entry, context, phase) {
-	if (!wakes(active, entry, context)) return;
-	guardedRun(ctx, entry, context, phase);
-	context.resumed = false;
-}
-/**
 * 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.
@@ -9057,9 +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. When a feature scopes its systems, the
-* active set is evaluated first, from the sources as they stand at the start of the phase; a
-* system of a feature that is not active is skipped in its slot.
+* 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.
@@ -9069,16 +8911,14 @@ 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.scope.scoped) refreshScope(ctx);
+	if (state.scene.leaving.length > 0) endLeaving(state);
 	const context = phaseContextOf(ctx, world, time);
 	const entries = state.systems[phase];
-	const active = state.scope.active;
 	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) continue;
-		if (entry.scope === -1) guardedRun(ctx, entry, context, phase);
-		else runScoped(ctx, active, entry, context, phase);
+		if (wakes(state, entry, context)) guardedRun(ctx, entry, context, phase);
 	}
 	else runTimed(ctx, state.timing, entries, context, phase, time);
 	state.running = void 0;
@@ -9098,26 +8938,24 @@ 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;
-	const active = ctx.state.ecs.scope.active;
 	for (let index = 0; index < count; index += 1) {
 		const entry = entries[index];
 		if (entry === void 0 || entry.frame >= time.frame) continue;
-		if (entry.scope !== -1 && !wakes(active, entry, context)) 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;
-		context.resumed = false;
 	}
 }
 //#endregion
 //#region src/plugins/world/ecs/api.ts
 /**
-* Empties the world in place: entities, components, resources, systems, hooks, the frame history
-* and the view counts of the scope. The holds stay: the plugins above still show their scene or
-* root. The owner table stays: the graph did not change. The state object keeps its identity, so
-* every view on it stays valid.
+* Empties the world in place: entities, components, resources, systems, hooks and the frame
+* 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.
 */
@@ -9148,7 +8986,6 @@ function clearWorldState(ctx) {
 	state.mode = "live";
 	state.frameSnapshot = void 0;
 	resetHistory(state);
-	viewsCleared(state.scope);
 }
 /**
 * Creates the ecs module: the public API a game and the plugins above call, plus the four methods
@@ -9161,8 +8998,6 @@ function createEcsApi(ctx) {
 	const state = ctx.state.ecs;
 	const api = {
 		system: (definition) => registerSystem(ctx, definition),
-		hold: (feature) => holdFeature(ctx, feature),
-		isActive: (feature) => isFeatureActive(ctx, feature),
 		spawn: (owner, components) => {
 			const entity = reserveEntity(state, owner);
 			queueOrApply(ctx, {
@@ -9242,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),
@@ -9266,15 +9104,6 @@ function createEcsApi(ctx) {
 		},
 		clear: () => {
 			clearWorldState(ctx);
-		},
-		viewCame: (projection) => {
-			viewCame(state.scope, projection);
-		},
-		viewLeft: (projection) => {
-			viewLeft(state.scope, projection);
-		},
-		viewsCleared: () => {
-			viewsCleared(state.scope);
 		}
 	};
 	return api;
@@ -9388,29 +9217,24 @@ 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. A feature's index is its place in the list: the systems
-* of a feature with `systemsRun: "active"` carry it as their scope, and each projection is counted
-* for it (rule V). A dev build warns about a feature nothing can make active.
+* 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, projection) {
-	const projections = ctx.state.ecs.scope.projections;
-	for (const [at, feature] of ctx.deps.flow.features.all().entries()) {
-		const scope = scopeOf(ctx, at, feature);
+function registerFeatures(ctx, ecs, projection) {
+	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) => registerSystem(ctx, entry, scope));
-		registerEach(ctx, feature, "projections", isProjectionEntry, (entry) => {
-			projection.register(entry);
-			projections.set(entry.name, at);
-		});
-		if (typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__) reportNeverActive(ctx, feature);
+		registerEach(ctx, feature, "systems", isSystemEntry, (entry) => ecs.system(entry));
+		registerEach(ctx, feature, "projections", isProjectionEntry, (entry) => projection.register(entry));
 	}
 }
 /**
-* Connects the world in `onStart`: it sizes the scope to the features, reads every feature
-* description, registers the five frame
+* Connects the world in `onStart`: it reads every feature description, registers the five frame
 * callbacks of the phases and listens to the released hints. In a dev build the `signals`
 * callback records the frame history before it clears the change sets; in an agent build the
 * timing table starts with the page clock of `time` and the `input` callback zeroes it each
@@ -9431,8 +9255,7 @@ function connectWorld(ctx) {
 		const clock = time.agentClock();
 		if (clock !== void 0) startTiming(worldCtx.state.ecs, clock);
 	}
-	openScope(worldCtx);
-	registerFeatures(worldCtx, projection);
+	registerFeatures(worldCtx, ecs, projection);
 	ecs.resource(Now).now = clock.now();
 	worldCtx.state.ecs.offFrame.push(ecs.onOwnerLeft((owner) => projection.ownerLeft(owner)), time.onFrame("input", (frame) => {
 		ecs.resource(Now).now = clock.now();
@@ -9450,8 +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, the scope and the frame history
-* are 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.
@@ -9502,7 +9325,9 @@ function clearWorld(state) {
 	state.ecs.mode = "live";
 	state.ecs.timing = void 0;
 	state.ecs.timingSlots.clear();
-	resetScope(state.ecs.scope);
+	state.ecs.scene.mounted = void 0;
+	state.ecs.scene.leaving.length = 0;
+	state.ecs.scene.declared = void 0;
 	resetHistory(state.ecs);
 }
 //#endregion
@@ -10415,7 +10240,7 @@ function despawnView(pctx, mounted, view) {
 	view.handles = [];
 	cancelTracks(pctx, view.entity);
 	const state = pctx.ctx.state.projection;
-	if (state.byEntity.delete(view.entity)) pctx.deps.views.left(view.projection);
+	state.byEntity.delete(view.entity);
 	state.mutes.delete(view.entity);
 	state.rests.delete(view.entity);
 	state.leaving.set(view.entity, view.cause);
@@ -10791,7 +10616,6 @@ function enterEntry(pctx, spec, mounted, entry) {
 	const view = createViewRecord(entity, spec.name, entry.key, entry.item, values, entry.direct ? "mount" : "change");
 	mounted.live.set(entry.key, view);
 	pctx.ctx.state.projection.byEntity.set(entity, view);
-	pctx.deps.views.came(spec.name);
 	pctx.ctx.state.projection.membershipVersion += 1;
 	const hook = spec.motion?.enter;
 	const loop = spec.motion?.loop;
@@ -11604,7 +11428,6 @@ function createProjectionApi(ctx, deps) {
 			state.mounted.clear();
 			state.specs.clear();
 			state.byEntity.clear();
-			pctx.deps.views.cleared();
 			state.mutes.clear();
 			state.rests.clear();
 			state.keys.clear();
@@ -11644,12 +11467,7 @@ function createModules$2(ctx) {
 		ecs,
 		projection: createProjectionApi(ctx, {
 			ecs,
-			components: WORLD_COMPONENTS,
-			views: {
-				came: ecs.viewCame,
-				left: ecs.viewLeft,
-				cleared: ecs.viewsCleared
-			}
+			components: WORLD_COMPONENTS
 		})
 	};
 }
@@ -11684,8 +11502,6 @@ function withKeys(diff, ecs, projection) {
 function exposeEcs(ecs, projection) {
 	return {
 		system: ecs.system,
-		hold: ecs.hold,
-		isActive: ecs.isActive,
 		spawn: ecs.spawn,
 		despawn: ecs.despawn,
 		despawnOwnedBy: ecs.despawnOwnedBy,
@@ -11709,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
@@ -11807,26 +11624,16 @@ function emptyMap$10() {
 	return /* @__PURE__ */ new Map();
 }
 /**
-* Creates the scope of a world that has not started: no feature, no table of owners, typed arrays
-* of length 0. `onStart` sizes it once to the feature count.
+* 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 scope.
+* @returns An empty scene state.
 */
-function emptyScope() {
+function emptyScene() {
 	return {
-		names: [],
-		index: /* @__PURE__ */ new Map(),
-		projections: /* @__PURE__ */ new Map(),
-		owners: void 0,
-		ownersFailed: false,
-		flow: void 0,
-		onStack: /* @__PURE__ */ new Uint8Array(0),
-		holds: /* @__PURE__ */ new Int32Array(0),
-		views: /* @__PURE__ */ new Int32Array(0),
-		active: /* @__PURE__ */ new Uint8Array(0),
-		dirty: false,
-		scoped: false,
-		generation: 0
+		mounted: void 0,
+		leaving: [],
+		declared: void 0
 	};
 }
 /**
@@ -11872,7 +11679,7 @@ function createEcsState() {
 		queryPlans: emptyMap$10(),
 		walkLists: [],
 		despawns: 0,
-		scope: emptyScope()
+		scene: emptyScene()
 	};
 }
 //#endregion
@@ -13012,336 +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) {
-	const { a, b, c, d } = linear;
-	return (Math.sqrt(a * a + b * b) + Math.sqrt(c * c + d * 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 key the state of a text's `uDistance` hangs under on its uniforms: a symbol, not enumerable, so Pixi's walk of
-* the uniforms (`for…in` on WebGL) and a deep compare see the four uniforms alone.
-*/
-const DISTANCE = Symbol("sdf-text-distance");
-/**
-* Pixi's read of `uDistance`, at every upload: the distance per unit of scale at the text's world scale, or Pixi's last
-* write without one, times the renderer's resolution.
+* 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.
 *
-* @param this - The text's uniforms.
-* @returns The distance in device pixels.
+* @param make - Makes the shader of one texture limit.
+* @returns The shader for a texture limit.
 */
-function readDistance() {
-	const state = this[DISTANCE];
-	const perScale = state.cell[1] ?? 0;
-	const text = state.text;
-	const distance = (text === void 0 || perScale === 0 ? state.cell[0] ?? 0 : perScale * scaleOf$1(text.worldTransform)) * state.density.resolution;
-	const answer = state.answer;
-	if (answer !== void 0 && distance === state.cell[2]) return answer;
-	state.cell[2] = distance;
-	state.answer = distance;
-	return distance;
-}
-/**
-* Pixi's write of `uDistance`, at a layout: the CSS distance and, while the pipe names the text, the distance per unit
-* of its group scale.
-*
-* @param this - The text's uniforms.
-* @param value - Pixi's distance, CSS px.
-*/
-function writeDistance(value) {
-	const state = this[DISTANCE];
-	const text = state.writing.text;
-	const scale = text === void 0 ? 0 : scaleOf$1(text.groupTransform);
-	state.cell[0] = value;
-	state.cell[1] = scale > 0 ? value / scale : 0;
-	state.text = text;
-}
-/**
-* The `uDistance` of every text's uniforms: one pair of functions, so every uniforms object has the same hidden class
-* and Pixi's generated sync function reads it monomorphic. A pair made per text, or an accessor laid over Pixi's data
-* property, sends each object to dictionary mode. The getter hands a still text's answer back boxed once (`answer`):
-* Pixi's sync may not inline it.
-*/
-const DISTANCE_ACCESSOR = {
-	enumerable: true,
-	configurable: true,
-	get: readDistance,
-	set: writeDistance
-};
+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 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.
+* 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.
 *
-* 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.
-*
-* 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.
-*
-* The uniforms object is the renderer's own, made in one shape for every text with the one accessor pair
-* `DISTANCE_ACCESSOR`, in place of the one Pixi's group made.
+* @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"
+* @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
+	});
+	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
+			}
 		},
-		uRound: {
-			value: 0,
-			type: "f32"
-		}
+		indexBuffer
 	});
-	const values = group.uniforms;
-	const state = {
-		cell: Float64Array.of(4, 0, NaN),
-		text: void 0,
-		writing,
-		density,
-		answer: void 0
-	};
-	const uniforms = {
-		uColor: values.uColor,
-		uTransformMatrix: values.uTransformMatrix,
-		uRound: values.uRound
-	};
-	Object.defineProperty(uniforms, "uDistance", DISTANCE_ACCESSOR);
-	Object.defineProperty(uniforms, DISTANCE, { value: state });
-	group.uniforms = uniforms;
-	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
@@ -13478,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.
@@ -13531,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;
@@ -13577,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.
@@ -26837,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.
@@ -27056,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,
@@ -29427,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
@@ -35770,24 +35732,9 @@ function overTargetOf(ctx, node, run) {
 	return takePending(ctx);
 }
 /**
-* Holds the feature that declares the scene now mounted, then releases the hold of the scene
-* before: the new hold first, so no phase sees the moment with neither. A scene no feature
-* declared holds nothing.
-*
-* @param ctx - Domain context of the plugin.
-* @param scene - The id of the scene now mounted.
-*/
-function holdOwner(ctx, scene) {
-	const state = ctx.state;
-	const release = state.held;
-	const owner = state.owners.get(scene);
-	state.held = owner === void 0 ? void 0 : ctx.deps.world.ecs.hold(owner);
-	release?.();
-}
-/**
 * 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, the hold on its feature, 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.
@@ -35802,7 +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;
-	holdOwner(ctx, scene.id);
+	ctx.deps.world.ecs.setScene(scene.id);
 	state.named = named;
 	ctx.deps.assets.sceneBundles(named);
 	ctx.deps.time.wake();
@@ -35916,16 +35863,22 @@ function withDeps$5(ctx) {
 	};
 }
 /**
-* Reads the `scenes` key of every registered feature into the registry, and which feature declared
-* each scene: a duplicate id names both, and the switch holds the declaring feature while its
-* scene is mounted. Features register in their own `onInit`, which runs before this `onStart`, so
-* every scene of the game is here.
+* Records which feature declared which scene, so a duplicate id can name both of them.
+*
+* @returns An empty table of scene id to feature name.
+*/
+function emptyOwners$1() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Reads the `scenes` key of every registered feature into the registry. Features register in
+* their own `onInit`, which runs before this `onStart`, so every scene of the game is here.
 *
 * @param ctx - Domain context of the plugin.
 * @throws {Error} When two features declare the same scene id.
 */
 function readScenes(ctx) {
-	const owners = ctx.state.owners;
+	const owners = emptyOwners$1();
 	for (const feature of ctx.deps.flow.features.all()) {
 		const list = feature.description.scenes;
 		if (!Array.isArray(list)) continue;
@@ -35956,9 +35909,9 @@ function startScenes(ctx) {
 	scenes.state.teardown = scenes.deps.flow.onEnter("scene", (node, run) => enterScene(scenes, node, run));
 }
 /**
-* Removes the `onEnter` callback in `onStop` and forgets every scene, the bundles the mounted
-* one named and the hold on its feature. Nothing is unmounted and nothing is released: a teardown
-* context may not call another plugin, and `world.onStop` clears every entity and its scope anyway.
+* Removes the `onEnter` callback in `onStop` and forgets every scene and the bundles the mounted
+* one named. Nothing is unmounted: a
+* teardown context may not call another plugin, and `world.onStop` clears every entity anyway.
 *
 * @param teardown - What the teardown context carries.
 * @param teardown.state - The plugin state.
@@ -35973,8 +35926,6 @@ function stopScenes(teardown) {
 	state.teardown?.();
 	state.teardown = void 0;
 	state.scenes.clear();
-	state.owners.clear();
-	state.held = void 0;
 	state.current = void 0;
 	state.pending = void 0;
 	state.named = [];
@@ -35991,15 +35942,6 @@ function emptyRegistry$1() {
 	return /* @__PURE__ */ new Map();
 }
 /**
-* Creates the table of which feature declared which scene, for the same reason as
-* `emptyRegistry`.
-*
-* @returns An empty table of scene id to feature name.
-*/
-function emptyOwners$1() {
-	return /* @__PURE__ */ new Map();
-}
-/**
 * Creates the one owner every mount of this plugin carries. One is enough: a single scene is
 * mounted at a time and `unmount` is what flushes.
 *
@@ -36012,8 +35954,8 @@ function sceneOwner() {
 	};
 }
 /**
-* Creates the initial scenes state: nothing declared, nothing mounted, nothing pending, nothing
-* held. The registry and its owners are filled in `onStart` from the feature descriptions.
+* Creates the initial scenes state: nothing declared, nothing mounted, nothing pending. The
+* registry is filled in `onStart` from the feature descriptions.
 *
 * @returns A fresh state, owned by one app.
 */
@@ -36024,9 +35966,7 @@ function createScenesState() {
 		pending: void 0,
 		named: [],
 		owner: sceneOwner(),
-		teardown: void 0,
-		owners: emptyOwners$1(),
-		held: void 0
+		teardown: void 0
 	};
 }
 //#endregion
@@ -42258,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.
@@ -42275,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);
 		}
@@ -42602,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.
@@ -42610,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);
 }
 /**
@@ -53470,16 +53431,6 @@ function entitySet(entities) {
 	return new Set(entities);
 }
 /**
-* Takes the hold of the feature a root shows, when the root belongs to a feature.
-*
-* @param ctx - Domain context of the ui plugin.
-* @param feature - The feature of the root's component or projection, if any.
-* @returns The release, or `undefined` for a root of no feature.
-*/
-function holdFor(ctx, feature) {
-	return feature === void 0 ? void 0 : ctx.deps.world.ecs.hold(feature);
-}
-/**
 * Builds the reconcile half of the jsx module: the two systems of the frame and the root
 * bookkeeping around them.
 *
@@ -54084,7 +54035,6 @@ function createReconciler(ctx, modules, fields) {
 			if (root === void 0) continue;
 			if (root.element !== void 0 && state.elements.has(root.element)) continue;
 			state.removing.delete(entity);
-			root.held?.();
 			state.roots.delete(entity);
 			state.byKey.delete(entity);
 			ecs.despawn(entity);
@@ -54502,21 +54452,15 @@ function createReconciler(ctx, modules, fields) {
 		if (element?.live === true && root.slot === void 0) ecs.set(element.entity, Order, { value: order });
 	}
 	/**
-	* Reconciles one dirty root: reads its current tree and projection name, then diffs it. A
-	* projection root takes the hold of its projection's feature here, at the first reconcile that
-	* names its projection: its `Tree` hook fires inside the spawn, before the world knows the view.
-	* The root stays dirty while the layout engine is not loaded, and a failure is logged for this
-	* root only.
+	* Reconciles one dirty root: reads its current tree and projection name, then diffs it. The root
+	* stays dirty while the layout engine is not loaded, and a failure is logged for this root only.
 	*
 	* @param root - A root with work this frame.
 	*/
 	function reconcileDirtyRoot(root) {
 		const tree = ecs.get(root.entity, Tree);
 		const place = ctx.deps.world.projection.keyOf(root.entity);
-		if (place !== void 0) {
-			root.name = place.projection;
-			if (root.popup === void 0) root.held ??= holdFor(ctx, state.featureOfProjection.get(place.projection));
-		}
+		if (place !== void 0) root.name = place.projection;
 		if (tree !== void 0) root.tree = tree.node;
 		refreshRootOrder(root);
 		root.dirty = !modules.layout.loaded();
@@ -54593,10 +54537,7 @@ function createReconciler(ctx, modules, fields) {
 	/**
 	* Records a root: a projection view that returned a tree, or a popup this plugin spawned. The
 	* `Tree` hook and the popup handler both call it, in either order, so a second call fills in
-	* what the first one could not know. A new popup root holds its component's feature; a root
-	* first recorded by the `Tree` hook takes that hold when the popup handler names the component,
-	* and a reclaimed root keeps the hold it has. A projection root takes its projection's hold at
-	* its first reconcile.
+	* what the first one could not know.
 	*
 	* @param entity - The entity that carries `Tree`.
 	* @param name - The projection name, or the component name of a popup.
@@ -54612,7 +54553,6 @@ function createReconciler(ctx, modules, fields) {
 				known.popup = popup;
 				known.name = name;
 				known.cause = "change";
-				known.held ??= holdFor(ctx, state.featureOfComponent.get(name));
 			}
 			return;
 		}
@@ -54636,8 +54576,7 @@ function createReconciler(ctx, modules, fields) {
 			cause: popup === void 0 ? void 0 : "change",
 			slot: void 0,
 			slotRect: void 0,
-			pending: false,
-			held: popup === void 0 ? void 0 : holdFor(ctx, state.featureOfComponent.get(name))
+			pending: false
 		});
 	}
 	/**
@@ -56872,45 +56811,14 @@ function isComponent(entry) {
 	return typeof entry === "function" && entry.isUiComponent === true;
 }
 /**
-* The name of a projection a feature lists, read without trusting the entry.
-*
-* @param entry - What the feature put under its `projections` key.
-* @returns The name, or `undefined` when the entry carries none.
-* @example
-* ```ts
-* projectionName({ name: "shop.sheet", layer: "ui" }); // "shop.sheet"
-* ```
-*/
-function projectionName(entry) {
-	if (typeof entry !== "object" || entry === null) return void 0;
-	const name = entry.name;
-	return typeof name === "string" ? name : void 0;
-}
-/**
-* Fills the component registry from the `ui` key of every feature, in feature order, and records
-* which feature each component and each projection belongs to: a root holds that feature while it
-* is shown, so the feature's systems run with `systemsRun: "active"`. Two tables, because a
-* component and a projection may share a name.
+* Fills the component registry from the `ui` key of every feature, in feature order.
 *
 * @param ctx - Domain context of the ui plugin.
 * @param jsx - The jsx module, which owns the registry.
 * @throws {Error} When two features define the same component name.
 */
 function registerComponents(ctx, jsx) {
-	const { featureOfComponent, featureOfProjection } = ctx.state.jsx;
-	for (const feature of ctx.deps.flow.features.all()) {
-		for (const entry of feature.description.ui ?? []) {
-			if (!isComponent(entry)) continue;
-			jsx.register(entry);
-			featureOfComponent.set(entry.name, feature.name);
-		}
-		const projections = feature.description.projections;
-		if (!Array.isArray(projections)) continue;
-		for (const entry of projections) {
-			const name = projectionName(entry);
-			if (name !== void 0) featureOfProjection.set(name, feature.name);
-		}
-	}
+	for (const feature of ctx.deps.flow.features.all()) for (const entry of feature.description.ui ?? []) if (isComponent(entry)) jsx.register(entry);
 }
 /**
 * Opens the two systems of phase `layout`, the seven world hooks of `Tree`, `Box`, `Pressed` and
@@ -56990,8 +56898,6 @@ function stopUi(state) {
 	state.layout.scrolling = void 0;
 	state.layout.iconLine = void 0;
 	state.jsx.components.clear();
-	state.jsx.featureOfComponent.clear();
-	state.jsx.featureOfProjection.clear();
 	state.jsx.roots.clear();
 	state.jsx.elements.clear();
 	state.jsx.byIdentity.clear();
@@ -57387,9 +57293,7 @@ function createJsxState() {
 		written: 0,
 		debugTaps: [],
 		debugWarned: false,
-		overlays: emptySet(),
-		featureOfComponent: emptyMap$1(),
-		featureOfProjection: emptyMap$1()
+		overlays: emptySet()
 	};
 }
 //#endregion
@@ -58135,18 +58039,6 @@ function assertFeatures(name, children) {
 	for (const [index, child] of children.entries()) if (typeof child?.logicOnly !== "object" || !Array.isArray(child.features)) throw notAFeature(`Feature "${name}"`, `features[${index}]`);
 }
 /**
-* Throws for a `systemsRun` outside its type. The type already says so; a game in JavaScript, or
-* a factory that passes a string through, is caught here, before the world reads it.
-*
-* @param name - The feature that declares it.
-* @param value - What the description holds under `systemsRun`.
-* @throws {Error} When the value is present and neither `"always"` nor `"active"`.
-*/
-function assertSystemsRun(name, value) {
-	if (value === void 0 || value === "always" || value === "active") return;
-	throw new Error(`[game] Feature "${name}" has systemsRun "${String(value)}".\n  Use "always" (the default) or "active".`);
-}
-/**
 * Builds the plugin of one feature: it depends on `flow`, checks in `onInit` that the app composes
 * every declared sub-feature, then registers its description, before any plugin above reads the
 * registry in `onStart`.
@@ -58185,14 +58077,12 @@ function featurePluginOf(name, description, children) {
 * same plugin built from the V1 keys of the description, for headless tests. A feature that
 * declares `features` is a parent: its `onInit` throws when one of them is not composed. The
 * plugin carries them in `features`, its `logicOnly` carries their `logicOnly`.
-* `systemsRun: "active"` runs the feature's systems only while it is active (see `SystemsRun`).
 *
 * @param name - Feature name. Shares the namespace with plugin names.
 * @param description - What the feature brings: nodes, flows, slot contributions, sub-features.
 * @returns The feature plugin, with its `logicOnly` twin.
-* @throws {Error} When the name is reserved or belongs to an engine plugin, for an entry of
-*   `features` that `defineFeature` did not make, and for a `systemsRun` that is neither
-*   `"always"` nor `"active"`.
+* @throws {Error} When the name is reserved or belongs to an engine plugin, and for an entry of
+*   `features` that `defineFeature` did not make.
 * @example
 * ```ts
 * // The reward popup is a feature: the main flow only declares slot("afterOrder").
@@ -58207,7 +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.`);
-	assertSystemsRun(name, description.systemsRun);
+	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)) });
@@ -58217,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.
 *