@moku-labs/game 0.15.1 → 0.15.3

package/dist/{types-E2ykwIUO.d.mts → types-DlC3Ytbj.d.mts}

@@ -3365,12 +3365,31 @@ type FeatureTextStyles = {
   readonly kind: "textStyles";
   readonly map: Record<string, object>;
 };
+/**
+ * When the systems of a feature run. `"always"` (the default): every frame, as before. `"active"`: only while the
+ * feature is active — a node of it is on the flow stack, a scene it declares is mounted, a view of a projection it
+ * registered exists, or `ui` holds a popup or a JSX root of it — leaving included, until the last view is gone.
+ * Skipping changes nothing the flow sees: systems never write the model. The systems the engine's plugins
+ * register always run.
+ *
+ * @example
+ * ```ts
+ * // features/board/index.ts: the board's four systems stop on the ward and on the splash.
+ * export const boardFeature = defineFeature("board", {
+ *   flows: [mergeBoard],
+ *   systems: [looks, fade, leaving, veil],
+ *   systemsRun: "active"
+ * });
+ * ```
+ */
+type SystemsRun = "always" | "active";
 /**
  * What a feature brings to the game. The logic keys are typed here; the keys of later milestones
  * pass through the index signature until their plugin types them. `flow` stores them untouched,
  * and `logicOnly` drops them. The V2 screen plugins read five of them through the index signature:
  * `projections`, `systems` and `components` (`world`), `scenes` (`scenes`, `assets`, and the
- * scene-id check of `flow`) and `assets` (`assets`). The V3 interface keys are typed below.
+ * scene-id check of `flow`) and `assets` (`assets`). `world` also reads the typed `systemsRun`.
+ * The V3 interface keys are typed below.
  *
  * @example
  * ```ts
@@ -3400,7 +3419,8 @@ type FeatureDescription = {
   strings?: Record<string, CompiledMessagesLike | (() => Promise<unknown>)>; /** Text styles the feature owns, read by `text`. */
   textStyles?: FeatureTextStyles; /** Particle emitters the feature owns, read by `effects`. */
   emitters?: readonly FeatureEmitter[]; /** Filters the feature puts on its interface components, read by `effects`. */
-  filters?: readonly FeatureFilter[];
+  filters?: readonly FeatureFilter[]; /** When the feature's systems run, read by `world`. Absent is `"always"`. */
+  systemsRun?: SystemsRun;
   [later: string]: unknown;
 };
 /**
@@ -3600,7 +3620,7 @@ declare function to<const TargetName extends string, Payload, Output>(target: Ta
  */
 declare function slot(name: string): SlotNode;
 declare namespace types_d_exports$4 {
-  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$4 as Config, Contribution, DefineNode, Deps$4 as Deps, Descriptor, Edges, Effect, EffectHandler, EffectOptions, EmitterIdOf, EnterCallback, Events$4 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeatureTree, FeaturesApi, FlowCtx, FlowDefinition, FlowEntry, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, HudKeysOf, InboxApi, JournalEntry, KernelSlice$4 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, NodeTable, OutcomeTags, Position, RecoverContext, RegisteredFeature, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$4 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
+  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$4 as Config, Contribution, DefineNode, Deps$4 as Deps, Descriptor, Edges, Effect, EffectHandler, EffectOptions, EmitterIdOf, EnterCallback, Events$4 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeatureTree, FeaturesApi, FlowCtx, FlowDefinition, FlowEntry, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, HudKeysOf, InboxApi, JournalEntry, KernelSlice$4 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, NodeTable, OutcomeTags, Position, RecoverContext, RegisteredFeature, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$4 as State, StringTableLike, SystemsRun, Target, TextStylesOf, TypeTag, WorldEvent };
 }
 /**
  * flow plugin events.
@@ -4275,7 +4295,8 @@ type Cause = "edge" | "rollback" | "restore" | "load" | "mount" | "rerun";
 type View$1 = {
   entity: Entity;
   projection: string;
-  key: string;
+  key: string; /** `{ projection, key }`, made once with the view: what `keyOf` answers, every call the same object. */
+  readonly address: ProjectionKey;
   item: unknown; /** The last output of `view(item)`, by component name: what the picture equals at rest. */
   rest: Map<string, AnyComponentValue>;
   handles: MotionHandle[];
@@ -4363,6 +4384,13 @@ type Dirty = {
   roots: Set<Root>;
   force: boolean;
 };
+/**
+ * A mute's fields joined with a type's owned fields, and the owned set they were joined with.
+ */
+type JoinedFields = {
+  readonly owned: ReadonlySet<string>;
+  readonly joined: ReadonlySet<string>;
+};
 /**
  * projection module state.
  */
@@ -4386,10 +4414,28 @@ type ProjectionState = {
    * entity that is gone is dropped with its rest pose, and its side of `keys` with it.
    */
   keysByEntity: Map<Entity, ProjectionKey>; /** Entity to component name to the fields another writer owns. */
-  mutes: Map<Entity, Map<string, Set<string>>>; /** The `onConverged` listeners: the owners of elements, told after a restore or a load. */
+  mutes: Map<Entity, Map<string, Set<string>>>; /** The owned fields of each component type as a set, by the type's frozen `owned` list: made once. */
+  ownedSets: WeakMap<readonly string[], ReadonlySet<string>>; /** The muted and the owned fields joined, by the mute's field set: dropped when `mute()` or its release changes it. */
+  joinedMutes: WeakMap<ReadonlySet<string>, JoinedFields>; /** The `onConverged` listeners: the owners of elements, told after a restore or a load. */
   converged: Array<() => void>;
   offHints: Array<() => void>; /** The cause of every view despawned since the last sweep, so a removal hook can still ask. */
   leaving: Map<Entity, MotionCause>;
+  /**
+   * Moves on every time a view enters `live`, leaves it, or leaves `leaving`, and on a clear:
+   * `ui` hosts the views of a projection again only when it moved (`projection.membershipVersion()`).
+   */
+  membershipVersion: number;
+  /**
+   * A live view may hold a running handle: set by every view handle made, cleared by a sweep that
+   * walked the live views and found none moving. While it is false the sweep walks no live view.
+   */
+  moving: boolean; /** Views were marked as owing their loop since the last start of the owed loops. */
+  owedLoops: number;
+  /**
+   * The despawn count of the ecs when the sweep last looked for dead elements; -1 after a new
+   * key, so the next sweep looks.
+   */
+  sweptDespawns: number;
 };
 /**
  * projection module API, `app.world.projection`: the bridge from the model to entities.
@@ -4543,7 +4589,8 @@ type ProjectionApi = {
   lift(entity: Entity, on: boolean): void;
   /**
    * The projection and key of an entity. Also answers for a view in the despawn queue and for an
-   * element registered with `registerKey`.
+   * element registered with `registerKey`. A view answers the address it keeps for its life, the
+   * same frozen object every call, so asking every frame allocates nothing.
    *
    * @param entity - The entity to ask about.
    * @returns The projection name and the key, or `undefined`.
@@ -4551,10 +4598,27 @@ type ProjectionApi = {
    * ```ts
    * // `renderer.sync` labels its display objects for the inspector.
    * app.world.projection.keyOf(1_048_576); // { projection: "board.items", key: "i7" }
+   * app.world.projection.keyOf(1_048_576) === app.world.projection.keyOf(1_048_576); // true
    * app.world.projection.keyOf(42); // undefined: not a view
    * ```
    */
   keyOf(entity: Entity): ProjectionKey | undefined;
+  /**
+   * A number that moves every time a view enters the live views of a mounted projection, leaves
+   * them (an exit or a despawn), or is forgotten after its despawn, and when the projections are
+   * cleared. An equal number means the same views live as at the last read, so a plugin that
+   * works on the live views (`ui` hosting them in an element) skips its step while it holds.
+   * Reading it allocates nothing.
+   *
+   * @returns The version; 0 for a world where no view ever came or went.
+   * @example
+   * ```ts
+   * // ui, at the start of its hosting step: nothing to do while no view came or went.
+   * const version = ctx.require(worldPlugin).projection.membershipVersion(); // 7, as on the last frame
+   * if (version === state.hostedMembership) return;
+   * ```
+   */
+  membershipVersion(): number;
   /**
    * How the view of an entity came, or how it is leaving: `"mount"` when a direct reconcile or an unmount moved it,
    * `"change"` when a live commit did. A despawned view still answers until the next sweep, so a hook on its removal
@@ -4799,6 +4863,81 @@ type QueryPlan = {
   readonly names: readonly string[];
   readonly written: readonly string[];
 };
+/**
+ * The walk of one system's declared query, made once when the system registers and reset by the
+ * runner before every run. It allocates nothing per run: the entity list and the store list are
+ * kept and overwritten by index, and every row it yields is the same array, written in place.
+ * A row is valid until the next row; a system that keeps one copies it.
+ */
+declare class SystemWalk implements Iterator<readonly unknown[], undefined> {
+  private readonly ctx;
+  /** The step handed back for every row: always the one row array. */
+  private readonly step;
+  /** The one row: the entity, then one stored value per name, sized at registration. */
+  private readonly row;
+  /** The component names of the terms, in order. */
+  private readonly names;
+  /** The names of the `mut()` terms, marked for every yielded row. */
+  private readonly written;
+  /** The store of each name, read once per run at the first step; `undefined` for a name no entity carried yet. */
+  private readonly stores;
+  /** The matching entities of this run, from index 0 to `count`; kept and overwritten by index. */
+  private readonly entities;
+  /** How many entities this run collected. */
+  private count;
+  /** The next entity to visit. */
+  private index;
+  /** Whether this run took its entities yet. */
+  private started;
+  /** The first store's size at the first step: a dev build compares it; -1 when not watched. */
+  private size;
+  /**
+   * Prepares the walk of one system.
+   *
+   * @param ctx - Domain context of the world plugin.
+   * @param plan - The system's resolved query.
+   */
+  constructor(ctx: WorldCtx, plan: QueryPlan);
+  /**
+   * The walk is its own iterator, so the runner hands it to `run` as the rows. A second loop over
+   * it in the same run finds it walked.
+   *
+   * @returns This walk.
+   */
+  [Symbol.iterator](): SystemWalk;
+  /**
+   * Starts a new run: nothing is read before the first step.
+   *
+   * @returns This walk, the rows of the run.
+   */
+  reset(): SystemWalk;
+  /**
+   * Keeps one key of the first store when the entity carries every other name.
+   *
+   * @param entity - The key.
+   */
+  keep(entity: Entity): void;
+  /**
+   * Hands out the next row: the next collected entity, its values written into the one row, and
+   * marked for every `mut()` name.
+   *
+   * @returns The step of the row, or the end.
+   */
+  next(): IteratorResult<readonly unknown[], undefined>;
+  /**
+   * Reads the stores of this run and collects the entities that carry every name, in the first
+   * store's order. Structural changes are queued until the phase ends, so the matches stay true
+   * while the rows are consumed.
+   */
+  private start;
+  /**
+   * Writes the row of one entity in place: the entity, then the value of every name.
+   *
+   * @param entity - The entity.
+   * @returns False when the entity no longer carries a name, and the row is not handed out.
+   */
+  private fill;
+}
 //#endregion
 //#region src/plugins/world/ecs/types.d.ts
 /**
@@ -5087,6 +5226,7 @@ type QueryTuple<Terms extends readonly QueryTerm[]> = [Entity, ...QueryValues<Te
  * const run = (entities: Iterable<[Entity]>, ctx: SystemContext): void => {
  *   ctx.res(Pointer).x = 0;
  *   ctx.time.delta; // 16
+ *   ctx.resumed; // false: the system ran in the frame before
  * };
  * ```
  */
@@ -5095,6 +5235,13 @@ type SystemContext = {
   res<Value extends object>(resource: ResourceType<Value>): Value;
   readonly snapshot: Snapshot;
   readonly time: Readonly<Time>;
+  /**
+   * True on the first run after one or more runs of this system were skipped because its feature was not active
+   * (`systemsRun: "active"`). Nothing was kept for it while it slept: `world.changed()` holds this frame's changes
+   * only, so a system that caches what it drew rebuilds from the components when this is true. Always false for a
+   * system that always runs. Read it during the run.
+   */
+  readonly resumed: boolean;
 };
 /**
  * A system definition, typed over its query tuple.
@@ -5115,6 +5262,12 @@ type SystemDefinition<Terms extends readonly QueryTerm[]> = {
   readonly name: string;
   readonly phase: WorldPhase;
   readonly query: Terms;
+  /**
+   * Runs the system once a frame in its phase. `entities` walks the declared `query` once; every
+   * row it hands out is the same array, rewritten for the next row, so a row is valid until the
+   * next row. A system that keeps a row copies what it keeps: `const [entity, transform] = row`.
+   * `ecs.query()` called inside `run` hands out a new array per row.
+   */
   run(entities: Iterable<QueryTuple<Terms>>, ctx: SystemContext): void;
 };
 /**
@@ -5168,23 +5321,52 @@ type SystemFor<Player, Session> = <const Terms extends readonly QueryTerm[]>(def
 type AnySystem = {
   readonly name: string;
   readonly phase: WorldPhase;
-  readonly query: readonly QueryTerm[];
+  readonly query: readonly QueryTerm[]; /** As `SystemDefinition.run`: one row array per walk, valid until the next row. */
   run(entities: Iterable<readonly unknown[]>, ctx: SystemContext): void;
 };
 /**
- * One registered system, the frame it was registered in and its query resolved once. A system
- * registered during a frame runs from the next frame on. Spec 28 (deferred) extends it with the
- * system's scope.
- *
- * @example
- * ```ts
- * const entry: SystemEntry = { definition: bobSystem, frame: 12, plan: { names: ["Transform"], written: ["Transform"] } };
- * ```
+ * One registered system, the frame it was registered in, its query resolved once, the walk the
+ * runner resets for every run and its scope. A system registered during a frame runs from the
+ * next frame on. Module state: no game reads it.
  */
 type SystemEntry = {
   readonly definition: AnySystem;
   readonly frame: number;
   readonly plan: QueryPlan;
+  /**
+   * The index of its feature in `ScopeState` for a system of a feature with `systemsRun: "active"`, -1 for a
+   * system that always runs.
+   */
+  readonly scope: number; /** The system's last chance to run was skipped because its feature was not active. */
+  skipped: boolean;
+  /**
+   * The walk of the declared query, made at registration; `undefined` for an empty query, which
+   * the runner never walks. An entry built without one gets it on its first run.
+   */
+  walk?: SystemWalk | undefined;
+};
+/**
+ * Which features are active, kept so a phase reads one byte per scoped system. Indexed by the feature's position in
+ * `flow.features.all()`. Filled in `onStart`, sized once; nothing in it grows per frame.
+ */
+type ScopeState = {
+  /** Feature names by index, registration order. */names: string[]; /** Feature name to index. */
+  index: Map<string, number>; /** Projection name to the index of the feature that registered it (rule V). */
+  projections: Map<string, number>; /** Flow id to node name to the owner's index (rule N); built from one `describe()` when first needed. */
+  owners: Map<string, Map<string, number>> | undefined; /** `describe()` threw: every feature counts as on the stack while the stack is not empty (fail-safe). */
+  ownersFailed: boolean; /** The `flow.state()` object the stack flags were read from. */
+  flow: FlowState | undefined; /** 1 while a frame of the stack addresses a node the feature owns. */
+  onStack: Uint8Array; /** The holds `scenes` and `ui` keep on the feature. */
+  holds: Int32Array; /** The live and leaving views of the projections the feature registered. */
+  views: Int32Array; /** 1 while the feature is active, as of the last evaluation. */
+  active: Uint8Array; /** A hold or a view count moved since the last evaluation. */
+  dirty: boolean; /** At least one registered system runs only while its feature is active. */
+  scoped: boolean;
+  /**
+   * Moves on at every start and every stop: a hold's release remembers the generation it was
+   * taken in, and a release from an older one changes nothing (spec 28 W7.1).
+   */
+  generation: number;
 };
 /**
  * A structural change queued while a phase runs. Applied in call order when the phase ends.
@@ -5223,17 +5405,24 @@ type Command = {
  */
 type StructuralHook = (entity: Entity, value: unknown) => void;
 /**
- * The frozen model snapshot of one frame, kept so four phases read it once.
- *
- * @example
- * ```ts
- * const cached: FrameSnapshot = { frame: 12, snapshot: { player: {}, session: {}, rng: rngState } };
- * ```
+ * The frozen model snapshot of one frame, kept so four phases read it once. One object per world,
+ * rewritten when a new frame reads its snapshot.
  */
 type FrameSnapshot = {
   frame: number;
   snapshot: Snapshot;
 };
+/**
+ * The context the runner hands every system of one world: one object, made at the first phase
+ * run, whose `time` and `snapshot` are rewritten for every phase.
+ */
+type PhaseContext = {
+  /** The ecs API the systems of this world receive. */readonly world: EcsApi; /** The resource reader, one function per world. */
+  readonly res: <Value extends object>(resource: ResourceType<Value>) => Value; /** The frozen model snapshot of the running frame. */
+  snapshot: Snapshot; /** The running frame's `Time`. */
+  time: Readonly<Time>; /** Written before every run: the system's runs before this one were skipped for its scope. */
+  resumed: boolean;
+};
 /**
  * The JSON kind of one component field, read from its default value: what the editor's component
  * palette shows next to the field name. A nested shape is not described; `defaults` carries it.
@@ -5380,6 +5569,24 @@ type MarkCount = {
   marked: number;
   changed: number;
 };
+/**
+ * The entities marked changed for one component in the current frame, each once, in mark order.
+ * Both collections are kept from frame to frame, so a frame's marks allocate nothing once they
+ * have grown to its size.
+ */
+type ChangeList = {
+  /** The marked entities of this frame, in mark order: what `changed()` hands out. */readonly entities: Entity[]; /** Entity to the frame stamp of its last mark; a stamp of the current frame is a repeat. */
+  readonly frames: Map<Entity, number>;
+};
+/**
+ * A plan `ecs.query()` remembers: the plan, and the type objects and `mut()` places it was made
+ * for, compared by identity at every call.
+ */
+type KnownPlan = {
+  readonly plan: QueryPlan;
+  readonly types: readonly AnyComponentType[];
+  readonly written: readonly boolean[];
+};
 /**
  * ecs module state.
  */
@@ -5389,8 +5596,10 @@ type EcsState = {
   owners: Map<Entity, Owner>; /** Key is `"kind:name"` of the owner. */
   byOwner: Map<string, Set<Entity>>;
   types: Map<string, AnyComponentType>;
-  stores: Map<string, Map<Entity, object | true>>;
-  resources: Map<string, object>;
+  stores: Map<string, Map<Entity, object | true>>; /** The store of each type object that was read, written or asked through, once it has one. */
+  typeStores: Map<AnyComponentType, Map<Entity, object | true>>;
+  resources: Map<string, object>; /** The value of each resource type object that was read, so a read is one lookup. */
+  resourceSlots: Map<ResourceType<object>, object>;
   /**
    * The type object stored under each engine resource name (`"Now"`, `"Pointer"`, …), so a game
    * resource of the same name is refused instead of sharing the engine's value.
@@ -5398,18 +5607,24 @@ type EcsState = {
   engineResources: Map<string, object>;
   systems: Record<WorldPhase, SystemEntry[]>;
   running: WorldPhase | undefined;
-  commands: Command[];
-  changed: Map<string, Set<Entity>>;
+  commands: Command[]; /** The change list of each component marked since the world began, emptied at every `signals`. */
+  changed: Map<string, ChangeList>; /** The stamp of the current frame's marks, moved on by every clear of the change lists. */
+  changeFrame: number;
   added: Map<string, StructuralHook[]>;
   removed: Map<string, StructuralHook[]>;
   ownerLeft: Array<(owner: Owner) => void>;
   mode: WorldMode;
   offFrame: Array<() => void>;
-  frameSnapshot: FrameSnapshot | undefined; /** The frame history: dev builds only, from the first frame on; `undefined` before it. */
+  frameSnapshot: FrameSnapshot | undefined; /** The context of every system run of this world; `undefined` before the first phase ran. */
+  phaseContext: PhaseContext | undefined; /** The frame history: dev builds only, from the first frame on; `undefined` before it. */
   history: History | undefined; /** Time per system of an agent build (H2b); `undefined` without the flag and before start. */
   timing: SystemTiming | undefined; /** The row of each timed system in `timing`, by name: a system that comes back keeps its row. */
   timingSlots: Map<string, number>; /** A dev build reported a store whose keys changed while a phase walked it: reported once. */
-  walkReported: boolean;
+  walkReported: boolean; /** The plans of `ecs.query()` by the type of their first term, made once per tuple of types. */
+  queryPlans: Map<AnyComponentType, KnownPlan[]>; /** The entity lists of ended `ecs.query()` walks, taken by the next walks: no key copy per call. */
+  walkLists: Entity[][]; /** How many entities were despawned since the world began: the sweep looks for dead elements when it moved. */
+  despawns: number; /** Which features are active, for the systems of the features with `systemsRun: "active"`. */
+  scope: ScopeState;
 };
 /**
  * ecs module API, `app.world.ecs`: the screen as data. Plain-object components in one store per
@@ -5441,6 +5656,40 @@ type EcsApi = {
    * ```
    */
   system(definition: AnySystem): () => void;
+  /**
+   * Keeps a feature active while something of it is shown that the world cannot see: `scenes` holds the feature that
+   * declares the mounted scene, `ui` the feature of each popup or JSX root it holds. Holds are counted; the returned
+   * release is idempotent. A name that is not a registered feature holds nothing (a dev warning
+   * `world:hold-unknown-feature`). Takes effect at the next phase that runs systems.
+   *
+   * @param feature - The feature to keep active.
+   * @returns The release.
+   * @example
+   * ```ts
+   * // scenes, as it mounts the scene "ward" that the feature "screens" declares:
+   * const release = ctx.require(worldPlugin).ecs.hold("screens");
+   * app.world.ecs.isActive("screens"); // true
+   * release(); // the next scene replaced the ward
+   * app.world.ecs.isActive("screens"); // false: no node, view or hold of "screens" is left
+   * ```
+   */
+  hold(feature: string): () => void;
+  /**
+   * Whether a feature is active now: a node of it is on the flow stack, a scene it declares is mounted, a view of a
+   * projection it registered exists (leaving included), or `ui` holds a popup or JSX root of it. Answers for any
+   * feature, whatever its `systemsRun`; the systems of a feature with `systemsRun: "active"` run exactly while this
+   * is true. False for a name that is not a feature.
+   *
+   * @param feature - The feature name.
+   * @returns True while it is active.
+   * @example
+   * ```ts
+   * // A test of the board: the graph rests at the board's awaitIntent and the shop sheet is closed.
+   * app.world.ecs.isActive("board"); // true: a node of the board is on the stack, its views are drawn
+   * app.world.ecs.isActive("shop"); // false: no view of the sheet, no node of the shop on the stack
+   * ```
+   */
+  isActive(feature: string): boolean;
   /**
    * Creates an entity. The id is reserved and returned at once, also inside a phase, where the
    * components are attached when the phase ends.
@@ -5590,8 +5839,10 @@ type EcsApi = {
    * Walks the store of the FIRST term in insertion order and keeps the entities that carry every
    * term. Deterministic. A `mut()` term marks every yielded entity changed for that component
    * (README, "Marking what changed"). Inside a system the walk reads the store live (changes are
-   * queued until the phase ends); outside one it walks the keys taken at the start. Every row is a
-   * new array: keep it if you like. Put the rarest component first: the walk visits its store.
+   * queued until the phase ends); outside one it walks the keys taken at the start. Every row of
+   * `ecs.query()` is a new array: keep it if you like. The rows a system's `run` gets for its
+   * declared `query` are not: they share one array, valid until the next row. Put the rarest
+   * component first: the walk visits its store.
    *
    * @param terms - Component types, tag types and `mut()` terms.
    * @returns The matching rows: the entity and one value per term.
@@ -5696,7 +5947,12 @@ type EcsApi = {
   onRemoved(tagType: TagType, fn: (entity: Entity) => void): () => void;
   /**
    * The coarse change set of the frame, cleared in `time` phase `signals` after every `sync`
-   * system ran.
+   * system ran. It is the world's own list, in mark order, each entity once: walk it in the frame
+   * and copy what you keep, because the clear empties it in place. A component nothing marked
+   * answers one shared empty list. Asking allocates nothing. Inside a system nothing leaves the
+   * list until the phase ends. Outside a phase a despawn, or a removal of the component, takes the
+   * entity out at once and the entities after it move up, so a loop that despawns or removes
+   * outside a phase walks a copy: `const copy = [...ecs.changed(C)]`.
    *
    * @param component - The component type to ask about.
    * @returns The entities marked changed for it this frame.
@@ -5874,6 +6130,22 @@ type EcsInternal = {
    * Drops every entity, component, resource, system and hook.
    */
   clear(): void;
+  /**
+   * Counts a new view of a projection for the feature that registered it (rule V of `systemsRun`).
+   *
+   * @param projection - The projection name.
+   */
+  viewCame(projection: string): void;
+  /**
+   * Takes back the count of a despawned view; never below 0.
+   *
+   * @param projection - The projection name.
+   */
+  viewLeft(projection: string): void;
+  /**
+   * Drops every view count: the projections were cleared.
+   */
+  viewsCleared(): void;
 };
 //#endregion
 //#region src/plugins/world/ecs/systems.d.ts
@@ -6058,6 +6330,52 @@ type ProjectionModule = ProjectionApi & ProjectionInternal;
  */
 declare const DEMAND_REASONS: readonly ["always", "first", "resize", "restore", "layers", "debug", "wake", "capture", "request", "mark", "verify", "none", "overlay", "retake"];
 //#endregion
+//#region src/plugins/renderer/demand/marks.d.ts
+/**
+ * The marks of one kind of the decision running now, in mark order, each entity once.
+ */
+declare class MarkList implements Marks {
+  /** Entities marked in this decision. */
+  size: number;
+  /** The marked entities: the first `size` of them; the rest is left from earlier decisions. */
+  private readonly entities;
+  /** The decision each entity was last marked in. */
+  private readonly stamps;
+  /** The number of this decision. */
+  private stamp;
+  /**
+   * Tells whether an entity is marked in this decision.
+   *
+   * @param entity - The entity.
+   * @returns True when it is.
+   */
+  has(entity: Entity): boolean;
+  /**
+   * The entity marked `index`-th in this decision.
+   *
+   * @param index - 0 to `size - 1`.
+   * @returns The entity; 0 past the end.
+   */
+  at(index: number): Entity;
+  /**
+   * Marks an entity; a second mark of the same decision changes nothing.
+   *
+   * @param entity - The entity.
+   */
+  add(entity: Entity): void;
+  /**
+   * Empties the list: the next decision gets a new number, so every stamp is stale. Allocates nothing, except when the
+   * stamps grew past `STAMPS_KEPT` or the numbers ran out: then they are dropped.
+   */
+  clear(): void;
+  /**
+   * Walks the marks of this decision in mark order. Allocates an iterator: for a test or a spread, never per frame.
+   *
+   * @yields {Entity} Each marked entity.
+   */
+  [Symbol.iterator](): Iterator<Entity>;
+}
+//#endregion
 //#region src/plugins/renderer/demand/types.d.ts
 /**
  * Why the render phase drew a frame, or `"none"` when it did not. Internal: `monitor` and the agent log read it.
@@ -6070,6 +6388,28 @@ type DemandReason = (typeof DEMAND_REASONS)[number];
  * out of the tree, no view). Internal: `sync.loopsHeld` reads it.
  */
 type Unseen = "shown" | "alpha-above" | "alpha-own" | "off-screen" | "other";
+/**
+ * The change marks of one kind of the running decision, read: each entity once, in mark order. What a `Set` offered
+ * its readers, kept in a list that empties without allocating (`MarkList`). Internal.
+ */
+type Marks = {
+  /** Entities marked in this decision. */readonly size: number;
+  /**
+   * Tells whether an entity is marked in this decision.
+   *
+   * @param entity - The entity.
+   * @returns True when it is.
+   */
+  has(entity: Entity): boolean;
+  /**
+   * The entity marked `index`-th in this decision: a walk by index makes no iterator.
+   *
+   * @param index - 0 to `size - 1`.
+   * @returns The entity; 0 past the end.
+   */
+  at(index: number): Entity; /** Walks the marks, allocating an iterator: for a test or a spread, never per frame. */
+  [Symbol.iterator](): Iterator<Entity>;
+};
 /**
  * The last decision of the render phase, one object reused every frame.
  */
@@ -6082,12 +6422,12 @@ type DemandFrame = {
  * demand module state, `ctx.state.demand`.
  */
 type DemandState = {
-  /** Entities marked by a compared or structural write since the last decision. */marked: Set<Entity>; /** Marked entities whose view was not drawn at mark time; counted at the decision when drawn then. */
-  pending: Set<Entity>; /** Entities a display adapter reported after its `update` (not `false`): counted unless an ancestor is hidden. */
-  loose: Set<Entity>; /** Marked by a write that changes what the view draws (`mark`): the kept cache retakes its picture. */
-  visual: Set<Entity>; /** Marked by a write of the view's own transform or depth (`markMoved`): a kept picture only moves. */
-  moved: Set<Entity>; /** Marked through the public `invalidate`: a filter value or a self-drawn object about to change. */
-  published: Set<Entity>;
+  /** Entities marked by a compared or structural write since the last decision. */marked: MarkList; /** Marked entities whose view was not drawn at mark time; counted at the decision when drawn then. */
+  pending: MarkList; /** Entities a display adapter reported after its `update` (not `false`): counted unless an ancestor is hidden. */
+  loose: MarkList; /** Marked by a write that changes what the view draws (`mark`): the kept cache retakes its picture. */
+  visual: MarkList; /** Marked by a write of the view's own transform or depth (`markMoved`): a kept picture only moves. */
+  moved: MarkList; /** Marked through the public `invalidate`: a filter value or a self-drawn object about to change. */
+  published: MarkList;
   /**
    * Every whole-frame reason found since the last decision (O17, LEAD-FIXES-3). The first one added is
    * `frame().reason`, as spec 14 says; the set keeps the others visible to the overlay step and `kept.collect`.
@@ -6128,11 +6468,11 @@ type DemandInternal = {
   frame(): Readonly<DemandFrame>; /** The F6/F18a predicate: `unseenBy(entity) === "shown"`. */
   shown(entity: Entity): boolean; /** Where the walk of `shown` stopped for the entity's view, for `sync.loopsHeld` (spec 26 R1.7.3). */
   unseenBy(entity: Entity): Unseen; /** Marks of the current decision. */
-  marked(): ReadonlySet<Entity>; /** The adapter marks of the current decision, as `marked()` for the others. */
-  loose(): ReadonlySet<Entity>; /** The marks of the current decision made by `mark`: what a view draws changed. */
-  visual(): ReadonlySet<Entity>; /** The marks of the current decision made by `markMoved`: a view's own transform or depth changed. */
-  moved(): ReadonlySet<Entity>; /** The marks of the current decision made through the public `invalidate`. */
-  published(): ReadonlySet<Entity>; /** The pixel oracle switch, behind `DebugApi.verifyFrames`. */
+  marked(): Marks; /** The adapter marks of the current decision, as `marked()` for the others. */
+  loose(): Marks; /** The marks of the current decision made by `mark`: what a view draws changed. */
+  visual(): Marks; /** The marks of the current decision made by `markMoved`: a view's own transform or depth changed. */
+  moved(): Marks; /** The marks of the current decision made through the public `invalidate`. */
+  published(): Marks; /** The pixel oracle switch, behind `DebugApi.verifyFrames`. */
   verifyFrames(on: boolean): void; /** Whether the pixel oracle is on. */
   verifying(): boolean; /** The body of the public `renderer.invalidate`: a mark of an entity that has a view. */
   invalidate(entity: Entity): void;
@@ -6569,6 +6909,12 @@ type KeptState = {
   verifySkipped: number; /** True while `bypass(true)` draws everything live for an extract. */
   bypassed: boolean; /** Render passes the last flush cost: the estimate `sync.renderPasses()` adds (P9.2). */
   flushPasses: number;
+  /**
+   * The frame `collect` read had no mark and no whole-frame reason: nothing a kept picture reads changed, so a kept
+   * record that owes nothing is drawn from its picture as it stands, without its step (E5). Set by `collect`, spent by
+   * the next flush.
+   */
+  calm: boolean;
 };
 //#endregion
 //#region src/plugins/renderer/viewport/types.d.ts
@@ -7669,6 +8015,12 @@ type SyncInternal = {
    */
   layerOf(entity: Entity): string | undefined; /** The overlays of this frame: modes, ranges, reasons, dims, HUD parts, and the pictures to take (spec 22). */
   stepOverlays(): void;
+  /**
+   * Hands Pixi again the filters of every view whose filters were switched on or off since they were written: Pixi
+   * holds only the enabled ones (E3). Run by the draw callback before anything reads the tree, so a switch is drawn in
+   * the frame it was made. Allocates nothing when no filter was switched.
+   */
+  stepFilters(): void;
   /**
    * The `Graphics` paths the engine drew since the last call (shapes, clip masks, nine-slice outlines), and zeroes the
    * count: the monitor's `stats().redraws` (spec 26 R2.3).
@@ -7998,10 +8350,20 @@ type SyncState = {
   overlay: OverlayState; /** `Graphics` paths drawn since the monitor last took them: shapes, clip masks, outlines (spec 26 R2.3). */
   redraws: number;
   /**
-   * Where the walk of `shown` stopped for the entities whose loops asked since the last sync pass (spec 26 R1.7.3):
-   * an entity with several endless loops is walked once a frame. Cleared by every pass, which may change the tree.
+   * Where the walk of `shown` stopped for the entities whose loops asked (spec 26 R1.7.3), at the `passesVersion` it
+   * was taken: an answer stands while the version does, so an entity with several endless loops is walked once, and a
+   * still board not at all (E4). One record per entity, made at its first ask, dropped with its view.
+   */
+  held: Map<Entity, HeldUnseen>;
+  /**
+   * Moves on with every change that may change the render passes of a frame or where a walk of `shown` stops: a filter
+   * set, forgotten or switched, a node's `renderable` flipped (every hidden reason, the alpha's too), a view hung,
+   * moved, wrapped or dropped (a pass that did work), a kept picture taken or let go, a HUD factor, a new viewport, a
+   * write a plugin announced with `invalidate`.
    */
-  held: Map<Entity, Unseen>;
+  passesVersion: number; /** The filtered views' passes of `renderPassesOf`, counted at `passesVersion` `at` under `root`. */
+  passes: PassCount; /** The name of the scene's HUD layer (`above: "overlays"`), kept with the layers; `undefined` without one. */
+  hudLayer: string | undefined;
   cleanups: Array<() => void>;
 };
 /**
@@ -8017,6 +8379,24 @@ type OverdrawState = {
   matrix: PixiFilter | undefined;
   listeners: Array<(on: boolean) => void>;
 };
+/** Where the walk of `shown` stopped for one entity, and the `passesVersion` it was taken at. */
+type HeldUnseen = {
+  answer: Unseen;
+  at: number;
+};
+/**
+ * The filtered views' part of the render passes, counted once and read every frame while nothing it reads changed: the
+ * version and the root it was counted at, and every filter of the filter table with its `enabled` then (a plugin may
+ * switch a filter by its field alone). Not public.
+ */
+type PassCount = {
+  at: number;
+  root: PixiContainer | undefined;
+  filtered: number; /** Filters recorded: the first `count` of `filters` and `enabled`. */
+  count: number;
+  filters: Array<PixiFilter | undefined>;
+  enabled: boolean[];
+};
 //#endregion
 //#region src/plugins/renderer/monitor/log-types.d.ts
 /**
@@ -8169,6 +8549,45 @@ type PerfLine<Kind extends string> = {
   t: number;
   build: string | null;
 };
+/**
+ * Which groups of the monitor's per-frame work run in an agent build, each on unless switched off (spec 11 R14, the
+ * names of the editor's contract, telemetry proposal §2.7): `gpu` the GPU timer; `passes` the pass ring with its stencil
+ * count and the draws, filter applies, uploads, instruction rebuilds and render targets the counting classes count;
+ * `shaders` the pipeline compiles and shader modules; `problems` the problem rules' accumulators and their judgment;
+ * `memory` the heap read of every frame and its `gc?` hint; `systems` the time of every world system and the five
+ * slowest of a frame; `nodes` the change marks of the frame and its draw reason; `longFrames` the long frames the
+ * browser reports. A section switched off skips its work, and its columns and sample fields read as not measured.
+ *
+ * @example
+ * ```ts
+ * // The editor measures the ward without the per-system timing, the rest as it was.
+ * const sections: MonitorSections = {
+ *   gpu: true, passes: true, shaders: true, problems: true, memory: true, systems: false, nodes: true, longFrames: true
+ * };
+ * ```
+ */
+type MonitorSections = {
+  gpu: boolean;
+  passes: boolean;
+  shaders: boolean;
+  problems: boolean;
+  memory: boolean;
+  systems: boolean;
+  nodes: boolean;
+  longFrames: boolean;
+};
+/**
+ * The sections of the monitor in their order: the order of a `sections` event's lists and of `sample.sectionsMs`
+ * (which adds `base`, the rest of the commit). New sections are only ever appended.
+ *
+ * @example
+ * ```ts
+ * // The editor draws one switch per section of the device's monitor, in the engine's order, and greys the ones off.
+ * app.renderer.monitor.sections({ systems: false });
+ * MONITOR_SECTIONS.filter(section => !app.renderer.monitor.sections()[section]); // ["systems"]
+ * ```
+ */
+declare const MONITOR_SECTIONS: readonly ["gpu", "passes", "shaders", "problems", "memory", "systems", "nodes", "longFrames"];
 /**
  * What an agent build could measure on this page; the header lists it.
  */
@@ -8254,6 +8673,12 @@ type PerfHeaderLine = PerfLine<"header"> & {
   debug?: {
     overdraw: boolean;
   };
+  /**
+   * The sections of the monitor at the moment of the header, as `monitor.sections()` answers them (a `sections` event
+   * marks a switch later): a section `measured` lists but `false` here is switched off, not missing. The engine always
+   * writes it; optional for a reader of an older log.
+   */
+  sections?: Readonly<MonitorSections>;
 };
 /**
  * One Long Animation Frame (or long task) of the page.
@@ -8426,6 +8851,13 @@ type PerfSampleLine = PerfLine<"sample"> & {
     created: number;
     destroyed: number;
   } | null;
+  /**
+   * What each section of the monitor cost in the second: page-clock ms its part of the frame commits took, summed over
+   * the second, 0 for a section switched off; `base` is the rest of the commits. Pixi-side counting is not timed. A
+   * WebView's clock ticks in 0.1 ms, so a part shorter than that adds 0 or 0.1 at a time: the sum over a second is
+   * what to read. The engine always writes it; optional for a reader of an older log.
+   */
+  sectionsMs?: { readonly [Section in keyof MonitorSections | "base"]: number };
 };
 /**
  * Why a frame is a spike: a rule (`gap`, `js`, `gpu`) or an annotation of a spike. `compile` is a compile in the frame or,
@@ -8569,9 +9001,10 @@ type PerfLongFrameLine = PerfLine<"longFrame"> & LongFrameEntry & {
 /**
  * The names of `event` lines (`"devtools"` is the editor's overlay event, in 2b because the editor's page agent emits
  * it on the 2b debug build; `"pool-trim"` is the pool trim of spec 25, detail `PoolTrimDetail`; `"warm"` is the end of
- * a pipeline warm-up run of spec 27, detail `WarmDetail`).
+ * a pipeline warm-up run of spec 27, detail `WarmDetail`; `"sections"` is a switch of the monitor's sections, detail
+ * `{ on, off }`: the names of the sections on and off, in the order of `MONITOR_SECTIONS`).
  */
-type PerfEventName = "scene" | "overlay" | "bundle" | "compile" | "upload" | "resolution" | "device-lost" | "device-restored" | "pause" | "resume" | "switch" | "display" | "command" | "recorder" | "rate" | "devtools" | "pool-trim" | "warm" | "shader" | "problem" | "debug";
+type PerfEventName = "scene" | "overlay" | "bundle" | "compile" | "upload" | "resolution" | "device-lost" | "device-restored" | "pause" | "resume" | "switch" | "display" | "command" | "recorder" | "rate" | "devtools" | "pool-trim" | "warm" | "shader" | "problem" | "debug" | "sections";
 /**
  * What an `overlay` event line says happened to an overlay (spec 22 O10.2): it opened, landed (its enter motion is
  * over), started to leave, is gone, or its range went live or was kept again (the live fallback).
@@ -9428,7 +9861,9 @@ type MonitorSinks = {
   compiles: CompileRing; /** The WebGPU pass sink, set at attach. */
   passes: PassSink | undefined; /** A pass counter runs (F8): the counting encoder exists, or the WebGL runner items are subscribed. */
   measuring: boolean; /** Pixi's instruction rebuilds since the monitor last took them, in a frame or between frames (spec 26 R2.3). */
-  rebuildsWindow: number;
+  rebuildsWindow: number; /** The `SECTION` bits of the sections that run in the frame now: what the commit and the counting classes test. */
+  sections: number; /** The `SECTION` bits a switch asked for: they apply at the start of the next frame, so a frame is measured whole. */
+  sectionsNext: number;
 };
 /**
  * The ring's render passes, written in place: `capacity * 4` of them. Not public.
@@ -9593,8 +10028,14 @@ type PerfState = {
   /** `config.monitor.budgetMs`; a frame's budget is `budgetOf` it. */budget: number | "rate"; /** `config.monitor.frames`: the capacity the ring gets at the first attach. */
   frames: number;
   ring: PerfRing; /** `capacity` long, for percentiles at a flush. */
-  scratch: Float32Array; /** Doubles kept unboxed: `[0]` the budget of the frame being committed, `[1]` the end of a flushed window. */
-  staged: Float64Array; /** The display's frame period from the ticks: the budget's display part while `time` does not know the display. */
+  scratch: Float32Array;
+  /**
+   * Doubles kept unboxed: `[0]` the budget of the frame being committed, `[1]` the end of a flushed window, `[2]` the
+   * page clock of the last lap of the commit, where the next section's cost starts.
+   */
+  staged: Float64Array; /** The sections `monitor.sections()` answers: the config's at first, then the last switch; frozen. */
+  sections: Readonly<MonitorSections>; /** Page-clock ms of the commits of the current second, by section in `COST` order, `base` last. */
+  sectionsMs: Float64Array; /** The display's frame period from the ticks: the budget's display part while `time` does not know the display. */
   ticks: TickEstimate; /** The `time.rate()` snapshot the last frame saw: a new one may carry another `displayHz` (a `display` event). */
   rate: Readonly<FrameRate> | undefined;
   drawn: boolean; /** The `CHANGED` bits of the frame running now. */
@@ -9636,8 +10077,9 @@ type PerfState = {
  * wait for a drawn frame.
  */
 type MonitorState = {
-  /** Clock time at the start of the frame being drawn; `undefined` between frames. */frameStart: number | undefined; /** Clock time at the start of the last frame, the far end of the next interval. */
-  lastStart: number | undefined; /** Clock milliseconds between frame starts, summed over the open window. */
+  /** Clock time at the start of the frame being drawn; NaN between frames. A double from the start: never boxed. */frameStart: number; /** Clock time at the start of the last frame, the far end of the next interval; NaN before the first. */
+  lastStart: number; /** `[0]`: the clock reading `begin` or `end` hands the window, staged: a double handed to a call is boxed. */
+  staged: Float64Array; /** Clock milliseconds between frame starts, summed over the open window. */
   windowMs: number; /** Intervals between frame starts in the open window. */
   intervals: number; /** Clock milliseconds spent inside frames in the open window. */
   workMs: number; /** Frames finished in the open window. */
@@ -9843,6 +10285,25 @@ type PerfMonitorApi = {
    * ```
    */
   setResolution(resolution: number | undefined): number;
+  /**
+   * The sections of the monitor of a debug build, each on unless switched off: what runs every frame, and what can be
+   * switched off to measure the game without it. Without an argument it reads them. With one it switches the sections
+   * it names, from the next frame on, and writes a `sections` event; a write needs control (`--debug`, or a dev page):
+   * a read-only page (`--debug=read`) keeps the sections and throws. A section off skips its work: its ring columns and its sample fields read as not measured, and its
+   * `sample.sectionsMs` is 0. Agent builds only: elsewhere every section answers on and nothing switches.
+   *
+   * @param next - The sections to switch: `true` on, `false` off; a section left out keeps its switch.
+   * @returns The sections from the next frame on, one frozen object until the next switch.
+   * @throws {Error} With `reason: "read-only"` when a page without control is asked to change a section.
+   * @example
+   * ```ts
+   * // The editor's Mission control: what does the ward cost without the per-system timing?
+   * app.renderer.monitor.sections().systems; // true
+   * app.renderer.monitor.sections({ systems: false }); // { gpu: true, passes: true, shaders: true, problems: true, memory: true, systems: false, nodes: true, longFrames: true }
+   * // a stream() listener gets { kind: "event", name: "sections", detail: { on: ["gpu", "passes", "shaders", "problems", "memory", "nodes", "longFrames"], off: ["systems"] }, … }
+   * ```
+   */
+  sections(next?: Partial<MonitorSections>): Readonly<MonitorSections>;
   /**
    * The live object counts of a debug build: a plugin the renderer cannot depend on (it depends on the renderer)
    * registers a count here, and the monitor reads it once a second into `sample.counts` and `stats().counts`.
@@ -10065,7 +10526,7 @@ type PictureRequest = {
   reject: (error: Error) => void;
 };
 declare namespace types_d_exports$2 {
-  export { Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfCounts, PerfDisplay, PerfEventLine, PerfEventName, PerfGapLine, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfTelemetryLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, Point, PoolTrim, PoolTrimDetail, ProblemEventDetail, ProblemRule, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, ShaderEventDetail, ShaderWhat, SliceFrame, State$2 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState, WarmDetail };
+  export { Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, MonitorSections, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfCounts, PerfDisplay, PerfEventLine, PerfEventName, PerfGapLine, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfTelemetryLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, Point, PoolTrim, PoolTrimDetail, ProblemEventDetail, ProblemRule, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, ShaderEventDetail, ShaderWhat, SliceFrame, State$2 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState, WarmDetail };
 }
 /**
  * The part of Pixi the engine uses: the classes `sync` builds views from (a `Rectangle` frames the
@@ -10290,6 +10751,8 @@ type Config$2 = {
  * createApp({ pluginConfigs: { renderer: { mount: "#game", monitor: { budgetMs: 8.3, frames: 2048 } } } });
  * // A game with a large blurred backdrop flags it sooner: 30 still frames over 0.1 Mpx.
  * createApp({ pluginConfigs: { renderer: { mount: "#game", monitor: { budgetMs: "rate", frames: 1024, stillFrames: 30, stillMpx: 0.1 } } } });
+ * // A debug build that starts without the per-system timing: app.renderer.monitor.sections().systems is false.
+ * createApp({ pluginConfigs: { renderer: { mount: "#game", monitor: { budgetMs: "rate", frames: 1024, sections: { systems: false } } } } });
  * ```
  */
 type MonitorConfig = {
@@ -10306,6 +10769,11 @@ type MonitorConfig = {
   churnPerSecond?: number; /** `target-churn`: seconds of churn in a row before the problem. Default 3. */
   churnSeconds?: number; /** `target-churn`: a render target made this many ms after a pool trim is churn at once. Default 1000. */
   churnAfterTrimMs?: number;
+  /**
+   * The sections of the monitor a debug build starts with (spec 11 R14): a section left out is on. `monitor.sections`
+   * switches them later.
+   */
+  sections?: Partial<MonitorSections>;
 };
 /**
  * renderer plugin state: one branch per module.
@@ -10716,7 +11184,13 @@ type State$1 = {
    */
   named: readonly string[];
   owner: SceneOwner; /** The remover of the `onEnter` callback: set in `onStart`, run in `onStop`. */
-  teardown: (() => void) | undefined;
+  teardown: (() => void) | undefined; /** Scene id to the feature that declares it, filled in `onStart`. */
+  owners: Map<string, string>;
+  /**
+   * The release of the hold on the mounted scene's feature (`world.ecs.hold`), so the systems of a
+   * feature with `systemsRun: "active"` run while its scene is mounted.
+   */
+  held: (() => void) | undefined;
 };
 /**
  * scenes plugin events.
@@ -11732,4 +12206,4 @@ type BundleCompanion = {
   unload(bundle: string): void;
 };
 //#endregion
-export { PerfCause as $, JournalEntry as $n, types_d_exports$3 as $t, PixiSprite as A, Api$3 as An, SnapshotOf as Ar, ViewportSize as At, FrameReadResult as B, defineFlow as Bn, Api$7 as Br, Shape as Bt, State$1 as C, NumericFields as Cn, types_d_exports$6 as Cr, ShaderWhat as Ct, MonitorConfig as D, TrackOptions as Dn, SaveDoc as Dr, FilterSlotInputs as Dt, Config$2 as E, ReducedMotion as En, ProviderCall as Er, FilterSlot as Et, types_d_exports$2 as F, HudKeysOf as Fn, Config$7 as Fr, NineSlice$1 as Ft, OverlayEventDetail as G, FeatureDescription as Gn, ThermalReading as Gr, Transform as Gt, FrameRecord as H, slot as Hn, FrameRate as Hr, Sprite as Ht, Captured as I, Position as In, Events$6 as Ir, NineSliceValue as It, PERF_GAP_BUCKETS as J, AnyFlow as Jn, Config$9 as Jr, DEMAND_REASONS as Jt, OverlayWhat as K, FeaturePlugin as Kn, Time as Kr, TransformValue as Kt, MonitorCounts as L, State$4 as Ln, PauseReason as Lr, Overlay as Lt, PoolTrim as M, Config$4 as Mn, RngApi as Mr, Display as Mt, State$2 as N, EmitterIdOf as Nn, RngState as Nr, HudPart as Nt, PixiFilter as O, TrackSegment as On, SaveUnreadableError as Or, Orientation as Ot, Under as P, GameTypes as Pn, Api$6 as Pr, HudPartValue as Pt, PassRecord as Q, FlowState as Qn, State$3 as Qt, RenderStats as R, TextStylesOf as Rn, State$7 as Rr, OverlayValue as Rt, ScenesApi as S, MotionHandle as Sn, State$6 as Sr, ShaderEventDetail as St, Api$1 as T, ProjectionSpec as Tn, PlayerStateProvider as Tr, DebugSwitches as Tt, FrameRing as U, to as Un, RateChange as Ur, SpriteOptions as Ut, FrameReadout as V, exit as Vn, Config$8 as Vr, ShapeValue as Vt, LongFrameEntry as W, type as Wn, State$8 as Wr, SpriteValue as Wt, PROBLEM_RULES as X, DefineNode as Xn, Require as Xr, Config$3 as Xt, PERF_LOG_VERSION as Y, Bookmark as Yn, Events$8 as Yr, Api$2 as Yt, PassKind as Z, FlowGraph as Zn, Explained as Zt, DefineScene as _, ChangeHook as _n, Api$5 as _r, PerfThermalLine as _t, Config as a, ComponentType as an, Effect as ar, PerfEventLine as at, SceneDefinition as b, Motion as bn, Json as br, ProblemRule as bt, LoadBundles as c, EntitySnapshot as cn, Hint as cr, PerfHeaderLine as ct, Manifest as d, Narrowed as dn, Api$4 as dr, PerfMarkLine as dt, AnyComponent as en, NodeTable as er, PerfChange as et, State as f, QueryTerm as fn, ClockSource as fr, PerfMeasured as ft, AnySceneProjection as g, TagType as gn, types_d_exports$5 as gr, PerfTelemetryLine as gt, types_d_exports as h, SystemFor as hn, State$5 as hr, PerfStartupLine as ht, BundleSpec as i, ComponentSchema as in, Descriptor as ir, PerfDisplay as it, PixiTexture as j, BundlesOf as jn, StoreApi as jr, FilterCache as jt, PixiModule as k, ViewHandle as kn, Snapshot as kr, Point as kt, LoadReason as l, FrameDiff as ln, NodeFx as lr, PerfLogLine as lt, Usage as m, SystemDefinition as mn, FakeClock as mr, PerfSpikeLine as mt, AssetsIo as n, AnyComponentValue as nn, SceneIdOf as nr, PerfCollectorLine as nt, DefineBundles as o, ComponentValue as on, EffectOptions as or, PerfEventName as ot, Tier as p, ResourceType as pn, Config$5 as pr, PerfSampleLine as pt, PERF_CAUSES as q, FeatureTree as qn, types_d_exports$8 as qr, sprite as qt, BundleMap as r, ComponentHandle as rn, TypeTag as rr, PerfCounts as rt, Events as s, Entity as sn, GuideOptions as sr, PerfGapLine as st, Api as t, AnyComponentType as tn, RouteStep as tr, PerfChangeEntry as tt, LoadResult as u, Mut as un, Answer as ur, PerfLongFrameLine as ut, Events$1 as v, DescriptionNode as vn, Config$6 as vr, PoolTrimDetail as vt, types_d_exports$1 as w, ProjectionMotion as wn, Patch as wr, WarmDetail as wt, SceneSpec as x, MotionCause as xn, Root as xr, SHADER_WHATS as xt, LayerMap as y, Ease as yn, Events$5 as yr, ProblemEventDetail as yt, FrameColumns as z, types_d_exports$4 as zn, types_d_exports$7 as zr, Parent as zt };
+export { PassKind as $, FlowGraph as $n, Explained as $t, PixiSprite as A, TrackSegment as An, SaveUnreadableError as Ar, Orientation as At, FrameReadResult as B, TextStylesOf as Bn, State$7 as Br, OverlayValue as Bt, State$1 as C, MotionCause as Cn, Root as Cr, SHADER_WHATS as Ct, MonitorConfig as D, ProjectionSpec as Dn, PlayerStateProvider as Dr, DebugSwitches as Dt, Config$2 as E, ProjectionMotion as En, Patch as Er, WarmDetail as Et, types_d_exports$2 as F, EmitterIdOf as Fn, RngState as Fr, HudPart as Ft, MONITOR_SECTIONS as G, to as Gn, RateChange as Gr, SpriteOptions as Gt, FrameRecord as H, defineFlow as Hn, Api$7 as Hr, Shape as Ht, Captured as I, GameTypes as In, Api$6 as Ir, HudPartValue as It, OverlayWhat as J, FeaturePlugin as Jn, Time as Jr, TransformValue as Jt, MonitorSections as K, type as Kn, State$8 as Kr, SpriteValue as Kt, MonitorCounts as L, HudKeysOf as Ln, Config$7 as Lr, NineSlice$1 as Lt, PoolTrim as M, Api$3 as Mn, SnapshotOf as Mr, ViewportSize as Mt, State$2 as N, BundlesOf as Nn, StoreApi as Nr, FilterCache as Nt, PixiFilter as O, ReducedMotion as On, ProviderCall as Or, FilterSlot as Ot, Under as P, Config$4 as Pn, RngApi as Pr, Display as Pt, PROBLEM_RULES as Q, DefineNode as Qn, Require as Qr, Config$3 as Qt, RenderStats as R, Position as Rn, Events$6 as Rr, NineSliceValue as Rt, ScenesApi as S, Motion as Sn, Json as Sr, ProblemRule as St, Api$1 as T, NumericFields as Tn, types_d_exports$6 as Tr, ShaderWhat as Tt, FrameRing as U, exit as Un, Config$8 as Ur, ShapeValue as Ut, FrameReadout as V, types_d_exports$4 as Vn, types_d_exports$7 as Vr, Parent as Vt, LongFrameEntry as W, slot as Wn, FrameRate as Wr, Sprite as Wt, PERF_GAP_BUCKETS as X, AnyFlow as Xn, Config$9 as Xr, DEMAND_REASONS as Xt, PERF_CAUSES as Y, FeatureTree as Yn, types_d_exports$8 as Yr, sprite as Yt, PERF_LOG_VERSION as Z, Bookmark as Zn, Events$8 as Zr, Api$2 as Zt, DefineScene as _, SystemFor as _n, State$5 as _r, PerfStartupLine as _t, Config as a, ComponentHandle as an, TypeTag as ar, PerfCounts as at, SceneDefinition as b, DescriptionNode as bn, Config$6 as br, PoolTrimDetail as bt, LoadBundles as c, ComponentValue as cn, EffectOptions as cr, PerfEventName as ct, Manifest as d, FrameDiff as dn, NodeFx as dr, PerfLogLine as dt, State$3 as en, FlowState as er, PassRecord as et, State as f, Mut as fn, Answer as fr, PerfLongFrameLine as ft, AnySceneProjection as g, SystemDefinition as gn, FakeClock as gr, PerfSpikeLine as gt, types_d_exports as h, ResourceType as hn, Config$5 as hr, PerfSampleLine as ht, BundleSpec as i, AnyComponentValue as in, SceneIdOf as ir, PerfCollectorLine as it, PixiTexture as j, ViewHandle as jn, Snapshot as jr, Point as jt, PixiModule as k, TrackOptions as kn, SaveDoc as kr, FilterSlotInputs as kt, LoadReason as l, Entity as ln, GuideOptions as lr, PerfGapLine as lt, Usage as m, QueryTerm as mn, ClockSource as mr, PerfMeasured as mt, AssetsIo as n, AnyComponent as nn, NodeTable as nr, PerfChange as nt, DefineBundles as o, ComponentSchema as on, Descriptor as or, PerfDisplay as ot, Tier as p, Narrowed as pn, Api$4 as pr, PerfMarkLine as pt, OverlayEventDetail as q, FeatureDescription as qn, ThermalReading as qr, Transform as qt, BundleMap as r, AnyComponentType as rn, RouteStep as rr, PerfChangeEntry as rt, Events as s, ComponentType as sn, Effect as sr, PerfEventLine as st, Api as t, types_d_exports$3 as tn, JournalEntry as tr, PerfCause as tt, LoadResult as u, EntitySnapshot as un, Hint as ur, PerfHeaderLine as ut, Events$1 as v, TagType as vn, types_d_exports$5 as vr, PerfTelemetryLine as vt, types_d_exports$1 as w, MotionHandle as wn, State$6 as wr, ShaderEventDetail as wt, SceneSpec as x, Ease as xn, Events$5 as xr, ProblemEventDetail as xt, LayerMap as y, ChangeHook as yn, Api$5 as yr, PerfThermalLine as yt, FrameColumns as z, State$4 as zn, PauseReason as zr, Overlay as zt };