@moku-labs/game 0.4.6 → 0.5.0

package/dist/{types-C-4f2jD_.d.mts → types-CXyipKhE.d.mts}

@@ -1,243 +1,9 @@
-import { $ as Ease, Gt as Events$2, I as AnyComponentValue, K as Owner, Kt as Json, L as ComponentHandle, Nt as TypeTag, P as AnyComponent, Pt as Descriptor, Rt as Api, Ut as Api$5, V as Entity, ct as TrackSegment, et as LayerSort, it as NumericFields, k as Api$2, m as Api$3, o as Events$4, rt as MotionHandle, sn as Events$3, st as TrackOptions, t as Api$4, tt as LayerSpec, ut as Api$1, vn as Require, z as ComponentType } from "./types-Dy1xB68L.mjs";
-import { D as TextApi, H as InputApi, I as I18nApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-VErbiEXy.mjs";
+import { $ as Ease, Gt as Events$3, I as AnyComponentValue, K as Owner, Kt as Json, L as ComponentHandle, Nt as TypeTag, P as AnyComponent, Pt as Descriptor, Rt as Api, Ut as Api$5, V as Entity, _n as Events$2, ct as TrackSegment, et as LayerSort, it as NumericFields, k as Api$2, m as Api$3, o as Events$5, rt as MotionHandle, sn as Events$4, st as TrackOptions, t as Api$4, tt as LayerSpec, ut as Api$1, vn as Require, z as ComponentType } from "./types-BMEn0tSC.mjs";
+import { D as TextApi, H as InputApi, I as I18nApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-BaUUcIaN.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
 
-//#region src/plugins/ui/layout/types.d.ts
-/**
- * layout module state. `nodes` is attach minus detach: Yoga 3.2.1 has no instance counter.
- */
-type LayoutState = {
-  yoga: Yoga | undefined;
-  byEntity: Map<Entity, Node>;
-  nodes: number;
-  measured: number;
-  solves: number;
-  scrolling: Entity | undefined;
-  scrollStart: {
-    pointerY: number;
-    offset: number;
-  };
-  order: number;
-  cleanups: Array<() => void>;
-};
-declare namespace types_d_exports$3 {
-  export { Config$3 as Config, Deps$3 as Deps, ElementChange, ElementMotion, Finding, FocusRing, KernelSlice$3 as KernelSlice, State$3 as State, TextInputLook, UiApi, UiCtx, UiNode };
-}
-/**
- * The look of the keyboard focus ring: a dashed ring with a solid halo under it, drawn around the
- * focused control. Colours are `0xRRGGBB`, lengths reference units.
- *
- * @example
- * ```ts
- * // A dashed ink ring with a cream halo, 9 u outside the control.
- * const ring: FocusRing = {
- *   stroke: 0x3a2212, strokeWidth: 4, dash: 10, offset: 9, halo: 0xfff3d6, haloWidth: 12
- * };
- * ```
- */
-type FocusRing = {
-  /** The colour of the dashed ring. */stroke: number; /** The stroke width of the dashed ring. */
-  strokeWidth: number; /** The dash length of the ring, with gaps of half a dash; 0 draws it solid. */
-  dash: number; /** How far outside the control's rect the ring runs, on every side. */
-  offset: number; /** The colour of the solid halo drawn under the ring. */
-  halo: number; /** The stroke width of the halo, centred on the same path as the ring. */
-  haloWidth: number;
-};
-/**
- * The look of a text field while it is edited: the caret, the selection box and the IME
- * underline. Colours are `0xRRGGBB`, lengths reference units, `keyboardMargin` CSS px. The caret
- * does not blink.
- *
- * @example
- * ```ts
- * // A thick ink caret, a pale blue selection, the field 16 px above the keyboard.
- * const look: TextInputLook = {
- *   caretWidth: 3, caret: 0x3a2212, selection: 0x3390ff, selectionAlpha: 0.35,
- *   composingUnderline: 3, keyboardMargin: 16
- * };
- * ```
- */
-type TextInputLook = {
-  /** The width of the caret. */caretWidth: number; /** The colour of the caret and of the underline under an IME composing range. */
-  caret: number; /** The colour of the selection box. */
-  selection: number; /** The alpha of the selection box. */
-  selectionAlpha: number; /** The height of the underline under an IME composing range. */
-  composingUnderline: number; /** How far above the keyboard the bottom of the edited field is lifted, in CSS px. */
-  keyboardMargin: number;
-};
-/**
- * ui plugin config.
- *
- * @example
- * ```ts
- * createApp({ pluginConfigs: { ui: { tapTargetPt: 48, breakpoints: { tall: 2, wide: 1.5 } } } });
- * // A game with a white focus ring on a dark board.
- * createApp({
- *   pluginConfigs: {
- *     ui: {
- *       focusRing: {
- *         stroke: 0xffffff, strokeWidth: 4, dash: 10, offset: 9, halo: 0x000000, haloWidth: 12
- *       }
- *     }
- *   }
- * });
- * // A game whose text fields have an ink caret.
- * createApp({
- *   pluginConfigs: {
- *     ui: {
- *       textInput: {
- *         caretWidth: 3, caret: 0x3a2212, selection: 0x3390ff, selectionAlpha: 0.35,
- *         composingUnderline: 3, keyboardMargin: 16
- *       }
- *     }
- *   }
- * });
- * ```
- */
-type Config$3 = {
-  /** Smallest tap target `lint()` accepts, in CSS px (points). */tapTargetPt: number; /** `when` flags: `tall` when height / width is at least `tall`, `wide` the other way round. */
-  breakpoints: {
-    tall: number;
-    wide: number;
-  };
-  /**
-   * The ring drawn around the control the keyboard focused. Shallow merge: a game that sets
-   * `focusRing` gives all six fields.
-   */
-  focusRing: FocusRing;
-  /**
-   * The caret, the selection and the IME underline of a text field. Shallow merge: a game that
-   * sets `textInput` gives all six fields.
-   */
-  textInput: TextInputLook;
-};
-/**
- * ui plugin state: one branch per module.
- */
-type State$3 = {
-  jsx: JsxState;
-  styles: StylesState;
-  layout: LayoutState;
-};
-/**
- * Resolved dependency APIs. `anim` is not here: its edge is validation only, and its work
- * reaches `ui` through the tween driver behind every `ViewHandle`.
- */
-type Deps$3 = {
-  time: Api;
-  flow: Api$1;
-  world: Api$2;
-  renderer: Api$3;
-  input: InputApi;
-  i18n: I18nApi;
-  text: TextApi;
-};
-/**
- * What the kernel context offers before the deps are attached.
- *
- * `ui` owns no event, so `emit` is the kernel's and never called here.
- */
-type KernelSlice$3 = PluginCtx<Config$3, State$3> & {
-  readonly global: object;
-  readonly log: Log.LogApi;
-  readonly require: Require;
-};
-/**
- * Domain context shared by the three modules: the kernel slice plus the resolved deps.
- */
-type UiCtx = KernelSlice$3 & {
-  readonly deps: Deps$3;
-};
-/**
- * ui plugin API, `app.ui`. The screen is one more projection, so three members read it the way a
- * test reads the board: a snapshot, a key lookup and a list of findings; the fourth types into a
- * text field.
- *
- * @example
- * ```ts
- * // A headless scenario taps the claim button of the reward popup.
- * app.ui.tree().type; // "row", the root element of the HUD
- * app.input.tap(app.ui.find("claim") ?? 0);
- * app.ui.lint(); // []
- * ```
- */
-type UiApi = {
-  /**
-   * The live screen as plain data: every root in layer order, every element in child order, with
-   * its rect in root coordinates, its resolved style and its seven state flags. A rect is natural:
-   * under a `fit: "contain"` element it is the rect before that scale, and the fitted element
-   * adds `fitScale`. A windowed scroll adds `window`, and its content lists the live rows only.
-   * Works headless.
-   *
-   * @returns The root node; several roots come back under one `screen` node.
-   * @example
-   * ```ts
-   * // On an iPhone SE the 970 u board is drawn smaller to fit the slot between the bars.
-   * const screen = app.ui.tree();
-   * screen.children.map(child => child.key); // ["fitTop", "slot", "fitBottom"]
-   * const board = screen.children[1]?.children[0];
-   * board?.rect.w; // 970, the natural width
-   * board?.fitScale; // 0.805, the 781 u the slot leaves over 970 u
-   * ```
-   */
-  tree(): UiNode;
-  /**
-   * The entity of a keyed element, so a test can tap it and `anim` can aim at it. Popup roots
-   * come first, then the projection roots in layer order.
-   *
-   * @param key - The `key` prop of the element.
-   * @returns The entity, or `undefined` for an unknown or exiting element.
-   * @example
-   * ```ts
-   * // A headless scenario answers the gate through the button of the popup.
-   * app.input.tap(app.ui.find("claim") ?? 0); // true
-   * app.ui.find("nothing"); // undefined
-   * ```
-   */
-  find(key: string): Entity | undefined;
-  /**
-   * Reads the live screen against the five rules: a tap target under `tapTargetPt` at the size
-   * it is drawn (a `fit: "contain"` on it or above it shrinks it), a text that does not fit its
-   * box in some registered locale, an absolute element with no `reason`, a clipping element
-   * (`scroll`, `overflow: "hidden"`) whose style names a nine-slice it never draws, and a root
-   * element whose style sets a `zIndex` it ignores. Never throws; empty when nothing is mounted.
-   *
-   * @returns One finding per rule and element.
-   * @example
-   * ```ts
-   * // A game test keeps the board honest on an iPhone SE: a 140 u cell in the 0.8 slot.
-   * app.ui.lint(); // [{ rule: "tap-target", key: "cell", detail: "39 x 39 pt" }]
-   * // A list styled with a nine-slice: the clip keeps it from drawing.
-   * app.ui.lint(); // [{ rule: "nine-slice-clipped", key: "orders", detail: "scroll" }]
-   * // A screen root that asks to be drawn over the others: the layer decides that.
-   * app.ui.lint(); // [{ rule: "z-index-on-root", key: "board", detail: "zIndex 2" }]
-   * ```
-   */
-  lint(): readonly Finding[];
-  /**
-   * Types into a text field the way a player does, for a headless test or an agent: the field
-   * becomes the one being edited, `value` cut to its `maxLength` is written into it, and the
-   * local field it names is written, so the component re-renders on the next frame. Nothing
-   * reaches the gate: Enter submits.
-   *
-   * @param key - The `key` prop of the `input` element.
-   * @param value - The text to type.
-   * @returns True when the field took the text; false with one warning when no live `input` has
-   *   the key.
-   * @example
-   * ```ts
-   * // A headless test renames the player through the Rename popup.
-   * app.ui.fill("nameField", "Alex"); // true
-   * app.time.step(16);
-   * app.input.pressKey("Enter"); // true: the gate took { intent: "save", payload: { name: "Alex" } }
-   * app.ui.fill("nothing", "Alex"); // false, with the warning "ui:fill-without-input"
-   * ```
-   */
-  fill(key: string, value: string): boolean;
-};
-//#endregion
 //#region src/plugins/anim/tween/types.d.ts
 /**
  * One running track: the numeric fields of one component of one entity moving from the values
@@ -865,8 +631,8 @@ type RunningTimeline = {
   readonly resolve: () => void;
   ended: boolean;
 };
-declare namespace types_d_exports$2 {
-  export { AnimApi, AnimCtx, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config$2 as Config, Cursor, Deps$2 as Deps, ErasedFields, Events$1 as Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice$2 as KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State$2 as State, Step, StepMotion, Target, TimelineRuntime, Track };
+declare namespace types_d_exports$3 {
+  export { AnimApi, AnimCtx, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config$3 as Config, Cursor, Deps$3 as Deps, ErasedFields, Events$1 as Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice$3 as KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State$3 as State, Step, StepMotion, Target, TimelineRuntime, Track };
 }
 /**
  * What a step and a slot are pointed at: the projection key of a live view or of an element a
@@ -1118,7 +884,7 @@ type FrameLoop = {
  * createApp({ plugins: [...screen], pluginConfigs: { anim: { maxTracks: 500, reducedMotion: true } } });
  * ```
  */
-type Config$2 = {
+type Config$3 = {
   /** Dev guard: one warning each time the running track count rises past this number. */maxTracks: number;
   /**
    * Start value of reduced motion: every track but a loop takes 0 ms and every loop stands on
@@ -1130,7 +896,7 @@ type Config$2 = {
  * anim plugin state: the one track table, the field bookkeeping of the retarget policy and the
  * offsets accumulator, the running timelines and the animation registry.
  */
-type State$2 = {
+type State$3 = {
   /** The one track table. Insertion order is advance order. */tracks: Map<number, Track>; /** Ids of tracks and timelines. */
   nextId: number; /** `"<entity>:<component>:<field>"` to the id of the absolute track that drives the field. */
   owner: Map<string, number>; /** Per field key, the delta each additive track contributes. */
@@ -1271,6 +1037,24 @@ type AnimApi = {
    * ```
    */
   onMark(fn: MarkListener): () => void;
+  /**
+   * Swaps a registered animation for a new definition of the same id. The dev hot swap of `ui`
+   * calls it when a saved `animations.ts` exports one. The next `play` effect of a node builds
+   * the new definition; a timeline that runs now keeps the tree it was built with.
+   *
+   * @param definition - The new definition; its id names the animation it replaces.
+   * @throws {Error} When no feature registered an animation with that id.
+   * @example
+   * ```ts
+   * // The ui hot swap: a save of `board/animations.ts` brings a bigger merge burst.
+   * const mergeBurst = defineAnimation("board.mergeBurst", { slots: { cell: type<Target>() },
+   *   build: ({ cell }) => tween(cell, Transform, { scale: 1.4 }, { ms: 300 }) });
+   * ctx.require(animPlugin).replace(mergeBurst);
+   * // A node then runs fx(play(mergeBurst, { cell: { projection: "board.items", key: "i3" } })):
+   * // the play effect builds the new tree, and item i3 grows to scale 1.4 in 300 ms.
+   * ```
+   */
+  replace(definition: AnyAnimationDefinition): void;
 };
 /**
  * Resolved dependency APIs. `renderer` is not among them: `anim` writes its `Sprite` and reads
@@ -1278,7 +1062,7 @@ type AnimApi = {
  * of `at` with the pure `rootPoseOf` of `renderer/sync/pose.ts`, and turns the target of a
  * `tween` in `space: "root"` local with the pure `localPoseOf` of the same module.
  */
-type Deps$2 = {
+type Deps$3 = {
   time: Api;
   flow: Api$1;
   world: Api$2;
@@ -1290,7 +1074,7 @@ type Deps$2 = {
  * row 8), so the own events reach the context the kernel hands the factories and `emit` is the
  * kernel's own, anim-typed one. No member of the context is cast.
  */
-type KernelSlice$2 = PluginCtx<Config$2, State$2, Events$1> & {
+type KernelSlice$3 = PluginCtx<Config$3, State$3, Events$1> & {
   readonly global: object;
   readonly log: Log.LogApi;
   readonly require: Require;
@@ -1298,9 +1082,244 @@ type KernelSlice$2 = PluginCtx<Config$2, State$2, Events$1> & {
 /**
  * Domain context of the anim plugin: the kernel slice and the three resolved dependencies.
  */
-type AnimCtx = KernelSlice$2 & {
+type AnimCtx = KernelSlice$3 & {
+  readonly deps: Deps$3;
+};
+//#endregion
+//#region src/plugins/ui/layout/types.d.ts
+/**
+ * layout module state. `nodes` is attach minus detach: Yoga 3.2.1 has no instance counter.
+ */
+type LayoutState = {
+  yoga: Yoga | undefined;
+  byEntity: Map<Entity, Node>;
+  nodes: number;
+  measured: number;
+  solves: number;
+  scrolling: Entity | undefined;
+  scrollStart: {
+    pointerY: number;
+    offset: number;
+  };
+  order: number;
+  cleanups: Array<() => void>;
+};
+declare namespace types_d_exports$2 {
+  export { Config$2 as Config, Deps$2 as Deps, ElementChange, ElementMotion, Finding, FocusRing, KernelSlice$2 as KernelSlice, State$2 as State, TextInputLook, UiApi, UiCtx, UiNode };
+}
+/**
+ * The look of the keyboard focus ring: a dashed ring with a solid halo under it, drawn around the
+ * focused control. Colours are `0xRRGGBB`, lengths reference units.
+ *
+ * @example
+ * ```ts
+ * // A dashed ink ring with a cream halo, 9 u outside the control.
+ * const ring: FocusRing = {
+ *   stroke: 0x3a2212, strokeWidth: 4, dash: 10, offset: 9, halo: 0xfff3d6, haloWidth: 12
+ * };
+ * ```
+ */
+type FocusRing = {
+  /** The colour of the dashed ring. */stroke: number; /** The stroke width of the dashed ring. */
+  strokeWidth: number; /** The dash length of the ring, with gaps of half a dash; 0 draws it solid. */
+  dash: number; /** How far outside the control's rect the ring runs, on every side. */
+  offset: number; /** The colour of the solid halo drawn under the ring. */
+  halo: number; /** The stroke width of the halo, centred on the same path as the ring. */
+  haloWidth: number;
+};
+/**
+ * The look of a text field while it is edited: the caret, the selection box and the IME
+ * underline. Colours are `0xRRGGBB`, lengths reference units, `keyboardMargin` CSS px. The caret
+ * does not blink.
+ *
+ * @example
+ * ```ts
+ * // A thick ink caret, a pale blue selection, the field 16 px above the keyboard.
+ * const look: TextInputLook = {
+ *   caretWidth: 3, caret: 0x3a2212, selection: 0x3390ff, selectionAlpha: 0.35,
+ *   composingUnderline: 3, keyboardMargin: 16
+ * };
+ * ```
+ */
+type TextInputLook = {
+  /** The width of the caret. */caretWidth: number; /** The colour of the caret and of the underline under an IME composing range. */
+  caret: number; /** The colour of the selection box. */
+  selection: number; /** The alpha of the selection box. */
+  selectionAlpha: number; /** The height of the underline under an IME composing range. */
+  composingUnderline: number; /** How far above the keyboard the bottom of the edited field is lifted, in CSS px. */
+  keyboardMargin: number;
+};
+/**
+ * ui plugin config.
+ *
+ * @example
+ * ```ts
+ * createApp({ pluginConfigs: { ui: { tapTargetPt: 48, breakpoints: { tall: 2, wide: 1.5 } } } });
+ * // A game with a white focus ring on a dark board.
+ * createApp({
+ *   pluginConfigs: {
+ *     ui: {
+ *       focusRing: {
+ *         stroke: 0xffffff, strokeWidth: 4, dash: 10, offset: 9, halo: 0x000000, haloWidth: 12
+ *       }
+ *     }
+ *   }
+ * });
+ * // A game whose text fields have an ink caret.
+ * createApp({
+ *   pluginConfigs: {
+ *     ui: {
+ *       textInput: {
+ *         caretWidth: 3, caret: 0x3a2212, selection: 0x3390ff, selectionAlpha: 0.35,
+ *         composingUnderline: 3, keyboardMargin: 16
+ *       }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+type Config$2 = {
+  /** Smallest tap target `lint()` accepts, in CSS px (points). */tapTargetPt: number; /** `when` flags: `tall` when height / width is at least `tall`, `wide` the other way round. */
+  breakpoints: {
+    tall: number;
+    wide: number;
+  };
+  /**
+   * The ring drawn around the control the keyboard focused. Shallow merge: a game that sets
+   * `focusRing` gives all six fields.
+   */
+  focusRing: FocusRing;
+  /**
+   * The caret, the selection and the IME underline of a text field. Shallow merge: a game that
+   * sets `textInput` gives all six fields.
+   */
+  textInput: TextInputLook;
+};
+/**
+ * ui plugin state: one branch per module.
+ */
+type State$2 = {
+  jsx: JsxState;
+  styles: StylesState;
+  layout: LayoutState;
+};
+/**
+ * Resolved dependency APIs. `anim` is here for the dev hot swap, which replaces animations; the
+ * motions of `ui` reach `anim` through the tween driver behind every `ViewHandle`.
+ */
+type Deps$2 = {
+  anim: AnimApi;
+  time: Api;
+  flow: Api$1;
+  world: Api$2;
+  renderer: Api$3;
+  input: InputApi;
+  i18n: I18nApi;
+  text: TextApi;
+};
+/**
+ * What the kernel context offers before the deps are attached.
+ *
+ * `ui` owns no event of its own; `emit` sends the global `ui:hot-swap` of the dev hot swap.
+ */
+type KernelSlice$2 = PluginCtx<Config$2, State$2, Events$2> & {
+  readonly global: object;
+  readonly log: Log.LogApi;
+  readonly require: Require;
+};
+/**
+ * Domain context shared by the three modules: the kernel slice plus the resolved deps.
+ */
+type UiCtx = KernelSlice$2 & {
   readonly deps: Deps$2;
 };
+/**
+ * ui plugin API, `app.ui`. The screen is one more projection, so three members read it the way a
+ * test reads the board: a snapshot, a key lookup and a list of findings; the fourth types into a
+ * text field.
+ *
+ * @example
+ * ```ts
+ * // A headless scenario taps the claim button of the reward popup.
+ * app.ui.tree().type; // "row", the root element of the HUD
+ * app.input.tap(app.ui.find("claim") ?? 0);
+ * app.ui.lint(); // []
+ * ```
+ */
+type UiApi = {
+  /**
+   * The live screen as plain data: every root in layer order, every element in child order, with
+   * its rect in root coordinates, its resolved style and its seven state flags. A rect is natural:
+   * under a `fit: "contain"` element it is the rect before that scale, and the fitted element
+   * adds `fitScale`. A windowed scroll adds `window`, and its content lists the live rows only.
+   * Works headless.
+   *
+   * @returns The root node; several roots come back under one `screen` node.
+   * @example
+   * ```ts
+   * // On an iPhone SE the 970 u board is drawn smaller to fit the slot between the bars.
+   * const screen = app.ui.tree();
+   * screen.children.map(child => child.key); // ["fitTop", "slot", "fitBottom"]
+   * const board = screen.children[1]?.children[0];
+   * board?.rect.w; // 970, the natural width
+   * board?.fitScale; // 0.805, the 781 u the slot leaves over 970 u
+   * ```
+   */
+  tree(): UiNode;
+  /**
+   * The entity of a keyed element, so a test can tap it and `anim` can aim at it. Popup roots
+   * come first, then the projection roots in layer order.
+   *
+   * @param key - The `key` prop of the element.
+   * @returns The entity, or `undefined` for an unknown or exiting element.
+   * @example
+   * ```ts
+   * // A headless scenario answers the gate through the button of the popup.
+   * app.input.tap(app.ui.find("claim") ?? 0); // true
+   * app.ui.find("nothing"); // undefined
+   * ```
+   */
+  find(key: string): Entity | undefined;
+  /**
+   * Reads the live screen against the five rules: a tap target under `tapTargetPt` at the size
+   * it is drawn (a `fit: "contain"` on it or above it shrinks it), a text that does not fit its
+   * box in some registered locale, an absolute element with no `reason`, a clipping element
+   * (`scroll`, `overflow: "hidden"`) whose style names a nine-slice it never draws, and a root
+   * element whose style sets a `zIndex` it ignores. Never throws; empty when nothing is mounted.
+   *
+   * @returns One finding per rule and element.
+   * @example
+   * ```ts
+   * // A game test keeps the board honest on an iPhone SE: a 140 u cell in the 0.8 slot.
+   * app.ui.lint(); // [{ rule: "tap-target", key: "cell", detail: "39 x 39 pt" }]
+   * // A list styled with a nine-slice: the clip keeps it from drawing.
+   * app.ui.lint(); // [{ rule: "nine-slice-clipped", key: "orders", detail: "scroll" }]
+   * // A screen root that asks to be drawn over the others: the layer decides that.
+   * app.ui.lint(); // [{ rule: "z-index-on-root", key: "board", detail: "zIndex 2" }]
+   * ```
+   */
+  lint(): readonly Finding[];
+  /**
+   * Types into a text field the way a player does, for a headless test or an agent: the field
+   * becomes the one being edited, `value` cut to its `maxLength` is written into it, and the
+   * local field it names is written, so the component re-renders on the next frame. Nothing
+   * reaches the gate: Enter submits.
+   *
+   * @param key - The `key` prop of the `input` element.
+   * @param value - The text to type.
+   * @returns True when the field took the text; false with one warning when no live `input` has
+   *   the key.
+   * @example
+   * ```ts
+   * // A headless test renames the player through the Rename popup.
+   * app.ui.fill("nameField", "Alex"); // true
+   * app.time.step(16);
+   * app.input.pressKey("Enter"); // true: the gate took { intent: "save", payload: { name: "Alex" } }
+   * app.ui.fill("nothing", "Alex"); // false, with the warning "ui:fill-without-input"
+   * ```
+   */
+  fill(key: string, value: string): boolean;
+};
 declare namespace types_d_exports$1 {
   export { AnySceneProjection, CheckedProjections, Config$1 as Config, DefineScene, Deps$1 as Deps, Events, KernelSlice$1 as KernelSlice, LayerMap, RunContext, SceneDefinition, SceneLayer, SceneOwner, SceneProjection, SceneSpec, ScenesApi, ScenesCtx, SortRule, State$1 as State, UiLayer };
 }
@@ -1473,7 +1492,12 @@ type Config$1 = Record<string, never>;
  */
 type State$1 = {
   /** Scene id to its declaration, filled in `onStart` from `flow.features`. */scenes: Map<string, SceneDefinition>; /** Id of the scene that is mounted now. */
-  current: string | undefined; /** Fast mode: the scene a transit node named, applied at the next rest node. */
+  current: string | undefined;
+  /**
+   * The scene the next rest node without its own `scene` mounts: the one a transit node named in
+   * fast mode, or the one the restore door expected with `expect`. A rest node clears it; an over
+   * rest node takes it only while nothing is mounted.
+   */
   pending: string | undefined;
   owner: SceneOwner; /** The remover of the `onEnter` callback: set in `onStart`, run in `onStop`. */
   teardown: (() => void) | undefined;
@@ -1499,7 +1523,7 @@ type Events = {
 };
 /**
  * scenes plugin API, `app.scenes`. A scene is switched by the graph, never by a call, so the
- * plugin answers one question and takes no orders.
+ * plugin answers one question and takes one order, for the restore door.
  *
  * @example
  * ```ts
@@ -1520,6 +1544,24 @@ type ScenesApi = {
    * ```
    */
   current(): string | undefined;
+  /**
+   * Names the scene the next rest node without its own `scene` mounts. The restore door calls it
+   * with the scene of a bookmark, so a bookmark at a popup comes back with the scene under it.
+   * An over rest node takes the expected scene only while nothing is mounted; it never switches a
+   * mounted one.
+   *
+   * @param id - Id of a scene a feature declared.
+   * @throws {Error} For an id no feature declared, also before `onStart` filled the registry.
+   * @example
+   * ```ts
+   * // A fresh page restores a bookmark taken at the Settings popup over Home.
+   * app.scenes.expect("home");
+   * await app.flow.restore(bookmark);
+   * await app.flow.walk([]); // the scene stage runs after restore resolves
+   * app.scenes.current(); // "home"
+   * ```
+   */
+  expect(id: string): void;
 };
 /**
  * Resolved dependency APIs.
@@ -1925,7 +1967,7 @@ type AudioCtx = KernelSlice & {
 /**
  * Payload of the `model:committed` hook: the source of every volume a game sets.
  */
-type ModelCommitted = Events$2["model:committed"];
+type ModelCommitted = Events$3["model:committed"];
 /**
  * Payload of the `scenes:changed` hook: `music` is the track the next scene declared.
  */
@@ -1933,11 +1975,11 @@ type SceneChanged = Events["scenes:changed"];
 /**
  * Payload of the `lifecycle:changed` hook: the pause that holds every bus at zero.
  */
-type LifecycleChanged = Events$3["lifecycle:changed"];
+type LifecycleChanged = Events$4["lifecycle:changed"];
 /**
  * Payload of the `assets:bundle-unloaded` hook: `keys` names every decoded sound that is gone.
  */
-type BundleUnloaded = Events$4["assets:bundle-unloaded"];
+type BundleUnloaded = Events$5["assets:bundle-unloaded"];
 /**
  * What one play of a sound asks for: the key and the bus the sound goes to.
  */
@@ -1953,4 +1995,4 @@ type MusicRequest = {
   fadeMs: number;
 };
 //#endregion
-export { haptic as A, tween as B, HapticKind as C, defineAnimation as D, HAPTIC_KINDS as E, set as F, UiApi as G, wait as H, sfx as I, types_d_exports$3 as K, spawn as L, parallel as M, play as N, external as O, sequence as P, spawned as R, types_d_exports$2 as S, Step as T, Config$3 as U, use as V, State$3 as W, Config$2 as _, SoundEntry as a, State$2 as b, AnySceneProjection as c, SceneDefinition as d, SceneSpec as f, AnimApi as g, types_d_exports$1 as h, MusicOptions as i, mark as j, frames as k, DefineScene as l, State$1 as m, Config as n, State as o, ScenesApi as p, MusicDescriptor as r, types_d_exports as s, AudioApi as t, LayerMap as u, FramesValue as v, SfxDescriptor as w, Target as x, MotionKeyframe as y, stagger as z };
+export { HAPTIC_KINDS as A, sfx as B, MotionKeyframe as C, HapticKind as D, types_d_exports$3 as E, mark as F, use as G, spawned as H, parallel as I, wait as K, play as L, external as M, frames as N, SfxDescriptor as O, haptic as P, sequence as R, FramesValue as S, Target as T, stagger as U, spawn as V, tween as W, State$2 as _, SoundEntry as a, AnimApi as b, AnySceneProjection as c, SceneDefinition as d, SceneSpec as f, Config$2 as g, types_d_exports$1 as h, MusicOptions as i, defineAnimation as j, Step as k, DefineScene as l, State$1 as m, Config as n, State as o, ScenesApi as p, MusicDescriptor as r, types_d_exports as s, AudioApi as t, LayerMap as u, UiApi as v, State$3 as w, Config$3 as x, types_d_exports$2 as y, set as z };

package/dist/{types-DtmFVCHf.d.mts → types-CYYKjvLn.d.mts}

@@ -1,4 +1,4 @@
-import { At as JournalEntry, Kt as Json, Lt as Answer, Rt as Api, in as RngState, jt as RouteStep, kt as FlowState, tn as Snapshot, ut as Api$1 } from "./types-Dy1xB68L.mjs";
+import { At as JournalEntry, Kt as Json, Lt as Answer, Rt as Api, in as RngState, jt as RouteStep, kt as FlowState, tn as Snapshot, ut as Api$1 } from "./types-BMEn0tSC.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/headless.d.ts

package/dist/{types-w646dMeA.d.mts → types-ClF8say0.d.mts}

@@ -1,5 +1,5 @@
-import { D as Point, E as FilterSlot, L as ComponentHandle, V as Entity, _ as PixiModule, g as PixiFilter, k as Api$1, m as Api$2, o as Events, t as Api$3, ut as Api, v as PixiSprite, vn as Require, y as PixiTexture, z as ComponentType } from "./types-Dy1xB68L.mjs";
-import { g as AnimApi } from "./types-C-4f2jD_.mjs";
+import { D as Point, E as FilterSlot, L as ComponentHandle, V as Entity, _ as PixiModule, _n as Events$1, g as PixiFilter, k as Api$1, m as Api$2, o as Events, t as Api$3, ut as Api, v as PixiSprite, vn as Require, y as PixiTexture, z as ComponentType } from "./types-BMEn0tSC.mjs";
+import { b as AnimApi } from "./types-CXyipKhE.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -523,7 +523,7 @@ type EmitterInstance = {
   readonly particleClass: PixiModule["Particle"];
 };
 declare namespace types_d_exports {
-  export { AlphaValue, BlurValue, BundleUnloaded, ColorMatrixValue, Config, CoreKind, Curve, Deps, DisplacementValue, EffectsApi, EffectsCtx, EffectsStats, EmitterConfig, EmitterDefinition, EmitterValue, FilterComponent, FilterDefinition, FilterSpec, FilterValueOf, GlowValue, KernelSlice, NoiseValue, OutlineValue, Range, ResolvedEmitterConfig, Shape, State, UniformDeclaration, UniformSpec, UniformValue };
+  export { AlphaValue, BlurValue, BundleUnloaded, ColorMatrixValue, Config, CoreKind, Curve, Deps, DisplacementValue, EffectsApi, EffectsCtx, EffectsStats, EmitterConfig, EmitterDefinition, EmitterValue, FilterComponent, FilterDefinition, FilterSpec, FilterValueOf, GlowValue, HotSwap, KernelSlice, NoiseValue, OutlineValue, Range, ResolvedEmitterConfig, Shape, State, UniformDeclaration, UniformSpec, UniformValue };
 }
 /**
  * effects plugin config. `maxParticles` here is the global warning line; the `maxParticles` of an
@@ -644,5 +644,9 @@ type EffectsCtx = KernelSlice & {
  * Payload of the `assets:bundle-unloaded` hook: `keys` names every texture that is gone.
  */
 type BundleUnloaded = Events["assets:bundle-unloaded"];
+/**
+ * Payload of the global `ui:hot-swap` hook: the saved file and its new exports.
+ */
+type HotSwap = Events$1["ui:hot-swap"];
 //#endregion
 export { NoiseValue as _, types_d_exports as a, EmitterValue as c, ColorMatrixValue as d, DisplacementValue as f, GlowValue as g, FilterValueOf as h, State as i, AlphaValue as l, FilterSpec as m, EffectsApi as n, EmitterConfig as o, FilterComponent as p, EffectsStats as r, EmitterDefinition as s, Config as t, BlurValue as u, OutlineValue as v, UniformDeclaration as y };