@moku-labs/game 0.15.2 → 0.15.3

package/dist/{src-Ca8W8Dvv.mjs → src-xChMXzwH.mjs}

@@ -8546,6 +8546,294 @@ 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";
@@ -8636,14 +8924,17 @@ function frameSnapshot(ctx, time) {
 }
 /**
 * 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.
+* 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.
 *
 * @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.
 */
-function registerSystem(ctx, definition) {
+function registerSystem(ctx, definition, scope = -1) {
 	const state = ctx.state.ecs;
 	for (const phase of [
 		"input",
@@ -8656,10 +8947,13 @@ function registerSystem(ctx, definition) {
 		definition,
 		frame: ctx.deps.time.snapshot().frame,
 		plan,
+		scope,
+		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);
@@ -8682,7 +8976,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 +9002,42 @@ 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.
+*
+* @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 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) {
+		entry.skipped = true;
+		return false;
+	}
+	context.resumed = entry.skipped;
+	entry.skipped = false;
+	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.
@@ -8726,7 +9057,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. 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.
 *
 * @param ctx - Domain context of the world plugin.
 * @param world - The ecs API a system's `run` receives.
@@ -8736,21 +9069,26 @@ 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);
 	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) guardedRun(ctx, entry, context, phase);
+		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);
 	}
 	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.
@@ -8761,20 +9099,25 @@ function runPhase(ctx, world, phase, time) {
 */
 function runTimed(ctx, timing, entries, context, phase, time) {
 	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);
 		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 and the frame
-* history. The state object keeps its identity, so every view on it stays valid.
+* 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.
 *
 * @param ctx - Domain context of the world plugin.
 */
@@ -8805,6 +9148,7 @@ 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
@@ -8817,6 +9161,8 @@ 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, {
@@ -8920,6 +9266,15 @@ function createEcsApi(ctx) {
 		},
 		clear: () => {
 			clearWorldState(ctx);
+		},
+		viewCame: (projection) => {
+			viewCame(state.scope, projection);
+		},
+		viewLeft: (projection) => {
+			viewLeft(state.scope, projection);
+		},
+		viewsCleared: () => {
+			viewsCleared(state.scope);
 		}
 	};
 	return api;
@@ -9033,21 +9388,29 @@ 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. 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.
 *
 * @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()) {
+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);
 		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));
+		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);
 	}
 }
 /**
-* Connects the world in `onStart`: it reads every feature description, registers the five frame
+* Connects the world in `onStart`: it sizes the scope to the features, 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
@@ -9068,7 +9431,8 @@ function connectWorld(ctx) {
 		const clock = time.agentClock();
 		if (clock !== void 0) startTiming(worldCtx.state.ecs, clock);
 	}
-	registerFeatures(worldCtx, ecs, projection);
+	openScope(worldCtx);
+	registerFeatures(worldCtx, 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();
@@ -9086,7 +9450,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, the scope 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 +9502,7 @@ function clearWorld(state) {
 	state.ecs.mode = "live";
 	state.ecs.timing = void 0;
 	state.ecs.timingSlots.clear();
+	resetScope(state.ecs.scope);
 	resetHistory(state.ecs);
 }
 //#endregion
@@ -10049,7 +10415,7 @@ function despawnView(pctx, mounted, view) {
 	view.handles = [];
 	cancelTracks(pctx, view.entity);
 	const state = pctx.ctx.state.projection;
-	state.byEntity.delete(view.entity);
+	if (state.byEntity.delete(view.entity)) pctx.deps.views.left(view.projection);
 	state.mutes.delete(view.entity);
 	state.rests.delete(view.entity);
 	state.leaving.set(view.entity, view.cause);
@@ -10425,6 +10791,7 @@ 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;
@@ -11237,6 +11604,7 @@ 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();
@@ -11276,7 +11644,12 @@ function createModules$2(ctx) {
 		ecs,
 		projection: createProjectionApi(ctx, {
 			ecs,
-			components: WORLD_COMPONENTS
+			components: WORLD_COMPONENTS,
+			views: {
+				came: ecs.viewCame,
+				left: ecs.viewLeft,
+				cleared: ecs.viewsCleared
+			}
 		})
 	};
 }
@@ -11311,6 +11684,8 @@ 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,
@@ -11432,6 +11807,29 @@ 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.
+*
+* @returns An empty scope.
+*/
+function emptyScope() {
+	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
+	};
+}
+/**
 * 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 +11871,8 @@ function createEcsState() {
 		walkReported: false,
 		queryPlans: emptyMap$10(),
 		walkLists: [],
-		despawns: 0
+		despawns: 0,
+		scope: emptyScope()
 	};
 }
 //#endregion
@@ -11585,7 +11984,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 +12144,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 +12155,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 +12177,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 +12193,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 +12271,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 +12293,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 +12308,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 +12438,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 +12489,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 +12507,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 +12533,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 +12649,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,
@@ -12617,9 +13040,60 @@ const PROGRAM_NAME = "sdf-shader-single-alpha";
 * ```
 */
 function scaleOf$1(linear) {
-	return (Math.hypot(linear.a, linear.b) + Math.hypot(linear.c, linear.d)) / 2;
+	const { a, b, c, d } = linear;
+	return (Math.sqrt(a * a + b * b) + Math.sqrt(c * c + d * d)) / 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.
+*
+* @param this - The text's uniforms.
+* @returns The distance in device pixels.
+*/
+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
+};
+/**
 * 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.
 *
@@ -12639,6 +13113,9 @@ function scaleOf$1(linear) {
 * 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.
 * @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.
@@ -12669,21 +13146,22 @@ function createLocalUniforms(pixi, density, writing) {
 			type: "f32"
 		}
 	});
-	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 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;
 }
 /**
@@ -14018,8 +14496,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 +14735,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 +15145,8 @@ function createKeptState(config) {
 		warnedBudget: false,
 		verifySkipped: 0,
 		bypassed: false,
-		flushPasses: 0
+		flushPasses: 0,
+		calm: false
 	};
 }
 /**
@@ -14798,11 +15282,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 +15319,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 +15612,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 +15728,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 +16026,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 +16144,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 +16354,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 +16407,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 +16419,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 +16490,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 +16504,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 +16889,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 +18721,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 +21469,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 +21490,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 +22055,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 +22205,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 +22215,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 +22227,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 +22271,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 +22284,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 +22377,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 +25658,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 +26414,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 +26637,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();
@@ -27796,8 +28401,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 +28413,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 +28813,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 +28959,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) => {
@@ -28861,7 +29474,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 +31608,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 +31624,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 +31644,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 +31934,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;
@@ -35123,9 +35770,24 @@ 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, 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 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.
 *
 * @param ctx - Domain context of the plugin.
 * @param scene - The scene whose bundles are there.
@@ -35140,6 +35802,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);
 	state.named = named;
 	ctx.deps.assets.sceneBundles(named);
 	ctx.deps.time.wake();
@@ -35253,22 +35916,16 @@ function withDeps$5(ctx) {
 	};
 }
 /**
-* 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.
+* 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.
 *
 * @param ctx - Domain context of the plugin.
 * @throws {Error} When two features declare the same scene id.
 */
 function readScenes(ctx) {
-	const owners = emptyOwners$1();
+	const owners = ctx.state.owners;
 	for (const feature of ctx.deps.flow.features.all()) {
 		const list = feature.description.scenes;
 		if (!Array.isArray(list)) continue;
@@ -35299,9 +35956,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 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.
+* 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.
 *
 * @param teardown - What the teardown context carries.
 * @param teardown.state - The plugin state.
@@ -35316,6 +35973,8 @@ 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 = [];
@@ -35332,6 +35991,15 @@ 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.
 *
@@ -35344,8 +36012,8 @@ function sceneOwner() {
 	};
 }
 /**
-* Creates the initial scenes state: nothing declared, nothing mounted, nothing pending. The
-* registry is filled in `onStart` from the feature descriptions.
+* 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.
 *
 * @returns A fresh state, owned by one app.
 */
@@ -35356,7 +36024,9 @@ function createScenesState() {
 		pending: void 0,
 		named: [],
 		owner: sceneOwner(),
-		teardown: void 0
+		teardown: void 0,
+		owners: emptyOwners$1(),
+		held: void 0
 	};
 }
 //#endregion
@@ -52800,6 +53470,16 @@ 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.
 *
@@ -53404,6 +54084,7 @@ 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);
@@ -53821,15 +54502,21 @@ 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. 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. 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.
 	*
 	* @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 (place !== void 0) {
+			root.name = place.projection;
+			if (root.popup === void 0) root.held ??= holdFor(ctx, state.featureOfProjection.get(place.projection));
+		}
 		if (tree !== void 0) root.tree = tree.node;
 		refreshRootOrder(root);
 		root.dirty = !modules.layout.loaded();
@@ -53906,7 +54593,10 @@ 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.
+	* 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.
 	*
 	* @param entity - The entity that carries `Tree`.
 	* @param name - The projection name, or the component name of a popup.
@@ -53922,6 +54612,7 @@ function createReconciler(ctx, modules, fields) {
 				known.popup = popup;
 				known.name = name;
 				known.cause = "change";
+				known.held ??= holdFor(ctx, state.featureOfComponent.get(name));
 			}
 			return;
 		}
@@ -53945,7 +54636,8 @@ function createReconciler(ctx, modules, fields) {
 			cause: popup === void 0 ? void 0 : "change",
 			slot: void 0,
 			slotRect: void 0,
-			pending: false
+			pending: false,
+			held: popup === void 0 ? void 0 : holdFor(ctx, state.featureOfComponent.get(name))
 		});
 	}
 	/**
@@ -56180,14 +56872,45 @@ function isComponent(entry) {
 	return typeof entry === "function" && entry.isUiComponent === true;
 }
 /**
-* Fills the component registry from the `ui` key of every feature, in feature order.
+* 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.
 *
 * @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) {
-	for (const feature of ctx.deps.flow.features.all()) for (const entry of feature.description.ui ?? []) if (isComponent(entry)) jsx.register(entry);
+	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);
+		}
+	}
 }
 /**
 * Opens the two systems of phase `layout`, the seven world hooks of `Tree`, `Box`, `Pressed` and
@@ -56267,6 +56990,8 @@ 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();
@@ -56662,7 +57387,9 @@ function createJsxState() {
 		written: 0,
 		debugTaps: [],
 		debugWarned: false,
-		overlays: emptySet()
+		overlays: emptySet(),
+		featureOfComponent: emptyMap$1(),
+		featureOfProjection: emptyMap$1()
 	};
 }
 //#endregion
@@ -57408,6 +58135,18 @@ 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`.
@@ -57446,12 +58185,14 @@ 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, and for an entry of
-*   `features` that `defineFeature` did not make.
+* @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"`.
 * @example
 * ```ts
 * // The reward popup is a feature: the main flow only declares slot("afterOrder").
@@ -57466,6 +58207,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);
 	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)) });
@@ -57947,6 +58689,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 +59059,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 };