@moku-labs/game 0.15.14 → 0.15.17

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { Qn as AnyFlow, Xn as FeaturePlugin, cr as Descriptor, fr as Hint, gr as ClockSource, ir as NodeTable, pr as NodeFx, vr as FakeClock, wr as Json } from "./types-CuEK0Vam.mjs";
-import { t as createApp } from "./index-YUceiUFm.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-Dm4tM5nH.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-DHtavbqk.mjs";
+import { Qn as AnyFlow, Xn as FeaturePlugin, cr as Descriptor, fr as Hint, gr as ClockSource, ir as NodeTable, pr as NodeFx, vr as FakeClock, wr as Json } from "./types-DOldmhIw.mjs";
+import { t as createApp } from "./index-BYDIzUDh.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-D8zAAXLt.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-ByFLyHxx.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { $t as exit, Qt as refuseStart, m as flattenFeatures, nn as type, t as createApp } from "./src-Co5sO4z1.mjs";
+import { $t as exit, Qt as refuseStart, m as flattenFeatures, nn as type, t as createApp } from "./src-sg41xWNr.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-3bEK86Z1.d.mts → types-Bi6hj1OB.d.mts}

@@ -1,8 +1,7 @@
-import { $r as Events$2, $t as Api$3, An as ReducedMotion, Br as Events$5, Cn as Ease, Cr as Events$3, D as FilterSlotInputs, Dn as NumericFields, E as FilterSlot, En as MotionHandle, K as Api$4, Mn as TrackSegment, O as SyncApi, Pn as Api$2, Q as PixiTexture, Wr as Api$1, X as PixiModule, Y as PixiFilter, Z as PixiSprite, cr as Descriptor, dn as Entity, ei as Require, in as AnyComponent, jn as TrackOptions, ln as ComponentType, lt as FilterCache, on as AnyComponentValue, s as Events$1, sn as ComponentHandle, sr as TypeTag, st as Point, t as Api$5, v as Events$4, wr as Json, xr as Api$6 } from "./types-CuEK0Vam.mjs";
-import { C as TextApi, L as I18nApi, M as InputApi, Y as StylesState, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion } from "./types-xmH1X8qd.mjs";
+import { $r as Events$2, $t as Api$3, An as ReducedMotion, Br as Events$5, Cn as Ease, Cr as Events$3, D as FilterSlotInputs, Dn as NumericFields, E as FilterSlot, En as MotionHandle, K as Api$4, Mn as TrackSegment, O as SyncApi, Pn as Api$2, Q as PixiTexture, Wr as Api$1, X as PixiModule, Y as PixiFilter, Z as PixiSprite, cr as Descriptor, dn as Entity, ei as Require, in as AnyComponent, jn as TrackOptions, ln as ComponentType, lt as FilterCache, on as AnyComponentValue, s as Events$1, sn as ComponentHandle, sr as TypeTag, st as Point, t as Api$5, v as Events$4, wr as Json, xr as Api$6 } from "./types-DOldmhIw.mjs";
+import { N as InputApi, R as I18nApi, X as StylesState, c as UiNode, i as Finding, l as LayoutState, n as ElementChange, o as JsxState, r as ElementMotion, w as TextApi } from "./types-ae0jg0r4.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
-import { Node, Yoga } from "yoga-layout/load";
 
 //#region src/plugins/debug/types.d.ts
 declare namespace types_d_exports$4 {
@@ -2807,56 +2806,6 @@ type MusicRequest = {
   key: string | null;
   fadeMs: number;
 };
-//#endregion
-//#region src/plugins/ui/layout/types.d.ts
-/**
- * The patches the scroll step writes with, one object each, filled in place: a frame builds none.
- * Every number in them is a whole reference unit.
- */
-type ScrollPatches = {
-  scroll: {
-    offset: number;
-    min: number;
-  };
-  state: {
-    offset: number;
-    max: number;
-    moving: boolean;
-  };
-  scrollable: {
-    moving: boolean;
-  };
-  x: {
-    x: number;
-  };
-  y: {
-    y: number;
-  };
-};
-/**
- * layout module state. `nodes` is attach minus detach: Yoga 3.2.1 has no instance counter.
- * `scrolling` is the scroll the finger holds; `scrollClock` the ms the scroll step has run, the
- * clock of the samples; `scrollRing` the last pointer samples of the press on its axis, a
- * position and a time each, `scrollHead` the slot the next one takes and `scrollSamples` how
- * many it holds; `scrollMoved` when the finger last moved.
- */
-type LayoutState = {
-  yoga: Yoga | undefined;
-  byEntity: Map<Entity, Node>;
-  nodes: number;
-  measured: number;
-  solves: number;
-  scrolling: Entity | undefined;
-  scrollClock: number;
-  scrollRing: Float64Array;
-  scrollHead: number;
-  scrollSamples: number;
-  scrollMoved: number;
-  scrollPatches: ScrollPatches; /** One line of the `body` style as the icons were last measured with it; none before that. */
-  iconLine: number | undefined;
-  order: number;
-  cleanups: Array<() => void>;
-};
 declare namespace types_d_exports {
   export { Config, Deps, ElementChange, ElementMotion, Finding, FocusRing, KernelSlice, State, TextInputLook, UiApi, UiCtx, UiNode };
 }

package/dist/{types-Dm4tM5nH.d.mts → types-D8zAAXLt.d.mts}

@@ -1,7 +1,7 @@
-import { Ar as ProviderCall, In as Config$1, Pr as SnapshotOf, Qn as AnyFlow, Sr as Config, X as PixiModule, Xn as FeaturePlugin, a as Config$3, d as Manifest, gr as ClockSource, jr as SaveDoc, kr as PlayerStateProvider, n as AssetsIo, ot as Orientation, q as Config$2, sr as TypeTag, vr as FakeClock, wr as Json } from "./types-CuEK0Vam.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-3bEK86Z1.mjs";
-import { H as StringTable, L as I18nApi, U as TextKey } from "./types-xmH1X8qd.mjs";
-import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-YUceiUFm.mjs";
+import { Ar as ProviderCall, In as Config$1, Pr as SnapshotOf, Qn as AnyFlow, Sr as Config, X as PixiModule, Xn as FeaturePlugin, a as Config$3, d as Manifest, gr as ClockSource, jr as SaveDoc, kr as PlayerStateProvider, n as AssetsIo, ot as Orientation, q as Config$2, sr as TypeTag, vr as FakeClock, wr as Json } from "./types-DOldmhIw.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-Bi6hj1OB.mjs";
+import { R as I18nApi, U as StringTable, W as TextKey } from "./types-ae0jg0r4.mjs";
+import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-BYDIzUDh.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{types-CuEK0Vam.d.mts → types-DOldmhIw.d.mts}

@@ -11712,7 +11712,11 @@ type ManifestBundle = {
    * manifest.
    */
   dir?: string;
-  tier: Tier; /** `"leave"`: unloaded at the next rest once its feature left. Absent: `"budget"`. */
+  tier: Tier;
+  /**
+   * `"leave"`: unloaded at the next rest once its feature left, or once the exit of a scene that named it is over.
+   * Absent: `"budget"`.
+   */
   release?: "leave";
   mb: number;
   pages?: readonly AtlasPage[];
@@ -11962,11 +11966,17 @@ type State = {
   queue: PreloadQueue | undefined;
   current: NodeInfo | undefined;
   useCounter: number; /** Keys already reported missing, so one key warns and starts its background load once. */
-  warned: Set<string>; /** `onEnter`, the `load` handler and the texture provider. */
+  warned: Set<string>; /** `onEnter`, the `load` handler, the texture provider, and the start and the end of an exit in `world`. */
   removers: Array<() => void>; /** The `files` map of the stamp the dev hot swap applied last. `undefined` until the first swap. */
   stamps: Readonly<Record<string, string>> | undefined; /** The running dev hot swap. The next one waits for it, so two swaps never overlap. */
   swapping: Promise<void> | undefined; /** The list the mounted scene names, from the last `sceneBundles` call. */
-  sceneNamed: readonly string[]; /** Registered companions, in registration order. */
+  sceneNamed: readonly string[];
+  /**
+   * The bundles a scene named before and the list names no more: held while anything carries `Exiting`, so a
+   * leaving scene's pictures stay until its elements played their exit (F51).
+   */
+  sceneLeaving: string[]; /** How many entities carry `Exiting` now, counted from the world's `onAdded` and `onRemoved` of the tag. */
+  exiting: number; /** Registered companions, in registration order. */
   companions: BundleCompanion[]; /** A live rest was announced; the arriving node's `load` stage runs the release. */
   restPending: boolean;
 };
@@ -12188,7 +12198,9 @@ type Api = {
   /**
    * Tells assets which bundles the mounted scene names: its `bundle`, then what its `bundles(state)` returned.
    * Each call replaces the list before it. A bundle in the list is never a victim of the budget and is not
-   * released by `release: "leave"` while it stays in the list. Called by `scenes`; a game never calls it.
+   * released by `release: "leave"` while it stays in the list. A bundle the list named before and names no more
+   * stays held while anything carries `Exiting`, so a leaving scene's pictures stay until its elements played their
+   * exit; then a `"leave"` one goes at once (F51). Called by `scenes`; a game never calls it.
    *
    * @param named - The bundle names of the mounted scene, the scene bundle first.
    * @example
@@ -12196,6 +12208,8 @@ type Api = {
    * // scenes, right after it mounted the ward for episode 1 (and after a re-read that changed the list).
    * ctx.require(assetsPlugin).sceneBundles(["ui", "ep01"]);
    * // ep01 (release "leave") now stays while the ward shows it, even after the ep01 flow left the stack
+   * ctx.require(assetsPlugin).sceneBundles(["board"]);
+   * // the board is mounted: ep01 stays until the ward's elements played their exit, then goes
    * ```
    */
   sceneBundles(named: readonly string[]): void;
@@ -12248,6 +12262,7 @@ type Deps = {
   renderer: Api$1;
   time: Api$7;
   model: Api$5;
+  world: Api$2;
 };
 /**
  * What the kernel context offers before the deps are attached.
@@ -12282,7 +12297,8 @@ type HotSwap = Events$8["ui:hot-swap"];
 /**
  * When a bundle leaves besides the budget. `"budget"` (default): only the LRU unloads it when memory
  * runs out. `"leave"`: also unloaded at the next rest once no node of its feature is on the stack
- * and no mounted scene names it.
+ * and no mounted scene names it; a scene that named it and left holds it until its elements played
+ * their exit, and then it goes at once.
  *
  * @example
  * ```ts

package/dist/{types-xmH1X8qd.d.mts → types-ae0jg0r4.d.mts}

@@ -1,6 +1,7 @@
-import { $t as Api$2, Dn as NumericFields, En as MotionHandle, K as Api$3, Nn as ViewHandle, On as ProjectionMotion, Pn as Api$1, Tn as MotionCause, U as TransformValue, Wr as Api, an as AnyComponentType, bn as TagType, cr as Descriptor, ct as ViewportSize, dn as Entity, ei as Require, fr as Hint, hr as Api$5, in as AnyComponent, ln as ComponentType, mr as Answer, on as AnyComponentValue, s as Events$1, t as Api$4, wn as Motion, wr as Json, xn as ChangeHook } from "./types-CuEK0Vam.mjs";
+import { $t as Api$2, An as ReducedMotion, Cn as Ease, Dn as NumericFields, En as MotionHandle, K as Api$3, Nn as ViewHandle, On as ProjectionMotion, Pn as Api$1, Tn as MotionCause, U as TransformValue, Wr as Api, an as AnyComponentType, bn as TagType, cr as Descriptor, ct as ViewportSize, dn as Entity, ei as Require, fr as Hint, hr as Api$5, in as AnyComponent, ln as ComponentType, mr as Answer, on as AnyComponentValue, s as Events$1, t as Api$4, wn as Motion, wr as Json, xn as ChangeHook } from "./types-DOldmhIw.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/styles/types.d.ts
 /**
@@ -1421,7 +1422,10 @@ type CountdownValue = {
 /**
  * What the `Text` component holds. `resolved` is engine-owned: a game writes `content`, `style`,
  * `bind`, `anchor` and `alpha`, and reads `resolved`. `alpha` fades every run, shadow and icon of
- * the block together, 1 by default; a change is written in place and a tween can drive it.
+ * the block together, 1 by default; a change is written in place and a tween can drive it. `box`
+ * is the width a style with `wrap: "box"` wraps at: `ui` writes the laid-out width of the text
+ * element there, only on a text that wrapped at it, so a saved or described value has none; with no
+ * box or 0 it is one line. A style that wraps otherwise ignores it.
  *
  * @example
  * ```ts
@@ -1431,6 +1435,11 @@ type CountdownValue = {
  * };
  * // The hint of an empty name field, at half alpha.
  * const hint: TextValue = { ...value, content: "Your name", alpha: 0.5, resolved: "Your name" };
+ * // A player name in a "card.name" style with wrap "box", laid out 200 wide by ui: two lines.
+ * const name: TextValue = {
+ *   ...value, content: "Aleksandra Kucherenko", style: "card.name", box: 200,
+ *   resolved: "Aleksandra Kucherenko"
+ * };
  * ```
  */
 type TextValue = {
@@ -1439,6 +1448,7 @@ type TextValue = {
   bind: TextBind | undefined;
   anchor: Point;
   alpha: number;
+  box?: number;
   resolved: string;
 };
 /**
@@ -1451,14 +1461,17 @@ type TextValue = {
  */
 type TextAlign = "left" | "center" | "right";
 /**
- * The wrap width of a style in reference pixels, or `"none"` for one line per `\n` segment.
+ * The wrap width of a style in reference pixels; `"box"` for the width the `ui` layout gave the
+ * text element, one line outside a layout; or `"none"` for one line per `\n` segment.
  *
  * @example
  * ```ts
  * const wrap: TextWrap = 480;
+ * // A name that wraps at the room its row leaves it: the boxes on the way need `shrink: 1`.
+ * const name: TextWrap = "box";
  * ```
  */
-type TextWrap = number | "none";
+type TextWrap = number | "box" | "none";
 /**
  * The drop shadow of a style as the plugin stores it: a copy of every glyph run in `color`, at
  * `alpha`, moved by `dx` and `dy` reference pixels.
@@ -1662,13 +1675,15 @@ type LayoutOptions = {
  * What was resolved for one entity last, so the frame step knows whether anything moved. `unit`
  * is what the shown string of a bound label was built from: the rounded value for `"int"`, whole
  * seconds for a time format. `bindRef` is the bind object `bind` was keyed from, so the key is
- * built once per attached bind and a frame compares one reference.
+ * built once per attached bind and a frame compares one reference. `box` is the `Text.box` the
+ * label was laid out at: a label of a `"box"` style is laid out again when it moves.
  *
  * @example
  * ```ts
  * const left = bind(Countdown, "left", { format: "mm:ss" });
  * const seen: SeenText = {
- *   content: "", style: "digits", bindRef: left, bind: "Countdown.left:mm:ss", locale: "ru", unit: 95
+ *   content: "", style: "digits", bindRef: left, bind: "Countdown.left:mm:ss", locale: "ru",
+ *   unit: 95, box: undefined
  * };
  * ```
  */
@@ -1679,6 +1694,7 @@ type SeenText = {
   bind: string | undefined;
   locale: string;
   unit: number | undefined;
+  box: number | undefined;
 };
 /**
  * text plugin config.
@@ -1705,7 +1721,7 @@ type State = {
   installed: Set<string>; /** What was resolved for an entity last. */
   seen: Map<Entity, SeenText>; /** `bind.component` to its world type; `undefined` after the one warning. */
   bindTypes: Map<string, AnyComponent | undefined>; /** The measured size of every live label, for `ui`. */
-  measured: Map<Entity, Size>; /** Layout per `style + resolved`, oldest dropped first. */
+  measured: Map<Entity, Size>; /** Layout per `style + resolved`, and the box width for a `"box"` style; oldest dropped first. */
   cache: Map<string, TextLayout>; /** What every live label container was last filled from, by container. */
   drawn: WeakMap<object, DrawnLabel>; /** Entities to re-resolve in the next layout phase. */
   dirty: Set<Entity>;
@@ -1743,10 +1759,13 @@ type TextApi = {
   /**
    * The size of a piece of text in reference pixels, from the advance table of the style's font.
    * A `Message` is formatted in the current locale first. Never touches a canvas, so the answer
-   * is the same in a browser and in plain Bun. Cached per style and resolved string.
+   * is the same in a browser and in plain Bun. Cached per style and resolved string, and per
+   * width for a `"box"` style.
    *
    * @param content - A plain string, or what `tr` returned.
    * @param style - A registered style name. An unknown one warns once and measures as `body`.
+   * @param width - The width a style with `wrap: "box"` wraps at, in reference pixels. Left out
+   *   (or 0) the block is one line. A style that wraps otherwise ignores it.
    * @returns The width and height of the block.
    * @example
    * ```ts
@@ -1754,9 +1773,12 @@ type TextApi = {
    * const text = ctx.require(textPlugin);
    *
    * text.measure("120", "digits"); // { width: 57.6, height: 38.4 } on the 0.6 em fallback
+   * // "card.name" is a 32 px style with wrap "box": the width Yoga offers wraps it.
+   * text.measure("Aleksandra Kucherenko", "card.name", 200); // { width: 192, height: 76.8 }
+   * text.measure("Aleksandra Kucherenko", "card.name"); // { width: 403.2, height: 38.4 }
    * ```
    */
-  measure(content: string | Message, style: string): Size;
+  measure(content: string | Message, style: string, width?: number): Size;
   /**
    * Whether the font of a style has a glyph for one character, the lookup Pixi draws by. A
    * character its font lacks is drawn as nothing and `measure` counts it 0 wide. While the font is
@@ -2339,6 +2361,74 @@ declare function popup<Properties extends object, Local extends object, Outcomes
   over?: string;
 }): Descriptor<Answer<keyof Outcomes & string>>;
 //#endregion
+//#region src/plugins/ui/layout/types.d.ts
+/**
+ * The patches the scroll step writes with, one object each, filled in place: a frame builds none.
+ * Every number in them is a whole reference unit.
+ */
+type ScrollPatches = {
+  scroll: {
+    offset: number;
+    min: number;
+  };
+  state: {
+    offset: number;
+    max: number;
+    moving: boolean;
+  };
+  scrollable: {
+    moving: boolean;
+  };
+  x: {
+    x: number;
+  };
+  y: {
+    y: number;
+  };
+};
+/**
+ * layout module state. `nodes` is attach minus detach: Yoga 3.2.1 has no instance counter.
+ * `scrolling` is the scroll the finger holds; `scrollClock` the ms the scroll step has run, the
+ * clock of the samples; `scrollRing` the last pointer samples of the press on its axis, a
+ * position and a time each, `scrollHead` the slot the next one takes and `scrollSamples` how
+ * many it holds; `scrollMoved` when the finger last moved.
+ */
+type LayoutState = {
+  yoga: Yoga | undefined;
+  byEntity: Map<Entity, Node>;
+  nodes: number;
+  measured: number;
+  solves: number;
+  scrolling: Entity | undefined;
+  scrollClock: number;
+  scrollRing: Float64Array;
+  scrollHead: number;
+  scrollSamples: number;
+  scrollMoved: number;
+  scrollPatches: ScrollPatches; /** One line of the `body` style as the icons were last measured with it; none before that. */
+  iconLine: number | undefined;
+  order: number;
+  cleanups: Array<() => void>;
+};
+/**
+ * The longest finite track a motion hook started through its view handle: where it ends (delay included), its length,
+ * delay, ease and reduced-motion rule. The level of an overlay follows the root's own enter and exit motion by it
+ * (spec 22, LEAD-FIXES-4 item 5a); `end` 0 means the hook started no timed track.
+ *
+ * @example
+ * ```ts
+ * // A sheet that fades in over 250 ms after 40 ms.
+ * const span: MotionSpan = { end: 290, ms: 250, delayMs: 40, ease: "out", reduced: undefined };
+ * ```
+ */
+type MotionSpan = {
+  end: number;
+  ms: number;
+  delayMs: number;
+  ease: Ease | undefined;
+  reduced: ReducedMotion | undefined;
+};
+//#endregion
 //#region src/plugins/ui/jsx/types.d.ts
 /**
  * One node of an element description, as the JSX runtime builds it. `key` is the third argument
@@ -2534,7 +2624,9 @@ type StyleBasis = {
  * warnings of its props in `warned`; `scrolledIn` marks an element a range change of a windowed
  * scroll created: it plays no `enter` hook. A scroll carries its `scroll` motion from its enter. A text or an icon that sizes itself keeps in
  * `measuredSize` what its measure function last answered, before Yoga's clamp: a bound text whose
- * new string measures the same asks for no solve. `basis` is what `style` was resolved on, set
+ * new string measures the same asks for no solve. `measuredWidth` is the width Yoga offered that
+ * call when the text wrapped at it (only a `"box"` style does), `undefined` otherwise: such a text
+ * is measured again at its laid-out width and gets a `Text.box`, any other gets none. `basis` is what `style` was resolved on, set
  * once the style is on the layout node and the components are written; an element without one is
  * patched in full at its next patch. `index` is its place among the element children of its parent
  * at the last diff (0 for a root element): with its `zIndex` it gives the child its `Order`.
@@ -2592,8 +2684,35 @@ type Element = {
     width: number;
     height: number;
   };
+  measuredWidth?: number | undefined; /** True once the text wrapped at its box: from then on `ui` writes its box, 0 when it fits. */
+  boxed?: boolean;
   basis?: StyleBasis; /** The motions of its hooks that started a `repeat: "forever"` track; made with the first one. */
-  endless?: Set<MotionHandle>;
+  endless?: Set<MotionHandle>; /** What its enter hook did at the `Box`, until `ui.enter` keeps the play or plays it again (F49). */
+  posed?: PosedEnter | undefined;
+};
+/**
+ * One `set` of an enter hook: the fields it wrote, and the values they had before. A hook may write any component of
+ * the game, so the fields are kept by name, as records.
+ */
+type PoseWrite = {
+  component: ComponentType<Record<string, unknown>>;
+  wrote: Record<string, unknown>;
+  before: Record<string, unknown>;
+};
+/**
+ * What the play of an enter hook at the `Box` kept: the motion it returned, the components it read
+ * (with their fields as they stood after the play), the names of the components it wrote, its
+ * `set` writes, and the span noted for an overlay.
+ */
+type PosedEnter = {
+  motion: MotionHandle | undefined;
+  reads: Array<{
+    component: ComponentType<Record<string, unknown>>;
+    seen: Record<string, unknown>;
+  }>;
+  written: string[];
+  writes: PoseWrite[];
+  span: MotionSpan | undefined;
 };
 /**
  * The popup side of a root: the handler that shows it now and the root it was opened over.
@@ -2792,8 +2911,8 @@ type JsxState = {
   text: TextState;
   hints: Hint[];
   /**
-   * The elements whose `Box` came since the last `sync`: their enter hooks play there, after the game's systems
-   * (F48). The first `count` slots are the queue; the array keeps its length, so a frame allocates nothing.
+   * The elements whose `Box` came since the last `sync`: their enter hooks played at the `Box` (F49) and are settled
+   * there, after the game's systems, played again when a system changed what a hook read (F48). The first `count` slots are the queue; the array keeps its length, so a frame allocates nothing.
    */
   entering: {
     list: Entity[];
@@ -2922,4 +3041,4 @@ type CommonProps = {
   components?: ElementComponents;
 };
 //#endregion
-export { defineComponent as A, Part as B, TextApi as C, TextStyles as D, TextStyleInput as E, Argument as F, types_d_exports$2 as G, StringTable as H, Config$2 as I, Style as J, IsFlags as K, I18nApi as L, InputApi as M, State$1 as N, TextValue as O, types_d_exports$1 as P, IntlKit as R, State as S, TextFormat as T, TextKey as U, State$2 as V, TypedTr as W, WhenFlags as X, StylesState as Y, BindField as _, JsxChild as a, CountdownValue as b, UiNode as c, LocalWrite as d, ScrollState as f, UiIntrinsicElements as g, IntrinsicElementsFor as h, Finding as i, Config$1 as j, types_d_exports as k, Box as l, defineTokens as m, ElementChange as n, JsxState as o, popup as p, ResolvedStyle as q, ElementMotion as r, PopupComponent as s, DescriptionNode as t, DebugTrigger as u, BindOptions as v, TextBind as w, Point as x, Config as y, Message as z };
+export { types_d_exports as A, Message as B, State as C, TextStyleInput as D, TextFormat as E, types_d_exports$1 as F, TypedTr as G, State$2 as H, Argument as I, ResolvedStyle as J, types_d_exports$2 as K, Config$2 as L, Config$1 as M, InputApi as N, TextStyles as O, State$1 as P, I18nApi as R, Point as S, TextBind as T, StringTable as U, Part as V, TextKey as W, StylesState as X, Style as Y, WhenFlags as Z, UiIntrinsicElements as _, JsxChild as a, Config as b, UiNode as c, DebugTrigger as d, LocalWrite as f, IntrinsicElementsFor as g, defineTokens as h, Finding as i, defineComponent as j, TextValue as k, LayoutState as l, popup as m, ElementChange as n, JsxState as o, ScrollState as p, IsFlags as q, ElementMotion as r, PopupComponent as s, DescriptionNode as t, Box as u, BindField as v, TextApi as w, CountdownValue as x, BindOptions as y, IntlKit as z };

package/dist/{types-_a6-ALzz.d.mts → types-qsE-I59e.d.mts}

@@ -1,5 +1,5 @@
-import { Nr as Snapshot, wr as Json } from "./types-CuEK0Vam.mjs";
-import { t as HeadlessApp } from "./headless-DHtavbqk.mjs";
+import { Nr as Snapshot, wr as Json } from "./types-DOldmhIw.mjs";
+import { t as HeadlessApp } from "./headless-ByFLyHxx.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{visual-CbGKzlj0.mjs → visual-DNM5oFYx.mjs}

@@ -618,7 +618,8 @@ function rootPointOf(ecs, entity, point) {
 * Words on the screen: a string or a message, the style it is drawn in, and the string `text`
 * resolved out of it. A game writes `content`, `style`, `bind`, `anchor` and `alpha`; `resolved`
 * is engine-owned and `ui` and the tests read it. `alpha` (1 by default) fades the whole block and
-* is patched in place, so a tween on it rebuilds nothing.
+* is patched in place, so a tween on it rebuilds nothing. `box` (none by default) is the width a
+* style with `wrap: "box"` wraps at; `ui` writes the laid-out width of a text element there.
 */
 const Text = /*#__PURE__*/ component("Text", {
 	content: "",
@@ -726,16 +727,30 @@ function shadowOf(input) {
 	};
 }
 /**
-* Fills the defaults of one style and refuses a wrap that is neither a width nor `"none"`.
+* Tells whether a wrap is one a style can carry: a width above zero, `"box"` or `"none"`. A style
+* read back from a feature may carry anything, so a word is checked as well as a number.
+*
+* @param wrap - The wrap a style names, as it was stored.
+* @returns False for a number that is not above zero, and for anything else.
+* @example
+* ```ts
+* isWrap("box"); // true
+* ```
+*/
+function isWrap(wrap) {
+	return typeof wrap === "number" ? wrap > 0 : wrap === "box" || wrap === "none";
+}
+/**
+* Fills the defaults of one style and refuses a wrap that is not a width, `"box"` or `"none"`.
 *
 * @param name - The style name, for the error.
 * @param input - What the game wrote.
 * @returns The style with every field filled.
-* @throws {Error} When `wrap` is a number that is not greater than zero.
+* @throws {Error} When `wrap` is a number that is not greater than zero, or another word.
 */
 function normalizeStyle(name, input) {
 	const wrap = input.wrap ?? "none";
-	if (wrap !== "none" && wrap <= 0) throw new Error(`[game] Text style "${name}" has wrap ${wrap}.\n  Use a width in reference px or "none".`);
+	if (!isWrap(wrap)) throw new Error(`[game] Text style "${name}" has wrap ${wrap}.\n  Use a width in reference px, "box" or "none".`);
 	return {
 		font: input.font,
 		bold: input.bold,
@@ -757,7 +772,7 @@ function normalizeStyle(name, input) {
 *
 * @param map - Style name to what that style looks like.
 * @returns The registration a feature carries.
-* @throws {Error} When a style names a wrap that is not a width and not `"none"`.
+* @throws {Error} When a style names a wrap that is not a width, `"box"` or `"none"`.
 * @example
 * ```ts
 * defineTextStyles({ "hud.digits": { font: "ui.font-digits", size: 40, fill: 0xffe082 } });
@@ -1182,9 +1197,24 @@ function contentOf(props) {
 	return props.content ?? "";
 }
 /**
-* The visual component of an element: a sprite for an image or an icon, the text for a text, the
-* nine-slice of its style (outlined when the style sets `debug`), or a rounded rectangle, a
-* triangle with `shape: "triangle"`, its stroke dashed with `dash`, or an arc with `shape: "arc"`
+* The box a text wraps at: its laid-out width while it wraps at it, 0 once it fits again, so a
+* text that wrapped draws on one line, and no field on a text that never wrapped.
+*
+* @param element - The text element, with its rect known.
+* @returns `{ box }`, or nothing.
+*/
+function boxOf(element) {
+	if (element.measuredWidth !== void 0) {
+		element.boxed = true;
+		return { box: element.rect.w };
+	}
+	return element.boxed === true ? { box: 0 } : {};
+}
+/**
+* The visual component of an element: a sprite for an image or an icon, the text for a text (with
+* its laid-out width as the box a `"box"` style wraps at), the nine-slice of its style (outlined
+* when the style sets `debug`), or a rounded rectangle, a triangle with `shape: "triangle"`, its
+* stroke dashed with `dash`, or an arc with `shape: "arc"`
 * over the `sweep` of its style, ended by its `cap`. A clipping element (`scroll`,
 * `overflow: "hidden"`) keeps the rectangle, which carries the clip; a text field's rectangle
 * clips too, and a nine-slice field draws its slices and clips to them. A style with a stroke and
@@ -1221,7 +1251,8 @@ function visualOf(element) {
 			anchor: {
 				x: 0,
 				y: 0
-			}
+			},
+			...boxOf(element)
 		})];
 	}
 	const clip = type === "scroll" || style.overflow === "hidden";

package/dist/{visual-DExHHx-a.d.mts → visual-Hj0oNqPP.d.mts}

@@ -1,9 +1,9 @@
-import { $t as Api$1, K as Api, Rr as Api$3, xr as Api$2 } from "./types-CuEK0Vam.mjs";
-import { P as AnimApi, r as UiApi } from "./types-3bEK86Z1.mjs";
-import { M as InputApi } from "./types-xmH1X8qd.mjs";
-import { r as Repro } from "./headless-DHtavbqk.mjs";
-import { a as InputOf, r as ControlApp } from "./types-_a6-ALzz.mjs";
-import { t as commands } from "./commands-aLTGwuyk.mjs";
+import { $t as Api$1, K as Api, Rr as Api$3, xr as Api$2 } from "./types-DOldmhIw.mjs";
+import { P as AnimApi, r as UiApi } from "./types-Bi6hj1OB.mjs";
+import { N as InputApi } from "./types-ae0jg0r4.mjs";
+import { r as Repro } from "./headless-ByFLyHxx.mjs";
+import { a as InputOf, r as ControlApp } from "./types-qsE-I59e.mjs";
+import { t as commands } from "./commands-DEVJzdsr.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-DExHHx-a.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-Hj0oNqPP.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,4 +1,4 @@
-import { n as read, t as sources } from "./sources-Fbq_PFVH.mjs";
+import { n as read, t as sources } from "./sources-BYKXYPhd.mjs";
 import { n as commands, t as run } from "./run-BqYmcNo7.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";

package/llms.txt

@@ -554,7 +554,7 @@ A screen is a projection whose `view` returns JSX. The game's `tsconfig.json` se
 - `defineComponent(name, { local?, outcomes?, view(props, local) })`. A component with `outcomes` is a popup: `await fx(popup(Component, props))` opens the gate for its outcomes and resolves with `{ intent, payload }` of the pressed button. A button with `local` writes into the nearest component instance; it never reaches the graph.
 - `tr(key, params?)` returns a frozen `Message` `{ key, params }`; no locale is read at the call site. Strings live in `strings/<locale>.json` of any feature or sub-feature, as ICU MessageFormat 1 (`{n, plural, one {# order} other {# orders}}`, `select`, `selectordinal`, `number`, `date`, `time`; no skeletons, no `currency`). `bun run assets:keys` compiles them. The keys of the top-level features and the layers go into `generated/strings.<locale>.ts`, which one feature registers; a sub-feature's keys start with `<name>.` (`ep01.title`) and go into `generated/strings.<name>.<locale>.ts`, which the sub-feature registers lazily, `strings: { en: () => import("@generated/strings.ep01.en"), ru: () => import("@generated/strings.ep01.ru") }`. With `assets` composed those modules load and unload with the bundle named like the sub-feature: every way the bundle comes (a node entry, a scene's `bundles`, `load`, a restore, the `safeNode`) brings its strings, a locale switch brings them in the new locale, and while the bundle is not loaded a key of it gives `⟦key⟧` and `has(key)` is false. A compiled module calls the root helpers `messageArgument(value, intl)` (an element stays an element part, a list goes through `Intl.ListFormat`, a number through `Intl.NumberFormat`, else text) and `messageDuration(ms)` (`95_000` gives `{ minutes: 1, seconds: 35 }`). `app.i18n`: `locale()`, `setLocale(locale)` (async, emits `i18n:locale-changed`), `format(message, locale?)` returns `Part[]`, `plain(message)` returns a string, `has(key)`, `isKey(value)`, `locales()`, `replace(locale, messages)` (dev hot swap of a generated strings file). Config: `locale: "en"`, `fallback: "en"`, `locales: {}`.
 - Keys that come from data: `I18n.TextKey<Strings>` is the keys of the generated `Strings` without parameters (nothing new is generated). A data table types its keys `TextKey` or builds them with the kit's `key("board.hint.red")`; the kit's `tr` never takes a plain `string`. A key read back from a save is checked where the app is (an effect handler, app or page code, loading a save) with one `isKey(value)`: `defineGameApp({ ..., strings: type<Strings>() })` types the game's `app.i18n`, so a true `app.i18n.isKey(value)` narrows the value to `TextKey`; `ctx.require(i18nPlugin).isKey(value)` in a plugin narrows to `string`. `app.i18n.isKey(value)` answers true for a key of the loaded tables of the current locale or the fallback, and for the `<feature>.` prefix of a sub-feature whose strings are not loaded yet; a key that takes parameters answers true too.
-- Text: `Text` component, `label({ text, style, at, anchor? })` for board text in a projection view, `defineTextStyles({ "hud.digits": { font, size, fill, bold?, italic?, stroke?, strokeWidth?, letterSpacing?, align?, wrap?, digits? } })` under the feature's `textStyles` key. Tags inside a string: `<b>`, `<i>`, `<color=#rrggbb>`, `<icon=key>`, `\<`, `\n`. Built-in styles `body` and `digits` from config `fonts: { body: "ui.font-body", digits: "ui.font-digits" }`. `app.text.measure(content, style)` gives the same numbers in a browser and in Bun. `app.text.replaceStyles(styles)` is the dev hot swap of a saved `defineTextStyles` value.
+- Text: `Text` component, `label({ text, style, at, anchor? })` for board text in a projection view, `defineTextStyles({ "hud.digits": { font, size, fill, bold?, italic?, stroke?, strokeWidth?, letterSpacing?, align?, wrap? (a width, "none" or "box": wrap at the laid-out width of its ui element), digits? } })` under the feature's `textStyles` key. Tags inside a string: `<b>`, `<i>`, `<color=#rrggbb>`, `<icon=key>`, `\<`, `\n`. Built-in styles `body` and `digits` from config `fonts: { body: "ui.font-body", digits: "ui.font-digits" }`. `app.text.measure(content, style, width?)` gives the same numbers in a browser and in Bun. `app.text.replaceStyles(styles)` is the dev hot swap of a saved `defineTextStyles` value.
 - Animation is data: `defineAnimation(id, { slots: { name: type<Anim.Target>() }, build: (slots, { at }) => Step })`. Steps: `sequence(...)`, `parallel(...)`, `stagger(items, ms, item => Step)`, `tween(target, Component, to, { ms, ease?, delayMs?, additive?, space?, reduced? })`, `set(target, Component, patch)`, `wait(ms)`, `mark(name)`, `frames(target, { keys, fps, loop? })`, `sfx(key, { bus? })`, `haptic(kind)`, `use(animation, slots, tools?)`, `spawn` (a temporary entity, flying coins, that the timeline despawns when it ends; see the anim README). `Frames({ keys, fps, loop, playing })` is a component that walks a sprite through its textures for the entity's whole life. A target is `{ projection, key }` or an entity. A timeline resolves each `{ projection, key }` target once, when it starts: every step writes the view that held the key then, also after a commit removed it and while its exit plays, until it despawns; a view spawned again under the same key is not followed, and a key nothing held at the start is looked up at its step. `reduced: "keep"` (on a `tween` step, `transition` and `loop` of `defineMotion`, `TweenOptions`, `RestOptions`) plays a track as written under reduced motion, a fade for one; the default `"cut"` lands it at once or holds a loop on its first key. A node plays it with `await fx(play(animation, slots))`; in fast mode it finishes at once. `defineMotion({ states, transition?, on: { enter?, exit?, change? }, when? })` builds the enter, exit and change hooks for a projection or the `motion` prop of a tag; `when: "change"` plays enter and exit only for a commit, so an element that comes or goes with its screen stands at rest and leaves without a motion (default `"always"`). Events `anim:mark` `{ animation, mark }` and `anim:finished` `{ animation }`. `app.anim.replace(definition)` is the dev hot swap: the next `play` builds the new tree. A system cannot `require` a plugin, so it plays through the resource `AnimPlayer`: `res(AnimPlayer).play(animation, slots)` returns the same handle as `app.anim.play`, and the registered animation of `animation.id` wins, so a hot swap reaches the system. Play on a change, never every frame; from phase `input` the tree moves in `animate` of the same frame. Before `anim` starts it throws `[game] AnimPlayer is not ready: anim has not started.` Config `maxTracks: 2000`.
 - Audio is opt-in: `plugins: [...screen, audioPlugin]`. `fx(sfx("orders.complete"))` resolves when the sound started. `await fx(music("board.theme"))` cross-fades; `music(null)` fades out; a scene's `music` key switches the track on `scenes:changed`. Buses `master`, `music`, `sfx`. Volumes come from the committed player: config `volumes: player => (player as Player).settings.audio`, applied on every `model:committed`. `app.audio`: `setVolume(bus, value)`, `volume(bus)`, `mute(bus, on)`, `muted(bus)`, `unlocked()`, `journal()` (the last started sounds, empty unless config `journal` is above 0). Config: `buses: { master: 1, music: 0.6, sfx: 1 }`, `musicFadeMs: 600`, `volumes`, `context`, `journal: 0`, `music: "decode" | "stream"` default `"decode"` (gapless buffer; `"stream"` is an `<audio>` element, less memory, a gap at every loop), `session: "ambient" | "playback" | "auto"` default `"ambient"` (iOS only: ambient mixes with other apps and obeys the silent switch). The context is asked to run at start: where the shell lets audio play (a native webview with the gesture requirement off) `unlocked()` is true with no touch; a browser that wants a gesture unlocks on the first `pointerdown` or `touchend`. Without `audio` every `sfx` and `music` effect resolves `undefined` at once, so the same node runs in a game with no sound.
 - `app.ui`: `tree()` the live screen as plain data (a text node carries `content`, the words it draws after `tr()` and `bind`; a text field carries `value`), `find(key)` the entity of a keyed element, `fill(key, value)` types into the text field with that `key`, `scroll(key, to)` puts the `scroll` with that `key` at `to` from its start at once, inside `0..max`, its fling or glide stopped (`false` and `ui:scroll-without-scroll` for no live `scroll`, `false` and `ui:scroll-before-solve` for a `scroll` its first solve has not placed yet), `lint()` tap targets under `tapTargetPt` (default `44`), text that overflows in some locale, absolute elements without `reason`. Config: `tapTargetPt: 44`, `breakpoints: { tall: 2, wide: 1.5 }`. `ui` emits only the dev global event `ui:hot-swap`, see "Hot swap".

package/package.json

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