@moku-labs/game 0.15.5 → 0.15.7

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { Jn as FeaturePlugin, Sr as Json, Xn as AnyFlow, dr as NodeFx, gr as FakeClock, mr as ClockSource, nr as NodeTable, or as Descriptor, ur as Hint } from "./types-DnttyLeu.mjs";
-import { t as createApp } from "./index-Bq_93oZv.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-6inPYTzE.mjs";
-import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-DDkRwLnJ.mjs";
+import { Cr as Json, Yn as FeaturePlugin, Zn as AnyFlow, _r as FakeClock, dr as Hint, fr as NodeFx, hr as ClockSource, rr as NodeTable, sr as Descriptor } from "./types-C4D9UVgb.mjs";
+import { t as createApp } from "./index-CU4Oc2Qv.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-MocH_igX.mjs";
+import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-DobgwTKK.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { an as exit, cn as type, in as refuseStart, m as flattenFeatures, t as createApp } from "./src-DnclBdeU.mjs";
+import { an as exit, cn as type, in as refuseStart, m as flattenFeatures, t as createApp } from "./src-nJYt0LMr.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { t as fakeClock } from "./fake-6mazmHK3.mjs";
 import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-BA6ffzqD.mjs";

package/dist/{types-C2g2KYCN.d.mts → types-BkcgFOoB.d.mts}

@@ -1,5 +1,5 @@
-import { A as PixiSprite, An as TrackSegment, Hr as Api$1, Mn as Api$2, Nt as FilterCache, O as PixiFilter, On as ReducedMotion, Ot as FilterSlot, Qr as Require, Rr as Events$5, Sr as Json, T as Api$4, Tn as NumericFields, Zr as Events$2, Zt as Api$3, an as ComponentHandle, ar as TypeTag, in as AnyComponentValue, j as PixiTexture, jt as Point, k as PixiModule, kn as TrackOptions, kt as FilterSlotInputs, ln as Entity, nn as AnyComponent, or as Descriptor, s as Events$1, sn as ComponentType, t as Api$5, v as Events$4, wn as MotionHandle, xn as Ease, xr as Events$3, yr as Api$6 } from "./types-DnttyLeu.mjs";
-import { I as I18nApi, J as StylesState, S as TextApi, c as UiNode, i as Finding, j as InputApi, n as ElementChange, o as JsxState, r as ElementMotion } from "./types-CWSMo70I.mjs";
+import { $r as Require, A as PixiModule, An as TrackOptions, At as FilterSlotInputs, Cr as Json, E as Api$4, En as NumericFields, M as PixiTexture, Mt as Point, Nn as Api$2, Pt as FilterCache, Qr as Events$2, Qt as Api$3, Sn as Ease, Sr as Events$3, Tn as MotionHandle, Ur as Api$1, an as AnyComponentValue, br as Api$6, cn as ComponentType, j as PixiSprite, jn as TrackSegment, k as PixiFilter, kn as ReducedMotion, kt as FilterSlot, on as ComponentHandle, or as TypeTag, rn as AnyComponent, s as Events$1, sr as Descriptor, t as Api$5, un as Entity, v as Events$4, zr as Events$5 } from "./types-C4D9UVgb.mjs";
+import { I as I18nApi, J as StylesState, S as TextApi, c as UiNode, i as Finding, j as InputApi, n as ElementChange, o as JsxState, r as ElementMotion } from "./types-CZGuMhV8.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -1358,15 +1358,17 @@ type FilterArea = readonly [x: number, y: number, width: number, height: number]
  *
  * @example
  * ```ts
- * // A Memory Missing's frost: the body reads a blurred copy of the scene through sampleBlur(uv).
+ * // A Memory Missing's frost on the layer of its panels: the body reads a blurred copy of the scene drawn under them.
  * const Frost = defineFilter("Frost", {
  *   wgsl: FROST_WGSL,
  *   glsl: FROST_GLSL,
  *   uniforms: { view: [0, 0, 1], rectA: [0, 0, 0, 0], strength: 16, vivid: 1.2 },
- *   inputs: { blur: { stages: [FrostBox4, FrostHalf, FrostGauss], chain: frostChain } },
+ *   backdrop: true,
+ *   inputs: { blur: { from: "back", stages: [FrostBox4, FrostHalf, FrostGauss], chain: frostChain } },
+ *   area: value => [value.rectA[0] ?? 0, value.rectA[1] ?? 0, value.rectA[2] ?? 0, value.rectA[3] ?? 0],
  *   fallback: FrostVeil
  * });
- * Frost.filter.fallback?.id; // "FrostVeil"
+ * [Frost.filter.backdrop, Frost.filter.cache, Frost.filter.inputs[0]?.from]; // [true, "screen", "back"]
  * ```
  */
 type FilterSpec<Uniforms extends Record<string, UniformDeclaration>> = {
@@ -1408,6 +1410,22 @@ type FilterSpec<Uniforms extends Record<string, UniformDeclaration>> = {
    * only when the value changed.
    */
   readonly area?: (value: Readonly<FilterValueOf<Uniforms>>) => FilterArea | undefined;
+  /**
+   * The texels per CSS px the view and its filters are drawn at under this filter, from 0 to 4; `0` (the default) for
+   * the resolution of the canvas. Pixi draws all the filters of a view at the smallest resolution among them, so a
+   * resolution below the canvas's lowers the others on the same view too. A stage of an input ignores it: its step's
+   * `scale` sizes it.
+   */
+  readonly resolution?: number;
+  /**
+   * `true` for a filter that reads what was drawn under its view, inside its box (the view's bounds, or its `area`):
+   * Pixi copies that part of the canvas before the view draws, the body reads it through `sampleBack(uv)`, and an input
+   * may start from it (`from: "back"`). Its output is laid over the canvas like the view's own pixels: where the body
+   * answers transparent the canvas stays as it is. A backdrop is drawn live in every frame, never kept (`cache` may only
+   * be left out or `false`), has no padding, and is no stage; its fallback may be one. On WebGL the renderer then draws
+   * every frame into Pixi's back buffer. Default `false`.
+   */
+  readonly backdrop?: boolean;
 };
 /**
  * How one uniform travels to the GPU: its name, its WGSL type and the form it was declared in.
@@ -1452,7 +1470,9 @@ type FilterDefinition = {
    * `undefined` for any other body.
    */
   readonly origin: UniformSpec | undefined; /** The rectangle outside of which the filter draws nothing, from the value; present only when the spec gave one. */
-  readonly area?: (value: Readonly<FilterFields>) => FilterArea | undefined;
+  readonly area?: (value: Readonly<FilterFields>) => FilterArea | undefined; /** The texels per CSS px it draws at; 0 for the resolution of the canvas. */
+  readonly resolution: number; /** True for a filter that reads what was drawn under its view: Pixi's `blendRequired`, and `sampleBack` in its body. */
+  readonly backdrop: boolean;
 };
 /**
  * A filter a chain may draw: any component `defineFilter` made. Listed in an input's `stages` and named by its steps.
@@ -1520,6 +1540,12 @@ type FilterChainContext = {
  * ```
  */
 type FilterInput<Value> = {
+  /**
+   * Where the first step reads: `"input"` (the default), the view's own input; `"back"`, what was drawn under the
+   * view inside its box, for a backdrop filter only. A chain from back runs at the resolution of the surface under the
+   * view, which `context.resolution` then holds.
+   */
+  readonly from?: "input" | "back";
   readonly stages: readonly FilterStage[];
   /**
    * The steps of the second texture for this value and resolution. Pure: no state, no randomness; the context object
@@ -1543,12 +1569,13 @@ type FilterInput<Value> = {
  * @example
  * ```ts
  * const [blur] = Frost.filter.inputs;
- * [blur?.texture, blur?.sampler, blur?.scale.name, blur?.clamp.name, blur?.sample];
- * // ["blurTexture", "blurSampler", "blurScale", "blurClamp", "sampleBlur"]
+ * [blur?.texture, blur?.sampler, blur?.scale.name, blur?.clamp.name, blur?.sample, blur?.from];
+ * // ["blurTexture", "blurSampler", "blurScale", "blurClamp", "sampleBlur", "back"]
  * ```
  */
 type FilterInputDefinition = {
-  readonly name: string;
+  readonly name: string; /** Where its first step reads: the view's own input, or what was drawn under the view. */
+  readonly from: "input" | "back";
   readonly texture: string;
   readonly sampler: string;
   readonly scale: UniformSpec;
@@ -1685,15 +1712,22 @@ type DisplacementValue = {
   order: number;
 };
 /**
- * `Alpha`: Pixi's alpha over the whole subtree, as one layer.
+ * `Alpha`: Pixi's alpha over the whole subtree, as one layer. `resolution` is the texels per CSS px the subtree is drawn
+ * at, at most 4, `0` for the resolution of the canvas; Pixi draws all the filters of a view at the smallest resolution
+ * among them, so `Alpha({ resolution: 0.5 })` beside a `Glow` draws the glow at 0.5 too. At `alpha: 1` and
+ * `resolution: 0` the filter would copy the subtree unchanged through a pass of its own: it is switched off, at once
+ * when it is built so, otherwise after 8 frames at rest there (a keyframe that touches 1 switches nothing), and the
+ * subtree draws as if the Alpha were not there.
  *
  * @example
  * ```ts
- * const value: AlphaValue = { alpha: 0.5, enabled: true, order: 0 };
+ * // The fog of a memory screen, opaque, drawn at half a texel per CSS px through the Alpha's one pass.
+ * const value: AlphaValue = { alpha: 1, resolution: 0.5, enabled: true, order: 0 };
  * ```
  */
 type AlphaValue = {
   alpha: number;
+  resolution: number;
   enabled: boolean;
   order: number;
 };
@@ -1789,6 +1823,11 @@ type FilterBody = {
   readonly applied: Record<string, FilterField>; /** The keys of `applied`, listed once: a compare walks them by index, with no `Object.keys` per frame. */
   readonly fields: readonly string[];
   passes: number;
+  /**
+   * Syncs in a row its value drew the view unchanged (at 1, at the canvas's resolution) while its filter was on;
+   * the filter is switched off at `CALM_AFTER` and the count starts over.
+   */
+  calm: number;
 };
 /**
  * A probe of the warm-up (spec 27 F4): the Pixi filter handed to `renderer.sync.filters.warm`, and its teardown.
@@ -1844,8 +1883,11 @@ type Place = {
  * pictures through.
  */
 type InputsState = {
-  /** A uniform of the value changed since the last evaluation (set by `writeFilter`). */stale: boolean; /** The resolution of the last evaluation. */
-  resolution: number; /** Changes whenever what the stages draw changes; 1 after the first evaluation. */
+  /** A uniform of the value changed since the last evaluation (set by `writeFilter`). */stale: boolean; /** The resolution of the view's input at the last evaluation. */
+  resolution: number; /** The resolution of what was drawn under the view at the last evaluation; the input's for a filter that reads none. */
+  backResolution: number; /** An input starts from the view's own input: a new resolution of the input runs the chains again. */
+  readonly fromInput: boolean; /** An input starts from what was drawn under the view: a new resolution of the back runs the chains again. */
+  readonly fromBack: boolean; /** Changes whenever what the stages draw changes; 1 after the first evaluation. */
   version: number; /** The object `chain` receives, reused: its `resolution` is written before each call. */
   readonly context: {
     resolution: number;

package/dist/{types-DnttyLeu.d.mts → types-C4D9UVgb.d.mts}

@@ -189,7 +189,7 @@ 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", asked: null, heldBy: null }
+ * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null, scale: 0.75 }
  * ```
  */
 type FrameRate = {
@@ -220,13 +220,20 @@ type FrameRate = {
    * unknown.
    */
   heldBy: "panel" | null;
+  /**
+   * The share of its resolution the canvas draws at for the adaptive rule: 1, or a step of 0.85, 0.75, 0.6 and 0.5
+   * down to the floor the renderer allows on a GPU-bound screen. Always 1 without `adaptive`, outside mode `"auto"` and
+   * while the renderer allows no scale.
+   */
+  scale: number;
 };
 /**
- * Payload of `time:rate`: a change of the loop's rate or of its mode, with the evidence the rule read.
+ * Payload of `time:rate`: a change of the loop's rate, of its mode or of the render scale, with the evidence the rule
+ * read. A change of the scale alone has `from` equal to `to`.
  *
  * @example
  * ```ts
- * const change: RateChange = { from: 120, to: 60, reason: "missed", mode: "auto", displayHz: 120, thermal: "none", window: { drawn: 41, missed: 9, heavy: 0 }, dwellMs: 5000 };
+ * const change: RateChange = { from: 120, to: 120, reason: "missed", mode: "auto", displayHz: 120, thermal: "none", window: { drawn: 41, missed: 9, heavy: 0 }, dwellMs: 5000, scale: 0.85 };
  * ```
  */
 type RateChange = {
@@ -240,8 +247,9 @@ type RateChange = {
     drawn: number;
     missed: number;
     heavy: number;
-  }; /** How long a return must now wait at the lower rate, ms; 0 without `adaptive`. */
-  dwellMs: number;
+  }; /** How long a return must now wait at the lower rate, ms (twice that for a step up of the scale); 0 without `adaptive`. */
+  dwellMs: number; /** The render scale after the change, as `FrameRate.scale`. */
+  scale: number;
 };
 /**
  * What `time` measured of one frame, handed to the measure listeners after the `render` phase. One object, rewritten
@@ -338,8 +346,8 @@ type Events$7 = {
    */
   "time:thermal": ThermalReading;
   /**
-   * The loop's frame rate or its mode changed (the adaptive rule, the display, the thermal input or `setRate`).
-   * Never per frame, never at start.
+   * The loop's frame rate, its mode or the render scale changed (the adaptive rule, the display, the thermal input or
+   * `setRate`). Never per frame, never at start.
    */
   "time:rate": RateChange;
 };
@@ -457,7 +465,8 @@ type DisplayState = {
  * The loop's frame rate and what decides it. Not public: exported for `rate.ts`.
  */
 type RateState = {
-  /** The loop's rate now; `maxFps` at creation. */fps: number; /** `"auto"` with `adaptive`, else `"fixed"`, until `setRate` forces a number. */
+  /** The loop's rate now; `maxFps` at creation. */fps: number; /** The render scale the adaptive rule chose; 1 at creation. */
+  scale: number; /** `"auto"` with `adaptive`, else `"fixed"`, until `setRate` forces a number. */
   mode: RateMode; /** The reason of the last change; `"start"` at creation. */
   reason: RateReason; /** `frameDrawn()` was called during the running frame. */
   drawnNow: boolean; /** `frameProbed()` was called during the running frame. */
@@ -474,7 +483,8 @@ type RateState = {
  */
 type Governor = {
   /** The lowest rate the rule may choose. */floor: number; /** The rates the rule chooses from, highest first, frozen; empty until the display rate is known. */
-  ladder: readonly number[]; /** The shell's last thermal status; `null` before the first reading. */
+  ladder: readonly number[]; /** The render scales the rule steps through before a rate, highest first, frozen; empty while the renderer allows none. */
+  scales: readonly number[]; /** The shell's last thermal status; `null` before the first reading. */
   thermal: ThermalStatus | null; /** The frame that ran last was drawn. */
   lastDrawn: boolean; /** The frame that ran last ran under the idle cap. */
   lastIdle: boolean; /** The frame that ran last drew warm-up probes. */
@@ -482,18 +492,20 @@ type Governor = {
   lastWorkMs: number; /** The rate the frame that ran last ran at. */
   lastFps: number; /** The next interval is not judged: set at creation, at every switch and at `resume()`. */
   skipNext: boolean; /** Timestamp of each sample, a ring of `RING`. */
-  sampleAt: Float64Array; /** Flags of each sample: bit 0 missed, bit 1 heavy. */
+  sampleAt: Float64Array; /** Flags of each sample: bit 0 missed, bit 1 heavy, bit 2 missed and busy. */
   sampleFlags: Uint8Array; /** Samples written since creation: the next slot is `written % RING`. */
   written: number; /** The oldest sample of the drop window. */
   dropTail: number; /** Samples in the drop window. */
   dropDrawn: number; /** Late samples in the drop window. */
-  dropMissed: number; /** The oldest sample of the return window. */
+  dropMissed: number; /** Late samples in the drop window whose frame was busy on the main thread. */
+  dropBusy: number; /** The oldest sample of the return window. */
   returnTail: number; /** Samples in the return window. */
   returnDrawn: number; /** Late samples in the return window. */
   returnMissed: number; /** Heavy samples in the return window. */
   returnHeavy: number; /** When the rate or its mode last changed. */
   switchedAt: number; /** When the rule last returned a step up; -Infinity before the first return. */
-  lastReturnAt: number; /** How long a return waits after a switch, ms. */
+  lastReturnAt: number; /** The last step of the rule was a return: its first drop judges it. */
+  climbed: boolean; /** How long a return waits after a switch, ms. */
   dwellMs: number; /** The rate last asked of the shell. */
   requested: number; /** Sequence number of the last request: an answer to an older one is stale. */
   requestSeq: number;
@@ -695,8 +707,8 @@ type Api$7 = {
   chargeAgent(ms: number): void;
   /**
    * The loop's frame rate now: the rate, who decides it, why it is what it is, the display rate and the ladder the
-   * 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.
+   * adaptive rule chooses from, the native shell's thermal status and the render scale. 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.
@@ -705,11 +717,11 @@ type Api$7 = {
    * @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", asked: null, heldBy: null }
+   * app.time.rate(); // { fps: 120, mode: "auto", reason: "start", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null, scale: 1 }
    * // 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", asked: null, heldBy: null }
+   * app.time.rate(); // { fps: 60, mode: "auto", reason: "missed", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null, scale: 0.75 }
    * // 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" }
+   * app.time.rate(); // { fps: 60, mode: "fixed", reason: "start", displayHz: 60, ladder: [], thermal: null, asked: 120, heldBy: "panel", scale: 1 }
    * ```
    */
   rate(): Readonly<FrameRate>;
@@ -717,8 +729,9 @@ type Api$7 = {
    * Forces the frame rate, or gives it back with `"auto"`. A number is the cap from now on, like a `maxFps` of that
    * value (never above `maxFps`): the adaptive rule and the thermal input leave it alone. `"auto"` hands the rate back
    * to the config: the top of the adaptive ladder (a step lower while the shell reports heat), or `maxFps` without
-   * `adaptive`. A choice equal to the current one changes nothing, so a game may apply its player's setting on every
-   * commit. Every change emits `time:rate` and asks the native shell for the panel rate.
+   * `adaptive`. Both start the render scale over at 1. A choice equal to the current one changes nothing, so a game may
+   * apply its player's setting on every commit. Every change emits `time:rate` and asks the native shell for the panel
+   * rate.
    *
    * @param choice - `"auto"`, 30, 60 or 120.
    * @returns The frame rate after the call.
@@ -726,14 +739,49 @@ 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", asked: 60, heldBy: null }
+   * app.time.setRate(60); // { fps: 60, mode: "forced", reason: "forced", displayHz: 120, ladder: [120, 60], thermal: "none", asked: 60, heldBy: null, scale: 1 }
    * // …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", asked: null, heldBy: null }
+   * app.time.setRate("auto"); // { fps: 120, mode: "auto", reason: "auto", displayHz: 120, ladder: [120, 60], thermal: "none", asked: null, heldBy: null, scale: 1 }
    * // 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" }
+   * app.time.setRate(120); // { fps: 60, mode: "forced", reason: "forced", displayHz: 60, ladder: [60], thermal: "none", asked: 120, heldBy: "panel", scale: 1 }
    * ```
    */
   setRate(choice: RateChoice): Readonly<FrameRate>;
+  /**
+   * Lets the adaptive frame rate lower the render scale before it lowers the rate. When the late frames of a window
+   * kept the main thread no longer than their frame (from their timestamp, a stall that held the callback included) the
+   * screen is GPU-bound: the rule steps the scale down through 0.85, 0.75, 0.6 and 0.5 to `floor` (at the lowest rate
+   * too), and only then drops the rate. The way back is the reverse: the rate first, at the scale it dropped at, then
+   * the scale, a step after twice the dwell. A late window busy on the main thread skips the scale. For engine
+   * plugins: the renderer calls it at start with the floor of its `adaptiveScale`, with 1 while a player's resolution
+   * holds, and with the floor again after. A scale under a new floor goes up to it at once, without `time:rate`.
+   * Without `adaptive` nothing changes.
+   *
+   * @param floor - The lowest share of its resolution the canvas may draw at; 1 allows no scale.
+   * @returns The frame rate after the call.
+   * @example
+   * ```ts
+   * // The renderer on a phone, at start:
+   * ctx.require(timePlugin).allowScale(0.75); // { fps: 120, …, scale: 1 }
+   * // on the memory screen of a weak phone, half a second later:
+   * app.time.rate(); // { fps: 120, mode: "auto", reason: "missed", …, scale: 0.75 }
+   * // the player picked a resolution in the settings: the renderer takes the scale away from the rule
+   * ctx.require(timePlugin).allowScale(1); // { fps: 120, …, scale: 1 }
+   * ```
+   */
+  allowScale(floor: number): Readonly<FrameRate>;
+  /**
+   * Tells the adaptive frame rate that a new scene stands: the back-off of failed returns starts over at a dwell of
+   * 5 s, and the new screen is judged on its own frames (both windows start empty, the first interval is skipped). The
+   * rate and the scale stay. For engine plugins: `scenes` calls it when a switch has built the new scene.
+   *
+   * @example
+   * ```ts
+   * // scenes, once the new scene stands:
+   * ctx.require(timePlugin).sceneChanged(); // the next return waits 5 s, not the 40 s three failed returns had grown
+   * ```
+   */
+  sceneChanged(): void;
   /**
    * Tells the clock that the frame running now was drawn. For engine plugins: the renderer calls it from its `render`
    * phase after Pixi drew; a frame without it — a still screen under `onDemand` — never counts for the adaptive
@@ -9004,9 +9052,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`; `"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`).
+ * `{ on, off }`: the names of the sections on and off, in the order of `MONITOR_SECTIONS`; `"scale"` is a move of the
+ * render scale of the adaptive frame rate, detail `{ from, to, reason, fps }`).
  */
-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";
+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" | "scale";
 /**
  * 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).
@@ -9244,23 +9293,26 @@ type PerfLogLine = PerfHeaderLine | PerfStartupLine | PerfSampleLine | PerfSpike
 //#endregion
 //#region src/plugins/renderer/host/resolution.d.ts
 /**
- * Why the resolution changed. Exported: `HostInternal` and spec 14's demand subscriber use it (11-I14).
+ * Why the resolution changed: the device pixels, a setting, the debug switch, the render scale of the adaptive frame
+ * rate. Exported: `HostInternal` and spec 14's demand subscriber use it (11-I14).
  */
-type ResolutionReason = "dpr" | "setting" | "debug";
+type ResolutionReason = "dpr" | "setting" | "debug" | "rate";
 //#endregion
 //#region src/plugins/renderer/host/types.d.ts
 /**
- * Where the drawing resolution comes from (contract C-d): the device pixels, the cap, the switch
- * that overrides both, and the change the next frame applies. Not public.
+ * Where the drawing resolution comes from (contract C-d): the device pixels, the cap, the render scale of the adaptive
+ * frame rate, the switch that overrides them, and the change the next frame applies. Not public.
  */
 type ResolutionState = {
   /** The last `devicePixelRatio` seen; 1 without a window. */dpr: number; /** `maxResolution` of the config. */
-  cap: number; /** Set by `monitor.setResolution`; `undefined` hands the choice back to `dpr` and `cap`. */
+  cap: number; /** Set by `monitor.setResolution`; `undefined` hands the choice back to `dpr`, `cap` and `scale`. */
   override: number | undefined; /** A change asked for and not applied yet: the next frame resizes with it. */
   pending: {
     value: number;
     reason: ResolutionReason;
-  } | undefined;
+  } | undefined; /** The render scale the adaptive frame rate chose, a share of `min(dpr, cap)`; 1 at start. */
+  scale: number; /** The lowest scale `adaptiveScale` allows on this device, read at init; 1 allows none. */
+  floor: number;
 };
 /**
  * A listener of a resolution change: what Pixi drew at, what it draws at now, and why.
@@ -9333,7 +9385,13 @@ type HostState = {
    * filter's input again after a cached group refreshed inside it (F10), went into Pixi's registry; `undefined` while
    * inert and when the module lacked the pieces.
    */
-  uninstallRenderGroup: (() => void) | undefined; /** The drawing resolution: device pixels, cap, override and the pending change. */
+  uninstallRenderGroup: (() => void) | undefined;
+  /**
+   * Swaps Pixi's own WebGPU render target and pipeline systems back in. Set once per host state when the lazy canvas
+   * pass (B3), which begins the canvas's pass at its first draw and keeps its stencil and depth only where something
+   * reads them, went into Pixi's registry; `undefined` while inert and when the module lacked the pieces.
+   */
+  uninstallRenderPass: (() => void) | undefined; /** The drawing resolution: device pixels, cap, override and the pending change. */
   resolution: ResolutionState; /** Run after a frame applied a new resolution; emptied by `stopHost`. */
   onResolutionChange: ResolutionListener[]; /** The engine's own adapter and device of an agent build on WebGPU; `undefined` otherwise. */
   ownGpu: OwnGpu | undefined; /** Texture sources the engine keeps as pictures (F12, C14): `textures()` counts them apart. */
@@ -10528,7 +10586,7 @@ type PictureRequest = {
   reject: (error: Error) => void;
 };
 declare namespace types_d_exports$2 {
-  export { Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, 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 };
+  export { AdaptiveScale, 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
@@ -10540,7 +10598,9 @@ declare namespace types_d_exports$2 {
  * (the three WebGPU draw classes, the filter system, both texture systems and the batcher pipe whose `buildStart`
  * begins every instruction rebuild; production swaps the encoder alone, to count the passes), and the pieces of
  * batched distance-field text `host` installs: Pixi's `Batcher` with its geometry and buffers, the bitmap text pipe
- * and the batcher pipe it subclasses, and the WGSL and GLSL shader pieces of the batch's SDF shader. The module object
+ * and the batcher pipe it subclasses, and the WGSL and GLSL shader pieces of the batch's SDF shader, and the WebGPU
+ * render target system with its adaptor, the pipeline system and the stencil system the lazy canvas pass of `host`
+ * subclasses or registers again (`host/render-pass.ts`). The module object
  * never arrives through a static import: `config.loadPixi()` returns it, so a game without a screen carries no
  * Pixi in its bundle.
  *
@@ -10556,7 +10616,7 @@ declare namespace types_d_exports$2 {
  * pixi.defaultFilterVert.startsWith("in vec2 aPosition;"); // true
  * ```
  */
-type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "Batcher" | "BatcherPipe" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Bounds" | "Buffer" | "BufferUsage" | "Cache" | "ColorMatrixFilter" | "Container" | "DefaultBatcher" | "DisplacementFilter" | "ExtensionType" | "Filter" | "FilterSystem" | "Geometry" | "GlProgram" | "GlTextureSystem" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "GpuTextureSystem" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "Rectangle" | "RenderGroupPipe" | "RenderTexture" | "Shader" | "Sprite" | "Texture" | "TexturePool" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
+type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "Batcher" | "BatcherPipe" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Bounds" | "Buffer" | "BufferUsage" | "Cache" | "ColorMatrixFilter" | "Container" | "DefaultBatcher" | "DisplacementFilter" | "ExtensionType" | "Filter" | "FilterSystem" | "Geometry" | "GlProgram" | "GlTextureSystem" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "GpuRenderTargetAdaptor" | "GpuRenderTargetSystem" | "GpuStencilSystem" | "GpuTextureSystem" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "PipelineSystem" | "Rectangle" | "RenderGroupPipe" | "RenderTexture" | "Shader" | "Sprite" | "Texture" | "TexturePool" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
 /**
  * One Pixi application: renderer, canvas and stage.
  */
@@ -10679,6 +10739,24 @@ type PoolTrim = {
    */
   aboveMb: number;
 };
+/**
+ * The render scale the adaptive frame rate may lower on a GPU-bound screen (`time.adaptive` on): before the rate drops,
+ * the canvas draws at 0.85, then 0.75 of its resolution, down to `floor`, and back up when there is room again.
+ *
+ * @example
+ * ```ts
+ * // The default: on a phone the memory screen draws at 1.5 instead of 2 before it drops to 60 fps.
+ * const scale: AdaptiveScale = { floor: 0.75, devices: "phone" };
+ * createApp({ pluginConfigs: { renderer: { mount: "#game", adaptiveScale: scale }, time: { maxFps: 120, adaptive: { floor: 60 } } } });
+ * ```
+ */
+type AdaptiveScale = {
+  /** The lowest share of the resolution, a step of the scale: 1, 0.85, 0.75, 0.6 or 0.5. 1 allows none. */floor: number;
+  /**
+   * Where it applies: `"phone"`, a coarse pointer and a short side of at most 820 CSS px (read at start), or `"all"`.
+   */
+  devices: "phone" | "all";
+};
 /**
  * renderer plugin config.
  *
@@ -10697,6 +10775,8 @@ type PoolTrim = {
  * createApp({ pluginConfigs: { renderer: { mount: "#game", keptMb: 32 } } }); // a game with small art
  * // A short splash: two probe draws a frame create the pipelines sooner.
  * createApp({ pluginConfigs: { renderer: { mount: "#game", onDemand: true, warm: 2 } } });
+ * // A game whose art must stay sharp: the adaptive frame rate drops the rate, never the resolution.
+ * createApp({ pluginConfigs: { renderer: { mount: "#game", adaptiveScale: false } } });
  * ```
  */
 type Config$2 = {
@@ -10744,6 +10824,12 @@ type Config$2 = {
    * created in the first frame that draws with it, as before. A whole number from 0 to 16; default 1.
    */
   warm: number;
+  /**
+   * The render scale of the adaptive frame rate on a GPU-bound screen: `{ floor: 0.75, devices: "phone" }` by default,
+   * `false` keeps the resolution. Needs `time.adaptive`. A player's `monitor.setResolution` wins over it. Every change
+   * of the scale redraws the canvas and retakes the kept pictures once.
+   */
+  adaptiveScale: AdaptiveScale | false;
 };
 /**
  * The performance monitor of an agent build (`__MOKU_GAME_AGENT__`: dev and `--debug` builds): the spike budget, the
@@ -12203,4 +12289,4 @@ type BundleCompanion = {
   unload(bundle: string): void;
 };
 //#endregion
-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 };
+export { PROBLEM_RULES as $, DefineNode as $n, Require as $r, Config$3 as $t, PixiModule as A, TrackOptions as An, SaveDoc as Ar, FilterSlotInputs as At, FrameColumns as B, State$4 as Bn, PauseReason as Br, Overlay as Bt, State$1 as C, Motion as Cn, Json as Cr, ProblemRule as Ct, Config$2 as D, ProjectionMotion as Dn, Patch as Dr, WarmDetail as Dt, Api$1 as E, NumericFields as En, types_d_exports$6 as Er, ShaderWhat as Et, Under as F, Config$4 as Fn, RngApi as Fr, Display as Ft, LongFrameEntry as G, slot as Gn, FrameRate as Gr, Sprite as Gt, FrameReadout as H, types_d_exports$4 as Hn, types_d_exports$7 as Hr, Parent as Ht, types_d_exports$2 as I, EmitterIdOf as In, RngState as Ir, HudPart as It, OverlayEventDetail as J, FeatureDescription as Jn, ThermalReading as Jr, Transform as Jt, MONITOR_SECTIONS as K, to as Kn, RateChange as Kr, SpriteOptions as Kt, Captured as L, GameTypes as Ln, Api$6 as Lr, HudPartValue as Lt, PixiTexture as M, ViewHandle as Mn, Snapshot as Mr, Point as Mt, PoolTrim as N, Api$3 as Nn, SnapshotOf as Nr, ViewportSize as Nt, MonitorConfig as O, ProjectionSpec as On, PlayerStateProvider as Or, DebugSwitches as Ot, State$2 as P, BundlesOf as Pn, StoreApi as Pr, FilterCache as Pt, PERF_LOG_VERSION as Q, Bookmark as Qn, Events$8 as Qr, Api$2 as Qt, MonitorCounts as R, HudKeysOf as Rn, Config$7 as Rr, NineSlice$1 as Rt, ScenesApi as S, Ease as Sn, Events$5 as Sr, ProblemEventDetail as St, AdaptiveScale as T, MotionHandle as Tn, State$6 as Tr, ShaderEventDetail as Tt, FrameRecord as U, defineFlow as Un, Api$7 as Ur, Shape as Ut, FrameReadResult as V, TextStylesOf as Vn, State$7 as Vr, OverlayValue as Vt, FrameRing as W, exit as Wn, Config$8 as Wr, ShapeValue as Wt, PERF_CAUSES as X, FeatureTree as Xn, types_d_exports$8 as Xr, sprite as Xt, OverlayWhat as Y, FeaturePlugin as Yn, Time as Yr, TransformValue as Yt, PERF_GAP_BUCKETS as Z, AnyFlow as Zn, Config$9 as Zr, DEMAND_REASONS as Zt, DefineScene as _, SystemDefinition as _n, FakeClock as _r, PerfSpikeLine as _t, Config as a, AnyComponentValue as an, SceneIdOf as ar, PerfCollectorLine as at, SceneDefinition as b, ChangeHook as bn, Api$5 as br, PerfThermalLine as bt, LoadBundles as c, ComponentType as cn, Effect as cr, PerfEventLine as ct, Manifest as d, EntitySnapshot as dn, Hint as dr, PerfHeaderLine as dt, Explained as en, FlowGraph as er, PassKind as et, State as f, FrameDiff as fn, NodeFx as fr, PerfLogLine as ft, AnySceneProjection as g, ResourceType as gn, Config$5 as gr, PerfSampleLine as gt, types_d_exports as h, QueryTerm as hn, ClockSource as hr, PerfMeasured as ht, BundleSpec as i, AnyComponentType as in, RouteStep as ir, PerfChangeEntry as it, PixiSprite as j, TrackSegment as jn, SaveUnreadableError as jr, Orientation as jt, PixiFilter as k, ReducedMotion as kn, ProviderCall as kr, FilterSlot as kt, LoadReason as l, ComponentValue as ln, EffectOptions as lr, PerfEventName as lt, Usage as m, Narrowed as mn, Api$4 as mr, PerfMarkLine as mt, AssetsIo as n, types_d_exports$3 as nn, JournalEntry as nr, PerfCause as nt, DefineBundles as o, ComponentHandle as on, TypeTag as or, PerfCounts as ot, Tier as p, Mut as pn, Answer as pr, PerfLongFrameLine as pt, MonitorSections as q, type as qn, State$8 as qr, SpriteValue as qt, BundleMap as r, AnyComponent as rn, NodeTable as rr, PerfChange as rt, Events as s, ComponentSchema as sn, Descriptor as sr, PerfDisplay as st, Api as t, State$3 as tn, FlowState as tr, PassRecord as tt, LoadResult as u, Entity as un, GuideOptions as ur, PerfGapLine as ut, Events$1 as v, SystemFor as vn, State$5 as vr, PerfStartupLine as vt, types_d_exports$1 as w, MotionCause as wn, Root as wr, SHADER_WHATS as wt, SceneSpec as x, DescriptionNode as xn, Config$6 as xr, PoolTrimDetail as xt, LayerMap as y, TagType as yn, types_d_exports$5 as yr, PerfTelemetryLine as yt, RenderStats as z, Position as zn, Events$6 as zr, NineSliceValue as zt };

package/dist/{types-CWSMo70I.d.mts → types-CZGuMhV8.d.mts}

@@ -1,4 +1,4 @@
-import { Cn as MotionCause, En as ProjectionMotion, Hr as Api, Jt as TransformValue, Mn as Api$1, Mt as ViewportSize, Qr as Require, Sn as Motion, Sr as Json, T as Api$3, Tn as NumericFields, Zt as Api$2, fr as Answer, in as AnyComponentValue, jn as ViewHandle, ln as Entity, nn as AnyComponent, or as Descriptor, pr as Api$5, rn as AnyComponentType, s as Events$1, sn as ComponentType, t as Api$4, ur as Hint, vn as TagType, wn as MotionHandle, yn as ChangeHook } from "./types-DnttyLeu.mjs";
+import { $r as Require, Cn as Motion, Cr as Json, Dn as ProjectionMotion, E as Api$3, En as NumericFields, Mn as ViewHandle, Nn as Api$1, Nt as ViewportSize, Qt as Api$2, Tn as MotionHandle, Ur as Api, Yt as TransformValue, an as AnyComponentValue, bn as ChangeHook, cn as ComponentType, dr as Hint, in as AnyComponentType, mr as Api$5, pr as Answer, rn as AnyComponent, s as Events$1, sr as Descriptor, t as Api$4, un as Entity, wn as MotionCause, yn as TagType } from "./types-C4D9UVgb.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/dist/{types-DFoxDq-g.d.mts → types-Mj75CDO6.d.mts}

@@ -1,5 +1,5 @@
-import { Sr as Json, jr as Snapshot } from "./types-DnttyLeu.mjs";
-import { t as HeadlessApp } from "./headless-DDkRwLnJ.mjs";
+import { Cr as Json, Mr as Snapshot } from "./types-C4D9UVgb.mjs";
+import { t as HeadlessApp } from "./headless-DobgwTKK.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{types-6inPYTzE.d.mts → types-MocH_igX.d.mts}

@@ -1,7 +1,7 @@
-import { At as Orientation, Dr as PlayerStateProvider, E as Config$2, Jn as FeaturePlugin, Mr as SnapshotOf, Or as ProviderCall, Pn as Config$1, Sr as Json, Xn as AnyFlow, a as Config$3, ar as TypeTag, br as Config, d as Manifest, gr as FakeClock, k as PixiModule, kr as SaveDoc, mr as ClockSource, n as AssetsIo } from "./types-DnttyLeu.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-C2g2KYCN.mjs";
-import { H as TextKey, I as I18nApi, V as StringTable } from "./types-CWSMo70I.mjs";
-import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-Bq_93oZv.mjs";
+import { A as PixiModule, Ar as SaveDoc, Cr as Json, D as Config$2, Fn as Config$1, Nr as SnapshotOf, Or as PlayerStateProvider, Yn as FeaturePlugin, Zn as AnyFlow, _r as FakeClock, a as Config$3, d as Manifest, hr as ClockSource, jt as Orientation, kr as ProviderCall, n as AssetsIo, or as TypeTag, xr as Config } from "./types-C4D9UVgb.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-BkcgFOoB.mjs";
+import { H as TextKey, I as I18nApi, V as StringTable } from "./types-CZGuMhV8.mjs";
+import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-CU4Oc2Qv.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{visual-DalSHy9z.d.mts → visual-BV2A3kpr.d.mts}

@@ -1,9 +1,9 @@
-import { Ir as Api$3, T as Api, Zt as Api$1, yr as Api$2 } from "./types-DnttyLeu.mjs";
-import { P as AnimApi, r as UiApi } from "./types-C2g2KYCN.mjs";
-import { j as InputApi } from "./types-CWSMo70I.mjs";
-import { r as Repro } from "./headless-DDkRwLnJ.mjs";
-import { a as InputOf, r as ControlApp } from "./types-DFoxDq-g.mjs";
-import { t as commands } from "./commands-e_I5i8dK.mjs";
+import { E as Api, Lr as Api$3, Qt as Api$1, br as Api$2 } from "./types-C4D9UVgb.mjs";
+import { P as AnimApi, r as UiApi } from "./types-BkcgFOoB.mjs";
+import { j as InputApi } from "./types-CZGuMhV8.mjs";
+import { r as Repro } from "./headless-DobgwTKK.mjs";
+import { a as InputOf, r as ControlApp } from "./types-Mj75CDO6.mjs";
+import { t as commands } from "./commands-C8aWbThW.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */

package/dist/visual.d.mts

@@ -1,2 +1,2 @@
-import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-DalSHy9z.mjs";
+import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-BV2A3kpr.mjs";
 export { type CheckpointResult, type VisualApp, type VisualOptions, type VisualPage, type VisualRenderer, type VisualReport, type VisualSetup, type VisualStart, type VisualStep, type VisualTest, type VisualTestResult, type VisualTolerance, defineVisualTest, parseVisualArgv, runVisualTests };

package/dist/visual.mjs

@@ -1,5 +1,5 @@
 import { n as read, t as sources } from "./sources-OvHvyeJS.mjs";
-import { n as commands, t as run } from "./run-C07NXds7.mjs";
+import { n as commands, t as run } from "./run-DlxDjgOO.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";
 import { mkdir, readFile, writeFile } from "node:fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.15.5",
+  "version": "0.15.7",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": [