@moku-labs/game 0.15.7 → 0.15.9

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-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 { 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-i77Nrrv-.mjs";
+import { t as createApp } from "./index-DT9aYVGd.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-DK-IYk-s.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-CrxofjLt.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-nJYt0LMr.mjs";
+import { an as refuseStart, ln as type, m as flattenFeatures, on as exit, t as createApp } from "./src-Cs1bP3v7.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-CZGuMhV8.d.mts → types-D8roM1u3.d.mts}

@@ -1,4 +1,4 @@
-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 { $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-i77Nrrv-.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -126,6 +126,8 @@ type PositionStyle = {
  * // The play glyph of the Watch button, and a dashed ring around a slot.
  * const play: VisualStyle = { shape: "triangle", fill: 0xfffbe8 };
  * const slot: VisualStyle = { stroke: 0x3a2212, strokeWidth: 4, dash: 10, radius: 24 };
+ * // The slot timer: the time left as 42 % of a ring, from 12 o'clock clockwise, with round ends.
+ * const timer: VisualStyle = { shape: "arc", stroke: 0xc8a15a, strokeWidth: 2.2, sweep: 0.42, cap: "round" };
  * ```
  */
 type VisualStyle<Asset extends string = string> = {
@@ -136,11 +138,19 @@ type VisualStyle<Asset extends string = string> = {
   alpha?: number;
   /**
    * The shape of the rectangle an element without a nine-slice is drawn with: `"rect"` (the
-   * default) or `"triangle"`, which fills the box pointing right and ignores `radius`. Turn the
-   * element with `rotation` for another direction.
+   * default), `"triangle"`, which fills the box pointing right and ignores `radius` (turn the
+   * element with `rotation` for another direction), or `"arc"`, a `stroke` of `strokeWidth` on the
+   * circle inscribed in the box (`min(width, height) − strokeWidth` across, centred) from 12 o'clock
+   * clockwise over `sweep` of it. An arc draws no `fill` and ignores `radius` and `dash`.
    */
-  shape?: "rect" | "triangle"; /** The dash length of the stroke in reference units, with gaps of half a dash; 0 is solid. */
+  shape?: "rect" | "triangle" | "arc"; /** The dash length of the stroke in reference units, with gaps of half a dash; 0 is solid. */
   dash?: number;
+  /**
+   * The share of the circle an arc sweeps, from 0 to 1 (1 by default): 0 draws nothing, 1 a
+   * closed ring; a value outside is clamped. A new value in a render draws the arc again once.
+   */
+  sweep?: number; /** How an open arc ends: `"round"` (the default) or `"butt"`, flat at its end. */
+  cap?: "round" | "butt";
   /**
    * The asset key of a nine-slice drawn at the rect instead of the rounded rectangle. Any tag
    * but `image`, `icon` and `text` takes it; a clipping element (`scroll`, `overflow: "hidden"`)
@@ -990,7 +1000,12 @@ type State$1 = {
    * over and cancels the resting press.
    */
   pointerId: number | undefined; /** The followed pointer left the tap slop since its press: it started a gesture and keeps the pointer. */
-  moved: boolean; /** The pressed or held entity. */
+  moved: boolean;
+  /**
+   * The press belongs to a scroll: it landed on a moving one and stopped it, or it was handed to
+   * one past the tap slop. Its release answers nothing and runs no `onTap` listener.
+   */
+  caught: boolean; /** The pressed or held entity. */
   entity: Entity | undefined; /** The projection key of `entity`, read once at press time. */
   key: {
     projection: string;
@@ -1870,8 +1885,51 @@ type ImageTexture = string & Brand<"ImageTexture">;
 type IconName = string & Brand<"IconName">;
 /** How an image or an icon fills its rect: inside it, over it (cropped), or stretched. */
 type ImageFit = ("contain" | "cover" | "fill") & Brand<"ImageFit">;
-/** The axis a scroll container moves on. `"x"` throws until V4. */
+/**
+ * The axis a scroll container moves on: `"y"`, the default, or `"x"`. Fixed when the scroll
+ * spawns: another axis on a later render keeps the first one, with one warning
+ * `ui:scroll-axis-fixed`. A windowed scroll moves on `"y"` only: `"x"` with `rows` throws.
+ *
+ * @example
+ * ```tsx
+ * // The order strip of the board moves sideways; the cards in it lay out in a row.
+ * <scroll key="strip" axis="x" style={{ width: 306, height: 120 }}>
+ *   <row key="track" style={{ width: 696, height: 120 }} />
+ * </scroll>;
+ * // ScrollState of the strip: { offset: 0, max: 390, moving: false }
+ * ```
+ */
 type ScrollAxis = ("x" | "y") & Brand<"ScrollAxis">;
+/**
+ * The stops a scroll comes to rest on, as offsets from the start, kept inside 0 to `max`. A
+ * release glides to the stop nearest to where its velocity carries in 260 ms, on the curve
+ * `1 − (1 − p)³`, in `min(620, 260 + distance × 1.1)` ms; without `snap` it flings.
+ *
+ * @example
+ * ```tsx
+ * // Three stops: the events, the orders, the end. A slow release at offset 300 glides to 318.
+ * <scroll key="strip" axis="x" snap={[0, 318, 390]} style={{ width: 306, height: 120 }}>
+ *   <row key="track" style={{ width: 696, height: 120 }} />
+ * </scroll>;
+ * ```
+ */
+type ScrollSnap = readonly number[] & Brand<"ScrollSnap">;
+/**
+ * How far a scroll stands from its start, in reference units, kept inside 0 to `max`; 0 when
+ * left out. The first frame draws it there. A later render with another value glides there on
+ * the curve and in the time of `snap`; the same value changes nothing, so a scroll the finger
+ * moved stays where it was left.
+ *
+ * @example
+ * ```tsx
+ * // The strip opens on the orders; closing the pinned column moves the game to 306.
+ * <scroll key="strip" axis="x" offset={318} snap={[0, 318, 390]} style={{ width: 306, height: 120 }}>
+ *   <row key="track" style={{ width: 696, height: 120 }} />
+ * </scroll>;
+ * // first drawn frame: the content stands 318 u left of its rest, the orders in view
+ * ```
+ */
+type ScrollOffset = number & Brand<"ScrollOffset">;
 /** How many rows a windowed scroll has. */
 type ScrollRows = number & Brand<"ScrollRows">;
 /** The height of every row, in reference units; above 0. */
@@ -2041,11 +2099,14 @@ type ScrollWindowForm = {
 };
 /**
  * What a scroll container takes: children for a short list, or `rows`, `rowHeight` and `row` for
- * a long one, whose rows exist only in the window.
+ * a long one, whose rows exist only in the window; the `axis` it moves on, the `snap` stops a
+ * release glides to, and the `offset` it stands at.
  *
  * @example
  * ```ts
  * const props: ScrollProps = { axis: "y" };
+ * // The order strip: sideways, three stops, opened on the orders.
+ * const strip: ScrollProps = { axis: "x", snap: [0, 318, 390], offset: 318 };
  * // 1000 orders of 120 u in a 1600 u list: rows 0 to 18 exist at offset 0.
  * const orders: ScrollProps = {
  *   style: { height: 1600 },
@@ -2057,6 +2118,8 @@ type ScrollWindowForm = {
  */
 type ScrollProps = CommonProps & {
   axis?: ScrollAxis;
+  snap?: ScrollSnap;
+  offset?: ScrollOffset;
 } & (ScrollChildForm | ScrollWindowForm);
 /**
  * What a text field takes. `local` is required: every keystroke writes that field of the local
@@ -2200,6 +2263,31 @@ declare const Box: ComponentType<{
  * and `ui` merges the patch into the nearest component instance.
  */
 declare const LocalWrite: ComponentType<LocalWriteValue>;
+/**
+ * On every scroll container: where it stands and whether it moves, for a game system and the
+ * read door. `ui` writes it in a frame where the offset or `max` changed, and once more with
+ * `moving: false` when it stops; a game reads it and never writes it.
+ *
+ * @example
+ * ```ts
+ * // A board system dims the events of the order strip while it rests on the orders.
+ * export const stripMist = system({
+ *   name: "board.stripMist",
+ *   phase: "animate",
+ *   query: [ScrollState, OrderStrip],
+ *   run: entities => {
+ *     for (const [entity, scroll] of entities) {
+ *       // scroll: { offset: 318, max: 390, moving: false }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare const ScrollState: ComponentType<{
+  offset: number;
+  max: number;
+  moving: boolean;
+}>;
 /**
  * On the view a player taps five times within three seconds to open the editor's overlay on a debug build: the
  * version line of the settings, usually. One helper on top of `app.debug.overlay.open()`; a game that wants another
@@ -2396,6 +2484,35 @@ type ScrollWindow = {
   first: number;
   last: number;
 };
+/**
+ * How a scroll container moves, kept on its element: the axis it spawned with, what moves it now
+ * (the finger `"held"`, a `"fling"` after a release, a `"glide"` to a stop or to a new `offset`
+ * prop, or nothing, `"still"`), and the numbers of that motion in offsets from the start, 0 to
+ * `max`. `offset` is exact: the components get it in whole units. `velocity` is in units a ms,
+ * positive toward `max`. A glide runs from `from` to `to` over `duration` ms, `elapsed` of them
+ * gone. `pointer` and `start` are the finger on the axis and the offset where the press began.
+ * `seen` is the `offset` prop of the last render, 0 when it is left out; `placed` turns true when
+ * the first solve put the scroll at it. `atProp` is true while the scroll follows that prop: it
+ * stands at it or glides to it, so a new range puts it at the prop again. The first place and a
+ * glide to a new prop set it; a press and `app.ui.scroll` clear it, and a fling or a snap glide
+ * only comes after a press. Plain numbers written in place: a frame allocates nothing.
+ */
+type ScrollMotion = {
+  axis: "x" | "y";
+  mode: "still" | "held" | "fling" | "glide";
+  offset: number;
+  max: number;
+  velocity: number;
+  from: number;
+  to: number;
+  duration: number;
+  elapsed: number;
+  pointer: number;
+  start: number;
+  seen: number;
+  placed: boolean;
+  atProp: boolean;
+};
 /**
  * What the style of an element was resolved on besides its own node: the epoch of the jsx state,
  * and the row height when the element is a row of a windowed scroll. While both stand, and the
@@ -2415,7 +2532,7 @@ type StyleBasis = {
  * `change` hook of each of them returned; `warnedOwned` the names of the `components` values the
  * element owns that were already logged. A windowed scroll carries its `window` and the one-time
  * warnings of its props in `warned`; `scrolledIn` marks an element a range change of a windowed
- * scroll created: it plays no `enter` hook. A text or an icon that sizes itself keeps in
+ * 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
  * once the style is on the layout node and the components are written; an element without one is
@@ -2469,6 +2586,7 @@ type Element = {
   warned: Set<string>;
   scrolledIn: boolean;
   window?: ScrollWindow;
+  scroll?: ScrollMotion;
   measuredSize?: {
     width: number;
     height: number;
@@ -2794,4 +2912,4 @@ type CommonProps = {
   components?: ElementComponents;
 };
 //#endregion
-export { Config$1 as A, State$2 as B, TextBind as C, TextValue as D, TextStyles as E, Config$2 as F, IsFlags as G, TextKey as H, I18nApi as I, StylesState as J, ResolvedStyle as K, IntlKit as L, State$1 as M, types_d_exports$1 as N, types_d_exports as O, Argument as P, Message as R, TextApi as S, TextStyleInput as T, TypedTr as U, StringTable as V, types_d_exports$2 as W, WhenFlags as Y, BindOptions as _, JsxChild as a, Point as b, UiNode as c, LocalWrite as d, popup as f, BindField as g, UiIntrinsicElements as h, Finding as i, InputApi as j, defineComponent as k, Box as l, IntrinsicElementsFor as m, ElementChange as n, JsxState as o, defineTokens as p, Style as q, ElementMotion as r, PopupComponent as s, DescriptionNode as t, DebugTrigger as u, Config as v, TextFormat as w, State as x, CountdownValue as y, Part as z };
+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 };

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

@@ -1,5 +1,5 @@
-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 { $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-i77Nrrv-.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-D8roM1u3.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -2809,8 +2809,36 @@ type MusicRequest = {
 };
 //#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;
@@ -2819,10 +2847,12 @@ type LayoutState = {
   measured: number;
   solves: number;
   scrolling: Entity | undefined;
-  scrollStart: {
-    pointerY: number;
-    offset: number;
-  }; /** One line of the `body` style as the icons were last measured with it; none before that. */
+  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>;
@@ -2960,7 +2990,7 @@ type UiCtx = KernelSlice & {
 /**
  * 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.
+ * text field, the fifth scrolls a `scroll`.
  *
  * @example
  * ```ts
@@ -3043,6 +3073,28 @@ type UiApi = {
    * ```
    */
   fill(key: string, value: string): boolean;
+  /**
+   * Scrolls a `scroll` element to an offset from its start, at once: the offset is kept inside 0
+   * to `max`, a fling or a glide stops, and `ScrollState` reads the new offset with
+   * `moving: false`. A finger that holds the scroll goes on from there. Works headless, for a
+   * test, an agent or a visual test (the `game.scroll` command, the step `{ scroll: { key, to } }`).
+   *
+   * @param key - The `key` prop of the `scroll` element.
+   * @param to - How far from the start, in reference units. `NaN` leaves the scroll where it is.
+   * @returns True when a live scroll took it. False in two cases, each with one warning `{ key }`:
+   *   `ui:scroll-without-scroll` when no live `scroll` has the key, and `ui:scroll-before-solve`
+   *   when the `scroll` came in this frame and its first solve has not placed it yet: call it
+   *   again after the frame.
+   * @example
+   * ```ts
+   * // A test shows the order strip on its events: the strip is 306 u over a 696 u track.
+   * app.ui.scroll("strip", 0); // true
+   * app.world.ecs.get(app.ui.find("strip") ?? 0, ScrollState); // { offset: 0, max: 390, moving: false }
+   * app.ui.scroll("strip", 999); // true: it stands on the end, offset 390
+   * app.ui.scroll("nothing", 0); // false, with the warning "ui:scroll-without-scroll"
+   * ```
+   */
+  scroll(key: string, to: number): boolean;
 };
 //#endregion
 export { sequence as $, GlowValue as A, Target as B, BlurValue as C, FilterComponent as D, FilterArea as E, AnimPlayerValue as F, HAPTIC_KINDS as G, HapticKind as H, Config$3 as I, frames as J, defineAnimation as K, FramesValue as L, OutlineValue as M, UniformDeclaration as N, FilterSpec as O, AnimApi as P, play as Q, MotionKeyframe as R, AlphaValue as S, DisplacementValue as T, SfxDescriptor as U, types_d_exports$3 as V, Step as W, mark as X, haptic as Y, parallel as Z, State$2 as _, AudioApi as a, tween as at, EmitterDefinition as b, MusicDescriptor as c, OverlayApi as ct, State$1 as d, set as et, VolumesFor as f, EffectsStats as g, EffectsApi as h, types_d_exports as i, stagger as it, NoiseValue as j, FilterValueOf as k, MusicOptions as l, types_d_exports$4 as lt, Config$2 as m, State as n, spawn as nt, AudioContextLike as o, use as ot, types_d_exports$1 as p, external as q, UiApi as r, spawned as rt, Config$1 as s, wait as st, Config as t, sfx as tt, SoundEntry as u, types_d_exports$2 as v, ColorMatrixValue as w, EmitterValue as x, EmitterConfig as y, State$3 as z };

package/dist/{types-MocH_igX.d.mts → types-DK-IYk-s.d.mts}

@@ -1,7 +1,7 @@
-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 { 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-i77Nrrv-.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-DDmfkONF.mjs";
+import { H as StringTable, L as I18nApi, U as TextKey } from "./types-D8roM1u3.mjs";
+import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-DT9aYVGd.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

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

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

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

@@ -6626,14 +6626,20 @@ type DisplayValue = {
   object: unknown;
 };
 /**
- * A filled rounded rectangle or a triangle, anchored at the top left of the `Transform`. `kind`
- * picks the outline: `"rect"` (the default) or `"triangle"`, which fills its `w × h` box pointing
- * right (rotate the element for another direction) and ignores `radius`. `fillAlpha` is the alpha
- * of the fill alone: 0 draws only the stroke, a ring. `alpha` fades the whole shape and the
- * entity's children: a disabled button at 0.6 draws its icon at 0.6 too. `dash` is the
- * dash length of the stroke in reference units, with gaps of half a dash; 0 strokes a solid line.
- * `clip` masks the children of the entity to the shape, always solid, which is how `ui` draws a
- * scroll and an overflow. The shape itself is never masked, so its stroke is drawn whole.
+ * A filled rounded rectangle, a triangle or an arc, anchored at the top left of the `Transform`. `kind` picks the
+ * outline: `"rect"` (the default), `"triangle"`, which fills its `w × h` box pointing right (rotate the element for
+ * another direction) and ignores `radius`, or `"arc"`. `fillAlpha` is the alpha of the fill alone: 0 draws only the
+ * stroke, a ring. `alpha` fades the whole shape and the entity's children: a disabled button at 0.6 draws its icon at
+ * 0.6 too. `dash` is the dash length of the stroke in reference units, with gaps of half a dash; 0 strokes a solid
+ * line. `clip` masks the children of the entity to the shape, always solid, which is how `ui` draws a scroll and an
+ * overflow. The shape itself is never masked, so its stroke is drawn whole. An arc is a stroke on the circle inscribed
+ * in the box: its diameter is `min(w, h) − strokeWidth`, centred, so the stroke stays inside the box. It starts at 12
+ * o'clock and runs clockwise over `sweep` of the circle (0 to 1, clamped): 0 draws nothing, 1 a closed ring. `cap` ends
+ * an open arc round or flat (`"butt"`). Both are optional: left out, `sweep` is 1 and `cap` is `"round"`
+ * (`arcDefaults`). Only an arc reads them; a rectangle or a triangle ignores them. An arc draws only its stroke, in
+ * `stroke`, `strokeWidth` and `alpha`: `fill`, `fillAlpha`, `radius` and `dash` are ignored, and `clip` masks the
+ * children to its box. The path is built again only when a field it is drawn from changes: a still arc costs nothing a
+ * frame, a new `fill` builds no arc again.
  *
  * @example
  * ```ts
@@ -6649,10 +6655,12 @@ type DisplayValue = {
  * // The play glyph of a watch button, and a dashed focus ring: 10 u dashes, 5 u gaps.
  * const play: ShapeValue = { ...ring, kind: "triangle", w: 36, h: 40, fillAlpha: 1, strokeWidth: 0 };
  * const focus: ShapeValue = { ...ring, w: 200, h: 80, stroke: 0x3a2212, strokeWidth: 4, dash: 10 };
+ * // The time left on a slot's timer: 42 % of a ring 25.8 u across in a 28 u box, from 12 o'clock clockwise, round ends.
+ * const timer: ShapeValue = { ...ring, kind: "arc", w: 28, h: 28, stroke: 0xc8a15a, strokeWidth: 2.2, sweep: 0.42 };
  * ```
  */
 type ShapeValue = {
-  kind: "rect" | "triangle";
+  kind: "rect" | "triangle" | "arc";
   w: number;
   h: number;
   fill: number;
@@ -6662,7 +6670,9 @@ type ShapeValue = {
   stroke: number;
   strokeWidth: number;
   dash: number;
-  clip: boolean;
+  clip: boolean; /** The share of the circle an arc sweeps, 0 to 1, from 12 o'clock clockwise; clamped. Only an arc reads it: 1 left out. */
+  sweep?: number; /** How an open arc ends: `"round"` or `"butt"` (flat at its end). Only an arc reads it: `"round"` left out. */
+  cap?: "round" | "butt";
 };
 /**
  * What `sprite()` takes: the two things every visual needs, and the four that have defaults.
@@ -6762,9 +6772,10 @@ declare const Parent: ComponentType<{
  */
 declare const Display: ComponentType<DisplayValue>;
 /**
- * A filled rounded rectangle or a right-pointing triangle, drawn with Pixi `Graphics` and redrawn
- * only when a field changed. `fillAlpha: 0` draws only the stroke, `dash` above 0 dashes it.
- * `clip: true` masks the children of the entity to the shape.
+ * A filled rounded rectangle, a right-pointing triangle or an arc (`kind: "arc"`, a stroke from 12 o'clock clockwise
+ * over `sweep` of the circle in its box), drawn with Pixi `Graphics` and redrawn only when a field changed.
+ * `fillAlpha: 0` draws only the stroke, `dash` above 0 dashes it. `clip: true` masks the children of the entity to the
+ * shape.
  */
 declare const Shape: ComponentType<ShapeValue>;
 /**
@@ -7241,7 +7252,7 @@ type HitBox = {
  */
 type DrawnShape = {
   /** Drawn white, coloured by the object's tint (no stroke); false for a shape painted in its own colours. */tinted: boolean;
-  kind: "rect" | "triangle";
+  kind: ShapeValue["kind"];
   w: number;
   h: number;
   fill: number;
@@ -7249,14 +7260,16 @@ type DrawnShape = {
   radius: number;
   stroke: number;
   strokeWidth: number;
-  dash: number;
+  dash: number; /** An arc's `sweep` as the value held it, `undefined` when left out. */
+  sweep: number | undefined; /** An arc's `cap` as the value held it, `undefined` when left out. */
+  cap: ShapeValue["cap"];
 };
 /**
  * The fields of the clip rectangle last drawn into a view's mask: an equal value draws no mask again. Private to
  * `sync`.
  */
 type ClipDrawn = {
-  kind: "rect" | "triangle";
+  kind: ShapeValue["kind"];
   w: number;
   h: number;
   radius: number;

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

@@ -1,9 +1,9 @@
-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";
+import { E as Api, Lr as Api$3, Qt as Api$1, br as Api$2 } from "./types-i77Nrrv-.mjs";
+import { P as AnimApi, r as UiApi } from "./types-DDmfkONF.mjs";
+import { M as InputApi } from "./types-D8roM1u3.mjs";
+import { r as Repro } from "./headless-CrxofjLt.mjs";
+import { a as InputOf, r as ControlApp } from "./types-YXykgTOp.mjs";
+import { t as commands } from "./commands-5woFUxUr.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */

package/dist/{visual-2m4wJL_z.mjs → visual-CIUx49C0.mjs}

@@ -195,6 +195,18 @@ const Now = /*#__PURE__*/ resource("Now", { now: 0 });
 * part), the engine's own overlay level, and the `sprite()` bundle helper. Pure: no ctx, no state, no Pixi. Made with the `component()` helper of `world`, so nothing has
 * to be registered.
 */
+/**
+* What an arc draws with when its `Shape` leaves `sweep` or `cap` out: the whole ring, round ends.
+*
+* @example
+* ```ts
+* arcDefaults.sweep; // 1
+* ```
+*/
+const arcDefaults = Object.freeze({
+	sweep: 1,
+	cap: "round"
+});
 const overlayDefaults = {
 	dim: 0,
 	dimColor: 0,
@@ -270,9 +282,10 @@ const Parent = /*#__PURE__*/ component("Parent", { entity: 0 });
 */
 const Display = /*#__PURE__*/ component("Display", displayDefaults);
 /**
-* A filled rounded rectangle or a right-pointing triangle, drawn with Pixi `Graphics` and redrawn
-* only when a field changed. `fillAlpha: 0` draws only the stroke, `dash` above 0 dashes it.
-* `clip: true` masks the children of the entity to the shape.
+* A filled rounded rectangle, a right-pointing triangle or an arc (`kind: "arc"`, a stroke from 12 o'clock clockwise
+* over `sweep` of the circle in its box), drawn with Pixi `Graphics` and redrawn only when a field changed.
+* `fillAlpha: 0` draws only the stroke, `dash` above 0 dashes it. `clip: true` masks the children of the entity to the
+* shape.
 */
 const Shape = /*#__PURE__*/ component("Shape", shapeDefaults);
 /**
@@ -724,7 +737,8 @@ function contentOf(props) {
 /**
 * 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`. A clipping element (`scroll`,
+* 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
 * no fill draws only the stroke, a ring. A container with no fill and no stroke gets a rectangle that draws
@@ -775,7 +789,7 @@ function visualOf(element) {
 	})];
 	const filled = style.fill !== void 0 || style.stroke !== void 0;
 	const invisible = isContainer(type) && !filled;
-	return [Shape({
+	const shape = {
 		kind: style.shape ?? "rect",
 		w: rect.w,
 		h: rect.h,
@@ -787,6 +801,12 @@ function visualOf(element) {
 		strokeWidth: invisible ? 0 : style.strokeWidth ?? 0,
 		dash: style.dash ?? 0,
 		clip: clip || type === "input"
+	};
+	if (shape.kind !== "arc") return [Shape(shape)];
+	return [Shape({
+		...shape,
+		sweep: style.sweep ?? arcDefaults.sweep,
+		cap: style.cap ?? arcDefaults.cap
 	})];
 }
 /**
@@ -895,4 +915,4 @@ function drawnRect(pose, local) {
 	};
 }
 //#endregion
-export { Order as A, Sprite as C, Exiting as D, sprite as E, system as F, systemsFor as I, tag as L, component as M, mut as N, Layer as O, resource as P, Shape as S, componentsFor as T, HudPart as _, scaleByFits as a, OverlayLevel as b, Countdown as c, builtInStyles as d, defineTextStyles as f, Display as g, textFor as h, samePose as i, Tree as j, Now as k, Text as l, readStyle as m, drawnRect as n, visualOf as o, label as p, fitScaleOf as r, visualRectOf as s, CONTENT as t, bind as u, NineSlice as v, Transform as w, Parent as x, Overlay as y };
+export { Now as A, Sprite as C, sprite as D, componentsFor as E, resource as F, system as I, systemsFor as L, Tree as M, component as N, Exiting as O, mut as P, tag as R, Shape as S, arcDefaults as T, HudPart as _, scaleByFits as a, OverlayLevel as b, Countdown as c, builtInStyles as d, defineTextStyles as f, Display as g, textFor as h, samePose as i, Order as j, Layer as k, Text as l, readStyle as m, drawnRect as n, visualOf as o, label as p, fitScaleOf as r, visualRectOf as s, CONTENT as t, bind as u, NineSlice as v, Transform as w, Parent as x, Overlay as y };

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-BV2A3kpr.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-1doiBOD3.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-DlxDjgOO.mjs";
+import { n as read, t as sources } from "./sources-QCowxSpC.mjs";
+import { n as commands, t as run } from "./run-BqYmcNo7.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";
 import { mkdir, readFile, writeFile } from "node:fs/promises";