@moku-labs/game 0.14.13 → 0.15.1

package/dist/{types-BGcda5Le.d.mts → types-E2ykwIUO.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.
@@ -5689,6 +5769,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 +5879,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 +5889,7 @@ type EcsInternal = {
  */
 type SystemTiming = {
   readonly clock: () => number;
-  readonly names: string[];
+  names: readonly string[];
   ms: Float64Array;
 };
 declare namespace types_d_exports$3 {
@@ -5858,7 +5958,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`.
@@ -6373,7 +6474,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 +6512,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 +7314,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 +7337,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 +7370,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 +7384,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 +7428,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 +7551,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 +7697,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 +7963,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 +7987,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). */
@@ -7840,6 +8004,19 @@ type SyncState = {
   held: Map<Entity, Unseen>;
   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>;
+};
 //#endregion
 //#region src/plugins/renderer/monitor/log-types.d.ts
 /**
@@ -7887,7 +8064,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 +8098,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 +8123,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
@@ -7977,7 +8172,7 @@ type PerfLine<Kind extends string> = {
 /**
  * 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 +8239,21 @@ 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;
+  };
 };
 /**
  * One Long Animation Frame (or long task) of the page.
@@ -8102,6 +8312,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 +8416,16 @@ 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;
 };
 /**
  * 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 +8520,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 +8530,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.
@@ -8322,7 +8571,7 @@ type PerfLongFrameLine = PerfLine<"longFrame"> & LongFrameEntry & {
  * 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`).
  */
-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";
 /**
  * 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 +8624,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 +8773,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 +8805,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 +9310,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 +9337,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 +9383,10 @@ type PassTarget = {
   readonly label?: string | undefined;
   readonly colorTexture?: {
     readonly label?: string | undefined;
+    readonly source?: {
+      readonly format?: string;
+      readonly resolution?: number;
+    } | undefined;
   } | undefined;
 };
 /**
@@ -9015,7 +9421,10 @@ 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). */
@@ -9037,6 +9446,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 +9474,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 +9542,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.
  */
@@ -9164,7 +9622,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. */
@@ -9382,6 +9843,51 @@ type PerfMonitorApi = {
    * ```
    */
   setResolution(resolution: number | undefined): number;
+  /**
+   * 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 +10065,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, 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 +10282,14 @@ 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 } } } });
  * ```
  */
 type MonitorConfig = {
@@ -9791,7 +10300,12 @@ 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;
 };
 /**
  * renderer plugin state: one branch per module.
@@ -11218,4 +11732,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 { PerfCause as $, JournalEntry as $n, types_d_exports$3 as $t, PixiSprite as A, Api$3 as An, SnapshotOf as Ar, ViewportSize as At, FrameReadResult as B, defineFlow as Bn, Api$7 as Br, Shape as Bt, State$1 as C, NumericFields as Cn, types_d_exports$6 as Cr, ShaderWhat as Ct, MonitorConfig as D, TrackOptions as Dn, SaveDoc as Dr, FilterSlotInputs as Dt, Config$2 as E, ReducedMotion as En, ProviderCall as Er, FilterSlot as Et, types_d_exports$2 as F, HudKeysOf as Fn, Config$7 as Fr, NineSlice$1 as Ft, OverlayEventDetail as G, FeatureDescription as Gn, ThermalReading as Gr, Transform as Gt, FrameRecord as H, slot as Hn, FrameRate as Hr, Sprite as Ht, Captured as I, Position as In, Events$6 as Ir, NineSliceValue as It, PERF_GAP_BUCKETS as J, AnyFlow as Jn, Config$9 as Jr, DEMAND_REASONS as Jt, OverlayWhat as K, FeaturePlugin as Kn, Time as Kr, TransformValue as Kt, MonitorCounts as L, State$4 as Ln, PauseReason as Lr, Overlay as Lt, PoolTrim as M, Config$4 as Mn, RngApi as Mr, Display as Mt, State$2 as N, EmitterIdOf as Nn, RngState as Nr, HudPart as Nt, PixiFilter as O, TrackSegment as On, SaveUnreadableError as Or, Orientation as Ot, Under as P, GameTypes as Pn, Api$6 as Pr, HudPartValue as Pt, PassRecord as Q, FlowState as Qn, State$3 as Qt, RenderStats as R, TextStylesOf as Rn, State$7 as Rr, OverlayValue as Rt, ScenesApi as S, MotionHandle as Sn, State$6 as Sr, ShaderEventDetail as St, Api$1 as T, ProjectionSpec as Tn, PlayerStateProvider as Tr, DebugSwitches as Tt, FrameRing as U, to as Un, RateChange as Ur, SpriteOptions as Ut, FrameReadout as V, exit as Vn, Config$8 as Vr, ShapeValue as Vt, LongFrameEntry as W, type as Wn, State$8 as Wr, SpriteValue as Wt, PROBLEM_RULES as X, DefineNode as Xn, Require as Xr, Config$3 as Xt, PERF_LOG_VERSION as Y, Bookmark as Yn, Events$8 as Yr, Api$2 as Yt, PassKind as Z, FlowGraph as Zn, Explained as Zt, DefineScene as _, ChangeHook as _n, Api$5 as _r, PerfThermalLine as _t, Config as a, ComponentType as an, Effect as ar, PerfEventLine as at, SceneDefinition as b, Motion as bn, Json as br, ProblemRule as bt, LoadBundles as c, EntitySnapshot as cn, Hint as cr, PerfHeaderLine as ct, Manifest as d, Narrowed as dn, Api$4 as dr, PerfMarkLine as dt, AnyComponent as en, NodeTable as er, PerfChange as et, State as f, QueryTerm as fn, ClockSource as fr, PerfMeasured as ft, AnySceneProjection as g, TagType as gn, types_d_exports$5 as gr, PerfTelemetryLine as gt, types_d_exports as h, SystemFor as hn, State$5 as hr, PerfStartupLine as ht, BundleSpec as i, ComponentSchema as in, Descriptor as ir, PerfDisplay as it, PixiTexture as j, BundlesOf as jn, StoreApi as jr, FilterCache as jt, PixiModule as k, ViewHandle as kn, Snapshot as kr, Point as kt, LoadReason as l, FrameDiff as ln, NodeFx as lr, PerfLogLine as lt, Usage as m, SystemDefinition as mn, FakeClock as mr, PerfSpikeLine as mt, AssetsIo as n, AnyComponentValue as nn, SceneIdOf as nr, PerfCollectorLine as nt, DefineBundles as o, ComponentValue as on, EffectOptions as or, PerfEventName as ot, Tier as p, ResourceType as pn, Config$5 as pr, PerfSampleLine as pt, PERF_CAUSES as q, FeatureTree as qn, types_d_exports$8 as qr, sprite as qt, BundleMap as r, ComponentHandle as rn, TypeTag as rr, PerfCounts as rt, Events as s, Entity as sn, GuideOptions as sr, PerfGapLine as st, Api as t, AnyComponentType as tn, RouteStep as tr, PerfChangeEntry as tt, LoadResult as u, Mut as un, Answer as ur, PerfLongFrameLine as ut, Events$1 as v, DescriptionNode as vn, Config$6 as vr, PoolTrimDetail as vt, types_d_exports$1 as w, ProjectionMotion as wn, Patch as wr, WarmDetail as wt, SceneSpec as x, MotionCause as xn, Root as xr, SHADER_WHATS as xt, LayerMap as y, Ease as yn, Events$5 as yr, ProblemEventDetail as yt, FrameColumns as z, types_d_exports$4 as zn, types_d_exports$7 as zr, Parent as zt };