@moku-labs/game 0.13.1 → 0.13.3

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { Dt as AnyFlow, Ht as ClockSource, Nt as NodeTable, Wt as FakeClock, Xt as Json, ht as FeaturePlugin } from "./types-ZQLYXo5X.mjs";
-import { t as createApp } from "./index-rnOYAriI.mjs";
-import { n as saveOf, t as memory } from "./memory-DwDhfFWK.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-G4nuZ-xz.mjs";
+import { Dt as AnyFlow, Ht as ClockSource, Nt as NodeTable, Wt as FakeClock, Xt as Json, ht as FeaturePlugin } from "./types-BSMmnpFm.mjs";
+import { t as createApp } from "./index-CjuObHhF.mjs";
+import { n as saveOf, t as memory } from "./memory-DKo9rRWW.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-CYgYzro0.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,7 +1,7 @@
-import { Kt as type, Ut as exit, t as createApp } from "./src-SmT-XxVf.mjs";
+import { Kt as type, Ut as exit, t as createApp } from "./src-DlyYl_9X.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { t as fakeClock } from "./fake-MpzwZhIZ.mjs";
-import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-BsNdJs9W.mjs";
+import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-BA6ffzqD.mjs";
 //#region src/testing/isolate.ts
 const noPayload = null;
 /** Id of the harness main flow. */

package/dist/{types-ZQLYXo5X.d.mts → types-BSMmnpFm.d.mts}

@@ -37,7 +37,12 @@ type Config$8 = {
  * ```
  */
 type Events$6 = {
-  /** A dev hot swap was applied: the saved module's new exports. `ui` emits it, `effects` replaces its emitters on it. */"ui:hot-swap": {
+  /**
+   * A dev hot swap was applied: the saved module's new exports. `ui` emits it, `effects` replaces
+   * its emitters on it, and `assets` hears it for the stamp module `.moku/assets-stamp.ts`: it
+   * replaces the asset files the stamp names as changed.
+   */
+  "ui:hot-swap": {
     file: string;
     module: Readonly<Record<string, unknown>>;
   };
@@ -831,7 +836,9 @@ type StoreState = {
 /**
  * store module API, `app.model.store`. Logic changes the trees only inside a transaction, and only
  * a rest point hands patches to the provider, so a kill between two rest nodes loses a whole
- * transition and never half of one.
+ * transition and never half of one. One restore differs: `flow.restore` of a bookmark taken at a
+ * transit node marks a rest point there, so the provider receives a document from between two rest
+ * nodes, and a kill right after it loads that state at the start node.
  *
  * @example
  * ```ts
@@ -2134,20 +2141,21 @@ type RouteStep = {
   };
 };
 /**
- * A rest node plus a state that really existed there. Serialisable. `graph` is the hash of
- * `describe()`.
+ * A node plus a state that really existed there. Serialisable. `path` names a rest node, or a
+ * transit node that waited at the gate for the answer of an effect (a popup); for the second the
+ * state is the one committed when the node was entered. `graph` is the hash of `describe()`.
  *
  * @example
  * ```ts
+ * // Taken while the info popup of the mini game waits for its answer, opened from "home".
  * const bookmark: Bookmark = {
- *   path: "board/awaitIntent", input: null,
- *   player: { coins: 7 }, session: { taps: 0 },
- *   rng: { seed: 42, streams: {} }, graph: "fe4d257a"
+ *   path: "info/show", input: null, player: { count: 0 }, session: { opened: 0 },
+ *   rng: { seed: 42, streams: {} }, graph: "0e0d2aa8", rest: { path: "home", input: null }
  * };
  * ```
  */
 type Bookmark = {
-  path: string;
+  /** Path of a rest node, or of a transit node that waited at the gate. */path: string;
   input: Json;
   player: Json;
   session: Json;
@@ -2158,6 +2166,15 @@ type Bookmark = {
    * `game.restore`; `flow.restore` ignores it.
    */
   scene?: string;
+  /**
+   * The rest point before a transit `path`: the last rest node and its input. `restore` enters
+   * it instead when the graph changed since the bookmark. Absent for a bookmark of a rest node,
+   * and when no rest node came before the transit node.
+   */
+  rest?: {
+    path: string;
+    input: Json;
+  };
 };
 /**
  * What `onEnter` callbacks learn about the node being entered.
@@ -2281,8 +2298,16 @@ type EnterCallback = (node: NodeInfo, ctx: {
  * game just runs: `walk.ts` and `restore` create it through `loopSeam` when they need it.
  */
 type LoopSeam = {
-  /** Sub-flow results a walk substitutes, by path. The loop takes each one once. */substitutions: Map<string, Result>; /** Called with the path every time the loop enters a rest node. */
-  rest: ((path: string) => void)[]; /** Called every time the loop opens the gate of a rest node. The walk waits on it. */
+  /** Sub-flow results a walk substitutes, by path. The loop takes each one once. */substitutions: Map<string, Result>;
+  /**
+   * Called with the path every time the loop enters a rest node, and once when it enters the
+   * node of a bookmark, which may be a transit node. `restore` resolves on the second.
+   */
+  rest: ((path: string) => void)[];
+  /**
+   * Called every time the loop opens a gate: the wait of a rest node, or an effect with answers
+   * inside any node. The walk waits on it, and so does `restore` after it entered a transit node.
+   */
   gateOpen: (() => void)[]; /** The bookmark the loop enters at the next turn. */
   restoring: Bookmark | undefined;
 };
@@ -2293,7 +2318,12 @@ type RunnerState = {
   /** Flush started by a background pause. `onStop` awaits it. */flushing: Promise<void> | undefined; /** Every flow of the graph by id, collected at `run()`. */
   flows: Map<string, AnyFlow>;
   enterCallbacks: Record<Stage, EnterCallback[]>; /** The position: one frame per nesting level. */
-  stack: Frame[]; /** The stack of the last rest node: the rollback target. */
+  stack: Frame[];
+  /**
+   * The frames a failed node is retried from, paired with the state a rollback returns to: the
+   * last rest node, or the node the graph started at or a restore entered. The last two may be
+   * transit nodes, so `bookmark()` writes its `rest` only when these frames name a rest node.
+   */
   restFrame: Frame[] | undefined; /** Inside a slot: the contribution the loop just finished. The slot continues after it. */
   slotAfter: string | undefined; /** Edges since the last checkpoint. */
   journal: JournalEntry[];
@@ -2368,7 +2398,10 @@ type RunnerApi = {
   /**
    * Walks a route in fast mode through the running loop: it answers the gate at each step's `at`
    * and substitutes the result of every sub-flow node the route skips. A `from` bookmark is
-   * entered through the same check as `restore`. The mode of the caller is put back afterwards.
+   * entered through the same check as `restore`, with the same fallback. A rest node is entered
+   * before the switch to fast mode: its stages see the mode of the caller. A transit node is
+   * entered after the switch and without the wait `restore` adds for it: its popup is not shown,
+   * the route answers it. The mode of the caller is put back afterwards.
    *
    * @param route - The player's answers and substituted sub-flow results, in order.
    * @param options - Walk options.
@@ -2390,32 +2423,57 @@ type RunnerApi = {
     from?: Bookmark;
   }): Promise<FlowState>;
   /**
-   * Makes a bookmark of the current rest point: the rest node plus the committed state.
+   * Makes a bookmark of where the graph stands: the last rest node plus the committed state.
+   * While a transit node waits at the gate for the answer of an effect (a `popup`, or any
+   * descriptor with `answers`), the bookmark names that node instead. Its state is the one
+   * committed when the node was entered: what the node wrote before the wait is not in it, the
+   * node writes it again when it is restored. `rest` then names the rest point before the node.
+   * While a transit node awaits anything else (an animation, a request) the bookmark still names
+   * the last rest node.
    *
    * @returns The bookmark, ready for JSON.
    * @throws {Error} When the graph has no position yet.
    * @example
    * ```ts
-   * // A devtools button keeps the position while the board rests.
-   * const bookmark = app.flow.bookmark();
-   * bookmark.path; // "board/awaitIntent"
-   * JSON.stringify(bookmark); // plain data: path, input, player, session, rng and the graph hash
+   * // A devtools button keeps the position. The board rests: the bookmark names its rest node.
+   * const atBoard = app.flow.bookmark(); // plain data, ready for JSON.stringify
+   * atBoard.path; // "board/awaitIntent"
+   * // The mini game with its info popup open: the bookmark names the node that waits.
+   * const atPopup = app.flow.bookmark();
+   * atPopup.path; // "info/show"
+   * atPopup.rest; // { path: "home", input: null }: the rest point before it
    * ```
    */
   bookmark(): Bookmark;
   /**
-   * Replaces the state with the bookmark's and enters its node. A checkpoint is always
-   * accepted; any other rest node only while the graph is unchanged.
+   * Replaces the state with the bookmark's and enters its node. A rest checkpoint is always
+   * accepted; any other node only while the graph is unchanged. A transit node is never taken
+   * for a checkpoint: when the graph changed, such a bookmark is entered at its `rest` point
+   * instead, if that is a checkpoint, and the log gets `flow:restore-fell-back`. A renamed or
+   * removed node is a changed graph too: a bookmark with `rest` whose path names no node takes
+   * the same fallback.
+   *
+   * A rest node: the promise resolves when the node is entered, before its scene stage ran. A
+   * transit node runs again from its first line, live, with the bookmark's input, so its effects
+   * before the gate play again; the promise resolves when its gate is open, or at the rest node
+   * or the end of the loop it reaches without one. A node that does none of these keeps the
+   * promise pending. An open gate is not a drawn popup: the popup shows on the next frame. And
+   * `setMode` still throws there, since the graph waits inside a transit node.
    *
    * @param bookmark - The bookmark to enter.
-   * @returns A promise that resolves once the graph rests at the bookmark's node.
-   * @throws {Error} When the bookmark names no rest node of this graph, when the graph changed
-   *   since a bookmark of a plain rest node, and before `run()`.
+   * @returns A promise that resolves once a rest node is entered, or a transit node waits at
+   *   its gate.
+   * @throws {Error} When the bookmark names no node of this graph and has no `rest`, when the
+   *   graph changed since the bookmark and neither it nor its `rest` point is a rest checkpoint,
+   *   and before `run()`.
    * @example
    * ```ts
    * // The next session opens where the last one stopped: state and position come back together.
-   * await app.flow.restore(bookmark);
+   * await app.flow.restore(atBoard);
    * app.flow.state().path; // "board/awaitIntent"
+   * // A bookmark the mini game took at its info popup: the popup waits again when this resolves.
+   * await app.flow.restore(atPopup);
+   * app.flow.state().pending.gate; // ["ok", "close"], and state().path is "info/show"
    * ```
    */
   restore(bookmark: Bookmark): Promise<void>;
@@ -2463,7 +2521,9 @@ type RunnerApi = {
    */
   history(): readonly JournalEntry[];
   /**
-   * Switches between live and fast mode. Legal before `run()` and while the graph rests.
+   * Switches between live and fast mode. Legal before `run()` and while the graph rests. A
+   * transit node that waits at the gate for a popup does not rest: it throws there too, also
+   * right after a `restore` into such a node.
    *
    * @param mode - `"live"` or `"fast"`.
    * @throws {Error} When a transit node is running.
@@ -2768,7 +2828,12 @@ type Events$3 = {
     };
     index: number;
     now: number;
-  }; /** The graph reached a rest node. */
+  };
+  /**
+   * The graph reached a rest node, or entered the node of a bookmark. The second also happens
+   * for a transit node that waited at the gate: `path` is then no rest node and `checkpoint` is
+   * false.
+   */
   "flow:rest": {
     path: string;
     checkpoint: boolean;
@@ -6465,7 +6530,7 @@ type TeardownScope = {
   readonly state: State$1;
 };
 declare namespace types_d_exports {
-  export { Api, AssetKind, AssetsCtx, AssetsIo, AtlasFrame, AtlasPage, AudioAsset, AudioMime, BundleMap, BundleRecord, BundleSpec, BundleUsage, Config, CreateTextureOptions, DecodedImage, DefineBundles, Deps, Events, FetchResponse, FlowRest, FontAsset, FontPage, Inflight, KernelSlice, LoadBundles, LoadReason, LoadResult, LoadedAssets, LoadedFont, Manifest, ManifestBundle, ManifestFile, NineBorders, NineSlice, PreloadQueue, State, Texture, Tier, Usage };
+  export { Api, AssetKind, AssetStamps, AssetsCtx, AssetsIo, AtlasFrame, AtlasPage, AudioAsset, AudioMime, BundleMap, BundleRecord, BundleSpec, BundleUsage, Config, CreateTextureOptions, DecodedImage, DefineBundles, Deps, Events, FetchResponse, FlowRest, FontAsset, FontPage, HotSwap, Inflight, KernelSlice, LoadBundles, LoadReason, LoadResult, LoadedAssets, LoadedFont, Manifest, ManifestBundle, ManifestFile, NineBorders, NineSlice, PreloadQueue, State, Texture, Tier, Usage };
 }
 /**
  * When a bundle is loaded. `boot` and `core` stay for the whole session, `scene` and `feature`
@@ -6920,6 +6985,27 @@ type PreloadQueue = {
   bundles: string[];
   controller: AbortController;
 };
+/**
+ * What the keys watch of `moku-game dev` knows about the asset files of a game: the default export
+ * of the generated `.moku/assets-stamp.ts`. The dev hot swap compares it with the map it applied
+ * last and replaces the files whose stamp differs.
+ *
+ * @example
+ * ```ts
+ * // The stamp after a save of fx-spark.webp: every watched file, and the one that changed.
+ * const stamps: AssetStamps = {
+ *   files: {
+ *     "features/ui/assets/font-body.fnt": "1810:1791536000000",
+ *     "features/ui/assets/fx-spark.webp": "2554:1791536552578"
+ *   },
+ *   changed: ["features/ui/assets/fx-spark.webp"]
+ * };
+ * ```
+ */
+type AssetStamps = {
+  /** Every watched asset file, root-relative with `/`, and its `size:mtimeMs`. Sorted by path. */files: Readonly<Record<string, string>>; /** The files whose stamp differs from the batch before. Empty in the first stamp of a run. */
+  changed: readonly string[];
+};
 /**
  * assets plugin config.
  *
@@ -6954,7 +7040,9 @@ type State = {
   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. */
-  removers: Array<() => void>;
+  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;
 };
 /**
  * What `usage()` reports about one loaded bundle.
@@ -7004,6 +7092,13 @@ type Usage = {
  *     }
  *   })
  * }); // a board bundle of four files sets share to 0.25, 0.5, 0.75 and 1; bundle-loaded follows
+ *
+ * // The audio plugin drops the buffer it decoded from a sound a dev save replaced.
+ * hooks: ctx => ({
+ *   "assets:replaced": ({ keys }) => {
+ *     for (const key of keys) ctx.state.decoded.delete(key); // the next play decodes the new bytes
+ *   }
+ * }); // a save of features/ui/assets/click.mp3 sends { bundle: "ui", keys: ["ui.click"] }
  * ```
  */
 type Events = {
@@ -7030,6 +7125,15 @@ type Events = {
     reason: "budget" | "request";
     keys: readonly string[];
   };
+  /**
+   * Files of a loaded bundle were replaced by a dev hot swap: one event per bundle per swap. `keys`
+   * names every asset that has new bytes; each of them answers a new texture, font or sound, and
+   * the old textures are destroyed. Dev builds only.
+   */
+  "assets:replaced": {
+    bundle: string;
+    keys: readonly string[];
+  };
 };
 /**
  * assets plugin API, `app.assets`. Bundles of textures by key: the graph decides when they arrive,
@@ -7159,7 +7263,7 @@ type Deps = {
  * What the kernel context offers before the deps are attached.
  *
  * `index.ts` writes `events` with an annotated `register` (core spec `14-EVENT-REGISTRATION.md`
- * row 8), so the two own events reach the context the kernel hands the factories and `emit` is the
+ * row 8), so the own events reach the context the kernel hands the factories and `emit` is the
  * kernel's own, assets-typed one. No member of the context is cast.
  */
 type KernelSlice = PluginCtx<Config, State, Events> & {
@@ -7174,11 +7278,16 @@ type AssetsCtx = KernelSlice & {
   readonly deps: Deps;
 };
 /**
- * Payload of the one event assets listens to.
+ * Payload of the `flow:rest` hook: where the graph rests.
  */
 type FlowRest = {
   path: string;
   checkpoint: boolean;
 };
+/**
+ * Payload of the global `ui:hot-swap` hook: the saved file and its new exports. For the stamp of
+ * the keys watch, `module.default` is the `AssetStamps`.
+ */
+type HotSwap = Events$6["ui:hot-swap"];
 //#endregion
 export { DescriptionNode as $, types_d_exports$5 as $t, Api$2 as A, FlowGraph as At, ComponentType as B, Answer as Bt, types_d_exports$1 as C, slot as Ct, FilterSlot as D, AnyFlow as Dt, DebugSwitches as E, FeatureDescription as Et, AnyComponent as F, SceneIdOf as Ft, Mut as G, State$4 as Gt, Entity as H, ClockSource as Ht, AnyComponentType as I, TypeTag as It, QueryTerm as J, Config$5 as Jt, Narrowed as K, types_d_exports$4 as Kt, AnyComponentValue as L, Descriptor as Lt, Explained as M, JournalEntry as Mt, State$2 as N, NodeTable as Nt, Point as O, Bookmark as Ot, types_d_exports$2 as P, RouteStep as Pt, ChangeHook as Q, State$5 as Qt, ComponentHandle as R, GuideOptions as Rt, Under as S, Require as Sn, exit as St, RenderStats as T, type as Tt, EntitySnapshot as U, Config$4 as Ut, ComponentValue as V, Api$4 as Vt, FrameDiff as W, FakeClock as Wt, SystemDefinition as X, Json as Xt, ResourceType as Y, Events$4 as Yt, TagType as Z, Root as Zt, PixiFilter as _, State$7 as _n, Position as _t, Config as a, Snapshot as an, NumericFields as at, PixiTexture as b, Config$8 as bn, types_d_exports$3 as bt, LoadBundles as c, RngState as cn, TrackOptions as ct, State as d, Events$5 as dn, Api$3 as dt, Patch as en, Ease as et, Tier as f, PauseReason as fn, BundlesOf as ft, Config$1 as g, Config$7 as gn, GameTypes as gt, Api$1 as h, Api$7 as hn, FeaturePlugin as ht, BundleSpec as i, SaveUnreadableError as in, MotionHandle as it, Config$2 as j, FlowState as jt, ViewportSize as k, DefineNode as kt, LoadReason as l, Api$6 as ln, TrackSegment as lt, types_d_exports as m, types_d_exports$6 as mn, EmitterIdOf as mt, AssetsIo as n, ProviderCall as nn, LayerSpec as nt, DefineBundles as o, StoreApi as on, ProjectionMotion as ot, Usage as p, State$6 as pn, Config$3 as pt, Owner as q, Api$5 as qt, BundleMap as r, SaveDoc as rn, Motion as rt, Events as s, RngApi as sn, ProjectionSpec as st, Api as t, PlayerStateProvider as tn, LayerSort as tt, Manifest as u, Config$6 as un, ViewHandle as ut, PixiModule as v, Time as vn, State$3 as vt, Captured as w, to as wt, State$1 as x, Events$6 as xn, defineFlow as xt, PixiSprite as y, types_d_exports$7 as yn, TextStylesOf as yt, ComponentSchema as z, Hint as zt };

package/dist/{types-Bcdo5-2w.d.mts → types-B_Bp2tWK.d.mts}

@@ -1,5 +1,5 @@
-import { A as Api$1, B as ComponentType, D as FilterSlot, H as Entity, O as Point, R as ComponentHandle, Sn as Require, _ as PixiFilter, b as PixiTexture, dt as Api, h as Api$2, s as Events, t as Api$3, v as PixiModule, xn as Events$1, y as PixiSprite } from "./types-ZQLYXo5X.mjs";
-import { x as AnimApi } from "./types-D_2G6Q68.mjs";
+import { A as Api$1, B as ComponentType, D as FilterSlot, H as Entity, O as Point, R as ComponentHandle, Sn as Require, _ as PixiFilter, b as PixiTexture, dt as Api, h as Api$2, s as Events, t as Api$3, v as PixiModule, xn as Events$1, y as PixiSprite } from "./types-BSMmnpFm.mjs";
+import { x as AnimApi } from "./types-dJMOXXL3.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -523,7 +523,7 @@ type EmitterInstance = {
   readonly particleClass: PixiModule["Particle"];
 };
 declare namespace types_d_exports {
-  export { AlphaValue, BlurValue, BundleUnloaded, ColorMatrixValue, Config, CoreKind, Curve, Deps, DisplacementValue, EffectsApi, EffectsCtx, EffectsStats, EmitterConfig, EmitterDefinition, EmitterValue, FilterComponent, FilterDefinition, FilterSpec, FilterValueOf, GlowValue, HotSwap, KernelSlice, NoiseValue, OutlineValue, Range, ResolvedEmitterConfig, Shape, State, UniformDeclaration, UniformSpec, UniformValue };
+  export { AlphaValue, AssetsReplaced, BlurValue, BundleUnloaded, ColorMatrixValue, Config, CoreKind, Curve, Deps, DisplacementValue, EffectsApi, EffectsCtx, EffectsStats, EmitterConfig, EmitterDefinition, EmitterValue, FilterComponent, FilterDefinition, FilterSpec, FilterValueOf, GlowValue, HotSwap, KernelSlice, NoiseValue, OutlineValue, Range, ResolvedEmitterConfig, Shape, State, UniformDeclaration, UniformSpec, UniformValue };
 }
 /**
  * effects plugin config. `maxParticles` here is the global warning line; the `maxParticles` of an
@@ -644,6 +644,10 @@ type EffectsCtx = KernelSlice & {
  * Payload of the `assets:bundle-unloaded` hook: `keys` names every texture that is gone.
  */
 type BundleUnloaded = Events["assets:bundle-unloaded"];
+/**
+ * Payload of the `assets:replaced` hook: `keys` names every asset a dev hot swap gave new bytes.
+ */
+type AssetsReplaced = Events["assets:replaced"];
 /**
  * Payload of the global `ui:hot-swap` hook: the saved file and its new exports.
  */

package/dist/{types-DAdwEJMp.d.mts → types-Bonifz5M.d.mts}

@@ -1,5 +1,5 @@
-import { Xt as Json, an as Snapshot } from "./types-ZQLYXo5X.mjs";
-import { t as HeadlessApp } from "./headless-G4nuZ-xz.mjs";
+import { Xt as Json, an as Snapshot } from "./types-BSMmnpFm.mjs";
+import { t as HeadlessApp } from "./headless-CYgYzro0.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{types-DLghaGEy.d.mts → types-DkO3s9YX.d.mts}

@@ -1,7 +1,7 @@
-import { Dt as AnyFlow, Ht as ClockSource, Jt as Config, Wt as FakeClock, Xt as Json, a as Config$3, g as Config$2, ht as FeaturePlugin, n as AssetsIo, pt as Config$1, tn as PlayerStateProvider, u as Manifest, v as PixiModule } from "./types-ZQLYXo5X.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-D_2G6Q68.mjs";
-import { _t as audioPlugin, ct as PlatformProvider, ht as effectsPlugin, i as screen, ot as platformPlugin, t as createApp } from "./index-rnOYAriI.mjs";
-import { t as memory } from "./memory-DwDhfFWK.mjs";
+import { Dt as AnyFlow, Ht as ClockSource, Jt as Config, Wt as FakeClock, Xt as Json, a as Config$3, g as Config$2, ht as FeaturePlugin, n as AssetsIo, pt as Config$1, tn as PlayerStateProvider, u as Manifest, v as PixiModule } from "./types-BSMmnpFm.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-dJMOXXL3.mjs";
+import { _t as audioPlugin, ct as PlatformProvider, ht as effectsPlugin, i as screen, ot as platformPlugin, t as createApp } from "./index-CjuObHhF.mjs";
+import { t as memory } from "./memory-DKo9rRWW.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/app/types.d.ts

package/dist/{types-BrTpz9oL.d.mts → types-Dm5Oh5bH.d.mts}

@@ -1,4 +1,4 @@
-import { A as Api$2, B as ComponentType, F as AnyComponent, H as Entity, I as AnyComponentType, L as AnyComponentValue, Lt as Descriptor, O as Point$2, Q as ChangeHook, Sn as Require, V as ComponentValue, Vt as Api$5, Xt as Json, at as NumericFields, dt as Api$1, h as Api$3, hn as Api, it as MotionHandle, k as ViewportSize, ot as ProjectionMotion, rt as Motion, s as Events$1, t as Api$4, ut as ViewHandle, zt as Hint } from "./types-ZQLYXo5X.mjs";
+import { A as Api$2, B as ComponentType, F as AnyComponent, H as Entity, I as AnyComponentType, L as AnyComponentValue, Lt as Descriptor, O as Point$2, Q as ChangeHook, Sn as Require, V as ComponentValue, Vt as Api$5, Xt as Json, at as NumericFields, dt as Api$1, h as Api$3, hn as Api, it as MotionHandle, k as ViewportSize, ot as ProjectionMotion, rt as Motion, s as Events$1, t as Api$4, ut as ViewHandle, zt as Hint } from "./types-BSMmnpFm.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -1403,7 +1403,7 @@ declare function defineComponent<Properties extends object, Local extends object
  */
 declare function defineComponent<Properties extends object, Local extends object>(name: string, spec: ComponentSpec<Properties, Local, never>): ComponentDefinition<Properties, Local, undefined>;
 declare namespace types_d_exports {
-  export { AdvanceTable, BindField, BindOptions, BundleLoaded, BundleUnloaded, Config, CountdownValue, Deps, DrawnLabel, IconRun, KernelSlice, LayoutOptions, Line, LocaleChanged, Point, Run, SeenText, Size, State, TextAlign, TextApi, TextBind, TextCtx, TextFormat, TextLayout, TextRun, TextShadow, TextStyle, TextStyleInput, TextStyles, TextValue, TextWrap, Warn };
+  export { AdvanceTable, AssetsReplaced, BindField, BindOptions, BundleLoaded, BundleUnloaded, Config, CountdownValue, Deps, DrawnLabel, IconRun, KernelSlice, LayoutOptions, Line, LocaleChanged, Point, Run, SeenText, Size, State, TextAlign, TextApi, TextBind, TextCtx, TextFormat, TextLayout, TextRun, TextShadow, TextStyle, TextStyleInput, TextStyles, TextValue, TextWrap, Warn };
 }
 /**
  * A point in reference units: where a label sits, and which point of the block sits there.
@@ -1707,13 +1707,16 @@ type TextLayout = {
   height: number;
 };
 /**
- * What one label container was last filled from: the style object and the laid-out block. An
- * update with the same style object, the same anchor and the same lines and runs writes the new
- * text and positions into the objects already there.
+ * What one label container was last filled from: the style object, the laid-out block and the
+ * generation of the state at that moment. An update with the same style object, the same
+ * generation, the same anchor and the same lines and runs writes the new text and positions into
+ * the objects already there. An older generation means a dev hot swap replaced a font or an icon
+ * since: the objects hold textures that are destroyed, so they are built again.
  */
 type DrawnLabel = {
   style: TextStyle;
   layout: TextLayout;
+  generation: number;
 };
 /**
  * A dev warning that is written once per key. Pure modules take it as an argument, so nothing
@@ -1783,7 +1786,12 @@ type State = {
   measured: Map<Entity, Size>; /** Layout per `style + resolved`, 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>; /** Warning keys already written, so a style, a tag, a glyph or a font warns once. */
+  dirty: Set<Entity>;
+  /**
+   * Counts the dev hot swaps that replaced a font or an inline icon of a live label. A label
+   * container drawn under an older count is built again on its next update.
+   */
+  generation: number; /** Warning keys already written, so a style, a tag, a glyph or a font warns once. */
   warned: Set<string>; /** The system, the two world hooks and the display adapter. */
   removers: Array<() => void>;
 };
@@ -1904,6 +1912,11 @@ type BundleLoaded = Events$1["assets:bundle-loaded"];
  * Payload of the `assets:bundle-unloaded` hook: `keys` names the assets that left.
  */
 type BundleUnloaded = Events$1["assets:bundle-unloaded"];
+/**
+ * Payload of the `assets:replaced` hook: a dev hot swap put new bytes behind `keys`. Each of them
+ * answers a new font or texture already, and the old pages and textures are destroyed.
+ */
+type AssetsReplaced = Events$1["assets:replaced"];
 /**
  * Payload of the `i18n:locale-changed` hook: every message has to be resolved again.
  */

package/dist/{types-D_2G6Q68.d.mts → types-dJMOXXL3.d.mts}

@@ -1,5 +1,5 @@
-import { A as Api$2, B as ComponentType, F as AnyComponent, H as Entity, It as TypeTag, L as AnyComponentValue, Lt as Descriptor, R as ComponentHandle, Sn as Require, Xt as Json, Yt as Events$2, at as NumericFields, ct as TrackOptions, dn as Events$3, dt as Api$1, et as Ease, h as Api$5, hn as Api, it as MotionHandle, lt as TrackSegment, nt as LayerSpec, q as Owner, qt as Api$4, s as Events$4, t as Api$3, tt as LayerSort, xn as Events$5 } from "./types-ZQLYXo5X.mjs";
-import { A as InputApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, q as I18nApi, r as ElementMotion, rt as StylesState, x as TextApi } from "./types-BrTpz9oL.mjs";
+import { A as Api$2, B as ComponentType, F as AnyComponent, H as Entity, It as TypeTag, L as AnyComponentValue, Lt as Descriptor, R as ComponentHandle, Sn as Require, Xt as Json, Yt as Events$2, at as NumericFields, ct as TrackOptions, dn as Events$3, dt as Api$1, et as Ease, h as Api$5, hn as Api, it as MotionHandle, lt as TrackSegment, nt as LayerSpec, q as Owner, qt as Api$4, s as Events$4, t as Api$3, tt as LayerSort, xn as Events$5 } from "./types-BSMmnpFm.mjs";
+import { A as InputApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, q as I18nApi, r as ElementMotion, rt as StylesState, x as TextApi } from "./types-Dm5Oh5bH.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -1297,9 +1297,10 @@ type State$2 = {
   /** Scene id to its declaration, filled in `onStart` from `flow.features`. */scenes: Map<string, SceneDefinition>; /** Id of the scene that is mounted now. */
   current: string | undefined;
   /**
-   * The scene the next rest node without its own `scene` mounts: the one a transit node named in
-   * fast mode, or the one the restore door expected with `expect`. A rest node clears it; an over
-   * rest node takes it only while nothing is mounted.
+   * The scene the next node without its own `scene` mounts, at a rest node or at a transit node
+   * in live mode: the one a transit node named in fast mode, or the one the restore door expected
+   * with `expect`. A rest node clears it; a transit node clears it only when it took it; an over
+   * node takes it only while nothing is mounted.
    */
   pending: string | undefined;
   owner: SceneOwner; /** The remover of the `onEnter` callback: set in `onStart`, run in `onStop`. */
@@ -1348,19 +1349,22 @@ type ScenesApi = {
    */
   current(): string | undefined;
   /**
-   * Names the scene the next rest node without its own `scene` mounts. The restore door calls it
-   * with the scene of a bookmark, so a bookmark at a popup comes back with the scene under it.
-   * An over rest node takes the expected scene only while nothing is mounted; it never switches a
+   * Names the scene the next node without its own `scene` mounts. A rest node reads it, and so
+   * does a transit node in live mode; a transit node of a fast walk leaves it for the rest point.
+   * The restore door calls it with the scene of a bookmark, so a bookmark at a popup comes back
+   * with the scene under it, also when the popup is a transit node that waits for its answer:
+   * the scene of such a popup is mounted before `flow.restore` resolves.
+   * An over node takes the expected scene only while nothing is mounted; it never switches a
    * mounted one.
    *
    * @param id - Id of a scene a feature declared.
    * @throws {Error} For an id no feature declared, also before `onStart` filled the registry.
    * @example
    * ```ts
-   * // A fresh page restores a bookmark taken at the Settings popup over Home.
+   * // A fresh page restores a bookmark taken at the Settings popup over Home, a transit node
+   * // that waits for its answer.
    * app.scenes.expect("home");
-   * await app.flow.restore(bookmark);
-   * await app.flow.walk([]); // the scene stage runs after restore resolves
+   * await app.flow.restore(bookmark); // resolves when the popup's gate is open
    * app.scenes.current(); // "home"
    * ```
    */
@@ -1406,7 +1410,7 @@ type RunContext = {
   signal: AbortSignal;
 };
 declare namespace types_d_exports$1 {
-  export { AudioApi, AudioContextLike, AudioCtx, AudioSessionLike, AudioSessionType, BundleUnloaded, Bus, BusState, Config$1 as Config, Deps$1 as Deps, KernelSlice$1 as KernelSlice, LifecycleChanged, ModelCommitted, MusicDescriptor, MusicMode, MusicOptions, MusicRequest, MusicSwitch, MusicTrack, RetiringTrack, SceneChanged, SfxRequest, SoundEntry, State$1 as State, StreamTrack, Volumes };
+  export { AssetsReplaced, AudioApi, AudioContextLike, AudioCtx, AudioSessionLike, AudioSessionType, BundleUnloaded, Bus, BusState, Config$1 as Config, Deps$1 as Deps, KernelSlice$1 as KernelSlice, LifecycleChanged, ModelCommitted, MusicDescriptor, MusicMode, MusicOptions, MusicRequest, MusicSwitch, MusicTrack, RetiringTrack, SceneChanged, SfxRequest, SoundEntry, State$1 as State, StreamTrack, Volumes };
 }
 /**
  * The three volume buses. `master` carries the whole game, `music` the scene track, `sfx` every
@@ -1623,7 +1627,7 @@ type State$1 = {
   paused: boolean;
   unlocked: boolean; /** A gesture called `resume()` and it has not settled yet. */
   resuming: boolean; /** Sounds fired while `resuming`, one per key; played when the context runs, dropped when it does not. */
-  pendingSfx: Map<string, SfxRequest>; /** Per key, evicted per key on `assets:bundle-unloaded`. */
+  pendingSfx: Map<string, SfxRequest>; /** Per key, evicted per key on `assets:bundle-unloaded` and `assets:replaced`. */
   decoded: Map<string, Promise<AudioBuffer>>; /** Asset keys that already got their one warning. */
   warned: Set<string>; /** `config.volumes` threw once and was reported; it is not reported again this run. */
   warnedVolumes: boolean;
@@ -1783,6 +1787,10 @@ type LifecycleChanged = Events$3["lifecycle:changed"];
  * Payload of the `assets:bundle-unloaded` hook: `keys` names every decoded sound that is gone.
  */
 type BundleUnloaded = Events$4["assets:bundle-unloaded"];
+/**
+ * Payload of the `assets:replaced` hook: `keys` names every asset a dev hot swap gave new bytes.
+ */
+type AssetsReplaced = Events$4["assets:replaced"];
 /**
  * What one play of a sound asks for: the key and the bus the sound goes to.
  */

package/dist/visual.d.mts

@@ -1,9 +1,9 @@
-import { A as Api$1, h as Api, ln as Api$3, qt as Api$2 } from "./types-ZQLYXo5X.mjs";
-import { r as UiApi, x as AnimApi } from "./types-D_2G6Q68.mjs";
-import { A as InputApi } from "./types-BrTpz9oL.mjs";
-import { r as Repro } from "./headless-G4nuZ-xz.mjs";
-import { a as InputOf, r as ControlApp } from "./types-DAdwEJMp.mjs";
-import { t as commands } from "./commands-DvFr8Uwp.mjs";
+import { A as Api$1, h as Api, ln as Api$3, qt as Api$2 } from "./types-BSMmnpFm.mjs";
+import { r as UiApi, x as AnimApi } from "./types-dJMOXXL3.mjs";
+import { A as InputApi } from "./types-Dm5Oh5bH.mjs";
+import { r as Repro } from "./headless-CYgYzro0.mjs";
+import { a as InputOf, r as ControlApp } from "./types-Bonifz5M.mjs";
+import { t as commands } from "./commands-DRhJ_LIH.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */

package/dist/visual.mjs

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