@moku-labs/game 0.15.0 → 0.15.2

package/dist/{types-BGcda5Le.d.mts → types-BHgJ1F6f.d.mts}

@@ -189,11 +189,16 @@ type ThermalStatus = "none" | "light" | "moderate" | "severe" | "critical" | "em
  *
  * @example
  * ```ts
- * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none" }
+ * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null }
  * ```
  */
 type FrameRate = {
-  /** Frames per second the loop runs at, the idle cap left out. */fps: number; /** Who decides the rate. */
+  /**
+   * Frames per second the loop really runs at, the idle cap left out: the cap on the known display. A cap above the
+   * display's rate runs at the display's rate (`heldBy: "panel"`); a cap between two vsyncs runs at the next divisor
+   * below it (60 on a 144 Hz panel runs at 48). The cap itself while the display is unknown.
+   */
+  fps: number; /** Who decides the rate. */
   mode: RateMode; /** Why the rate is what it is. */
   reason: RateReason;
   /**
@@ -204,6 +209,17 @@ type FrameRate = {
   displayHz: number | null; /** The rates the adaptive rule chooses from, highest first; empty until `displayHz` is known, and without `adaptive`. */
   ladder: readonly number[]; /** The native shell's last thermal status; `null` without a shell, before its first reading, and without `adaptive`. */
   thermal: ThermalStatus | null;
+  /**
+   * The rate the loop is told to hold: `maxFps` in mode `"fixed"`, the `setRate` value in mode `"forced"` (never above
+   * `maxFps`); `null` in mode `"auto"`, where the adaptive rule decides.
+   */
+  asked: Exclude<RateChoice, "auto"> | null;
+  /**
+   * `"panel"` when the asked rate is above the known `displayHz` (120 asked on a 60 Hz panel): the loop cannot run
+   * faster than the panel, and `fps` is the panel's rate. `null` otherwise, in mode `"auto"` and while the display is
+   * unknown.
+   */
+  heldBy: "panel" | null;
 };
 /**
  * Payload of `time:rate`: a change of the loop's rate or of its mode, with the evidence the rule read.
@@ -241,7 +257,12 @@ type FrameMeasure = {
   /** `Time.frame` of the measured frame. */frame: number; /** Start of the frame on the page clock (`performance` timeline), ms: the `requestAnimationFrame` timestamp, or the moment `step()` began. */
   at: number; /** `at` minus `at` of the previous measured frame; `NaN` for the first frame, the first after `resume()`, and a stepped frame. */
   gapMs: number; /** `1000 / cap` of this frame: the loop's rate, or `idleFps` while idle. */
-  capMs: number; /** `1000 / fps` of the loop's rate in this frame, the idle cap left out: `1000 / time.rate().fps`. */
+  capMs: number;
+  /**
+   * One frame of the cap of the loop's rate in this frame, the idle cap left out: `1000 / time.rate().asked` in mode
+   * `"fixed"` and `"forced"`, the adaptive rule's rate in `"auto"`. Equal to `1000 / time.rate().fps` while the cap is
+   * a divisor of the display rate.
+   */
   rateMs: number;
   /**
    * One period of the display, `1000 / time.rate().displayHz`, ms; `NaN` until the display rate is known. No frame
@@ -610,6 +631,24 @@ type Api$7 = {
    * ```
    */
   wakes(): number;
+  /**
+   * How many `onFrame` callbacks are registered now, over the six phases. The measure listeners of `measure` are not
+   * counted. A number, no allocation: a leak check reads it once a second, and a count that grows each time a screen
+   * is entered and left is a callback nobody unsubscribed.
+   *
+   * @returns The count.
+   * @example
+   * ```ts
+   * // The renderer's monitor reads it once a second for the leak counts of a debug build.
+   * const time = ctx.require(timePlugin);
+   * const before = time.frameListeners();
+   * const off = time.onFrame("animate", frame => counter.advance(frame.delta));
+   * time.frameListeners() - before; // 1
+   * off();
+   * time.frameListeners() - before; // 0
+   * ```
+   */
+  frameListeners(): number;
   /**
    * Hands what `time` measured of every frame to `listener`, after the `render` phase: the gap, the skipped ticks, the
    * six phase durations and the whole work. Agent builds only (`__MOKU_GAME_AGENT__`, true in dev and `--debug`
@@ -659,13 +698,18 @@ type Api$7 = {
    * adaptive rule chooses from, and the native shell's thermal status. One frozen object, the same until something in
    * it changes: cheap to read every frame.
    *
+   * `fps` is the rate the loop really runs at; `asked` the rate it is told to hold outside the adaptive rule, and
+   * `heldBy: "panel"` says the panel is slower than that.
+   *
    * @returns The frame rate.
    * @example
    * ```ts
    * // The settings screen shows the rate the game runs at on this phone.
-   * app.time.rate(); // { fps: 120, mode: "auto", reason: "start", displayHz: 120, ladder: [120, 60], thermal: "none" }
+   * app.time.rate(); // { fps: 120, mode: "auto", reason: "start", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null }
    * // on the memory screen of a weak phone, a second later:
-   * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none" }
+   * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null }
+   * // a game with maxFps 120 and no adaptive, on a 60 Hz phone:
+   * app.time.rate(); // { fps: 60, mode: "fixed", reason: "start", displayHz: 60, ladder: [], thermal: null, asked: 120, heldBy: "panel" }
    * ```
    */
   rate(): Readonly<FrameRate>;
@@ -682,9 +726,11 @@ type Api$7 = {
    * @example
    * ```ts
    * // The player picked "60" in the settings to save battery.
-   * app.time.setRate(60); // { fps: 60, mode: "forced", reason: "forced", displayHz: 120, ladder: [120, 60], thermal: "none" }
+   * app.time.setRate(60); // { fps: 60, mode: "forced", reason: "forced", displayHz: 120, ladder: [120, 60], thermal: "none", asked: 60, heldBy: null }
    * // …and later "Auto" again, on a 120 Hz phone:
-   * app.time.setRate("auto"); // { fps: 120, mode: "auto", reason: "auto", displayHz: 120, ladder: [120, 60], thermal: "none" }
+   * app.time.setRate("auto"); // { fps: 120, mode: "auto", reason: "auto", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null }
+   * // A pin of 120 on a 60 Hz phone runs at the panel's rate:
+   * app.time.setRate(120); // { fps: 60, mode: "forced", reason: "forced", displayHz: 60, ladder: [60], thermal: "none", asked: 120, heldBy: "panel" }
    * ```
    */
   setRate(choice: RateChoice): Readonly<FrameRate>;
@@ -1736,6 +1782,40 @@ type Api$4 = {
    * ```
    */
   dueAt(): number | undefined;
+  /**
+   * How many scheduled timers are not yet due. The clock holds one pending moment, so the answer
+   * is 0 or 1: a moment a screen scheduled and never cancelled reads 1 after the screen closed,
+   * where the count was 0 before it opened. It allocates nothing; the renderer's monitor reads it
+   * once a second in a debug build.
+   *
+   * @returns 1 while a moment is scheduled, else 0.
+   * @example
+   * ```ts
+   * app.clock.pending(); // 0
+   * app.clock.scheduleAt(app.clock.now() + 60_000);
+   * app.clock.pending(); // 1
+   * app.clock.scheduleAt(undefined);
+   * app.clock.pending(); // 0
+   * ```
+   */
+  pending(): number;
+  /**
+   * How many `onElapsed` listeners are registered. A screen that registers one on every visit and
+   * never calls the remover adds one per visit; a screen that cleans up leaves the count where it
+   * was. It allocates nothing; the renderer's monitor reads it once a second in a debug build.
+   *
+   * @returns The number of registered listeners.
+   * @example
+   * ```ts
+   * // A leak check over one visit of the screen that shows the refill timer.
+   * const before = app.clock.listeners();
+   * const off = app.clock.onElapsed(({ now }) => refillTimer.update(now));
+   * app.clock.listeners() - before; // 1
+   * off(); // the screen closed
+   * app.clock.listeners() - before; // 0
+   * ```
+   */
+  listeners(): number;
 };
 /**
  * Domain context of the clock plugin.
@@ -4195,7 +4275,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[];
@@ -4283,6 +4364,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.
  */
@@ -4306,10 +4394,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.
@@ -4463,7 +4569,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`.
@@ -4471,10 +4578,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
@@ -4719,6 +4843,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
 /**
@@ -5035,6 +5234,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;
 };
 /**
@@ -5088,23 +5293,23 @@ 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 and the walk the
+ * runner resets for every run. A system registered during a frame runs from the next frame on.
+ * Spec 28 (deferred) extends it with the system's scope.
  */
 type SystemEntry = {
   readonly definition: AnySystem;
   readonly frame: number;
   readonly plan: QueryPlan;
+  /**
+   * 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;
 };
 /**
  * A structural change queued while a phase runs. Applied in call order when the phase ends.
@@ -5143,17 +5348,23 @@ 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>;
+};
 /**
  * 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.
@@ -5300,6 +5511,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.
  */
@@ -5309,8 +5538,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.
@@ -5318,18 +5549,23 @@ 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;
 };
 /**
  * ecs module API, `app.world.ecs`: the screen as data. Plain-object components in one store per
@@ -5510,8 +5746,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.
@@ -5616,7 +5854,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.
@@ -5689,6 +5932,24 @@ type EcsApi = {
    * ```
    */
   ownerOf(entity: Entity): Owner | undefined;
+  /**
+   * How many entities live now: every id `spawn` handed out that no despawn took back, the views
+   * of the projections and the layers included. It reads a size the world keeps, so it allocates
+   * nothing and a monitor may call it every second. A screen entered and left returns the count to
+   * where it was; a count that grows with every visit is a leak.
+   *
+   * @returns The number of live entities.
+   * @example
+   * ```ts
+   * // A test that spawns an entity sees it counted until the despawn.
+   * const before = app.world.ecs.count();
+   * const coin = app.world.ecs.spawn({ kind: "plugin", name: "test" }, [Transform({ x: 10 })]);
+   * app.world.ecs.count(); // before + 1
+   * app.world.ecs.despawn(coin);
+   * app.world.ecs.count(); // before
+   * ```
+   */
+  count(): number;
   /**
    * The whole world as plain JSON, sorted by entity index. A component value that is not JSON is
    * left out and its name is listed in `skipped`.
@@ -5781,6 +6042,8 @@ type EcsInternal = {
 //#region src/plugins/world/ecs/systems.d.ts
 /**
  * Time each world system took in the current frame of an agent build: names by registration index, ms in the same order.
+ * `names` is a new array each time a system of a new name registers and the same array otherwise, so a reader that
+ * kept it sees growth by identity.
  *
  * @example
  * ```ts
@@ -5789,7 +6052,7 @@ type EcsInternal = {
  */
 type SystemTiming = {
   readonly clock: () => number;
-  readonly names: string[];
+  names: readonly string[];
   ms: Float64Array;
 };
 declare namespace types_d_exports$3 {
@@ -5858,7 +6121,8 @@ type Api$2 = {
    *
    * A live view, not a copy: the table is the world's own, the same object every call, and the next frame zeroes and
    * rewrites `ms` in place. The monitor reads it every frame of an agent build without allocating, which a copy would
-   * break. A caller that keeps numbers past the frame copies them (`[...systems.ms]`); a write into it changes what the
+   * break. `names` is replaced by a new array when a system of a new name registers, and only then: a reader that kept
+   * the array tells a new system by `names !== kept`. A caller that keeps numbers past the frame copies them (`[...systems.ms]`); a write into it changes what the
    * monitor logs.
    *
    * @returns The live timing table, or `undefined`.
@@ -5957,6 +6221,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.
@@ -5969,6 +6279,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.
  */
@@ -5981,12 +6313,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`.
@@ -6027,11 +6359,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;
@@ -6373,7 +6705,12 @@ type KeptInternal = {
   stats(): KeptStats; /** The takes since the last call; the monitor's window close. */
   drainTakes(): number; /** The stage-3-only redos since the last call. */
   drainRefreshes(): number; /** Dev and agent builds only: every record and range drawn live for one extract, and back. */
-  bypass(on: boolean): void; /** The debug switch: false draws every view live from the next drawn frame. */
+  bypass(on: boolean): void;
+  /**
+   * Dev and agent builds only: runs `draw` with every kept record drawn live and every range's entries lifted (its
+   * sprite hidden), then puts every picture back: the live render of the pixel leg and of the overdraw map.
+   */
+  live<Result>(draw: () => Result): Result; /** The debug switch: false draws every view live from the next drawn frame. */
   enabled(on: boolean): void; /** Whether the switch is on (and `keptMb` above 0). */
   isOn(): boolean; /** Every record back to live, every texture destroyed: device loss, rebuild, stop. */
   reset(): void;
@@ -6406,7 +6743,12 @@ type KeptRecord = {
   readonly matrix: PixiMatrix; /** Drawn frames without a stage-1 change (live), stage-1 retakes in a row (kept), and whether calm is needed. */
   still: number;
   churn: number;
-  calm: boolean; /** Drawn-frame number of the last frame its quad was drawn; the LRU key of P6. */
+  calm: boolean;
+  /**
+   * Drawn frames in a row its subtree did not change (no stage-1 mark), whether it may be kept or not: the monitor's
+   * `filter-still` rule reads it.
+   */
+  quiet: number; /** Drawn-frame number of the last frame its quad was drawn; the LRU key of P6. */
   lastDrawn: number; /** Depth of the top under the stage, for the inner-first order (P5.2). */
   depth: number; /** Bytes of s1, s2, s3 (estimate, P6.1). */
   bytes: number; /** A settle retake is owed: the view came to rest off its picture's grid (P2.5). */
@@ -7203,17 +7545,19 @@ type FiltersApi = {
   warm(filter: PixiFilter): Promise<boolean>;
 };
 /**
- * The debug switches of the renderer: the nine-slice outline, the pixel check of skipped frames and the kept pictures.
+ * The debug switches of the renderer: the nine-slice outline, the pixel check of skipped frames, the kept pictures and
+ * the overdraw heat map.
  *
  * @example
  * ```ts
- * const switches: DebugSwitches = { nineSlice: true, verifyFrames: false, kept: true };
+ * const switches: DebugSwitches = { nineSlice: true, verifyFrames: false, kept: true, overdraw: false };
  * ```
  */
 type DebugSwitches = {
   nineSlice: boolean;
   verifyFrames: boolean;
   kept: boolean;
+  overdraw: boolean;
 };
 /**
  * The debug drawing of the renderer, `app.renderer.sync.debug`. The switch outlines every
@@ -7224,7 +7568,7 @@ type DebugSwitches = {
  * ```ts
  * // Check where every panel of the open popup is cut: cyan lines, red where corners overlap.
  * app.renderer.sync.debug.nineSlice(true);
- * app.renderer.sync.debug.state(); // { nineSlice: true, verifyFrames: false, kept: true }
+ * app.renderer.sync.debug.state(); // { nineSlice: true, verifyFrames: false, kept: true, overdraw: false }
  * ```
  */
 type DebugApi = {
@@ -7257,7 +7601,7 @@ type DebugApi = {
    * ```ts
    * // The visual runner checks every stepped frame of a test in the browser.
    * app.renderer.sync.debug.verifyFrames(true);
-   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: true, kept: true }
+   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: true, kept: true, overdraw: false }
    * ```
    */
   verifyFrames(on: boolean): void;
@@ -7271,10 +7615,29 @@ type DebugApi = {
    * ```ts
    * // The editor's tools page compares the memory screen with and without kept pictures.
    * app.renderer.sync.debug.kept(false);
-   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: false, kept: false }
+   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: false, kept: false, overdraw: false }
    * ```
    */
   kept(on: boolean): void;
+  /**
+   * Draws every frame as the overdraw heat map (true) or as the game (false): a pixel's brightness counts the layers
+   * drawn there, 1/16 white for one, white for sixteen and more. While it is on every frame is drawn (also with
+   * `onDemand`), kept pictures are drawn live and filters are off, so the map shows what a frame would draw without
+   * them; the frames of the performance log are marked (`debug` event, header `debug.overdraw`), so a recording is not
+   * read as real cost. Only the stage pass changes: between frames every view keeps its own alpha, blend mode and
+   * filters, and off draws the game again from the next frame. A texel a texture leaves transparent counts nothing.
+   * Dev and debug builds only; elsewhere the switch stays off.
+   *
+   * @param on - True to draw the heat map.
+   * @example
+   * ```ts
+   * // The editor's Mission control shows where the board stacks its layers: three full-screen backdrops show 3/16 white.
+   * app.renderer.sync.debug.overdraw(true);
+   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: false, kept: true, overdraw: true }
+   * app.renderer.sync.debug.overdraw(false); // the next frame draws the board as before
+   * ```
+   */
+  overdraw(on: boolean): void;
   /**
    * What every overlay does this frame, bottom first: its phase, its mode, its level, how many entries its range has
    * and whether a picture holds them. The level and the landing are the engine's state of the overlay, read here. For
@@ -7296,7 +7659,7 @@ type DebugApi = {
    * @example
    * ```ts
    * // An e2e test makes sure no outline is drawn before it compares a screenshot.
-   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: false, kept: true }
+   * app.renderer.sync.debug.state(); // { nineSlice: false, verifyFrames: false, kept: true, overdraw: false }
    * ```
    */
   state(): DebugSwitches;
@@ -7419,7 +7782,7 @@ type SyncApi = {
    * ```ts
    * // Check where every panel of the open popup is cut: cyan lines, red where corners overlap.
    * app.renderer.sync.debug.nineSlice(true);
-   * app.renderer.sync.debug.state(); // { nineSlice: true, verifyFrames: false, kept: true }
+   * app.renderer.sync.debug.state(); // { nineSlice: true, verifyFrames: false, kept: true, overdraw: false }
    * ```
    */
   debug: DebugApi;
@@ -7565,6 +7928,27 @@ type SyncInternal = {
    * @param fn - Called with the probe draws made since the queue last started.
    */
   onWarm(fn: WarmListener): void;
+  /**
+   * Whether the overdraw heat map draws: the frame then asks to be drawn, and the stage pass goes through
+   * `drawOverdraw`.
+   *
+   * @returns True while `debug.overdraw` is on.
+   */
+  overdrawing(): boolean;
+  /**
+   * Draws the stage pass as the overdraw heat map and puts every node back after it (`overdraw.ts`).
+   *
+   * @param render - The stage pass, `host.render`.
+   * @returns What `render` answered.
+   */
+  drawOverdraw(render: () => boolean): boolean;
+  /**
+   * Subscribes to a move of the overdraw switch (the monitor of an agent build writes the `debug` event line).
+   * Emptied by `stopSync`.
+   *
+   * @param fn - Called with the switch, when it moved.
+   */
+  onOverdraw(fn: (on: boolean) => void): void;
   /**
    * Gives the view of an entity its wrapper before the kept cache takes its first picture (spec 23 D4), so the
    * picture's root is a plain container; marks nothing, since the wrapper draws the same pixels. The wrapper stays
@@ -7810,10 +8194,16 @@ type SyncState = {
    * parent's view (spec 16 U2.4).
    */
   orphans: Set<Entity>; /** Entities the tree check of a dev or agent build already reported, so each is reported once (spec 16 U2.5). */
-  mismatched: Set<Entity>; /** The nine-slice switch, from `config.debug` and `debug.nineSlice`; the pixel check lives in `demand`. */
+  mismatched: Set<Entity>;
+  /**
+   * The nine-slice and overdraw switches, from `config.debug` and `debug.nineSlice` / `debug.overdraw`; the pixel check
+   * lives in `demand`, the kept switch in `kept`.
+   */
   debug: {
     nineSlice: boolean;
-  }; /** The nine-slice switch moved: the next pass writes every nine-slice again. */
+    overdraw: boolean;
+  }; /** The restore table of the overdraw stage pass, its matrix and the listeners of the switch. */
+  overdraw: OverdrawState; /** The nine-slice switch moved: the next pass writes every nine-slice again. */
   outlinesStale: boolean; /** The filters `effects` set per entity, kept while the entity lives, view or not. */
   filters: Map<Entity, readonly FilterSlot[]>; /** The filter area `effects` set per entity, kept like its filters (B4). */
   areas: Map<Entity, AreaEntry>;
@@ -7828,7 +8218,12 @@ type SyncState = {
    * The kind of each Pixi filter a slot named, for the performance log of an agent build; a
    * blur's two passes are filters of their own and are in it too. Empty in a production build.
    */
-  filterKinds: WeakMap<object, string>; /** Hidden masks of engine objects that are no view (an overlay's dim, a kept quad). */
+  filterKinds: WeakMap<object, string>;
+  /**
+   * The entity each Pixi filter a slot hangs on (its stages and a blur's pass filters too), for the passes of the
+   * performance log; the slot set last wins. Empty in a production build.
+   */
+  filterOwners: WeakMap<object, Entity>; /** Hidden masks of engine objects that are no view (an overlay's dim, a kept quad). */
   objectHidden: WeakMap<PixiContainer, number>; /** The view whose top (`wrapper ?? object`) a node is, for the hidden masks (O15; skeleton choice, confirmed in LEAD-FIXES-3). */
   viewOfTop: WeakMap<PixiContainer, View>; /** The overlays, their ranges, dims and HUD parts (spec 22). */
   overlay: OverlayState; /** `Graphics` paths drawn since the monitor last took them: shapes, clip masks, outlines (spec 26 R2.3). */
@@ -7838,8 +8233,42 @@ type SyncState = {
    * an entity with several endless loops is walked once a frame. Cleared by every pass, which may change the tree.
    */
   held: Map<Entity, Unseen>;
+  /**
+   * Moves on with every change that may change the render passes of a frame: a filter set or forgotten, a node's
+   * `renderable` flipped, a view hung, wrapped or dropped (a pass that did work), a kept picture taken or let go, a
+   * write a plugin announced with `invalidate` (a filter switched on or off).
+   */
+  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>;
 };
+/**
+ * The overdraw heat map's state: the restore table of one stage pass (a node, its alpha, its blend mode, its filters
+ * or `undefined` for none), the root's own filters, the matrix made once, and who hears a move of the switch.
+ */
+type OverdrawState = {
+  nodes: PixiContainer[];
+  alphas: number[];
+  blends: Array<PixiContainer["blendMode"]>;
+  filters: Array<readonly PixiFilter[] | undefined>;
+  rootFilters: readonly PixiFilter[] | undefined;
+  matrix: PixiFilter | undefined;
+  listeners: Array<(on: boolean) => void>;
+};
+/**
+ * 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
 /**
@@ -7887,7 +8316,9 @@ type FrameColumns = {
   fltApplies: Uint16Array;
   fltMpx: Float32Array; /** Kept pictures drawn in the frame (spec 23); NaN before attach. */
   kept: Float32Array; /** Kept pictures and range pictures taken in the frame; refreshes go to the per-second count only. */
-  retakes: Float32Array;
+  retakes: Float32Array; /** Render targets Pixi created in the frame (WebGPU, counted on the texture system); NaN where not counted. */
+  targetsCreated: Float32Array; /** Render targets Pixi destroyed in the frame (a pool trim, a resize); NaN where not counted. */
+  targetsDestroyed: Float32Array;
 };
 /**
  * What `read` did: one object owned by the ring, rewritten by every call (copy the numbers you keep).
@@ -7919,6 +8350,11 @@ type FrameReadout = Partial<FrameColumns> & {
  * ```ts
  * const ring = app.renderer.monitor.frames();
  * ring.size; // 1024 after nine seconds at 120 fps; 0 in a production build
+ * // The filter of the newest pass, from the pass ring: `kind2` is 1-based, 0 is "no filter".
+ * const kind2 = ring.passes.kind2[ring.passes.newest] ?? 0; // 2
+ * kind2 === 0 ? null : ring.kindNames[kind2 - 1]; // "fog.blur"
+ * // The world systems the `sysIdx` column indexes; a new system makes a new array.
+ * ring.systemNames[ring.columns.sysIdx[ring.newest * 5] ?? 0]; // "board.looks"
  * ```
  */
 type FrameRing = {
@@ -7939,9 +8375,20 @@ type FrameRing = {
     width: Uint16Array;
     height: Uint16Array;
     gpuMs: Float32Array; /** Pre-sized; references, never copies. */
-    label: (string | null)[];
+    label: (string | null)[]; /** The entity whose filter drew the pass; 0 for none (the canvas, a texture pass, a filter no view hangs). */
+    owner: Uint32Array; /** The filter kind of a filter pass, 1-based into `kindNames` (`kindNames[kind2 - 1]`); 0 for none. */
+    kind2: Uint8Array; /** The draw count of the frame when the pass began: a pass drew up to the next one's (WebGPU; 0 on WebGL). */
+    drawsAt: Uint16Array; /** The target's texture format (`"rgba8unorm"`), by reference; `null` when unknown. */
+    format: (string | null)[]; /** The target's resolution; NaN when unknown. */
+    resolution: Float32Array;
   }; /** Path id → flow path. */
   readonly paths: readonly string[];
+  /**
+   * The interned filter kinds, `"other"` first: `fltKind` and the passes' `kind2` index it 1-based
+   * (`kindNames[kind - 1]`), 0 is none. It only grows, at most 32 names.
+   */
+  readonly kindNames: readonly string[]; /** The world's system names by registration index (`sysIdx`); a registration makes a new array. */
+  readonly systemNames: readonly string[];
   /**
    * Copies the frames committed after the cursor `since` (a `written` value read earlier), oldest first, into the
    * columns `into` provides (`phaseMs` takes 6 values a frame), at most `into.length` of the newest of them. Allocates
@@ -7974,10 +8421,49 @@ 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.
  */
-type PerfMeasured = "gpu" | "passes" | "stencilPasses" | "draws" | "filters" | "uploads" | "compiles" | "marks" | "rebuilds" | "longFrames" | "heap" | "systems" | "kept";
+type PerfMeasured = "gpu" | "passes" | "stencilPasses" | "draws" | "filters" | "uploads" | "compiles" | "marks" | "rebuilds" | "longFrames" | "heap" | "systems" | "kept" | "targets";
 /**
  * What the screen is: in the header and in every `display` event.
  */
@@ -8044,6 +8530,27 @@ type PerfHeaderLine = PerfLine<"header"> & {
     frames: number;
   };
   measured: readonly PerfMeasured[];
+  /**
+   * The bundle identifier of the app, `"com.mokulabs.timber.debug"` in a native debug build (`__MOKU_GAME_APP__`), so a
+   * device stream pairs with its project; `null` on a page without one. The engine always writes it; optional for a
+   * reader of an older log.
+   */
+  app?: {
+    id: string | null;
+  };
+  /**
+   * The debug drawing at the moment of the header: `overdraw` true while the overdraw heat map draws, so the frames that
+   * follow are not read as real cost (a `debug` event marks a switch later). Optional for a reader of an older log.
+   */
+  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.
@@ -8102,6 +8609,28 @@ type MeanMax = {
   mean: number;
   max: number;
 };
+/**
+ * The live object counts of a sample, read once a second: a count that grows each time a screen is entered and left
+ * is a leak. `entities` are the world's live entities, `views` the display objects `sync` holds, `timers` the clock's
+ * scheduled moments not yet due, `frameListeners` the `time.onFrame` callbacks, `clockListeners` the `clock.onElapsed`
+ * listeners; every count a plugin registered through `monitor.counts.register` sits beside them by its name
+ * (`inputListeners`).
+ *
+ * @example
+ * ```ts
+ * const counts: PerfCounts = {
+ *   entities: 412, views: 180, timers: 1, frameListeners: 9, clockListeners: 2, inputListeners: 6
+ * };
+ * ```
+ */
+type PerfCounts = {
+  readonly entities: number;
+  readonly views: number;
+  readonly timers: number;
+  readonly frameListeners: number;
+  readonly clockListeners: number;
+  readonly [registered: string]: number;
+};
 /**
  * One second of frames.
  */
@@ -8184,7 +8713,23 @@ type PerfSampleLine = PerfLine<"sample"> & {
   pooled: number;
   resolution: number;
   monitorMs: number;
-  spikes: number;
+  spikes: number; /** The live object counts of the moment (U3); optional for a reader of an older log. */
+  counts?: PerfCounts;
+  /**
+   * Render targets Pixi created and destroyed in the second (WebGPU); `null` where they are not counted. Not the
+   * texture memory of `textures.targets`. Optional for a reader of an older log.
+   */
+  targets?: {
+    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,
@@ -8279,7 +8824,8 @@ type FrameRecord = {
  */
 type PassKind = "canvas" | "texture" | "filter";
 /**
- * One render pass of a spike frame.
+ * One render pass of a spike frame. The fields after `gpuMs` came with the 0.15 telemetry; a reader of an older log
+ * finds them absent.
  */
 type PassRecord = {
   index: number;
@@ -8288,7 +8834,14 @@ type PassRecord = {
   stencil: boolean | null;
   w: number;
   h: number;
-  gpuMs: number | null;
+  gpuMs: number | null; /** The entity whose filter drew the pass; `null` for the canvas, a texture pass and a filter no view hangs. */
+  owner?: Entity | null; /** The label of the owner's view when the line was built; `null` without an owner or once the view left. */
+  view?: string | null; /** The kind id of the filter that drew it (`"fog.blur"`), `"other"` for a filter without one; `null` otherwise. */
+  filter?: string | null; /** The draws issued in the pass (WebGPU); `null` where draws are not counted. */
+  draws?: number | null; /** The target's texture format; `null` when unknown. */
+  format?: string | null; /** The target's resolution; `null` when unknown. */
+  resolution?: number | null; /** The pass took or refreshed a kept picture (its label starts with `kept:`). */
+  kept?: boolean;
 };
 /**
  * A frame over the budget, with its detail.
@@ -8320,9 +8873,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";
+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).
@@ -8375,6 +8929,113 @@ type PoolTrimDetail = {
 type WarmDetail = {
   draws: number;
 };
+/**
+ * What a `shader` event line reports, in its `what`: a render pipeline (WebGPU) or a program (WebGL) created, or a
+ * WebGPU shader module compiled. New values are only ever appended.
+ *
+ * @example
+ * ```ts
+ * // The editor counts the pipelines of a recording without a switch over strings it does not know.
+ * const pipelines = lines.filter(line => line.kind === "event" && line.name === "shader" && line.detail.what === SHADER_WHATS[0]).length; // 14
+ * ```
+ */
+declare const SHADER_WHATS: readonly ["compile", "module"];
+/**
+ * One value of `SHADER_WHATS`.
+ *
+ * @example
+ * ```ts
+ * const what: ShaderWhat = "module";
+ * ```
+ */
+type ShaderWhat = (typeof SHADER_WHATS)[number];
+/**
+ * The detail of a `shader` event line: one pipeline or program created, or one shader module compiled, in the frame
+ * `frame`, written at the flush of its second. `boot` is true up to the first drawn frame (the warm-up and the first
+ * screen); `during` names where it happened: the index of the pass of the frame, and the filter, its entity and the
+ * label of that entity's view when a filter was applying. A compile of a plain batch has no filter: `owner: null`.
+ *
+ * @example
+ * ```ts
+ * // The fog blur of the memory screen compiled its pipeline while it applied on the board's fog layer.
+ * const detail: ShaderEventDetail = {
+ *   what: "compile", label: "PIXI Pipeline (blur-pass-filter)", ms: 4.2, frame: 1824, boot: false,
+ *   during: { pass: 2, filter: "fog.blur", owner: 1_048_601, view: "Sprite#1048601 board.fog:fog" }
+ * };
+ * ```
+ */
+type ShaderEventDetail = {
+  what: ShaderWhat;
+  label: string | null;
+  ms: number;
+  frame: number;
+  boot: boolean;
+  during: {
+    pass: number | null;
+    filter: string | null;
+    owner: Entity | null;
+    view: string | null;
+  };
+};
+/**
+ * The rules of the `problem` event lines, judged once a second: `filter-still` (a filtered view stood still and was
+ * filtered again in every drawn frame), `target-churn` (render targets made and dropped all the time, or right after a
+ * pool trim, or while idle), `retakes` (a kept view taken again and again). New rules are only ever appended.
+ *
+ * @example
+ * ```ts
+ * // The editor reads the rule of the first problem a recording opened: a fog blur filtered again on a still board.
+ * const problems = lines.filter((line): line is PerfEventLine => line.kind === "event" && line.name === "problem");
+ * const opened = problems.find(line => line.detail.cleared !== true);
+ * PROBLEM_RULES.find(rule => rule === opened?.detail.rule); // "filter-still"
+ * ```
+ */
+declare const PROBLEM_RULES: readonly ["filter-still", "target-churn", "retakes"];
+/**
+ * One value of `PROBLEM_RULES`.
+ *
+ * @example
+ * ```ts
+ * const rule: ProblemRule = "target-churn";
+ * ```
+ */
+type ProblemRule = (typeof PROBLEM_RULES)[number];
+/**
+ * The detail of a `problem` event line: a rule crossed its threshold. Written once per crossing; the line with
+ * `cleared: true` follows when the condition stops. `value` is in the rule's unit (still frames, targets made and
+ * dropped per second, takes in two seconds), `since` the frame the run began, `frames` the frames it covers. `reason`
+ * says why a still filtered view is not kept (`"budget"`: its take was refused for the kept budget, `"not-eligible"`:
+ * the kept policy may not keep it) and which clause of `target-churn` fired (`"rate"`, `"idle"`, `"after-trim"`).
+ *
+ * @example
+ * ```ts
+ * // The fog of the board is blurred again in every frame of a still screen: the budget refused its picture.
+ * const opened: ProblemEventDetail = {
+ *   rule: "filter-still", severity: "warn", owner: 1_048_601, view: "Sprite#1048601 board.fog:fog",
+ *   filter: "fog.blur", value: 75, threshold: 60, since: 1700, frames: 75, reason: "budget"
+ * };
+ * const closed: ProblemEventDetail = {
+ *   rule: "filter-still", cleared: true, owner: 1_048_601, view: "Sprite#1048601 board.fog:fog"
+ * };
+ * ```
+ */
+type ProblemEventDetail = {
+  rule: ProblemRule;
+  severity: "info" | "warn";
+  owner: Entity | null;
+  view: string | null;
+  filter: string | null;
+  value: number;
+  threshold: number;
+  since: number;
+  frames: number;
+  reason?: "budget" | "not-eligible" | "rate" | "idle" | "after-trim";
+} | {
+  rule: ProblemRule;
+  cleared: true;
+  owner: Entity | null;
+  view: string | null;
+};
 /**
  * Something that happened, at the frame it happened in.
  */
@@ -8417,6 +9078,30 @@ type PerfCollectorLine = PerfLine<"gfx"> & {
   p99: number;
   hist: Readonly<Record<string, number>>;
 };
+/**
+ * A line the editor's collector writes into the computer's copy of a device log for lines the device lost before it
+ * sent them; the engine never produces it.
+ */
+type PerfGapLine = PerfLine<"gap"> & {
+  /** Computer epoch ms at receipt. */rx: number;
+  device: string | null; /** Lines lost. */
+  lines: number;
+};
+/**
+ * A line of wired device telemetry (GPU clock and load, CPU and memory per process, heap samples) the editor's
+ * collector writes into the computer's copy of a device log while it records; the engine never produces it. The
+ * readings are the editor's `DeviceTelemetry` fields as it defines them: the engine passes them as JSON.
+ */
+type PerfTelemetryLine = PerfLine<"telemetry"> & {
+  /** Computer epoch ms at receipt. */rx: number;
+  device: string;
+  serial: string | null;
+  wired: boolean;
+  gpu: Json;
+  cpu: Json;
+  memory: Json;
+  heap: Json;
+};
 /**
  * One line of the performance log.
  *
@@ -8425,7 +9110,7 @@ type PerfCollectorLine = PerfLine<"gfx"> & {
  * const off = app.renderer.monitor.stream((line: PerfLogLine) => lines.push(line));
  * ```
  */
-type PerfLogLine = PerfHeaderLine | PerfStartupLine | PerfSampleLine | PerfSpikeLine | PerfLongFrameLine | PerfEventLine | PerfMarkLine | PerfThermalLine | PerfCollectorLine;
+type PerfLogLine = PerfHeaderLine | PerfStartupLine | PerfSampleLine | PerfSpikeLine | PerfLongFrameLine | PerfEventLine | PerfMarkLine | PerfThermalLine | PerfCollectorLine | PerfGapLine | PerfTelemetryLine;
 //#endregion
 //#region src/plugins/renderer/host/resolution.d.ts
 /**
@@ -8930,6 +9615,11 @@ type RenderStats = {
    * rebuilds at its start and its end. Dev and debug builds only.
    */
   rebuilds?: number;
+  /**
+   * The live object counts of the moment, the same the performance log samples once a second: entities, views, the
+   * clock's timers and listeners, the frame callbacks and every count a plugin registered. Agent builds only.
+   */
+  counts?: PerfCounts;
 };
 /**
  * The draw-call counter of a dev build: the draws of the frame being drawn and of the last one.
@@ -8952,23 +9642,40 @@ type CountingClasses = {
   glTexture: PixiModule["GlTextureSystem"];
 };
 /**
- * One pipeline or program compile a wrapper saw: its frame, its label (by reference) and the CPU
- * time of the creation call. Not public.
+ * One pipeline or program compile, or one shader module, a wrapper saw: its frame, its label (by reference), the CPU
+ * time of the creation call, and where it happened: the pass of the frame, the filter kind and its owner. Not public.
  */
 type CompileRecord = {
   frame: number;
   label: string | null;
-  ms: number;
+  ms: number; /** A WebGPU shader module, not a pipeline: not a compile of the frame's count. */
+  module: boolean; /** The index of the pass of the frame it happened in; -1 before the first pass or outside a frame. */
+  pass: number; /** The interned kind of the filter applying then, 1-based; 0 without a filter. */
+  kind: number; /** The entity whose filter applied then; 0 without one. */
+  owner: number;
 };
 /**
- * The last 64 compiles, in pre-made records written in turn, and the shader modules counted for
- * the header. Not public.
+ * The last 64 compiles and shader modules, in pre-made records written in turn, the shader modules counted for the
+ * header, and how many records were ever written and sent as `shader` events. Not public.
  */
 type CompileRing = {
   records: CompileRecord[];
   next: number;
   size: number;
-  shaderModules: number;
+  shaderModules: number; /** Records ever written. */
+  written: number; /** Records sent as `shader` events: the ones from `sent` to `written` wait for a flush with a listener. */
+  sent: number;
+};
+/**
+ * The owners of the filter applies of a frame, in a fixed table: the entity, its applies and pixels of the frame
+ * (zeroed in `begin()`) and the kind of its last apply. A slot stays while its owner applies. The entities are held in
+ * a `Float64Array`, exact for every entity, read with `cellF64` like the applies and pixels beside them. Not public.
+ */
+type OwnerTable = {
+  ids: Float64Array;
+  applies: Float64Array;
+  pixels: Float64Array;
+  kinds: Uint8Array;
 };
 /**
  * A render target as the pass rules read it: the public fields of Pixi's `RenderTarget`. Not
@@ -8981,6 +9688,10 @@ type PassTarget = {
   readonly label?: string | undefined;
   readonly colorTexture?: {
     readonly label?: string | undefined;
+    readonly source?: {
+      readonly format?: string;
+      readonly resolution?: number;
+    } | undefined;
   } | undefined;
 };
 /**
@@ -9015,11 +9726,16 @@ type MonitorSinks = {
   kindNames: string[]; /** Applies of each kind in this frame, zeroed in `begin()`. */
   kindApplies: Float64Array; /** Pixels of each kind in this frame, zeroed in `begin()`. */
   kindPixels: Float64Array; /** The kind of each Pixi filter, `SyncState.filterKinds`, handed over at attach. */
-  filterKinds: WeakMap<object, string> | undefined;
+  filterKinds: WeakMap<object, string> | undefined; /** The entity each Pixi filter hangs on, `SyncState.filterOwners`, handed over at attach. */
+  filterOwners: WeakMap<object, number> | undefined; /** The entity of the apply running now (0 = none); names the owner of a filter pass. */
+  filterOwner: number; /** The owners of this frame's filter applies (agent builds). */
+  owners: OwnerTable;
   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.
@@ -9037,6 +9753,11 @@ type RingPasses = {
   height: Uint16Array;
   gpuMs: Float32Array;
   label: (string | null)[];
+  owner: Uint32Array;
+  kind2: Uint8Array;
+  drawsAt: Uint16Array;
+  format: (string | null)[];
+  resolution: Float32Array;
 };
 /**
  * The last 64 changes of a frame that had a subject: a scene switched to, a bundle loaded. Not
@@ -9060,7 +9781,7 @@ type PerfRing = {
   written: number;
   columns: FrameColumns;
   passes: RingPasses;
-  paths: string[]; /** Interned filter kind names, the sinks' list: `fltKind − 1` indexes it. */
+  paths: string[]; /** Interned filter kind names, the sinks' list: `fltKind − 1` and `passes.kind2 − 1` index it. */
   kindNames: readonly string[]; /** The world's system names by registration index: `sysIdx` indexes it. */
   systemNames: readonly string[]; /** The subjects of the changes of recent frames. */
   events: EventRing; /** The one answer `read` rewrites. */
@@ -9128,6 +9849,50 @@ type TickEstimate = {
   next: number; /** `[0]`: the period of the display rate the median snaps to, ms; NaN while it snaps to none. */
   periodMs: Float64Array;
 };
+/**
+ * The counts plugins registered with `monitor.counts.register`, in a table of `COUNT_SLOTS` read once a second. Not
+ * public.
+ */
+type CountTable = {
+  names: string[];
+  reads: Array<() => number>; /** Readers that threw once and were warned about. */
+  failed: Set<string>;
+};
+/**
+ * The thresholds of the problem rules, from `renderer.monitor`, defaults filled in. Not public.
+ */
+type ProblemThresholds = {
+  stillFrames: number;
+  stillMpx: number;
+  churnPerSecond: number;
+  churnSeconds: number;
+  churnAfterTrimMs: number;
+};
+/**
+ * The accumulators of the problem rules: per owner of a filter (the slots of `MonitorSinks.owners`) the drawn frames
+ * in a row it applied in, the frame that run began, its applies and pixels of the second; the render targets of the
+ * second and its churn seconds in a row; the takes of each kept record two flushes back; and the problems open now.
+ * Not public.
+ */
+type ProblemState = {
+  thresholds: ProblemThresholds;
+  run: Float64Array;
+  runSince: Float64Array;
+  secFrames: Float64Array;
+  secPixels: Float64Array; /** 1 while the `filter-still` problem of the owner in that slot is open. */
+  stillOpen: Uint8Array; /** Render targets made and dropped this second. */
+  secTargets: number; /** A create in an idle frame, this second. */
+  idleCreate: boolean; /** A create within `churnAfterTrimMs` after a pool trim, this second. */
+  trimCreate: boolean; /** The frame of the first such create of the second. */
+  createFrame: number; /** Page clock of the last pool trim; NaN before one. */
+  trimAt: number; /** Seconds in a row with `churnPerSecond` or more targets made and dropped, and the frame the run began. */
+  churnRun: number;
+  churnSince: number;
+  churnOpen: boolean; /** The stage-1 takes (`s1Version`) of each kept record at the last two flushes, newest first. */
+  takes: [Map<number, number>, Map<number, number>]; /** The frame of each of those two flushes. */
+  takesFrame: [number, number]; /** The owners with an open `retakes` problem. */
+  retakesOpen: Set<number>;
+};
 /**
  * What the monitor of an agent build keeps. `undefined` in a build without the flag. Not public.
  */
@@ -9135,8 +9900,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. */
@@ -9164,7 +9935,10 @@ type PerfState = {
   failed: WeakSet<(line: PerfLogLine) => void>; /** Whether the header waits for the native shell. */
   shell: "unknown" | "waiting" | "settled";
   startup: PerfStartupLine | undefined; /** Page-clock end of the first drawn frame; NaN before. */
-  firstDrawnAt: number;
+  firstDrawnAt: number; /** The number of the first drawn frame; NaN before. A compile up to it is a boot compile. */
+  firstDrawnFrame: number; /** The counts plugins registered. */
+  counts: CountTable; /** The problem rules' accumulators. */
+  problems: ProblemState;
   timer: FrameTimer | undefined;
   longFrames: LongFrameRing; /** Per-application removers: runners, wrappers, the timer. */
   detach: Array<() => void>; /** The first attach registered the time listener and the observer. */
@@ -9175,8 +9949,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. */
@@ -9382,6 +10157,70 @@ 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`.
+   *
+   * @example
+   * ```ts
+   * // A game's own pool of particles joins the leak counts of a debug build.
+   * app.renderer.monitor.counts.register("sparks", () => sparkPool.live);
+   * app.renderer.stats().counts?.sparks; // 24
+   * ```
+   */
+  counts: MonitorCounts;
+};
+/**
+ * The count registry of `renderer.monitor.counts`: at most 16 counts, read once a second. Agent builds only.
+ *
+ * @example
+ * ```ts
+ * // A game's pool of sparks joins the leak counts of the sample.
+ * app.renderer.monitor.counts.register("sparks", () => sparkPool.size);
+ * ```
+ */
+type MonitorCounts = {
+  /**
+   * Registers a count under a name: `read` is called once a second, at the flush of the sample, and its number goes
+   * into `sample.counts[name]` and `stats().counts[name]`. It must answer a number and allocate nothing. A name already
+   * registered gets the new reader. The renderer's `onStop` drops every registration. Agent builds only: without the
+   * flag nothing is kept and the returned remover does nothing.
+   *
+   * @param name - The count's name in the sample, beside `entities`, `views`, `timers`, `frameListeners` and
+   *   `clockListeners`.
+   * @param read - Answers the count now.
+   * @returns The remover; a second call does nothing.
+   * @throws {Error} When 16 counts are registered already: `[game] Monitor count table is full (16).`
+   * @example
+   * ```ts
+   * // A game's pool of sparks joins the leak counts: the reader answers the pool's size, and a pool that grows with
+   * // every visit of the shop shows as a count that grows in every sample.
+   * const off = app.renderer.monitor.counts.register("myPool", () => pool.size);
+   * app.renderer.stats().counts?.myPool; // 24 while the pool holds 24 sparks
+   * off();
+   * app.renderer.stats().counts?.myPool; // undefined
+   * ```
+   */
+  register(name: string, read: () => number): () => void;
 };
 /**
  * monitor methods the frame and the hooks drive. Not public.
@@ -9559,7 +10398,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, MonitorDeps, MonitorInternal, MonitorModule, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfDisplay, PerfEventLine, PerfEventName, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, Point, PoolTrim, PoolTrimDetail, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, 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
@@ -9776,11 +10615,16 @@ type Config$2 = {
   warm: number;
 };
 /**
- * The performance monitor of an agent build (`__MOKU_GAME_AGENT__`: dev and `--debug` builds).
+ * The performance monitor of an agent build (`__MOKU_GAME_AGENT__`: dev and `--debug` builds): the spike budget, the
+ * ring's frames and the thresholds of the `problem` rules. A threshold left out keeps its default.
  *
  * @example
  * ```ts
  * 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 = {
@@ -9791,7 +10635,17 @@ type MonitorConfig = {
    * no config change; a number is a fixed budget in ms.
    */
   budgetMs: number | "rate"; /** Frames the ring keeps in an agent build, 64 to 16384; render passes keep 4x as many. */
-  frames: number;
+  frames: number; /** `filter-still`: drawn frames a filtered view stands still, filtered in every one. Default 60. */
+  stillFrames?: number; /** `filter-still`: megapixels its filter covers a frame, at least. Default 0.25. */
+  stillMpx?: number; /** `target-churn`: render targets made and dropped a second that count as churn. Default 4. */
+  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.
@@ -11218,4 +12072,4 @@ type BundleCompanion = {
   unload(bundle: string): void;
 };
 //#endregion
-export { PerfChangeEntry as $, NodeFx as $n, FrameDiff as $t, PixiSprite as A, defineFlow as An, Api$7 as Ar, Shape as At, FrameReadout as B, DefineNode as Bn, Require as Br, Config$3 as Bt, State$1 as C, EmitterIdOf as Cn, RngState as Cr, HudPart as Ct, MonitorConfig as D, State$4 as Dn, PauseReason as Dr, Overlay as Dt, Config$2 as E, Position as En, Events$6 as Er, NineSliceValue as Et, types_d_exports$2 as F, FeatureDescription as Fn, ThermalReading as Fr, Transform as Ft, OverlayWhat as G, RouteStep as Gn, AnyComponentType as Gt, FrameRing as H, FlowState as Hn, State$3 as Ht, Captured as I, FeaturePlugin as In, Time as Ir, TransformValue as It, PERF_LOG_VERSION as J, Descriptor as Jn, ComponentSchema as Jt, PERF_CAUSES as K, SceneIdOf as Kn, AnyComponentValue as Kt, RenderStats as L, FeatureTree as Ln, types_d_exports$8 as Lr, sprite as Lt, PoolTrim as M, slot as Mn, FrameRate as Mr, Sprite as Mt, State$2 as N, to as Nn, RateChange as Nr, SpriteOptions as Nt, PixiFilter as O, TextStylesOf as On, State$7 as Or, OverlayValue as Ot, Under as P, type as Pn, State$8 as Pr, SpriteValue as Pt, PerfChange as Q, Hint as Qn, EntitySnapshot as Qt, FrameColumns as R, AnyFlow as Rn, Config$9 as Rr, DEMAND_REASONS as Rt, ScenesApi as S, Config$4 as Sn, RngApi as Sr, Display as St, Api$1 as T, HudKeysOf as Tn, Config$7 as Tr, NineSlice$1 as Tt, LongFrameEntry as U, JournalEntry as Un, types_d_exports$3 as Ut, FrameRecord as V, FlowGraph as Vn, Explained as Vt, OverlayEventDetail as W, NodeTable as Wn, AnyComponent as Wt, PassRecord as X, EffectOptions as Xn, ComponentValue as Xt, PassKind as Y, Effect as Yn, ComponentType as Yt, PerfCause as Z, GuideOptions as Zn, Entity as Zt, DefineScene as _, TrackOptions as _n, SaveDoc as _r, FilterSlotInputs as _t, Config as a, SystemFor as an, State$5 as ar, PerfLogLine as at, SceneDefinition as b, Api$3 as bn, SnapshotOf as br, ViewportSize as bt, LoadBundles as c, DescriptionNode as cn, Config$6 as cr, PerfMeasured as ct, Manifest as d, MotionCause as dn, Root as dr, PerfStartupLine as dt, Mut as en, Answer as er, PerfCollectorLine as et, State as f, MotionHandle as fn, State$6 as fr, PerfThermalLine as ft, AnySceneProjection as g, ReducedMotion as gn, ProviderCall as gr, FilterSlot as gt, types_d_exports as h, ProjectionSpec as hn, PlayerStateProvider as hr, DebugSwitches as ht, BundleSpec as i, SystemDefinition as in, FakeClock as ir, PerfHeaderLine as it, PixiTexture as j, exit as jn, Config$8 as jr, ShapeValue as jt, PixiModule as k, types_d_exports$4 as kn, types_d_exports$7 as kr, Parent as kt, LoadReason as l, Ease as ln, Events$5 as lr, PerfSampleLine as lt, Usage as m, ProjectionMotion as mn, Patch as mr, WarmDetail as mt, AssetsIo as n, QueryTerm as nn, ClockSource as nr, PerfEventLine as nt, DefineBundles as o, TagType as on, types_d_exports$5 as or, PerfLongFrameLine as ot, Tier as p, NumericFields as pn, types_d_exports$6 as pr, PoolTrimDetail as pt, PERF_GAP_BUCKETS as q, TypeTag as qn, ComponentHandle as qt, BundleMap as r, ResourceType as rn, Config$5 as rr, PerfEventName as rt, Events as s, ChangeHook as sn, Api$5 as sr, PerfMarkLine as st, Api as t, Narrowed as tn, Api$4 as tr, PerfDisplay as tt, LoadResult as u, Motion as un, Json as ur, PerfSpikeLine as ut, Events$1 as v, TrackSegment as vn, SaveUnreadableError as vr, Orientation as vt, types_d_exports$1 as w, GameTypes as wn, Api$6 as wr, HudPartValue as wt, SceneSpec as x, BundlesOf as xn, StoreApi as xr, FilterCache as xt, LayerMap as y, ViewHandle as yn, Snapshot as yr, Point as yt, FrameReadResult as z, Bookmark as zn, Events$8 as zr, Api$2 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 };