@moku-labs/game 0.15.36 → 0.15.38

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { $n as FeaturePlugin, Dr as Json, dr as Descriptor, gr as NodeFx, hr as Hint, sr as NodeTable, tr as AnyFlow, xr as FakeClock, yr as ClockSource } from "./types-K3qfyTu0.mjs";
-import { t as createApp } from "./index-Cs4qaPMq.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-Dh2cyp0H.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-BFI7EXHo.mjs";
+import { $n as FeaturePlugin, Dr as Json, dr as Descriptor, gr as NodeFx, hr as Hint, sr as NodeTable, tr as AnyFlow, xr as FakeClock, yr as ClockSource } from "./types-C_dk-lXz.mjs";
+import { t as createApp } from "./index-DFAjLwxi.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-H1FiWmKa.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-CRqMxzqv.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { en as refuseStart, in as type, m as flattenFeatures, t as createApp, tn as exit } from "./src-BPEIEsWH.mjs";
+import { en as refuseStart, in as type, m as flattenFeatures, t as createApp, tn as exit } from "./src-B2vblgmb.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { n as fakeClock } from "./fake-hnJcJeYf.mjs";
 import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-Bxxl_mQX.mjs";

package/dist/{types-BAv5qOZX.d.mts → types-0Br0SjTB.d.mts}

@@ -1,4 +1,4 @@
-import { An as NumericFields, Cn as TagType, Dn as Motion, Dr as Json, En as Ease, In as ViewHandle, K as TransformValue, Ln as Api$1, Nn as ReducedMotion, On as MotionCause, Y as Api$3, _r as Answer, cn as AnyComponentType, dr as Descriptor, dt as ViewportSize, fn as ComponentType, hr as Hint, jn as ProjectionMotion, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, nn as Api$2, qr as Api, ri as Require, s as Events$1, sn as AnyComponent, t as Api$4, vr as Api$5, wn as ChangeHook } from "./types-K3qfyTu0.mjs";
+import { An as NumericFields, Cn as TagType, Dn as Motion, Dr as Json, En as Ease, In as ViewHandle, K as TransformValue, Ln as Api$1, Nn as ReducedMotion, On as MotionCause, Y as Api$3, _r as Answer, cn as AnyComponentType, dr as Descriptor, dt as ViewportSize, fn as ComponentType, hr as Hint, jn as ProjectionMotion, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, nn as Api$2, qr as Api, ri as Require, s as Events$1, sn as AnyComponent, t as Api$4, vr as Api$5, wn as ChangeHook } from "./types-C_dk-lXz.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -2779,6 +2779,25 @@ type PopupLink = {
   released?: boolean;
   over?: Entity;
 };
+/**
+ * One part of a root built aside that waits for a later frame (spec 33 A2): an element that exists
+ * and whose children were not diffed yet, the nodes it would have diffed, the nearest component
+ * instance and the cause its children enter with. Back in the pool it holds no element.
+ */
+type Parked = {
+  element: Element | undefined;
+  nodes: readonly DescriptionNode[];
+  instance: string | undefined;
+  cause: MotionCause | undefined;
+};
+/**
+ * The application of a solved root built aside, in parts (spec 33 A6): the elements still to
+ * apply, the next one on top, and whether a live one takes its rect with no motion.
+ */
+type ApplyCursor = {
+  stack: Element[];
+  quiet: boolean;
+};
 /**
  * One reconciled tree: a projection view or a popup, with the flags the frame step reads.
  * `covered` is true while the root is kept under another popup; every element of the root then
@@ -2787,7 +2806,8 @@ type PopupLink = {
  * restore or a load. `slot` is the host element the root is laid out in (`undefined` for the
  * viewport), `slotRect` the content box it was last solved in, in the host's own units.
  * `pending` is true while the solve running now still waits to lay the root out; `mountRoot`
- * creates it `false`.
+ * creates it `false`. A root built aside carries its parked parts in `parked` and its
+ * application in parts in `applying` (spec 33 slice A).
  */
 type Root = {
   entity: Entity;
@@ -2815,6 +2835,12 @@ type Root = {
    * other root.
    */
   aside?: true;
+  /**
+   * The parts of a root built aside whose children wait for a later frame, in the order they were
+   * parked. Made with its first part and kept, empty, after its last: a later part reuses it.
+   */
+  parked?: Parked[]; /** The application of a root built aside in parts, while it is open; absent otherwise. */
+  applying?: ApplyCursor;
 };
 /**
  * Where the focus ring was last drawn: the layer and order of its root, the rect grown by the

package/dist/{types-B1W2CPUu.d.mts → types-54KzmAA6.d.mts}

@@ -1,5 +1,5 @@
-import { $ as PixiModule, A as SyncApi, An as NumericFields, Dr as Json, En as Ease, Er as Events$3, Fn as TrackSegment, Ln as Api$2, Nn as ReducedMotion, O as FilterSlot, Pn as TrackOptions, Q as PixiFilter, Ur as Events$5, Y as Api$4, b as Events$4, dr as Descriptor, et as PixiSprite, fn as ComponentType, ft as FilterCache, k as FilterSlotInputs, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, ni as Events$2, nn as Api$3, qr as Api$1, ri as Require, s as Events$1, sn as AnyComponent, t as Api$5, tt as PixiTexture, un as ComponentHandle, ur as TypeTag, ut as Point, wr as Api$6 } from "./types-K3qfyTu0.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-BAv5qOZX.mjs";
+import { $ as PixiModule, A as SyncApi, An as NumericFields, Dr as Json, En as Ease, Er as Events$3, Fn as TrackSegment, Ln as Api$2, Nn as ReducedMotion, O as FilterSlot, Pn as TrackOptions, Q as PixiFilter, Ur as Events$5, Y as Api$4, b as Events$4, dr as Descriptor, et as PixiSprite, fn as ComponentType, ft as FilterCache, k as FilterSlotInputs, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, ni as Events$2, nn as Api$3, qr as Api$1, ri as Require, s as Events$1, sn as AnyComponent, t as Api$5, tt as PixiTexture, un as ComponentHandle, ur as TypeTag, ut as Point, wr as Api$6 } from "./types-C_dk-lXz.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-0Br0SjTB.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/dist/{types-D52biu5v.d.mts → types-CGPWYbZO.d.mts}

@@ -1,5 +1,5 @@
-import { Dr as Json, Ir as Snapshot } from "./types-K3qfyTu0.mjs";
-import { t as HeadlessApp } from "./headless-BFI7EXHo.mjs";
+import { Dr as Json, Ir as Snapshot } from "./types-C_dk-lXz.mjs";
+import { t as HeadlessApp } from "./headless-CRqMxzqv.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{types-K3qfyTu0.d.mts → types-C_dk-lXz.d.mts}

@@ -4273,9 +4273,35 @@ type AnyProjectionMotion = {
   readonly change?: ChangeHooks<never>;
   settle?(view: ViewHandle<unknown>, components: readonly string[]): Motion;
 };
+/**
+ * One pair of `ProjectionSpec.initialOnly`: a component and the fields of it that `view` gives a
+ * view once, when it is born. The field names are checked against the component's own value.
+ *
+ * @example
+ * ```ts
+ * const arc: InitialOnlyPair<ShapeValue> = [Shape, ["sweep"]];
+ * ```
+ */
+type InitialOnlyPair<Value extends object> = readonly [ComponentHandle<Value>, readonly (keyof Value & string)[]];
+/**
+ * The `initialOnly` list of a projection: one pair for each value type of `Values`, each pair
+ * checked against its own component. `projection()` infers `Values` from the list, so
+ * `[[Shape, ["swep"]]]` is a type error.
+ *
+ * @example
+ * ```ts
+ * const fields: InitialOnly<[ShapeValue, TransformValue]> = [
+ *   [Shape, ["sweep", "alpha"]],
+ *   [Transform, ["rotation"]]
+ * ];
+ * ```
+ */
+type InitialOnly<Values extends readonly object[]> = { readonly [Index in keyof Values]: InitialOnlyPair<Values[Index]> };
 /**
  * One projection: keyed items of the model turned into entities. `Item` is inferred from the
  * return of `from`; `layer` and `lift` keep their literal types so a scene can check them.
+ * `Values` are the value types of the `initialOnly` pairs, inferred by `projection()`; an
+ * annotation that leaves it out accepts any field name.
  *
  * @example
  * ```ts
@@ -4289,7 +4315,7 @@ type AnyProjectionMotion = {
  * };
  * ```
  */
-type ProjectionSpec<Item, LayerName extends string, LiftName extends string, Player, Session> = {
+type ProjectionSpec<Item, LayerName extends string, LiftName extends string, Player, Session, Values extends readonly object[] = readonly Record<string, unknown>[]> = {
   readonly name: string;
   readonly layer: LayerName;
   readonly lift?: LiftName;
@@ -4297,6 +4323,35 @@ type ProjectionSpec<Item, LayerName extends string, LiftName extends string, Pla
   key?(item: Item): string;
   view(item: Item): ViewOutput;
   readonly motion?: ProjectionMotion<Item>;
+  /**
+   * Fields another writer owns once a view is born. `view` gives them their first value when the
+   * view spawns; from then on nothing of the projection writes or compares them: not a changed
+   * item, not a motion or its finish, not the check at the end of a motion (no
+   * `world:view-corrected`), not a rollback, `settle(entity)`, a restore or a load. These are the
+   * rules of `mute()`, for every view of the projection and for its whole life. A `mute()` on the
+   * view adds to them, and its release keeps them. Left out, the projection writes every field.
+   *
+   * @example
+   * ```ts
+   * // The timer ring of a chest: born full, then the system `board.rings` draws its arc from `Now`.
+   * export const marks = projection({
+   *   name: "board.marks",
+   *   layer: "marks",
+   *   from: (player: Player) => player.board.timers,
+   *   key: timer => timer.id,
+   *   view: timer => [Shape({ kind: "arc", w: 28, h: 28, strokeWidth: 2.2, sweep: 1 })],
+   *   motion: {
+   *     enter: view => {
+   *       view.set(Shape, { alpha: 0 });
+   *       return view.toRest(Shape, { ms: 200 });
+   *     }
+   *   },
+   *   initialOnly: [[Shape, ["sweep"]]]
+   * });
+   * // The fade ends with the 0.42 the system wrote: no full ring, no `world:view-corrected`.
+   * ```
+   */
+  readonly initialOnly?: InitialOnly<Values>;
 };
 /**
  * A projection spec with its item and layer types erased, as the world stores it.
@@ -4319,7 +4374,8 @@ type AnyProjectionSpec = {
   from(player: Json, session: Json): unknown;
   key?(item: unknown): string;
   view(item: unknown): ViewOutput;
-  readonly motion?: AnyProjectionMotion;
+  readonly motion?: AnyProjectionMotion; /** The `initialOnly` pairs, their field names no longer tied to the component. */
+  readonly initialOnly?: readonly (readonly [ComponentHandle<object>, readonly string[]])[];
 };
 /**
  * Why a reconcile runs. Merged over the frame; the cause table decides play or direct. A
@@ -4442,6 +4498,12 @@ type Dirty = {
   roots: Set<Root>;
   force: boolean;
 };
+/**
+ * Component name to the fields another writer owns, of one entity. A frozen table, and a frozen
+ * set in one, is the `initialOnly` seed every view of one projection shares: nothing writes into
+ * it, and `mute()` copies it before it adds a field.
+ */
+type MuteTable = ReadonlyMap<string, ReadonlySet<string>>;
 /**
  * A mute's fields joined with a type's owned fields, and the owned set they were joined with.
  */
@@ -4471,8 +4533,14 @@ type ProjectionState = {
    * The reverse of `keys`, so `keyOf` answers for a registered element too. The entry of an
    * entity that is gone is dropped with its rest pose, and its side of `keys` with it.
    */
-  keysByEntity: Map<Entity, ProjectionKey>; /** Entity to component name to the fields another writer owns. */
-  mutes: Map<Entity, Map<string, Set<string>>>; /** The owned fields of each component type as a set, by the type's frozen `owned` list: made once. */
+  keysByEntity: Map<Entity, ProjectionKey>;
+  /**
+   * Entity to component name to the fields another writer owns: what `mute()` handed over, and
+   * the shared `initialOnly` seed a view of such a projection is born with. A view a listener of
+   * its spawn muted keeps that table, and the seed joins it.
+   */
+  mutes: Map<Entity, MuteTable>; /** The `initialOnly` seed of each registered spec that has one, frozen, built at `register` and `replace`. */
+  initialOnly: WeakMap<AnyProjectionSpec, MuteTable>; /** The owned fields of each component type as a set, by the type's frozen `owned` list: made once. */
   ownedSets: WeakMap<readonly string[], ReadonlySet<string>>; /** The muted and the owned fields joined, by the mute's field set: dropped when `mute()` or its release changes it. */
   joinedMutes: WeakMap<ReadonlySet<string>, JoinedFields>; /** The `onConverged` listeners: the owners of elements, told after a restore or a load. */
   converged: Array<() => void>;
@@ -4646,7 +4714,9 @@ type ProjectionApi = {
    */
   settle(entity: Entity): void;
   /**
-   * Hands a set of fields to another writer. Tracks never write them, also not on `finish()`.
+   * Hands a set of fields to another writer. Tracks never write them, also not on `finish()`. On
+   * a view whose projection names `initialOnly` fields the mute adds to them, and the remover keeps
+   * them.
    *
    * @param entity - The entity of the view.
    * @param component - The component whose fields are taken over.
@@ -6421,7 +6491,7 @@ type SystemTiming = {
   ms: Float64Array;
 };
 declare namespace types_d_exports$3 {
-  export { AnyComponentType, AnyComponentValue, AnyProjectionSpec, AnySystem, Api$2 as Api, Cause, ChangeHook, ComponentHandle, ComponentSchema, ComponentType, ComponentValue, Config$3 as Config, Deps$3 as Deps, DescriptionNode, Ease, EcsApi, EcsModule, Entity, EntityDiff, EntitySnapshot, Events$3 as Events, Explained, FrameDiff, GameSystemDefinition, KernelSlice$3 as KernelSlice, LayerSort, LayerSpec, ModelCommitted, Motion, MotionCause, MotionHandle, Mut, Narrowed, NumericFields, Owner, ProjectionApi, ProjectionKey, ProjectionModule, ProjectionMotion, ProjectionSpec, QueryTerm, QueryTuple, ReducedMotion, ResourceType, RestOptions, State$3 as State, SystemContext, SystemContextOf, SystemDefinition, SystemFor, SystemTiming, TagType, TrackOptions, TrackSegment, TweenDriver, TweenOptions, ViewHandle, ViewOutput, WorldCtx, WorldMode, WorldPhase, WorldSnapshot };
+  export { AnyComponentType, AnyComponentValue, AnyProjectionSpec, AnySystem, Api$2 as Api, Cause, ChangeHook, ComponentHandle, ComponentSchema, ComponentType, ComponentValue, Config$3 as Config, Deps$3 as Deps, DescriptionNode, Ease, EcsApi, EcsModule, Entity, EntityDiff, EntitySnapshot, Events$3 as Events, Explained, FrameDiff, GameSystemDefinition, InitialOnly, InitialOnlyPair, KernelSlice$3 as KernelSlice, LayerSort, LayerSpec, ModelCommitted, Motion, MotionCause, MotionHandle, Mut, Narrowed, NumericFields, Owner, ProjectionApi, ProjectionKey, ProjectionModule, ProjectionMotion, ProjectionSpec, QueryTerm, QueryTuple, ReducedMotion, ResourceType, RestOptions, State$3 as State, SystemContext, SystemContextOf, SystemDefinition, SystemFor, SystemTiming, TagType, TrackOptions, TrackSegment, TweenDriver, TweenOptions, ViewHandle, ViewOutput, WorldCtx, WorldMode, WorldPhase, WorldSnapshot };
 }
 /**
  * world plugin events.
@@ -11725,7 +11795,7 @@ type SceneOwner = Owner & {
  *
  * @example
  * ```ts
- * // The default: half of each frame, read at the start of every build: 8.33… ms at 60 Hz, 4.17 ms at 120 Hz.
+ * // The default: two thirds of each frame, read at the start of every build: 11.1 ms at 60 Hz, 5.56 ms at 120 Hz.
  * const config: Config = { buildMs: "auto" };
  *
  * // A game on a slow phone gives the next scene a fixed 3 ms of each frame: the switch takes more frames.
@@ -11735,8 +11805,8 @@ type SceneOwner = Owner & {
 type Config$1 = {
   /**
    * Milliseconds per frame the next scene's building work may take on a live switch with a
-   * drawing renderer: a finite number above 0, or `"auto"` (the default) for half of the frame
-   * interval the loop runs at, `500 / time.rate().fps`, read once at the build start.
+   * drawing renderer: a finite number above 0, or `"auto"` (the default) for two thirds of the
+   * frame interval the loop runs at, `(1000 / time.rate().fps) * 2 / 3`, read once at the build start.
    */
   buildMs: number | "auto";
 };

package/dist/{types-Dh2cyp0H.d.mts → types-H1FiWmKa.d.mts}

@@ -1,7 +1,7 @@
-import { $ as PixiModule, $n as FeaturePlugin, Dr as Json, Lr as SnapshotOf, Mr as PlayerStateProvider, Nr as ProviderCall, Pr as SaveDoc, Tr as Config, X as Config$2, a as Config$3, d as Manifest, lt as Orientation, n as AssetsIo, tr as AnyFlow, ur as TypeTag, xr as FakeClock, yr as ClockSource, zn as Config$1 } from "./types-K3qfyTu0.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-B1W2CPUu.mjs";
-import { R as I18nApi, U as StringTable, W as TextKey } from "./types-BAv5qOZX.mjs";
-import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-Cs4qaPMq.mjs";
+import { $ as PixiModule, $n as FeaturePlugin, Dr as Json, Lr as SnapshotOf, Mr as PlayerStateProvider, Nr as ProviderCall, Pr as SaveDoc, Tr as Config, X as Config$2, a as Config$3, d as Manifest, lt as Orientation, n as AssetsIo, tr as AnyFlow, ur as TypeTag, xr as FakeClock, yr as ClockSource, zn as Config$1 } from "./types-C_dk-lXz.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-54KzmAA6.mjs";
+import { R as I18nApi, U as StringTable, W as TextKey } from "./types-0Br0SjTB.mjs";
+import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-DFAjLwxi.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{visual-DMx0vv_3.d.mts → visual-DjTJ02c3.d.mts}

@@ -1,9 +1,9 @@
-import { Vr as Api$3, Y as Api, nn as Api$1, vr as Api$4, wr as Api$2 } from "./types-K3qfyTu0.mjs";
-import { P as AnimApi, r as UiApi } from "./types-B1W2CPUu.mjs";
-import { N as InputApi } from "./types-BAv5qOZX.mjs";
-import { r as Repro } from "./headless-BFI7EXHo.mjs";
-import { a as InputOf, r as ControlApp } from "./types-D52biu5v.mjs";
-import { t as commands } from "./commands-BGrtxBga.mjs";
+import { Vr as Api$3, Y as Api, nn as Api$1, vr as Api$4, wr as Api$2 } from "./types-C_dk-lXz.mjs";
+import { P as AnimApi, r as UiApi } from "./types-54KzmAA6.mjs";
+import { N as InputApi } from "./types-0Br0SjTB.mjs";
+import { r as Repro } from "./headless-CRqMxzqv.mjs";
+import { a as InputOf, r as ControlApp } from "./types-CGPWYbZO.mjs";
+import { t as commands } from "./commands-CMFdiDcg.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-DMx0vv_3.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-DjTJ02c3.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/llms.txt

@@ -520,7 +520,7 @@ The graph. Modules `runner`, `gate`, `inbox`, `fx`, `features`. Runner methods s
 ### Screen plugins (V2, built)
 
 `world`, `renderer`, `input`, `assets`, `scenes`. Each has a README at `src/plugins/<name>/README.md`; the root README lists their APIs, events and config. Rendering: WebGPU preferred, with Pixi's WebGL fallback.
-- `app.scenes`: `current()` the mounted scene id, `expect(id)` the scene the next node without its own `scene` mounts, a rest node or a transit node in live mode (the restore door calls it; an unknown id throws). An `over` node takes it the same way, also over another mounted scene. A live switch, before it builds the scene, warms the bundles the scene names (`assets.warm`): their textures go to the GPU `renderer.uploads` a drawn frame while the old scene is still up, so the first frame of the new scene uploads none of them; textures already there are not waited for, and a fast walk or a headless app never waits. A bundle the scene does not name (a `core` bundle of portraits the board shows) is not warmed: name it in the scene's `bundles` or call `app.assets.warm`. Then, with a drawing renderer, the next scene is built aside: its logic runs in one block, the renderer makes its Pixi views over the next frames off the stage in a budget per frame, config `scenes.buildMs: number | "auto"` (default `"auto"`, half the frame interval: 8.33 ms at 60 Hz, 4.17 ms at 120 Hz; `0` throws), and it is swapped in one frame. Until the swap `current()` answers the old scene, nothing of the new one is drawn, hit or found by `ui.find`, its `enter` motions wait and the gate stays closed, so the first tap lands on a complete scene; `scenes:changed` is emitted at the swap. A fast walk, a world that is not live and a headless app mount in one block as before.
+- `app.scenes`: `current()` the mounted scene id, `expect(id)` the scene the next node without its own `scene` mounts, a rest node or a transit node in live mode (the restore door calls it; an unknown id throws). An `over` node takes it the same way, also over another mounted scene. A live switch, before it builds the scene, warms the bundles the scene names (`assets.warm`): their textures go to the GPU `renderer.uploads` a drawn frame while the old scene is still up, so the first frame of the new scene uploads none of them; textures already there are not waited for, and a fast walk or a headless app never waits. A bundle the scene does not name (a `core` bundle of portraits the board shows) is not warmed: name it in the scene's `bundles` or call `app.assets.warm`. Then, with a drawing renderer, the next scene is built aside: its ui elements are made by root and by part, laid out once and applied in parts, and the renderer makes its Pixi views, over the next frames off the stage in a budget per frame, config `scenes.buildMs: number | "auto"` (default `"auto"`, two thirds of the frame interval: 11.1 ms at 60 Hz, 5.56 ms at 120 Hz; `0` throws), and it is swapped in one frame. Until the swap `current()` answers the old scene, nothing of the new one is drawn, hit or found by `ui.find`, its `enter` motions wait and the gate stays closed, so the first tap lands on a complete scene; `scenes:changed` is emitted at the swap. A fast walk, a world that is not live and a headless app mount in one block as before.
 - `Shape({ kind, w, h, fill, fillAlpha, alpha, radius, stroke, strokeWidth, dash, clip, sweep?, cap? })` (`kind: "rect"`; `sweep` and `cap` are optional, `1` and `"round"` when left out; only an arc reads them; a rectangle or a triangle ignores them, also when an earlier arc left them on the `Shape`): a rounded rectangle, `kind: "triangle"` (fills its box pointing right) or `kind: "arc"`: a stroke on the circle inscribed in the box (`min(w, h) − strokeWidth` across, centred) from 12 o'clock clockwise over `sweep` (0..1, clamped; 0 draws nothing, 1 a closed ring), ended by `cap` (`"round" | "butt"`); an arc draws no fill and ignores `radius` and `dash`. The path is built again only when a field changes: a still arc costs nothing a frame. `Shape({ kind: "arc", w: 28, h: 28, stroke: 0xc8a15a, strokeWidth: 2.2, sweep: 0.42 })` is a slot timer's ring with 42 % left.
 - Overlays: `Overlay({ dim, dimColor, cover, hud, fade, hold })` on the root of an overlay (in `components`) keeps everything drawn before it as one picture, retaken in the frame anything in it changes, and with `cover: "opaque"` draws none of it once landed at alpha 1; `hold: true` (default `false`) holds the endless loops under it while it stands, as under a cover or a blurred picture (their phase follows time), so a dimmed sheet over a sharp scene draws no frame at rest; the engine draws the dim (`dim × level`, right under the root); the level follows the root's own enter and exit motion, `fade` (250 ms) only when it has none; level and landing are read through `app.renderer.sync.debug.overlays()`. A `backdrop: true` filter inside the kept range runs no pass while the picture stands (its look is in the picture) and is drawn again in the frame the overlay is gone. Types: `OverlayValue` (the component's value) and `HudPartValue` (a part of the HUD an overlay keeps shown or lets fade).
 - HUD: a scene layer `{ above: "overlays" }` is the HUD layer, drawn above every overlay and never in a picture; a scene with a HUD layer and no `ui` gets `ui` right under it. Its roots never take the keyboard: Escape and the Back press reach the top sheet under it. `HudPart({ key })` tags a HUD view; an overlay's `hud` (`"all"`, `"none"` or keys) names the parts that stay shown, the others fade with its level and take no tap. Keys are typed by `defineGame<{ …, hud: "energy" | "gems" }>()`.
@@ -532,6 +532,7 @@ The graph. Modules `runner`, `gate`, `inbox`, `fx`, `features`. Runner methods s
 - When a system runs: before each run the world checks it. A system with a `query` is skipped while a term of its query has no entity (the smallest store among the terms is empty): no walk, no `mut()` mark, no timing. A system without a query always runs. `system({ ..., scenes: ["board"] })` runs only while one of those scenes is mounted or leaving: `scenes` calls `app.world.ecs.setScene(id)` at every switch, and the scene before leaves until nothing carries `Exiting` (the elements of its JSX views played their exit; the next scene's entities already stand then, so a `scenes` system writes only its own scene's entities). A dev build throws at start for a name in `scenes` no feature declares: `[game] System "board.idle" runs on the scene "bord", which no feature declares.` `ctx.resumed` is true on the first run after a skip (a cache or a remembered cue starts over then). The same for every system, the engine's included; 0 B a frame. A run with no rows does not happen any more: work a system did besides its rows (a hover, a drop or a press that ends, a resource reset, something that outlives its entities) goes to a system with `query: []` and `scenes`, reading its rows with `world.query()`. From 0.15.3: delete `systemsRun` from every feature (the type refuses it), rewrite the systems that work outside their rows, add `scenes` only to a system whose entities stand on every screen; `ecs.hold` and `ecs.isActive` are gone (a test asks `app.scenes.current()` or whether the system ran). World README, "When a system runs".
 - Motion hooks are told why they play: `enter(view, item, hint, cause)` and `exit(view, item, hint, cause)` get `World.MotionCause`, `"mount"` (the view comes or goes with its screen: a mount, an unmount, a load, a restore, a paused or fast world) or `"change"` (a commit). A world projection plays them only for `"change"`; `ui` plays them for both. `app.world.projection.causeOf(entity)` answers how a view came or how it is leaving, also in a removal hook of its despawn, until the next frame.
 - `app.world.projection.replace(spec)` swaps the spec of a registered projection; a mounted one runs its new `view` on the next frame. An unknown name throws. The caller is the dev hot swap.
+- `projection({ …, initialOnly: [[Shape, ["sweep"]]] })`: `view` gives those fields once, at the birth of a view; after that they belong to another writer (a system drawing a timer arc from `Now`), and no changed item, motion, end-of-motion check (`world:view-corrected`), rollback, `settle`, restore or load writes or compares them, as with `mute()` for every view's whole life. Field names are checked per component; a pair with no field throws at register. Absent, every field is the projection's.
 - `input`: one followed pointer. A finger that has not started a gesture (pressed, inside the tap slop, no long press, no trace) gives way to the next finger that goes down, wherever it rests, and its press is cancelled; a finger that started a gesture keeps it. `Pointer.id` is the followed `pointerId` (`-1` at rest): a system that measures the finger's travel starts over when it changes.
 - `Draggable({ payload, carry?, aim? })`: `aim: { x, y }`, a point of the view in its own units, moves the hover and the drop lookup from the finger to that point of the view in the hand; `null` (default) is the finger.
 - `pluginConfigs.renderer.onDemand: true` draws a frame only when something visible changed (a written view, a filter value, a resize, a wake, a capture); `app.renderer.stats().drawn` is the frames drawn per second (`fps` without it); a game that writes into its own `Display` object calls `app.renderer.invalidate(entity)` before the write; `renderer.sync.debug.verifyFrames(true)` (dev/debug) checks skipped frames by pixels and logs `renderer:missed-frame`; a dev build warns `renderer:missed-mark` for a write without the call.

package/package.json

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