@moku-labs/game 0.14.11 → 0.14.13

package/dist/{index-0GIP3tgm.d.mts → index-DedbED3T.d.mts}

@@ -1,7 +1,6 @@
-import { $ as DescriptionNode, A as Api$6, B as ComponentType, Et as FeatureDescription, Ft as SceneIdOf, G as Mut, Gt as State$2, J as QueryTerm, Jt as Config$5, K as Narrowed, Lt as Descriptor, N as State$8, Qt as State$5, R as ComponentHandle, Rt as GuideOptions, Sn as Require, Ut as Config$2, V as ComponentValue, Vt as Api$1, X as SystemDefinition, Xt as Json, Y as ResourceType, Z as TagType, Zt as Root, _n as State$7, a as Config$1, at as NumericFields, bn as Config$9, c as LoadBundles, d as State$1, dn as Events, dt as Api$2, en as Patch, et as Ease, f as Tier, fn as PauseReason, ft as BundlesOf, g as Config$6, gn as Config$7, gt as GameTypes, h as Api$4, hn as Api$5, ht as FeaturePlugin, i as BundleSpec, j as Config$8, k as ViewportSize, kt as DefineNode, l as LoadReason, ln as Api$3, mt as EmitterIdOf, o as DefineBundles, on as StoreApi, ot as ProjectionMotion, pn as State$4, pt as Config$3, r as BundleMap, sn as RngApi, st as ProjectionSpec, t as Api, un as Config$4, vt as State$3, x as State$6, xn as Events$1, xt as defineFlow, yt as TextStylesOf, zt as Hint } from "./types-BT9S_Lo2.mjs";
-import { A as SfxDescriptor, C as Config$10, D as Target, E as State$9, N as defineAnimation, S as AnimPlayerValue, T as MotionKeyframe, _ as SceneSpec, a as AudioApi, c as MusicDescriptor, d as State$10, g as SceneDefinition, h as LayerMap, j as Step, k as HapticKind, l as MusicOptions, m as DefineScene, n as State$12, p as AnySceneProjection, r as UiApi, s as Config$11, t as Config$12, v as ScenesApi, w as FramesValue, x as AnimApi, y as State$11, z as play } from "./types-kNiV7iFj.mjs";
-import { _ as NoiseValue, c as EmitterValue, d as ColorMatrixValue, f as DisplacementValue, g as GlowValue, h as FilterValueOf, i as State$13, l as AlphaValue, m as FilterSpec, n as EffectsApi, o as EmitterConfig, p as FilterComponent, s as EmitterDefinition, t as Config$13, u as BlurValue, v as OutlineValue, y as UniformDeclaration } from "./types-DMoi447V.mjs";
-import { A as InputApi, B as SpriteOptions, E as TextValue, F as NineSliceValue, G as Argument, J as IntlKit, K as Config$14, O as defineComponent, Q as TypedTr, R as ShapeValue, S as TextBind, T as TextStyles, U as TransformValue, V as SpriteValue, W as sprite, X as Part, Y as Message, Z as State$14, _ as Config$16, b as State$16, et as IsFlags, f as defineTokens, g as BindOptions, h as BindField, it as WhenFlags, j as State$15, k as Config$15, nt as Style, p as IntrinsicElementsFor, q as I18nApi, s as PopupComponent, tt as ResolvedStyle, v as CountdownValue, w as TextStyleInput, x as TextApi, y as Point } from "./types-BZa187kz.mjs";
+import { An as defineFlow, Ar as Api$5, Bn as DefineNode, Br as Require, Bt as Config$8, C as State$7, Cn as EmitterIdOf, Dn as State$3, Dr as PauseReason, E as Config$6, Er as Events, Et as NineSliceValue, Fn as FeatureDescription, Fr as ThermalReading, H as FrameRing, Ht as State$9, In as FeaturePlugin, It as TransformValue, Jn as Descriptor, Kn as SceneIdOf, Ln as FeatureTree, Lt as sprite, N as State$6, Nr as RateChange, Nt as SpriteOptions, On as TextStylesOf, Or as State$4, Ot as OverlayValue, Pr as State$8, Pt as SpriteValue, Qn as Hint, Rr as Config$9, S as ScenesApi, Sn as Config$3, Sr as RngApi, T as Api$4, Tn as HudKeysOf, Tr as Config$4, V as FrameRecord, Xn as EffectOptions, Xt as ComponentValue, Yn as Effect, Yt as ComponentType, Zn as GuideOptions, _ as DefineScene, a as Config$1, an as SystemFor, ar as State$2, b as SceneDefinition, bn as Api$2, bt as ViewportSize, c as LoadBundles, cn as DescriptionNode, cr as Config$5, dr as Root, en as Mut, er as Answer, f as State$1, fr as State$5, g as AnySceneProjection, gn as ReducedMotion, hn as ProjectionSpec, i as BundleSpec, in as SystemDefinition, jr as Config$7, jt as ShapeValue, l as LoadReason, ln as Ease, mn as ProjectionMotion, mr as Patch, nn as QueryTerm, o as DefineBundles, on as TagType, p as Tier, pn as NumericFields, qt as ComponentHandle, r as BundleMap, rn as ResourceType, rr as Config$2, t as Api, tn as Narrowed, tr as Api$1, u as LoadResult, ur as Json, wn as GameTypes, wr as Api$3, wt as HudPartValue, x as SceneSpec, xn as BundlesOf, xr as StoreApi, y as LayerMap, zr as Events$1, zt as Api$6 } from "./types-BGcda5Le.mjs";
+import { A as GlowValue, B as Target, C as BlurValue, D as FilterComponent, F as AnimPlayerValue, H as HapticKind, I as Config$10, K as defineAnimation, L as FramesValue, M as OutlineValue, N as UniformDeclaration, O as FilterSpec, P as AnimApi, Q as play, R as MotionKeyframe, S as AlphaValue, T as DisplacementValue, U as SfxDescriptor, W as Step, _ as State$12, a as AudioApi, b as EmitterDefinition, c as MusicDescriptor, ct as OverlayApi, d as State$11, f as VolumesFor, h as EffectsApi, j as NoiseValue, k as FilterValueOf, l as MusicOptions, m as Config$12, n as State$13, r as UiApi, s as Config$11, t as Config$13, w as ColorMatrixValue, x as EmitterValue, y as EmitterConfig, z as State$10 } from "./types-GHE4J5Uf.mjs";
+import { A as Config$15, B as State$14, C as TextBind, D as TextValue, E as TextStyles, F as Config$14, G as IsFlags, H as TextKey, I as I18nApi, K as ResolvedStyle, L as IntlKit, M as State$15, P as Argument, R as Message, S as TextApi, T as TextStyleInput, U as TypedTr, Y as WhenFlags, _ as BindOptions, b as Point, g as BindField, j as InputApi, k as defineComponent, m as IntrinsicElementsFor, p as defineTokens, q as Style, s as PopupComponent, v as Config$16, x as State$16, y as CountdownValue, z as Part } from "./types-7GXcXxxv.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -151,7 +150,7 @@ type ProjectionFor<Player, Session> = <const LayerName extends string, const Lif
  * app.anim.play(coinsFly, { from: purse, to: counter }).marks(); // []: the first frame is next
  * ```
  */
-declare const animPlugin: import("@moku-labs/core").PluginInstance<"anim", Config$10, State$9, AnimApi, {
+declare const animPlugin: import("@moku-labs/core").PluginInstance<"anim", Config$10, State$10, AnimApi, {
   "anim:mark": {
     animation: string;
     mark: string;
@@ -193,7 +192,7 @@ declare const assetsPlugin: import("@moku-labs/core").PluginInstance<"assets", C
     bundle: string;
     tier: Tier;
     mb: number;
-    reason: "budget" | "request";
+    reason: "budget" | "request" | "leave";
     keys: readonly string[];
   };
   "assets:replaced": {
@@ -210,13 +209,14 @@ declare const assetsPlugin: import("@moku-labs/core").PluginInstance<"assets", C
  * @example
  * ```ts
  * // A game composes it next to the screen set and points it at the player's settings.
+ * // `volumes` comes from the game's `defineGame` kit, so `player` is the game's Player.
  * createApp({
  *   plugins: [...screen, audioPlugin, settingsFeature],
- *   pluginConfigs: { audio: { volumes: player => player.settings.audio } }
+ *   pluginConfigs: { audio: { volumes: volumes(player => player.settings.audio) } }
  * });
  * ```
  */
-declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Config$11, State$10, AudioApi, {}> & Record<never, never>;
+declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Config$11, State$11, AudioApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/clock/index.d.ts
 /**
@@ -233,10 +233,24 @@ declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Con
  */
 declare const clockPlugin: import("@moku-labs/core").PluginInstance<"clock", Config$2, State$2, Api$1, {}> & Record<never, never>;
 //#endregion
+//#region src/plugins/debug/index.d.ts
+/**
+ * Debug plugin: `app.debug.overlay.open()`, `close()`, `toggle()`, `isOpen()`.
+ *
+ * @example
+ * ```ts
+ * app.debug.overlay.open({ mode: "pill" }); // true on a debug build, false on the store build
+ * ```
+ */
+declare const debugPlugin: import("@moku-labs/core").PluginInstance<"debug", Record<string, never>, Record<string, never>, {
+  overlay: OverlayApi;
+}, {}> & Record<never, never>;
+//#endregion
 //#region src/plugins/effects/index.d.ts
 /**
- * Effects plugin: `app.effects.stats()`; the `Emitter` component and every filter component do
- * the rest as data on entities.
+ * Effects plugin: `app.effects.stats()` and the switches of a debug build,
+ * `app.effects.diagnostics`; the `Emitter` component and every filter component do the rest as
+ * data on entities.
  *
  * @example
  * ```ts
@@ -248,7 +262,7 @@ declare const clockPlugin: import("@moku-labs/core").PluginInstance<"clock", Con
  * app.effects.stats(); // { particles: 0, emitters: 0, filters: 0, renderPasses: 0 }: nothing runs before start
  * ```
  */
-declare const effectsPlugin: import("@moku-labs/core").PluginInstance<"effects", Config$13, State$13, EffectsApi, {}> & Record<never, never>;
+declare const effectsPlugin: import("@moku-labs/core").PluginInstance<"effects", Config$12, State$12, EffectsApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/flow/index.d.ts
 /**
@@ -304,6 +318,12 @@ declare const flowPlugin: import("@moku-labs/core").PluginInstance<"flow", Confi
  * });
  *
  * await app.i18n.setLocale("en"); // text re-resolves every message on i18n:locale-changed
+ *
+ * // A sub-feature registers its own modules lazily: they arrive with the bundle "ep01".
+ * export const ep01Feature = defineFeature("ep01", {
+ *   strings: { en: () => import("@generated/strings.ep01.en") }
+ * });
+ * await app.assets.load("ep01"); // resolves after strings.ep01 of the loaded locales arrived
  * ```
  */
 declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Config$14, State$14, I18nApi, {
@@ -568,9 +588,17 @@ declare const rendererPlugin: import("@moku-labs/core").PluginInstance<"renderer
  * });
  *
  * export const awaitIntent = defineNode({ scene: "board", rest: true, outcomes: { merge: type() } });
+ *
+ * // A scene whose art depends on the session: mounted once "location" and the episode are in.
+ * export const wardScene = defineScene("ward", {
+ *   bundle: "location",
+ *   bundles: ({ session }) => [session.episode],
+ *   layers: { room: {} },
+ *   projections: [wardRoom]
+ * });
  * ```
  */
-declare const scenesPlugin: import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$11, ScenesApi, {
+declare const scenesPlugin: import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$7, ScenesApi, {
   "scenes:changed": {
     from: string | undefined;
     to: string;
@@ -610,13 +638,16 @@ declare const textPlugin: import("@moku-labs/core").PluginInstance<"text", Confi
  * });
  * ```
  */
-declare const timePlugin: import("@moku-labs/core").PluginInstance<"time", Config$7, State$7, Api$5, {}> & Record<never, never>;
+declare const timePlugin: import("@moku-labs/core").PluginInstance<"time", Config$7, State$8, Api$5, {
+  "time:thermal": ThermalReading;
+  "time:rate": RateChange;
+}> & Record<never, never>;
 //#endregion
 //#region src/plugins/ui/index.d.ts
 /**
  * Ui plugin: `app.ui.tree()`, `app.ui.find(...)`, `app.ui.lint()`, `app.ui.fill(...)`, the
- * text field `<input local>`, the components `Box` and
- * `LocalWrite`, and the helpers `defineComponent`, `defineStyle`, `defineTokens` and `popup`.
+ * text field `<input local>`, the components `Box`, `LocalWrite` and
+ * `DebugTrigger`, and the helpers `defineComponent`, `defineStyle`, `defineTokens` and `popup`.
  *
  * @example
  * ```ts
@@ -627,7 +658,7 @@ declare const timePlugin: import("@moku-labs/core").PluginInstance<"time", Confi
  * app.input.tap(app.ui.find("claim") ?? 0);
  * ```
  */
-declare const uiPlugin: import("@moku-labs/core").PluginInstance<"ui", Config$12, State$12, UiApi, {}> & Record<never, never>;
+declare const uiPlugin: import("@moku-labs/core").PluginInstance<"ui", Config$13, State$13, UiApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/world/index.d.ts
 /**
@@ -643,7 +674,7 @@ declare const uiPlugin: import("@moku-labs/core").PluginInstance<"ui", Config$12
  * app.world.projection.entityOf("board.items", "i7"); // 1048576
  * ```
  */
-declare const worldPlugin: import("@moku-labs/core").PluginInstance<"world", Config$8, State$8, Api$6, {
+declare const worldPlugin: import("@moku-labs/core").PluginInstance<"world", Config$8, State$9, Api$6, {
   "world:reconciled": {
     mode: "play" | "direct";
     projections: number;
@@ -661,12 +692,15 @@ declare const worldPlugin: import("@moku-labs/core").PluginInstance<"world", Con
 /**
  * Turns a feature description into a plugin that registers it with `flow.features` in `onInit`.
  * Throws for a name that is reserved or already a plugin. The plugin carries `logicOnly`: the
- * same plugin built from the V1 keys of the description, for headless tests.
+ * same plugin built from the V1 keys of the description, for headless tests. A feature that
+ * declares `features` is a parent: its `onInit` throws when one of them is not composed. The
+ * plugin carries them in `features`, its `logicOnly` carries their `logicOnly`.
  *
  * @param name - Feature name. Shares the namespace with plugin names.
- * @param description - What the feature brings: nodes, flows, slot contributions.
+ * @param description - What the feature brings: nodes, flows, slot contributions, sub-features.
  * @returns The feature plugin, with its `logicOnly` twin.
- * @throws {Error} When the name is reserved or belongs to an engine plugin.
+ * @throws {Error} When the name is reserved or belongs to an engine plugin, and for an entry of
+ *   `features` that `defineFeature` did not make.
  * @example
  * ```ts
  * // The reward popup is a feature: the main flow only declares slot("afterOrder").
@@ -674,10 +708,31 @@ declare const worldPlugin: import("@moku-labs/core").PluginInstance<"world", Con
  *   flows: [rewardFlow],
  *   contribute: { afterOrder: { flow: rewardFlow, order: 10 } }
  * });
- * createApp({ plugins: [rewardFeature] }); // a headless test passes rewardFeature.logicOnly
+ * // features/episodes/index.ts: a parent declares its sub-features, each a feature of its own.
+ * export const episodesFeature = defineFeature("episodes", { features: [kitFeature, ep01Feature] });
+ * episodesFeature.features.map(child => child.name); // ["kit", "ep01"]
  * ```
  */
 declare function defineFeature(name: string, description: FeatureDescription): FeaturePlugin;
+/**
+ * Turns a list of features into the flat plugin list `createApp` takes: every feature followed by
+ * its sub-features, depth-first, in declaration order. `defineGameApp` does it for `features` and
+ * `headless.features`; a raw `createApp` calls it. A `logicOnly` tree flattens the same way. A
+ * flat list comes back unchanged.
+ *
+ * @param list - Features as the game lists them: full plugins, or their `logicOnly`.
+ * @returns A new array; the input is not touched.
+ * @throws {Error} When an entry at any depth is not a feature: a cast, or a plugin that
+ *   `defineFeature` did not make.
+ * @example
+ * ```ts
+ * // A test composes the game without defineGameApp: the parent first, then its sub-features.
+ * const plugins = flattenFeatures([homeFeature, episodesFeature]);
+ * plugins.map(plugin => plugin.name); // ["home", "episodes", "kit", "ep01", "ep02"]
+ * createApp({ plugins: [...screen, ...plugins], pluginConfigs: { flow: { mainFlow } } });
+ * ```
+ */
+declare function flattenFeatures(list: readonly FeatureTree[]): FeatureTree[];
 //#endregion
 //#region src/plugins/flow/fx/descriptors.d.ts
 /**
@@ -709,7 +764,7 @@ declare function hint(kind: string, payload?: Json): Hint;
  * await fx(schedule(undefined)); // payload: {}, the pending timer is cancelled
  * ```
  */
-declare function schedule(moment: number | undefined): Descriptor;
+declare function schedule(moment: number | undefined): Descriptor<void>;
 /**
  * Creates the tutorial descriptor: it narrows the gate to one answer until the node exits. Its
  * visual part (`target`, highlight, hand, text) is drawn by `ui`, which dims the screen and cuts
@@ -726,7 +781,55 @@ declare function schedule(moment: number | undefined): Descriptor;
  * // app.flow.gate.answer({ intent: "cancel" }) is false until the node exits
  * ```
  */
-declare function guide(options: GuideOptions): Descriptor;
+declare function guide(options: GuideOptions): Descriptor<void>;
+//#endregion
+//#region src/plugins/flow/fx/effect.d.ts
+/**
+ * Declares an effect whose handler runs in a fast walk too: `await fx(effect(payload))` resolves
+ * `Result`. `fast: "run"` is the promise of the effect's owner: its handler is registered with
+ * `runInFast` and in every app that awaits the effect, the headless app of the tests included. An
+ * app with no handler for the kind still resolves `undefined`, which this type does not show.
+ *
+ * @param kind - The effect kind, as `fx.handle` and the journal name it.
+ * @param options - How it behaves.
+ * @param options.fast - `"run"`: the handler also runs in a fast walk.
+ * @param options.cosmetic - Not set or `false`: a cosmetic effect may resolve `undefined`.
+ * @returns The descriptor constructor with `kind` and `handle`.
+ * @example
+ * ```ts
+ * // shared/effects.ts of a game: the page read, typed once.
+ * export const envRead = defineEffect<{ notice: boolean }, { reducedMotion: boolean; saveFallback: boolean }>(
+ *   "view-env.read",
+ *   { fast: "run" }
+ * );
+ * // In a node: no guard any more.
+ * const env = await fx(envRead({ notice: true })); // { reducedMotion: false, saveFallback: true }
+ * // In the plugin that owns it, at its start:
+ * const off = envRead.handle(ctx.require(flowPlugin).fx, payload => readPage(payload.notice));
+ * ```
+ */
+declare function defineEffect<Payload extends Json | void, Result>(kind: string, options: {
+  fast: "run";
+  cosmetic?: false;
+}): Effect<Payload, Result, Result>;
+/**
+ * Declares an effect that may resolve `undefined`: `await fx(effect(payload))` resolves
+ * `Result | undefined`, because a fast walk skips its handler, or a cosmetic effect whose handler
+ * failed resolves `undefined`.
+ *
+ * @param kind - The effect kind, as `fx.handle` and the journal name it.
+ * @param options - How it behaves.
+ * @param options.fast - `"skip"` (the default): the handler does not run in a fast walk.
+ * @param options.cosmetic - `true`: a handler error never reaches the node.
+ * @returns The descriptor constructor with `kind` and `handle`.
+ * @example
+ * ```ts
+ * // shared/effects.ts of a game: a confetti burst, nothing a fast walk needs.
+ * export const confetti = defineEffect<{ cell: string }, void>("board.confetti", { cosmetic: true });
+ * confetti({ cell: "c3" }); // { kind: "board.confetti", payload: { cell: "c3" }, cosmetic: true }
+ * ```
+ */
+declare function defineEffect<Payload extends Json | void, Result>(kind: string, options?: EffectOptions): Effect<Payload, Result, Result | undefined>;
 //#endregion
 //#region src/plugins/world/ecs/define.d.ts
 /**
@@ -842,6 +945,53 @@ declare const Exiting: TagType;
 declare const Tree: ComponentType<{
   node: DescriptionNode;
 }>;
+/**
+ * The moment of the frame on the game's clock: `clock.now()`, read by `world` once at the start of
+ * every frame (before the systems of `input`) and once when the world starts, headless too. It is
+ * the moment a node gets as `now`, so a fake clock makes it exact in tests. A system that shows
+ * time reads it and writes its component only when its picture changes; with `renderer.onDemand`
+ * that is when a frame is drawn. A write by a system is overwritten at the next frame. `0` only
+ * before the world started, and after `ecs.clear()` until the next frame. `"Now"` is an engine
+ * resource name: a game resource of that name is refused.
+ *
+ * @example
+ * ```ts
+ * // A toast shows the seconds left of its energy timer: it is written once a second, not every frame.
+ * const toastTime = system({
+ *   name: "shared.toastTime",
+ *   phase: "animate",
+ *   query: [ToastTime],
+ *   run: (rows, { world, res }) => {
+ *     const { now } = res(Now); // 1_790_000_016_000: the fake clock of the test stands there
+ *     for (const [entity, time] of rows) {
+ *       const left = Math.max(0, time.until - now);
+ *       if (Math.ceil(left / 1000) !== Math.ceil(time.left / 1000)) world.set(entity, ToastTime, { left });
+ *     }
+ *   }
+ * });
+ * app.world.ecs.resource(Now).now; // 1_790_000_016_000
+ * ```
+ */
+declare const Now: ResourceType<{
+  now: number;
+}>;
+//#endregion
+//#region src/plugins/renderer/monitor/ring.d.ts
+/**
+ * One slot of the ring as a plain record, `age` 0 the newest frame; `undefined` beyond the frames held. Allocates: for
+ * tests and tools, never per frame. A root export.
+ *
+ * @param ring - The ring of `monitor.frames()`.
+ * @param age - Frames back from the newest.
+ * @returns The record, or `undefined`.
+ * @example
+ * ```ts
+ * // A test of a debug build checks the frame that a sheet opened in.
+ * frameAt(app.renderer.monitor.frames(), 0)?.passes; // 3
+ * frameAt(app.renderer.monitor.frames(), 5000); // undefined: the ring holds 1024
+ * ```
+ */
+declare function frameAt(ring: FrameRing, age: number): FrameRecord | undefined;
 //#endregion
 //#region src/plugins/input/components.d.ts
 /**
@@ -860,25 +1010,38 @@ type IntentValue = {
 /**
  * A view that can be carried. It names no intent: the drop target does. `carry` lists the
  * projection keys of views of the same projection that ride along on top of it, such as the cards
- * that lie on a solitaire card.
+ * that lie on a solitaire card. `aim` is a point of the view in its own units, the units of its
+ * hit box: with it the hover and the drop look the target up under that point of the view in the
+ * hand, not under the finger. Absent, the default, or `null`, it looks under the finger; a
+ * projection takes an aim away by not giving it. Absent by default, so a view without an aim is
+ * stored and serialised exactly as before the aim existed.
  *
  * @example
  * ```ts
  * const value: CarryValue = { payload: { from: "c7" }, carry: ["c8", "c9"] };
+ * // A board item whose picture is lifted above the finger: the drop goes to the cell under the picture.
+ * const lifted: CarryValue = { payload: { from: "c7" }, carry: [], aim: { x: 25, y: 12 } };
  * ```
  */
 type CarryValue = {
   payload: Json;
-  carry: readonly string[];
+  carry: readonly string[]; /** A point of the view in the hand, in its own units, that aims the drop; absent (the default) or `null` aims with the finger. */
+  aim?: {
+    x: number;
+    y: number;
+  } | null;
 };
 /**
  * Where the one pointer is, in reference units. `justPressed` and `justReleased` are true for
- * exactly one frame.
+ * exactly one frame. `id` is the `pointerId` of the pointer the gesture machine follows, `-1` when
+ * it follows none. It changes while `down` stays true when a resting finger (pressed, not moved
+ * past the tap slop, no long press, no trace) gives way to another finger: a system that measures
+ * the finger's travel from frame to frame starts over then.
  *
  * @example
  * ```ts
  * const value: PointerValue = {
- *   x: 540, y: 960, down: true, justPressed: false, justReleased: false
+ *   x: 540, y: 960, down: true, justPressed: false, justReleased: false, id: 3
  * };
  * ```
  */
@@ -887,7 +1050,8 @@ type PointerValue = {
   y: number;
   down: boolean;
   justPressed: boolean;
-  justReleased: boolean;
+  justReleased: boolean; /** The `pointerId` the resource follows; `-1` at rest. */
+  id: number;
 };
 /**
  * A tap on this view answers `{ intent, payload }`.
@@ -899,7 +1063,8 @@ declare const Tappable: ComponentType<IntentValue>;
 declare const Pressable: ComponentType<IntentValue>;
 /**
  * This view can be carried by the finger. It names no intent; the drop target does. The views
- * whose keys `carry` lists hang under it from the grab to the release and fly home with it.
+ * whose keys `carry` lists hang under it from the grab to the release and fly home with it. With
+ * an `aim`, the hover and the drop are looked up under that point of the view in the hand.
  */
 declare const Draggable: ComponentType<CarryValue>;
 /**
@@ -948,7 +1113,8 @@ declare const Pressed: TagType;
  */
 declare const PointerOver: TagType;
 /**
- * Where the one pointer is, in reference units. Written once per frame by the frame step.
+ * Where the one pointer is, in reference units. Written once per frame by the frame step. `id`
+ * names the pointer it follows, `-1` at rest.
  */
 declare const Pointer: ResourceType<PointerValue>;
 //#endregion
@@ -958,44 +1124,53 @@ declare const Pointer: ResourceType<PointerValue>;
  * object cannot reach the scanner or the plugin. `defineGame` returns this helper typed by the
  * game's `BundleKey`, so a name the scanner never saw does not compile.
  *
- * @param map - Bundle name to its tier and, when it is a split bundle, its globs.
+ * @param map - Bundle name to its tier and, when it is a split bundle, its globs; its release
+ *   and its mipmaps when it declares them.
  * @returns The bundle map as plain data.
  * @example
  * ```ts
- * // features/board/assets.ts of a game: the board is a scene bundle, the chains load on demand.
+ * // features/board/assets.ts of a game: the board is a scene bundle, the chains load on demand
+ * // and leave with the board.
  * export const boardAssets = defineBundles({
  *   board: { tier: "scene" },
- *   "board.chains": { tier: "lazy", files: ["chains/*.png"] }
+ *   "board.chains": { tier: "lazy", files: ["chains/*.png"], release: "leave" }
  * });
  * ```
  */
 declare function defineBundles<Key extends string>(map: Partial<Record<Key, BundleSpec>>): BundleMap<Key>;
 /**
  * Creates the awaited effect that loads one or more bundles. The handler of the kind `"load"` is
- * registered by this plugin and runs in fast mode too, so a fast walk really loads.
+ * registered by this plugin and runs in fast mode too, so a fast walk really loads. It resolves
+ * `undefined` in an app without `assets`, such as the headless app of `game.headless()`.
  *
  * @param bundle - One bundle name, or a list of them in load order.
  * @returns The descriptor a loading node awaits.
  * @example
  * ```ts
  * // A loading node of a game: one bundle per turn, so the screen can draw progress.
- * await fx(load("board.chains")); // { loaded: ["board.chains"], mb: 1.25 }
+ * const loaded = await fx(load("board.chains")); // { loaded: ["board.chains"], mb: 1.25 }
+ * // undefined in an app without assets, such as the headless app of game.headless()
  * await fx(load(["board", "ui"])); // both, in that order
  * ```
  */
-declare function load(bundle: string | readonly string[]): Descriptor;
+declare function load(bundle: string | readonly string[]): Descriptor<LoadResult | undefined>;
 //#endregion
 //#region src/plugins/scenes/define.d.ts
 /**
  * Declares a scene: a bundle, named layers in draw order, the projections it mounts and optional
- * music. A layer `ui` is appended for the HUD and the popups unless the scene declares one. The
+ * music. A layer `ui` is appended for the HUD and the popups unless the scene declares one; a scene
+ * whose layer says `above: "overlays"` (its HUD layer, drawn above every overlay) gets `ui` right under it. The
  * layer names come from the keys of `layers` and that `ui`, so a projection whose `layer` or
  * `lift` is not among them does not compile — and throws here for a caller without types.
+ * `bundles` names bundles that depend on the committed state: the scene is mounted once those
+ * are in too.
  *
  * @param id - Id of the scene. A node names it with `defineNode({ scene: id })`.
- * @param scene - The bundle, the layers, the projections and the optional music key.
+ * @param scene - The bundle, the optional bundles of state, the layers, the projections and the
+ *   optional music key.
  * @returns The scene as frozen data, ready for the `scenes` key of a feature.
- * @throws {Error} For an integer-like layer name, and for a `layer` or `lift` that is not declared.
+ * @throws {Error} For an integer-like layer name, for a `layer` or `lift` that is not declared, for two HUD layers,
+ *   an `above` other than `"overlays"`, and a `ui` declared after the HUD layer.
  * @example
  * ```ts
  * // features/board/view/scene.ts of a game.
@@ -1006,10 +1181,23 @@ declare function load(bundle: string | readonly string[]): Descriptor;
  * });
  *
  * boardScene.layers[2]; // { name: "items", sort: "y" }
- * boardScene.layers[4]; // { name: "ui", sort: "none" }, appended for the HUD
+ * boardScene.layers[4]; // { name: "ui", sort: "order" }, appended for the HUD
+ *
+ * // A HUD layer above every overlay: `ui` goes right under it.
+ * defineScene("ward", { bundle: "ui", layers: { scene: {}, hud: { above: "overlays" } }, projections }).layers;
+ * // [{ name: "scene", sort: "none" }, { name: "ui", sort: "order" }, { name: "hud", sort: "none", above: "overlays" }]
+ *
+ * // features/location/view/ward.ts: the room is the art of the episode the session plays.
+ * export const wardScene = defineScene("ward", {
+ *   bundle: "location",
+ *   bundles: ({ session }) => [session.episode], // "ep01" | "ep02": bundle keys of the game
+ *   layers: { room: {}, glow: {} },
+ *   projections: [wardRoom, wardGlows]
+ * });
+ * wardScene.bundles?.({ player: {}, session: { episode: "ep02" } }); // ["ep02"]
  * ```
  */
-declare function defineScene<Layers extends LayerMap, const Projections extends readonly AnySceneProjection[]>(id: string, scene: SceneSpec<Layers, Projections, string, string>): SceneDefinition;
+declare function defineScene<Layers extends LayerMap, const Projections extends readonly AnySceneProjection[], Player extends Json = Json, Session extends Json = Json>(id: string, scene: SceneSpec<Layers, Projections, string, string, Player, Session>): SceneDefinition;
 //#endregion
 //#region src/plugins/anim/components.d.ts
 /**
@@ -1082,6 +1270,10 @@ type MotionState = { readonly [Name in keyof MotionComponents]?: Readonly<Partia
  * Transform key is an offset from rest, and the last key repeats the first one. It is not part of
  * the motion `enter` returns.
  *
+ * `when` says when `enter` and `exit` play: `"always"` (the default) or only for a commit
+ * (`"change"`). `transition.reduced` and `loop.reduced` say what reduced motion does to their
+ * tracks: `"cut"` (the default) or `"keep"`.
+ *
  * @example
  * ```ts
  * const spec: MotionSpec = {
@@ -1098,6 +1290,14 @@ type MotionState = { readonly [Name in keyof MotionComponents]?: Readonly<Partia
  *   loop: { track: "sway", ms: 2400 },
  *   on: { enter: "small" }
  * };
+ * // A card that stands at rest when its board mounts and fades in when a commit adds it, also
+ * // under reduced motion.
+ * const newCard: MotionSpec = {
+ *   states: { faded: { Shape: { alpha: 0 } } },
+ *   transition: { ms: 220, reduced: "keep" },
+ *   on: { enter: "faded" },
+ *   when: "change"
+ * };
  * ```
  */
 type MotionSpec = {
@@ -1106,16 +1306,24 @@ type MotionSpec = {
   readonly transition?: {
     readonly ms?: number;
     readonly ease?: Ease;
+    readonly reduced?: ReducedMotion;
   };
   readonly loop?: {
     readonly track: string;
     readonly ms?: number;
+    readonly reduced?: ReducedMotion;
   };
   readonly on: {
     readonly enter?: string;
     readonly exit?: string;
     readonly change?: readonly (keyof MotionComponents & string)[];
   };
+  /**
+   * When `enter` and `exit` play: `"always"` (the default, as before) or only for a commit
+   * (`"change"`); with `"change"` an element that comes or goes with its screen stands at rest and
+   * leaves without a motion. The loop is not concerned.
+   */
+  readonly when?: "always" | "change";
 };
 /**
  * Builds the projection motion hooks of an element from named poses and keyframe tracks. The
@@ -1124,15 +1332,16 @@ type MotionSpec = {
  * the `loop` hook: `world` and `ui` play it wherever they play `enter`, so a projection view loops
  * from its enter, or from the first live frame after a direct reconcile, and `ui` swaps it when
  * the motion prop of an element changes. One cycle of the loop is `loop.ms`, or `transition.ms`
- * when it is left out.
+ * when it is left out. With `when: "change"` the enter and exit play only for a commit: an element
+ * that comes or goes with its screen stands at rest and leaves without a motion.
  *
  * @param spec - The named poses, the keyframe tracks, the transition, the loop and the hooks to
  *   build.
  * @returns The `enter`, `loop`, `exit` and `change` hooks. `settle` is left out: the default of
  *   `world` applies.
  * @throws {Error} When a track is invalid, a name is both a state and a track, `on` names
- *   neither, `loop.track` names no track, `loop.ms` is not a finite number above 0, or the loop
- *   ends somewhere else than it starts.
+ *   neither, `loop.track` names no track, `loop.ms` is not a finite number above 0, the loop
+ *   ends somewhere else than it starts, or `when` or a `reduced` is not one of its words.
  * @example
  * ```ts
  * const buttonMotion = defineMotion({
@@ -1141,6 +1350,14 @@ type MotionSpec = {
  *   on: { enter: "hidden", exit: "hidden", change: ["Transform"] }
  * });
  * buttonMotion.settle; // undefined
+ *
+ * const cardMotion = defineMotion({
+ *   states: { small: { Transform: { scale: 0.8 }, Shape: { alpha: 0 } } },
+ *   transition: { ms: 220, ease: "out" },
+ *   on: { enter: "small", exit: "small" },
+ *   when: "change"
+ * });
+ * // a scene mount shows it at rest; a commit that adds it grows it in over 220 ms
  * ```
  */
 declare function defineMotion(spec: MotionSpec): ProjectionMotion<unknown>;
@@ -1267,7 +1484,7 @@ declare function resolve(style: Style | undefined, flags: StyleFlags, viewport:
  * // music("board.theme") is { kind: "music", payload: { key: "board.theme" }, cosmetic: true }
  * ```
  */
-declare function music(key: string | null, options?: MusicOptions): Descriptor;
+declare function music(key: string | null, options?: MusicOptions): Descriptor<void>;
 //#endregion
 //#region src/plugins/effects/filters/builtins.d.ts
 /**
@@ -1356,26 +1573,36 @@ declare const Alpha: ComponentType<AlphaValue>;
 //#region src/plugins/effects/filters/define.d.ts
 /**
  * Turns a WGSL fragment body and its GLSL ES 3.0 twin into a filter component type; Pixi draws
- * the one of the running backend. To the WGSL the engine prepends the vertex stage, the input
+ * the one of the running backend. A still view under the filter is kept as a picture by the
+ * renderer (`cache`, default `"local"`); a body that needs its canvas position calls
+ * `canvasPixel(uv)`, and then the view can still be kept as a picture. To the WGSL the engine prepends the vertex stage, the input
  * bindings and a `FilterUniforms` struct in declaration order, bound as `fu`. To the GLSL it
  * prepends `#version 300 es`, `vTextureCoord`, `finalColor`, `uTexture`, the global filter
  * uniforms as `vec4` and one `uniform` per declared uniform under its bare name. Every number
  * uniform is a number field, so the existing `tween` drives it; a colour is one hex field sent as
  * a `vec3`; a tuple is an array field and not tweenable. Every filter component also carries
- * `enabled: true` and `order: 0`. Register it through the `filters` key of a feature.
+ * `enabled: true` and `order: 0`. An input `blur` gives the body `sampleBlur(uv)`: the last texture
+ * of its chain, read at the body's `uv`. A `fallback` draws instead when the filter is broken.
+ * An `area` answers, from the value, the rectangle in the entity's own units outside of which the
+ * filter draws nothing: Pixi then renders and fills only that box, not the view's bounds.
+ * Register it through the `filters` key of a feature. The README shows a filter with a blur input
+ * and one with an `area`.
  *
  * @param id - The filter id, also the component name; unique, and not one of the built-ins.
- * @param spec - Both bodies, the uniforms, the passes one apply costs and the padding.
+ * @param spec - Both bodies, the uniforms, the passes one apply costs, the padding, the inputs, the fallback, the
+ *   cache category and the area.
  * @returns The component type, with the frozen `filter` definition attached.
  * @throws {Error} When the id is empty, the WGSL has no `mainFragment`, the GLSL no `void main(`,
- *   a uniform is reserved, badly named or of no known form, or the passes or the padding break
- *   their rules.
+ *   a uniform is reserved, badly named or of no known form, the passes or the padding break
+ *   their rules, an input or the fallback breaks one of its rules, `passes` is given with inputs,
+ *   or `area` is not a function.
  * @example
  * ```ts
  * // features/board/effects.ts: a gold tint a motion hook tweens on a merge, on WebGPU and WebGL.
  * const Tint = defineFilter("fx.tint", { wgsl: tintWgsl, glsl: tintGlsl, uniforms: { amount: 0, color: { color: 0xffd700 } } });
  * Tint({ amount: 1 }).value; // { amount: 1, color: 0xffd700, enabled: true, order: 0 }
  * Tint.filter.glsl.includes("uniform vec3 color;"); // true
+ * Tint.filter.cache; // "local"
  * ```
  */
 declare function defineFilter<Uniforms extends Record<string, UniformDeclaration> = Record<never, never>>(id: string, spec: FilterSpec<Uniforms>): FilterComponent<FilterValueOf<Uniforms>>;
@@ -1429,7 +1656,10 @@ declare function defineEmitter(id: string, config: EmitterConfig): EmitterDefini
  * });
  * ```
  */
-declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<Config$9, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$7, State$7, Api$5, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$4, State$4, Api$3, {
+declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<Config$9, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$7, State$8, Api$5, {
+  "time:thermal": ThermalReading;
+  "time:rate": RateChange;
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$4, State$4, Api$3, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -1445,7 +1675,9 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
     roots: readonly Root[];
     cause: "edge" | "rollback" | "restore" | "load";
   };
-}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"clock", Config$2, State$2, Api$1, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$3, State$3, Api$2, {
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"clock", Config$2, State$2, Api$1, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"debug", Record<string, never>, Record<string, never>, {
+  overlay: OverlayApi;
+}, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$3, State$3, Api$2, {
   "flow:edge": {
     flow: string;
     node: string;
@@ -1469,7 +1701,10 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
     rolledBackTo: string;
     retry: boolean;
   };
-}> & Record<never, never>) | ExtraPlugins[number], [...ExtraPlugins], import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi>, import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>]>, import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi> | import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>> | undefined) => import("@moku-labs/core").App<Config$9, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$7, State$7, Api$5, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$4, State$4, Api$3, {
+}> & Record<never, never>) | ExtraPlugins[number], [...ExtraPlugins], import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi>, import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>]>, import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi> | import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>> | undefined) => import("@moku-labs/core").App<Config$9, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$7, State$8, Api$5, {
+  "time:thermal": ThermalReading;
+  "time:rate": RateChange;
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$4, State$4, Api$3, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -1485,7 +1720,9 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
     roots: readonly Root[];
     cause: "edge" | "rollback" | "restore" | "load";
   };
-}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"clock", Config$2, State$2, Api$1, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$3, State$3, Api$2, {
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"clock", Config$2, State$2, Api$1, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"debug", Record<string, never>, Record<string, never>, {
+  overlay: OverlayApi;
+}, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$3, State$3, Api$2, {
   "flow:edge": {
     flow: string;
     node: string;
@@ -1525,16 +1762,18 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
 declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<Config$9, Events$1, import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi>, import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>]>>;
 /**
  * Binds the authoring helpers to the types of one game: "createApp for a game". Each plugin binds
- * its own helpers (`flowFor`, `projectionFor`, `componentsFor`, `bundlesFor`, `scenesFor`); this
- * only spreads them, so the kit's type is inferred and never written by hand. At run time these
- * are the same functions and component objects the plugins export.
+ * its own helpers (`flowFor`, `projectionFor`, `systemsFor`, `componentsFor`, `bundlesFor`,
+ * `scenesFor`, `i18nFor`, `audioFor`); this only spreads them, so the kit's type is inferred and
+ * never written by hand. At run time these are the same functions and component objects the
+ * plugins export. The kit's `system` and `volumes` read the game's player and session; `key` types
+ * a string key written in code (a key that comes from data is checked with `app.i18n.isKey`).
  *
- * @returns The helpers typed with the game's `player`, `session`, `assets`, `bundles`, `strings`
- *   and `emitters`.
+ * @returns The helpers typed with the game's `player`, `session`, `assets`, `bundles`, `strings`,
+ *   `emitters` and `hud` (the HUD part keys of `HudPart` and `Overlay`).
  * @example
  * ```ts
  * // kit.ts of a game: bound once, imported by every node, flow and view file.
- * export const { defineNode, defineFlow, defineFeature, projection, sprite, Sprite, defineBundles, load, defineScene } =
+ * export const { defineNode, defineFlow, defineFeature, projection, system, sprite, Sprite, defineBundles, load, defineScene, tr, key, volumes } =
  *   defineGame<{ player: Player; session: Session; assets: AssetKey; bundles: BundleKey; strings: StringTable }>();
  * ```
  */
@@ -1550,12 +1789,13 @@ declare function defineGame<Types extends GameTypes>(): {
     map?: Types["assets"];
   }>;
   music: MusicDescriptor<Types["assets"]>;
+  volumes: VolumesFor<Types["player"]>;
   defineComponent: typeof defineComponent;
   defineStyle: <const Given extends Style<Types["assets"]>>(style: Given) => Readonly<Given>;
   defineTokens: typeof defineTokens;
-  popup: <Properties extends object, Local extends object>(component: PopupComponent<Properties, Local>, props: Properties, options?: {
+  popup: <Properties extends object, Local extends object, Outcomes extends Record<string, unknown>>(component: PopupComponent<Properties, Local, Outcomes>, props: Properties, options?: {
     over?: string;
-  }) => Descriptor;
+  }) => Descriptor<Answer<keyof Outcomes & string>>;
   intrinsics: IntrinsicElementsFor<Types["assets"], TextStylesOf<Types>, Extract<keyof Types["strings"], string>>;
   label: (options: Omit<LabelOptions, "style"> & {
     style: TextStylesOf<Types>;
@@ -1567,6 +1807,7 @@ declare function defineGame<Types extends GameTypes>(): {
     italic?: Types["assets"];
   }>) => TextStyles;
   tr: TypedTr<Types["strings"]>;
+  key: <const Key extends TextKey<Types["strings"]>>(key: Key) => Key;
   defineAnimation: typeof defineAnimation;
   frames: (target: Target, options: {
     keys: readonly Types["assets"][];
@@ -1580,7 +1821,7 @@ declare function defineGame<Types extends GameTypes>(): {
   Frames: Narrowed<FramesValue, Partial<Omit<FramesValue, "keys">> & {
     keys?: readonly Types["assets"][];
   }>;
-  defineScene: DefineScene<Types["assets"], BundlesOf<Types>>;
+  defineScene: DefineScene<Types["assets"], BundlesOf<Types>, Types["player"], Types["session"]>;
   defineBundles: DefineBundles<BundlesOf<Types>>;
   load: LoadBundles<BundlesOf<Types>>;
   sprite: (options: Omit<SpriteOptions, "texture"> & {
@@ -1592,6 +1833,13 @@ declare function defineGame<Types extends GameTypes>(): {
   NineSlice: Narrowed<NineSliceValue, Partial<Omit<NineSliceValue, "texture">> & {
     texture?: Types["assets"];
   }>;
+  Overlay: Narrowed<OverlayValue, Partial<Omit<OverlayValue, "hud">> & {
+    hud?: "all" | "none" | readonly HudKeysOf<Types>[];
+  }>;
+  HudPart: Narrowed<HudPartValue, {
+    key: HudKeysOf<Types>;
+  }>;
+  system: SystemFor<Types["player"], Types["session"]>;
   projection: ProjectionFor<Types["player"], Types["session"]>;
   defineNode: DefineNode<{
     player: Types["player"];
@@ -1610,7 +1858,7 @@ declare function defineGame<Types extends GameTypes>(): {
  * createApp({ plugins: [...screen, boardFeature], pluginConfigs: { renderer: { mount: "#game" } } });
  * ```
  */
-declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world", Config$8, State$8, Api$6, {
+declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world", Config$8, State$9, Api$6, {
   "world:reconciled": {
     mode: "play" | "direct";
     projections: number;
@@ -1643,20 +1891,20 @@ declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world"
     bundle: string;
     tier: Tier;
     mb: number;
-    reason: "budget" | "request";
+    reason: "budget" | "request" | "leave";
     keys: readonly string[];
   };
   "assets:replaced": {
     bundle: string;
     keys: readonly string[];
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$11, ScenesApi, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$7, ScenesApi, {
   "scenes:changed": {
     from: string | undefined;
     to: string;
     music: string | undefined;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"anim", Config$10, State$9, AnimApi, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"anim", Config$10, State$10, AnimApi, {
   "anim:mark": {
     animation: string;
     mark: string;
@@ -1668,6 +1916,6 @@ declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world"
   "i18n:locale-changed": {
     locale: string;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"text", Config$16, State$16, TextApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"ui", Config$12, State$12, UiApi, {}> & Record<never, never>];
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"text", Config$16, State$16, TextApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"ui", Config$13, State$13, UiApi, {}> & Record<never, never>];
 //#endregion
-export { defineFeature as $, Held as A, Traced as B, Animation as C, bind as Ct, load as D, defineBundles as E, Pressed as F, component as G, Layer as H, Swipeable as I, system as J, mut as K, Tappable as L, Pointer as M, PointerOver as N, Draggable as O, Pressable as P, schedule as Q, Touchable as R, AnimPlayer as S, Text as St, defineScene as T, label as Tt, Order as U, Exiting as V, Tree as W, guide as X, tag as Y, hint as Z, defineStyle as _, audioPlugin as _t, defineEmitter as a, rendererPlugin as at, messageDuration as b, projection as bt, Alpha as c, PlatformProvider as ct, Displacement as d, lifecyclePlugin as dt, worldPlugin as et, Glow as f, inputPlugin as ft, resolve as g, clockPlugin as gt, music as h, effectsPlugin as ht, screen as i, scenesPlugin as it, Hovered as j, DropTarget as k, Blur as l, types_d_exports as lt, Outline as m, flowPlugin as mt, createPlugin as n, timePlugin as nt, Emitter as o, platformPlugin as ot, Noise as p, i18nPlugin as pt, resource as q, defineGame as r, textPlugin as rt, defineFilter as s, BackResult as st, createApp as t, uiPlugin as tt, ColorMatrix as u, modelPlugin as ut, tr as v, assetsPlugin as vt, Frames as w, defineTextStyles as wt, defineMotion as x, Countdown as xt, messageArgument as y, animPlugin as yt, Traceable as z };
+export { guide as $, Held as A, label as At, Traced as B, Animation as C, assetsPlugin as Ct, load as D, Text as Dt, defineBundles as E, Countdown as Et, Pressed as F, Order as G, Exiting as H, Swipeable as I, mut as J, Tree as K, Tappable as L, Pointer as M, PointerOver as N, Draggable as O, bind as Ot, Pressable as P, defineEffect as Q, Touchable as R, AnimPlayer as S, audioPlugin as St, defineScene as T, projection as Tt, Layer as U, frameAt as V, Now as W, system as X, resource as Y, tag as Z, defineStyle as _, i18nPlugin as _t, defineEmitter as a, uiPlugin as at, messageDuration as b, debugPlugin as bt, Alpha as c, scenesPlugin as ct, Displacement as d, BackResult as dt, hint as et, Glow as f, PlatformProvider as ft, resolve as g, inputPlugin as gt, music as h, lifecyclePlugin as ht, screen as i, worldPlugin as it, Hovered as j, DropTarget as k, defineTextStyles as kt, Blur as l, rendererPlugin as lt, Outline as m, modelPlugin as mt, createPlugin as n, defineFeature as nt, Emitter as o, timePlugin as ot, Noise as p, types_d_exports as pt, component as q, defineGame as r, flattenFeatures as rt, defineFilter as s, textPlugin as st, createApp as t, schedule as tt, ColorMatrix as u, platformPlugin as ut, tr as v, flowPlugin as vt, Frames as w, animPlugin as wt, defineMotion as x, clockPlugin as xt, messageArgument as y, effectsPlugin as yt, Traceable as z };