@moku-labs/game 0.0.2 → 0.1.0

package/dist/index.d.mts

@@ -1,16 +1,17 @@
-import { $ as PauseReason, A as Config$4, B as types_d_exports$8, C as SceneIdOf, D as Hint, E as GuideOptions, F as Config$3, G as SaveUnreadableError, J as RngApi, L as Json, N as types_d_exports$12, R as Root, T as Descriptor, V as Patch, X as Api$2, Z as Config$2, _ as DefineNode, a as GameTypes, at as State, c as TextStylesOf, ct as Events, d as exit, et as State$2, f as slot, h as FeatureDescription, i as FeaturePlugin, j as State$4, k as Api$3, l as types_d_exports$4, m as type, n as BundlesOf, nt as Api, ot as types_d_exports$3, p as to, q as StoreApi, r as Config$1, rt as Config, s as State$1, st as Config$5, t as Api$1, tt as types_d_exports$7, u as defineFlow, z as State$3 } from "./types-JNc_UQBo.mjs";
-import { A as ComponentHandle, B as SystemDefinition, C as ProjectionSpec, F as Mut, I as Narrowed, M as ComponentValue, R as QueryTerm, S as ProjectionMotion, V as TagType, a as types_d_exports$9, d as Config$7, f as State$6, g as Ease, h as DescriptionNode, i as State$5, j as ComponentType, k as AnyComponentValue, l as ViewportSize, n as Config$6, p as types_d_exports$14, t as Api$4, u as Api$5, x as NumericFields, z as ResourceType } from "./types-BxkNNYul.mjs";
-import { a as DefineBundles, c as LoadReason, d as Tier, i as Config$8, n as BundleMap, p as types_d_exports$1, r as BundleSpec, s as LoadBundles, t as Api$6, u as State$7 } from "./types-DWILGrPn.mjs";
-import { A as Transform, B as types_d_exports$5, C as NineSliceValue, D as Sprite, E as ShapeValue, H as InputApi, I as I18nApi, L as Message, M as sprite, N as Argument, O as SpriteOptions, P as Config$9, R as State$8, S as NineSlice, T as Shape, U as State$9, V as Config$10, W as types_d_exports$6, _ as Style, b as defineComponent, d as popup, f as defineTokens, g as ResolvedStyle, h as IsFlags, j as TransformValue, k as SpriteValue, l as Box, p as IntrinsicElementsFor, s as PopupComponent, u as LocalWrite, w as Parent, x as Display, y as WhenFlags, z as TypedTr } from "./types-yg_ywtT-.mjs";
-import { a as Config$11, c as TextApi, d as TextValue, f as types_d_exports$11, i as types_d_exports$13, l as TextStyleInput, n as State$11, o as Point, r as UiApi, s as State$10, t as Config$12, u as TextStyles } from "./types-DD-QrG_z.mjs";
-import { a as Config$13, c as SlotValues, d as types_d_exports, f as ExternalPlayer, g as Step, h as SfxDescriptor, i as BuildTools, l as State$12, m as PlayDescriptor, n as AnimationDefinition, o as MotionKeyframe, p as HapticDescriptor, r as AnimationSpec, s as SlotTags, t as AnimApi, u as Target } from "./types-CTPS9GBu.mjs";
-import { c as AnySceneProjection, d as SceneDefinition, f as SceneSpec, h as types_d_exports$10, i as MusicOptions, l as DefineScene, m as State$14, n as Config$14, o as State$13, p as ScenesApi, r as MusicDescriptor, s as types_d_exports$2, t as AudioApi, u as LayerMap } from "./types-DYLnSgMI.mjs";
+import { $t as types_d_exports$3, At as Json, B as Mut, Bt as StoreApi, Ct as Config$6, D as ProjectionMotion, E as NumericFields, Et as types_d_exports$14, F as ComponentHandle, G as SystemDefinition, Gt as Events, I as ComponentType, J as BundlesOf, Jt as types_d_exports$8, K as TagType, Kt as PauseReason, L as ComponentValue, Mt as State$4, Nt as types_d_exports$9, O as ProjectionSpec, Ot as Config$4, Pt as Patch, Q as GameTypes, Qt as State$1, Rt as SaveUnreadableError, St as Api$4, U as QueryTerm, Ut as Api$2, V as Narrowed, Vt as RngApi, W as ResourceType, Wt as Config$3, X as EmitterIdOf, Xt as Config$1, Y as Config$2, Yt as Api, Z as FeaturePlugin, _ as State$7, at as slot, b as DescriptionNode, bt as Hint, c as types_d_exports$11, ct as FeatureDescription, en as Config$8, et as State$2, g as Config$7, gt as SceneIdOf, h as Api$5, it as exit, jt as Root, m as ViewportSize, n as Config$5, nn as Require, nt as types_d_exports$5, ot as to, q as Api$1, qt as State$3, rt as defineFlow, s as State$5, st as type, t as Api$3, tn as Events$1, tt as TextStylesOf, ut as DefineNode, v as types_d_exports$16, vt as Descriptor, wt as State$6, x as Ease, yt as GuideOptions } from "./types-BZ1OLf24.mjs";
+import { a as DefineBundles, c as LoadReason, d as Tier, i as Config$9, n as BundleMap, p as types_d_exports$1, r as BundleSpec, s as LoadBundles, t as Api$6, u as State$8 } from "./types-C47fKNcn.mjs";
+import { A as Transform, B as types_d_exports$6, C as NineSliceValue, D as Sprite, E as ShapeValue, H as InputApi, I as I18nApi, L as Message, M as sprite, N as Argument, O as SpriteOptions, P as Config$10, R as State$9, S as NineSlice, T as Shape, U as State$10, V as Config$11, W as types_d_exports$7, _ as Style, b as defineComponent, d as popup, f as defineTokens, g as ResolvedStyle, h as IsFlags, j as TransformValue, k as SpriteValue, l as Box, p as IntrinsicElementsFor, s as PopupComponent, u as LocalWrite, w as Parent, x as Display, y as WhenFlags, z as TypedTr } from "./types-X9jXjka3.mjs";
+import { A as UiApi, C as spawned, D as wait, E as use, F as TextApi, I as TextStyleInput, L as TextStyles, M as Config$13, N as Point, O as Config$14, P as State$12, R as TextValue, S as spawn, T as tween, _ as parallel, a as State$11, b as set, c as HapticKind, d as HAPTIC_KINDS, f as defineAnimation, g as mark, h as haptic, i as MotionKeyframe, j as types_d_exports$15, k as State$13, l as SfxDescriptor, m as frames, n as Config$12, o as Target, p as external, r as FramesValue, s as types_d_exports, t as AnimApi, u as Step, v as play, w as stagger, x as sfx, y as sequence, z as types_d_exports$13 } from "./types-CqkrEY06.mjs";
+import { A as FilterValueOf, C as EmitterValue, D as DisplacementValue, E as ColorMatrixValue, M as NoiseValue, N as OutlineValue, O as FilterComponent, P as UniformDeclaration, S as EmitterDefinition, T as BlurValue, _ as EffectsApi, b as types_d_exports$4, c as AnySceneProjection, d as SceneDefinition, f as SceneSpec, g as Config$16, h as types_d_exports$12, i as MusicOptions, j as GlowValue, k as FilterSpec, l as DefineScene, m as State$16, n as Config$15, o as State$14, p as ScenesApi, r as MusicDescriptor, s as types_d_exports$2, t as AudioApi, u as LayerMap, w as AlphaValue, x as EmitterConfig, y as State$15 } from "./types-CxZy7Pi4.mjs";
+import { Log } from "@moku-labs/common/browser";
+import { PluginCtx } from "@moku-labs/core";
 
 //#region src/plugins/text/components.d.ts
 /**
  * Words on the screen: a string or a message, the style it is drawn in, and the string `text`
- * resolved out of it. A game writes `content`, `style`, `bind` and `anchor`; `resolved` is
- * engine-owned and `ui` and the tests read it.
+ * resolved out of it. A game writes `content`, `style`, `bind`, `anchor` and `alpha`; `resolved`
+ * is engine-owned and `ui` and the tests read it. `alpha` (1 by default) fades the whole block and
+ * is patched in place, so a tween on it rebuilds nothing.
  */
 declare const Text: ComponentType<TextValue>;
 /**
@@ -37,7 +38,7 @@ type LabelOptions = {
  * ```ts
  * label({ text: "+5", style: "board.float", at: { x: 90, y: 180 } });
  * // [Text({ content: "+5", style: "board.float", bind: undefined,
- * //   anchor: { x: 0.5, y: 0.5 }, resolved: "" }),
+ * //   anchor: { x: 0.5, y: 0.5 }, alpha: 1, resolved: "" }),
  * //  Transform({ x: 90, y: 180, rotation: 0, scale: 1 })]
  * ```
  */
@@ -112,7 +113,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$13, State$12, AnimApi, {
+declare const animPlugin: import("@moku-labs/core").PluginInstance<"anim", Config$12, State$11, AnimApi, {
   "anim:mark": {
     animation: string;
     mark: string;
@@ -138,7 +139,7 @@ declare const animPlugin: import("@moku-labs/core").PluginInstance<"anim", Confi
  * app.assets.usage().textureMb; // 0.188, the boot tier
  * ```
  */
-declare const assetsPlugin: import("@moku-labs/core").PluginInstance<"assets", Config$8, State$7, Api$6, {
+declare const assetsPlugin: import("@moku-labs/core").PluginInstance<"assets", Config$9, State$8, Api$6, {
   "assets:bundle-loaded": {
     bundle: string;
     tier: Tier;
@@ -173,7 +174,7 @@ declare const assetsPlugin: import("@moku-labs/core").PluginInstance<"assets", C
  * });
  * ```
  */
-declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Config$14, State$13, AudioApi, {}> & Record<never, never>;
+declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Config$15, State$14, AudioApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/clock/index.d.ts
 /**
@@ -188,7 +189,24 @@ declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Con
  * });
  * ```
  */
-declare const clockPlugin: import("@moku-labs/core").PluginInstance<"clock", Config, State, Api, {}> & Record<never, never>;
+declare const clockPlugin: import("@moku-labs/core").PluginInstance<"clock", Config$1, State$1, Api, {}> & 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.
+ *
+ * @example
+ * ```ts
+ * // A game composes it next to the screen set; its features bring the emitters and filters.
+ * const app = createApp({
+ *   plugins: [...screen, effectsPlugin, boardFeature],
+ *   pluginConfigs: { renderer: { mount: "#game" }, effects: { maxPasses: 16 } }
+ * });
+ * 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$16, State$15, EffectsApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/flow/index.d.ts
 /**
@@ -205,7 +223,7 @@ declare const clockPlugin: import("@moku-labs/core").PluginInstance<"clock", Con
  * });
  * ```
  */
-declare const flowPlugin: import("@moku-labs/core").PluginInstance<"flow", Config$1, State$1, Api$1, {
+declare const flowPlugin: import("@moku-labs/core").PluginInstance<"flow", Config$2, State$2, Api$1, {
   "flow:edge": {
     flow: string;
     node: string;
@@ -246,7 +264,7 @@ declare const flowPlugin: import("@moku-labs/core").PluginInstance<"flow", Confi
  * await app.i18n.setLocale("en"); // text re-resolves every message on i18n:locale-changed
  * ```
  */
-declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Config$9, State$8, I18nApi, {
+declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Config$10, State$9, I18nApi, {
   "i18n:locale-changed": {
     locale: string;
   };
@@ -271,7 +289,7 @@ declare const i18nPlugin: import("@moku-labs/core").PluginInstance<"i18n", Confi
  * });
  * ```
  */
-declare const inputPlugin: import("@moku-labs/core").PluginInstance<"input", Config$10, State$9, InputApi, {}> & Record<never, never>;
+declare const inputPlugin: import("@moku-labs/core").PluginInstance<"input", Config$11, State$10, InputApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/lifecycle/index.d.ts
 /**
@@ -286,7 +304,7 @@ declare const inputPlugin: import("@moku-labs/core").PluginInstance<"input", Con
  * });
  * ```
  */
-declare const lifecyclePlugin: import("@moku-labs/core").PluginInstance<"lifecycle", Config$2, State$2, Api$2, {
+declare const lifecyclePlugin: import("@moku-labs/core").PluginInstance<"lifecycle", Config$3, State$3, Api$2, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -311,7 +329,7 @@ declare const lifecyclePlugin: import("@moku-labs/core").PluginInstance<"lifecyc
  * });
  * ```
  */
-declare const modelPlugin: import("@moku-labs/core").PluginInstance<"model", Config$3, State$3, {
+declare const modelPlugin: import("@moku-labs/core").PluginInstance<"model", Config$4, State$4, {
   store: StoreApi;
   rng: RngApi;
 }, {
@@ -320,6 +338,141 @@ declare const modelPlugin: import("@moku-labs/core").PluginInstance<"model", Con
     cause: "edge" | "rollback" | "restore" | "load";
   };
 }> & Record<never, never>;
+declare namespace types_d_exports$10 {
+  export { BackResult, Config, HapticKind, KernelSlice, LifecycleChanged, PlatformApi, PlatformProvider, ProviderMethod, State };
+}
+/**
+ * The seam a game fills, usually from `@moku-labs/system` in its own bridge. The engine never
+ * imports a native package: the provider is built in the application layer. Every `on*` returns
+ * its remover, which the plugin calls on stop.
+ *
+ * @example
+ * ```ts
+ * // A headless test drives the plugin with a fake of six functions.
+ * const ticks: string[] = [];
+ * const provider: PlatformProvider = {
+ *   onPause: () => () => undefined,
+ *   onResume: () => () => undefined,
+ *   onBack: () => () => undefined,
+ *   haptic: kind => ticks.push(kind),
+ *   keepAwake: () => undefined,
+ *   exit: () => undefined
+ * };
+ * createApp({ plugins: [...screen, platformPlugin], pluginConfigs: { platform: { provider } } });
+ * ```
+ */
+type PlatformProvider = {
+  /** Calls `fn` when the app goes to the background. Returns the remover. */onPause(fn: () => void): () => void; /** Calls `fn` when the app comes back to the foreground. Returns the remover. */
+  onResume(fn: () => void): () => void;
+  /**
+   * Calls `fn` on every press of the system Back button. `fn` returns whether the engine took the
+   * press; `false` lets the provider do its default, which on Android leaves the app.
+   */
+  onBack(fn: () => boolean): () => void; /** Plays one haptic tick. */
+  haptic(kind: HapticKind): void; /** Keeps the screen on while `on` is true. */
+  keepAwake(on: boolean): void; /** Leaves the app. */
+  exit(): void;
+};
+/**
+ * What took one Back press: the Escape button of the top popup, the intent `back` of the resting
+ * node, the provider leaving the app, or nothing at all because the app has no provider.
+ *
+ * @example
+ * ```ts
+ * // Home rests and does not list "back": the provider leaves the app.
+ * const result: BackResult = app.platform.back(); // "exit"
+ * ```
+ */
+type BackResult = "popup" | "intent" | "exit" | "none";
+/**
+ * What a game sets on `pluginConfigs.platform`: the provider seam its application layer fills
+ * from the native shell, and whether the screen stays on while the game runs.
+ *
+ * @example
+ * ```ts
+ * // app.ts of a game in the native shell; `provider` is the game's own bridge to the shell.
+ * const config: Platform.Config = { provider, keepAwake: true };
+ * config.keepAwake; // true
+ * ```
+ */
+type Config = {
+  /** The provider. `undefined`, the default: the plugin is inert, as on the web without a bridge and in headless tests. */provider: PlatformProvider | undefined; /** Keep the screen on while the game runs. Default `false`. */
+  keepAwake: boolean;
+};
+/**
+ * platform plugin state.
+ */
+type State = {
+  /** Whether `provider.keepAwake(true)` is in force. */awake: boolean; /** Removers of the provider subscriptions and of the haptic handler, called on stop. */
+  offs: Array<() => void>; /** Haptic kinds already warned about in a dev build, so each warns once. */
+  warned: Set<string>;
+};
+/**
+ * platform plugin API, `app.platform`. The rest of the plugin runs on its own: the provider's
+ * pause, resume and Back press, the `haptic` effect and keep-awake need no call.
+ *
+ * @example
+ * ```ts
+ * // An e2e test plays the Android Back button on Home, which rests without "back".
+ * app.platform.back(); // "exit": the provider leaves the app
+ * ```
+ */
+type PlatformApi = {
+  /**
+   * Runs the Back chain once, exactly as a press of the system Back button does. The first step
+   * that takes the press wins: Escape taps the `escape` button of the top ui root (`"popup"`),
+   * then the intent `back` is answered to the resting node (`"intent"`), and otherwise the
+   * provider leaves the app (`"exit"`). While the graph moves between nodes the gate is closed and
+   * holds the answer for one frame, so the press answers `"intent"` and never leaves the app.
+   * Escape also ends the editing of a ui text field, so a
+   * press while a field is edited ends the edit and answers `"popup"`. Without a provider nothing
+   * is pressed and the answer is `"none"`.
+   *
+   * @returns What took the press.
+   * @example
+   * ```ts
+   * // An e2e test plays the Android Back button over the settings popup, then on Home.
+   * app.platform.back(); // "popup": the settings popup was open and closed like Escape
+   * // ...the runner settles on Home, which does not list "back"...
+   * app.platform.back(); // "exit": the provider leaves the app
+   * ```
+   */
+  back(): BackResult;
+};
+/**
+ * What the kernel context offers the files of the plugin.
+ *
+ * `platform` owns no event, so `emit` is the kernel's and never called here.
+ */
+type KernelSlice = PluginCtx<Config, State> & {
+  readonly global: object;
+  readonly log: Log.LogApi;
+  readonly require: Require;
+};
+/**
+ * Payload of the `lifecycle:changed` hook: the pause that releases keep-awake.
+ */
+type LifecycleChanged = Events["lifecycle:changed"];
+/**
+ * A method of the provider, named in the log when it throws.
+ */
+type ProviderMethod = keyof PlatformProvider;
+//#endregion
+//#region src/plugins/platform/index.d.ts
+/**
+ * Platform plugin: `app.platform`, the handler of the effect kind `haptic`, and the provider's
+ * pause, resume and Back press. Inert without a provider.
+ *
+ * @example
+ * ```ts
+ * // A game in the native shell composes it last and hands it the bridge it built.
+ * createApp({
+ *   plugins: [...screen, effectsPlugin, audioPlugin, platformPlugin, ...features],
+ *   pluginConfigs: { platform: { provider: fromSystem(system), keepAwake: true } }
+ * });
+ * ```
+ */
+declare const platformPlugin: import("@moku-labs/core").PluginInstance<"platform", Config, State, PlatformApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/renderer/index.d.ts
 /**
@@ -338,7 +491,7 @@ declare const modelPlugin: import("@moku-labs/core").PluginInstance<"model", Con
  * app.renderer.host.kind(); // "webgpu" in Chrome, "webgl" on an older device
  * ```
  */
-declare const rendererPlugin: import("@moku-labs/core").PluginInstance<"renderer", Config$6, State$5, Api$4, {
+declare const rendererPlugin: import("@moku-labs/core").PluginInstance<"renderer", Config$5, State$5, Api$3, {
   "renderer:device-lost": {
     kind: "webgpu" | "webgl";
     reason: string;
@@ -361,7 +514,7 @@ declare const rendererPlugin: import("@moku-labs/core").PluginInstance<"renderer
  * export const awaitIntent = defineNode({ scene: "board", rest: true, outcomes: { merge: type() } });
  * ```
  */
-declare const scenesPlugin: import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$14, ScenesApi, {
+declare const scenesPlugin: import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$16, ScenesApi, {
   "scenes:changed": {
     from: string | undefined;
     to: string;
@@ -386,7 +539,7 @@ declare const scenesPlugin: import("@moku-labs/core").PluginInstance<"scenes", R
  * app.text.styles(); // ["body", "digits", "hud.digits"]
  * ```
  */
-declare const textPlugin: import("@moku-labs/core").PluginInstance<"text", Config$11, State$10, TextApi, {}> & Record<never, never>;
+declare const textPlugin: import("@moku-labs/core").PluginInstance<"text", Config$13, State$12, TextApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/time/index.d.ts
 /**
@@ -401,11 +554,12 @@ declare const textPlugin: import("@moku-labs/core").PluginInstance<"text", Confi
  * });
  * ```
  */
-declare const timePlugin: import("@moku-labs/core").PluginInstance<"time", Config$4, State$4, Api$3, {}> & Record<never, never>;
+declare const timePlugin: import("@moku-labs/core").PluginInstance<"time", Config$6, State$6, Api$4, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/ui/index.d.ts
 /**
- * Ui plugin: `app.ui.tree()`, `app.ui.find(...)`, `app.ui.lint()`, the components `Box` and
+ * 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`.
  *
  * @example
@@ -417,7 +571,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$11, UiApi, {}> & Record<never, never>;
+declare const uiPlugin: import("@moku-labs/core").PluginInstance<"ui", Config$14, State$13, UiApi, {}> & Record<never, never>;
 //#endregion
 //#region src/plugins/world/index.d.ts
 /**
@@ -433,7 +587,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$7, State$6, Api$5, {
+declare const worldPlugin: import("@moku-labs/core").PluginInstance<"world", Config$7, State$7, Api$5, {
   "world:reconciled": {
     mode: "play" | "direct";
     projections: number;
@@ -789,6 +943,22 @@ declare function defineScene<Layers extends LayerMap, const Projections extends
 declare const Animation: ComponentType<{
   playing: number;
 }>;
+/**
+ * A frame loop on an entity, for as long as the entity carries it: every `1000 / fps` ms
+ * `Sprite.texture` becomes the next key of `keys`, after the last key it wraps to the first. No
+ * timeline around it, not counted by `Animation` or `app.anim.active()`. A running `frames` step on
+ * the same entity owns the sprite until it ends; the loop goes on from where its clock stands.
+ * Paused and fast world modes and reduced motion stop the clock on the frame it shows.
+ *
+ * @example
+ * ```ts
+ * // A coin spins on the board for its whole life: a projection view returns both components.
+ * const coinSpin = ["items.coin-0", "items.coin-1", "items.coin-2", "items.coin-3"] as const;
+ * const coin = [Sprite({ texture: "items.coin-0" }), Frames({ keys: coinSpin, fps: 12 })];
+ * Frames({ keys: coinSpin, fps: 12 }).value.loop; // true: the default
+ * ```
+ */
+declare const Frames: ComponentType<FramesValue>;
 //#endregion
 //#region src/plugins/anim/motion.d.ts
 /**
@@ -888,359 +1058,234 @@ type MotionSpec = {
  */
 declare function defineMotion(spec: MotionSpec): ProjectionMotion<unknown>;
 //#endregion
-//#region src/plugins/anim/timeline/steps.d.ts
-/**
- * Runs the steps one after another. The remainder past a step's end reaches the next step in the
- * same frame, so the tree takes exactly the sum of its durations.
- *
- * @param steps - The steps, in order.
- * @returns The sequence step.
- * @example
- * ```ts
- * sequence(wait(100), mark("done"));
- * // { kind: "sequence", steps: [{ kind: "wait", ms: 100 }, { kind: "mark", name: "done" }] }
- * ```
- */
-declare function sequence(...steps: readonly Step[]): Step;
-/**
- * Runs every step at once and ends with the longest one.
- *
- * @param steps - The steps.
- * @returns The parallel step.
- * @example
- * ```ts
- * parallel(wait(100), wait(300)); // ends after 300 ms
- * ```
- */
-declare function parallel(...steps: readonly Step[]): Step;
-/**
- * Builds one step per item and starts each one `staggerMs` later than the one before. The build
- * function runs here, so no function survives in the data.
- *
- * @param items - What to build a step for.
- * @param staggerMs - Delay between two neighbouring items, in game milliseconds.
- * @param build - Builds the step of one item.
- * @returns The parallel of delayed sequences.
- * @example
- * ```ts
- * stagger(["a", "b"], 60, item => mark(item));
- * // parallel(sequence(wait(0), mark("a")), sequence(wait(60), mark("b")))
- * ```
- */
-declare function stagger<Item>(items: readonly Item[], staggerMs: number, build: (item: Item, index: number) => Step): Step;
-/**
- * Holds still for a while.
- *
- * @param durationMs - How long to wait, in game milliseconds.
- * @returns The wait step.
- * @example
- * ```ts
- * wait(120); // { kind: "wait", ms: 120 }
- * ```
- */
-declare function wait(durationMs: number): Step;
-/**
- * Names a point in the choreography. Reaching it emits `anim:mark`, calls the `onMark` listeners
- * and appends the name to `marks()`. It is the only way out of a timeline.
- *
- * @param name - Name of the mark.
- * @returns The mark step.
- * @example
- * ```ts
- * mark("landed"); // { kind: "mark", name: "landed" }
- * ```
- */
-declare function mark(name: string): Step;
+//#region src/plugins/i18n/tr.d.ts
 /**
- * Moves the numeric fields of one component of one target to an exact target value. The component
- * is any handle `world.ecs` takes, so the kit's `Sprite` and `NineSlice` of `defineGame` pass as
- * they are.
- *
- * By default the fields are local: they are written into the target's own `Transform`. With
- * `space: "root"` the `x`, `y`, `rotation` and `scale` of a `Transform` are a root pose, the space
- * `at()` answers in, and are turned into the space of the target's `Parent` when the track starts.
- * That aims a hosted view, such as a board item inside the board slot, at another element. A
- * field the step does not name stays where it is, so under a turned parent name `x` and `y`
- * together. A target without a parent, and a component other than `Transform`, move as in the
- * local space.
+ * Builds a message. The result is frozen and the parameters are copied, so the caller's object
+ * stays its own and nothing downstream can rewrite a label in place.
  *
- * @param target - The projection key or the entity to animate.
- * @param component - The component to animate.
- * @param to - The numeric target fields.
- * @param options - Duration, easing, delay, the additive flag and the space of the fields.
- * @param options.ms - Duration in game milliseconds.
- * @param options.ease - Easing curve; `"out"` when omitted.
- * @param options.delayMs - How long the track waits before it reads its start values.
- * @param options.additive - `true` adds an offset instead of owning the fields.
- * @param options.space - `"root"` reads the `Transform` fields as a root pose; `"local"` when
- *   omitted.
- * @returns The tween step.
+ * @param key - The message key, one of the keys `compileStrings` generated.
+ * @param params - The parameters the message declares. An element parameter is kept as it is.
+ * @returns The message, frozen.
  * @example
  * ```ts
- * // An order is delivered: the board item flies out of the scaled board slot onto the order card.
- * const deliverFly = defineAnimation("orders.deliverFly", {
- *   slots: { item: type<Target>(), card: type<Target>() },
- *   build: ({ item, card }, { at }) =>
- *     tween(item, Transform, { x: at(card).x, y: at(card).y, scale: at(card).scale }, {
- *       ms: 400, ease: "inCubic", space: "root"
- *     })
- * });
- * app.anim.play(deliverFly, {
- *   item: { projection: "board.items", key: "i1" },
- *   card: { projection: "hud", key: "card0" }
- * });
- * // 400 ms later the item covers the card at the card's size; its Transform stays slot-local
+ * tr("hud.orders", { n: 3 }); // { key: "hud.orders", params: { n: 3 } }
+ * tr("orders.complete"); // { key: "orders.complete" }
  * ```
  */
-declare function tween<Value extends object>(target: Target, component: ComponentHandle<Value>, to: Partial<NumericFields<Value>>, options: {
-  ms: number;
-  ease?: Ease;
-  delayMs?: number;
-  additive?: boolean;
-  space?: "local" | "root";
-}): Step;
+declare function tr(key: string, params?: Record<string, Argument>): Message;
+//#endregion
+//#region src/plugins/ui/styles/define.d.ts
 /**
- * Writes a component patch at once. Any field may be written, not only the numeric ones. The
- * component is any handle `world.ecs` takes, the kit's `Sprite` and `NineSlice` included.
+ * Declares one style. The work is the type: a field outside the vocabulary, or a value outside
+ * its union, is an error where the style is written, not where it is used.
  *
- * @param target - The projection key or the entity to write.
- * @param component - The component to write.
- * @param patch - The fields to overwrite.
- * @returns The set step.
+ * @param style - The style, with its `is` and `when` variants.
+ * @returns The same object, frozen.
  * @example
  * ```ts
- * set({ projection: "hud", key: "coins" }, Sprite, { texture: "hud.coin-gold" });
- * // { kind: "set", patch: { texture: "hud.coin-gold" }, ... }
+ * defineStyle({ direction: "row", gap: 12 }).gap; // 12
  * ```
  */
-declare function set<Value extends object>(target: Target, component: ComponentHandle<Value>, patch: Partial<Value>): Step;
+declare function defineStyle<const Given extends Style>(style: Given): Readonly<Given>;
+//#endregion
+//#region src/plugins/ui/styles/resolve.d.ts
 /**
- * Plays a frame sprite: one texture key of the list per frame of `fps`, written into `Sprite`.
+ * The flags one element is resolved against: the viewport flags of the frame plus its own state.
  *
- * @param target - The projection key or the entity to animate.
- * @param options - The keys, the frame rate and whether the list repeats.
- * @param options.keys - The texture keys, in play order.
- * @param options.fps - Frames per second of the list.
- * @param options.loop - `true` repeats the list until the step is finished.
- * @returns The frames step.
  * @example
  * ```ts
- * frames({ projection: "board", key: "c3" }, { keys: ["fx.pop-1", "fx.pop-2"], fps: 12 });
- * // { kind: "frames", keys: ["fx.pop-1", "fx.pop-2"], fps: 12, loop: false, ... }
+ * const flags: StyleFlags = {
+ *   portrait: true, landscape: false, tall: false, wide: false,
+ *   pressed: false, hover: false, focus: false, disabled: false, active: true, selected: false,
+ *   covered: false
+ * };
  * ```
  */
-declare function frames(target: Target, options: {
-  keys: readonly string[];
-  fps: number;
-  loop?: boolean;
-}): Step;
+type StyleFlags = WhenFlags & IsFlags;
 /**
- * Makes a temporary entity when the step is reached: a flying coin, a toast sign, a sparkle. The
- * entity is owned by `anim`, drawn in `layer` at `order`, and despawned when the timeline ends, is
- * finished or is cancelled. Later steps of the same timeline aim at it with `spawned(id)`.
+ * Resolves one style against the flags of the frame and the viewport.
  *
- * @param id - Name of the entity inside this timeline; one timeline spawns each id once.
- * @param components - The component values the entity starts with, as `world.ecs.spawn` takes.
- * @param options - Where the entity is drawn.
- * @param options.layer - The layer; `"ui"` when omitted.
- * @param options.order - The draw order inside the layer; `0` when omitted.
- * @returns The spawn step.
+ * @param style - The style a game wrote, or nothing.
+ * @param flags - The four viewport flags and the seven state flags. While `disabled` is true the
+ *   `hover` and `pressed` variants are skipped.
+ * @param viewport - What `renderer.viewport.size()` answered, for the safe-area tokens.
+ * @returns The frozen style the layout and the visual are written from.
  * @example
  * ```ts
- * spawn("coin1", [Sprite({ texture: "ui.icon-coin" }), Transform({ x: 540, y: 900 })], { order: 50 });
- * // { kind: "spawn", id: "coin1", components: [...], layer: "ui", order: 50 }
+ * resolve(
+ *   { gap: 8, is: { pressed: { gap: 4 } } },
+ *   { portrait: true, landscape: false, tall: false, wide: false,
+ *     pressed: true, hover: false, focus: false, disabled: false, active: false, selected: false,
+ *     covered: false },
+ *   { width: 1080, height: 1920, scale: 1, orientation: "portrait",
+ *     safeArea: { top: 0, right: 0, bottom: 0, left: 0 } }
+ * ).gap; // 4
  * ```
  */
-declare function spawn(id: string, components: readonly AnyComponentValue[], options?: {
-  layer?: string;
-  order?: number;
-}): Step;
+declare function resolve(style: Style | undefined, flags: StyleFlags, viewport: ViewportSize): ResolvedStyle;
+//#endregion
+//#region src/plugins/audio/descriptors.d.ts
 /**
- * Aims a later step at the entity a `spawn` step of the same timeline made. Before that step is
- * reached nothing answers the id, so a step aimed at it ends silently.
+ * Creates the awaited effect that switches the music track. The same key as the one playing does
+ * nothing, and `null` fades the current track out. An absent `fadeMs` leaves the key out of the
+ * payload, so the descriptor stays plain JSON and the plugin's `musicFadeMs` decides at play time.
  *
- * @param id - The id the `spawn` step was given.
- * @returns The target.
+ * @param key - Asset key of an `.mp3`, or `null` to stop the music.
+ * @param options - `fadeMs` overrides the configured cross-fade for this switch.
+ * @returns The descriptor a node awaits, frozen.
  * @example
  * ```ts
- * tween(spawned("coin1"), Transform, { x: 40, y: 120 }, { ms: 600, ease: "inCubic" });
- * // { kind: "tween", target: { spawned: "coin1" }, ... }
+ * // A node of a game: the menu goes quiet before the ending cinematic starts.
+ * await fx(music(null, { fadeMs: 1500 }));
+ * // music("board.theme") is { kind: "music", payload: { key: "board.theme" }, cosmetic: true }
  * ```
  */
-declare function spawned(id: string): {
-  spawned: string;
-};
+declare function music(key: string | null, options?: MusicOptions): Descriptor;
+//#endregion
+//#region src/plugins/effects/filters/builtins.d.ts
 /**
- * A sound. `anim` owns the descriptor because it sits below `audio`; `audio` owns the handler,
- * and a game without `audio` plays nothing and hears no error.
+ * A soft halo of `color` around the opaque pixels of a view and its subtree, `distance` pixels
+ * wide, that follows the shape: rounded corners stay rounded. Its alpha is
+ * `strength × alpha ×` the share of the disc of radius `distance` around the pixel the view
+ * covers, so `strength: 2` is full next to a straight edge and fades to nothing at `distance`.
+ * The view is padded by its live `distance`. One render pass per apply.
  *
- * @param key - Asset key of the sound.
- * @param options - The bus to play it on.
- * @param options.bus - `"sfx"` when omitted.
- * @returns The descriptor, usable as a timeline step and as `fx(...)` in a node.
  * @example
  * ```ts
- * sfx("board.merge"); // { kind: "sfx", payload: { key: "board.merge", bus: "sfx" }, cosmetic: true }
+ * // A merged item glows, and a motion hook tweens the glow away.
+ * Glow({ strength: 4 }).value; // { strength: 4, distance: 10, color: 0xffffff, alpha: 1, enabled: true, order: 0 }
+ * view.tween(Glow, { strength: 0 }, { ms: 200 });
  * ```
  */
-declare function sfx(key: string, options?: {
-  bus?: string;
-}): SfxDescriptor;
+declare const Glow: FilterComponent<GlowValue>;
 /**
- * A haptic tick. `platform` owns the handler; a device without one stays still.
+ * A ring of `thickness` pixels in `color` around the opaque pixels of a view and its subtree; the
+ * view is padded by its live `thickness`. One render pass per apply.
  *
- * @param kind - Which tick to play, for example `"light"`.
- * @returns The descriptor, usable as a timeline step and as `fx(...)` in a node.
  * @example
  * ```ts
- * haptic("light"); // { kind: "haptic", payload: { kind: "light" }, cosmetic: true }
+ * // The selected card is outlined in honey.
+ * Outline({ thickness: 4, color: 0xffc233 }).value; // { thickness: 4, color: 0xffc233, alpha: 1, enabled: true, order: 0 }
  * ```
  */
-declare function haptic(kind: string): HapticDescriptor;
+declare const Outline: FilterComponent<OutlineValue>;
 /**
- * Reserved for Spine and the other external players. It throws until one arrives, so nobody
- * builds a choreography on a door that is not open yet.
+ * Pixi's blur over a view and its subtree. `quality: 0` means `config.blur.quality`;
+ * `resolution: 0` means `config.blur.phoneResolution` on a phone, otherwise 1. `repeatEdgePixels`
+ * keeps the padding at 0. Costs `2 × quality` render passes per apply.
  *
- * @param _player - The player that would run the clip.
- * @param _clip - Name of the clip.
- * @throws {Error} Always.
  * @example
  * ```ts
- * external(spine, "idle"); // throws: External players arrive with Spine.
+ * // The board behind a popup: the filter sits on the ui slot that hosts the board.
+ * Blur({ strength: 6 }).value; // { strength: 6, quality: 0, resolution: 0, repeatEdgePixels: true, enabled: true, order: 0 }
  * ```
  */
-declare function external(_player: ExternalPlayer, _clip: string): never;
+declare const Blur: ComponentType<BlurValue>;
 /**
- * Nests one animation inside another. The nested tree is built here, so its marks are reported
- * under the nested id and no function survives in the data. Pass the outer `tools` when the
- * nested `build` reads `at`.
+ * Pixi's colour matrix: brightness, saturation, contrast, hue in degrees and grayscale, composed
+ * in that order from the identity on every change. Every default is the identity.
  *
- * @param animation - The animation to nest.
- * @param slots - One target, or a list of targets, per slot of the nested animation.
- * @param tools - The build tools of the outer animation; without them `at` is the identity pose.
- * @returns The use step.
  * @example
  * ```ts
- * use(popCard, { card: { projection: "hud", key: "order" } });
- * // { kind: "use", id: "hud.popCard", step: { kind: "sequence", ... } }
+ * // A locked card goes gray.
+ * ColorMatrix({ grayscale: 1 }).value.grayscale; // 1
  * ```
  */
-declare function use<Tags extends SlotTags>(animation: AnimationDefinition<Tags>, slots: SlotValues<Tags>, tools?: BuildTools): Step;
+declare const ColorMatrix: ComponentType<ColorMatrixValue>;
 /**
- * The effect descriptor a node awaits to play a choreography. The payload names the animation,
- * so the handler resolves the definition from the registry the features filled.
+ * Pixi's noise. The seed is always given, never Pixi's random default, so two runs draw the same
+ * grain.
  *
- * @param animation - The animation to play.
- * @param slots - One target, or a list of targets, per slot.
- * @returns The descriptor, cosmetic, so a failing build never breaks the node.
  * @example
  * ```ts
- * play(coinsFly, { from: { projection: "hud", key: "purse" } });
- * // { kind: "play", payload: { animation: "hud.coinsFly", slots: { from: { ... } } }, cosmetic: true }
+ * Noise({ amount: 0.2, seed: 7 }).value; // { amount: 0.2, seed: 7, enabled: true, order: 0 }
  * ```
  */
-declare function play<Tags extends SlotTags>(animation: AnimationDefinition<Tags>, slots: SlotValues<Tags>): PlayDescriptor;
+declare const Noise: ComponentType<NoiseValue>;
 /**
- * Declares one animation: an id, the slots it takes and the pure function that builds its step
- * tree. `build` runs once per play, so the same animation may play twice at once.
+ * Pixi's displacement over the texture of the asset key `map`. Nothing is drawn while the map is
+ * not loaded; a missing key warns once.
  *
- * @param id - Animation id, unique across the features of a game.
- * @param spec - The slots and the build function.
- * @returns The animation as frozen plain data.
  * @example
  * ```ts
- * const coinsFly = defineAnimation("hud.coinsFly", {
- *   slots: { from: type<Target>() },
- *   build: ({ from }) => tween(from, Transform, { scale: 0.4 }, { ms: 600 })
- * });
- * coinsFly.id; // "hud.coinsFly"
+ * // Heat haze over the furnace.
+ * Displacement({ map: "fx.ripple", scaleX: 8, scaleY: 8 }).value.map; // "fx.ripple"
  * ```
  */
-declare function defineAnimation<Tags extends SlotTags>(id: string, spec: AnimationSpec<Tags>): AnimationDefinition<Tags>;
-//#endregion
-//#region src/plugins/i18n/tr.d.ts
+declare const Displacement: ComponentType<DisplacementValue>;
 /**
- * Builds a message. The result is frozen and the parameters are copied, so the caller's object
- * stays its own and nothing downstream can rewrite a label in place.
+ * Pixi's alpha over a view and its subtree as one layer, so overlapping children do not show
+ * through each other.
  *
- * @param key - The message key, one of the keys `compileStrings` generated.
- * @param params - The parameters the message declares. An element parameter is kept as it is.
- * @returns The message, frozen.
  * @example
  * ```ts
- * tr("hud.orders", { n: 3 }); // { key: "hud.orders", params: { n: 3 } }
- * tr("orders.complete"); // { key: "orders.complete" }
+ * Alpha({ alpha: 0.5 }).value; // { alpha: 0.5, enabled: true, order: 0 }
  * ```
  */
-declare function tr(key: string, params?: Record<string, Argument>): Message;
+declare const Alpha: ComponentType<AlphaValue>;
 //#endregion
-//#region src/plugins/ui/styles/define.d.ts
+//#region src/plugins/effects/filters/define.d.ts
 /**
- * Declares one style. The work is the type: a field outside the vocabulary, or a value outside
- * its union, is an error where the style is written, not where it is used.
+ * 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
+ * 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.
  *
- * @param style - The style, with its `is` and `when` variants.
- * @returns The same object, frozen.
+ * @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.
+ * @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.
  * @example
  * ```ts
- * defineStyle({ direction: "row", gap: 12 }).gap; // 12
+ * // 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
  * ```
  */
-declare function defineStyle<const Given extends Style>(style: Given): Readonly<Given>;
+declare function defineFilter<Uniforms extends Record<string, UniformDeclaration> = Record<never, never>>(id: string, spec: FilterSpec<Uniforms>): FilterComponent<FilterValueOf<Uniforms>>;
 //#endregion
-//#region src/plugins/ui/styles/resolve.d.ts
+//#region src/plugins/effects/particles/component.d.ts
 /**
- * The flags one element is resolved against: the viewport flags of the frame plus its own state.
+ * A particle effect on an entity. A `burst` effect emits when the component appears or its
+ * `effect` changes; a `rate` effect emits while `active` is true and the entity lives. An effect in
+ * `"world"` space outlives the entity, one in `"local"` space moves and dies with it. `""` draws
+ * nothing. Plain JSON: it shows in `snapshot()`.
  *
  * @example
  * ```ts
- * const flags: StyleFlags = {
- *   portrait: true, landscape: false, tall: false, wide: false,
- *   pressed: false, hover: false, focus: false, disabled: false, active: true, selected: false,
- *   covered: false
- * };
+ * // A merged item bursts stars from its enter hook; the generator steams for its whole life.
+ * view.set(Emitter, { effect: "fx.starsBurst" });
+ * Emitter({ effect: "fx.steam" }).value; // { effect: "fx.steam", active: true }
  * ```
  */
-type StyleFlags = WhenFlags & IsFlags;
-/**
- * Resolves one style against the flags of the frame and the viewport.
- *
- * @param style - The style a game wrote, or nothing.
- * @param flags - The four viewport flags and the seven state flags. While `disabled` is true the
- *   `hover` and `pressed` variants are skipped.
- * @param viewport - What `renderer.viewport.size()` answered, for the safe-area tokens.
- * @returns The frozen style the layout and the visual are written from.
- * @example
- * ```ts
- * resolve(
- *   { gap: 8, is: { pressed: { gap: 4 } } },
- *   { portrait: true, landscape: false, tall: false, wide: false,
- *     pressed: true, hover: false, focus: false, disabled: false, active: false, selected: false,
- *     covered: false },
- *   { width: 1080, height: 1920, scale: 1, orientation: "portrait",
- *     safeArea: { top: 0, right: 0, bottom: 0, left: 0 } }
- * ).gap; // 4
- * ```
- */
-declare function resolve(style: Style | undefined, flags: StyleFlags, viewport: ViewportSize): ResolvedStyle;
+declare const Emitter: ComponentType<EmitterValue>;
 //#endregion
-//#region src/plugins/audio/descriptors.d.ts
+//#region src/plugins/effects/particles/define.d.ts
 /**
- * Creates the awaited effect that switches the music track. The same key as the one playing does
- * nothing, and `null` fades the current track out. An absent `fadeMs` leaves the key out of the
- * payload, so the descriptor stays plain JSON and the plugin's `musicFadeMs` decides at play time.
+ * Describes a particle effect. Every field is optional except `textures` and exactly one of
+ * `burst` and `rate`; the definition is frozen, registered through the `emitters` key of a feature
+ * and started by an `Emitter` component naming its id.
  *
- * @param key - Asset key of an `.mp3`, or `null` to stop the music.
- * @param options - `fadeMs` overrides the configured cross-fade for this switch.
- * @returns The descriptor a node awaits, frozen.
+ * @param id - The effect id, unique across the features of the game.
+ * @param config - The effect as data.
+ * @returns The frozen definition `{ id, config }`, the config with every default filled in.
+ * @throws {Error} When the id is empty or a field breaks its rule.
  * @example
  * ```ts
- * // A node of a game: the menu goes quiet before the ending cinematic starts.
- * await fx(music(null, { fadeMs: 1500 }));
- * // music("board.theme") is { kind: "music", payload: { key: "board.theme" }, cosmetic: true }
+ * // features/board/effects.ts: the steam over the generator.
+ * const steam = defineEmitter("fx.steam", { textures: ["fx.puff"], rate: 12, space: "local" });
+ * steam.config.rate; // 12
+ * steam.config.lifeMs; // [600, 1000], the default
  * ```
  */
-declare function music(key: string | null, options?: MusicOptions): Descriptor;
+declare function defineEmitter(id: string, config: EmitterConfig): EmitterDefinition;
 //#endregion
 //#region src/index.d.ts
 /**
@@ -1255,7 +1300,7 @@ declare function music(key: string | null, options?: MusicOptions): Descriptor;
  * });
  * ```
  */
-declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<Config$5, Events, (import("@moku-labs/core").PluginInstance<"time", Config$4, State$4, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$2, State$2, Api$2, {
+declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs/core").AnyPluginInstance[] = readonly []>(options?: import("@moku-labs/core").CreateAppOptions<Config$8, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$6, State$6, Api$4, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$3, State$3, Api$2, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -1263,7 +1308,7 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
     paused: boolean;
     resumed: boolean;
   };
-}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"model", Config$3, State$3, {
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"model", Config$4, State$4, {
   store: StoreApi;
   rng: RngApi;
 }, {
@@ -1271,7 +1316,7 @@ 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, State, Api, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$1, State$1, Api$1, {
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"clock", Config$1, State$1, Api, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$2, State$2, Api$1, {
   "flow:edge": {
     flow: string;
     node: string;
@@ -1295,7 +1340,7 @@ 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>]>> | undefined) => import("@moku-labs/core").App<Config$5, Events, (import("@moku-labs/core").PluginInstance<"time", Config$4, State$4, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$2, State$2, Api$2, {
+}> & 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>]>> | undefined) => import("@moku-labs/core").App<Config$8, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$6, State$6, Api$4, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$3, State$3, Api$2, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -1303,7 +1348,7 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
     paused: boolean;
     resumed: boolean;
   };
-}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"model", Config$3, State$3, {
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"model", Config$4, State$4, {
   store: StoreApi;
   rng: RngApi;
 }, {
@@ -1311,7 +1356,7 @@ 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, State, Api, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$1, State$1, Api$1, {
+}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"clock", Config$1, State$1, Api, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"flow", Config$2, State$2, Api$1, {
   "flow:edge": {
     flow: string;
     node: string;
@@ -1348,14 +1393,15 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
  * });
  * ```
  */
-declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<Config$5, Events, 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>]>>;
+declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<Config$8, 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.
  *
- * @returns The helpers typed with the game's `player`, `session`, `assets`, `bundles` and `strings`.
+ * @returns The helpers typed with the game's `player`, `session`, `assets`, `bundles`, `strings`
+ *   and `emitters`.
  * @example
  * ```ts
  * // kit.ts of a game: bound once, imported by every node, flow and view file.
@@ -1364,6 +1410,16 @@ declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<
  * ```
  */
 declare function defineGame<Types extends GameTypes>(): {
+  defineEmitter: (id: EmitterIdOf<Types>, config: Omit<EmitterConfig, "textures"> & {
+    readonly textures: readonly Types["assets"][];
+  }) => EmitterDefinition;
+  Emitter: Narrowed<EmitterValue, {
+    effect?: EmitterIdOf<Types>;
+    active?: boolean;
+  }>;
+  Displacement: Narrowed<DisplacementValue, Partial<Omit<DisplacementValue, "map">> & {
+    map?: Types["assets"];
+  }>;
   music: MusicDescriptor<Types["assets"]>;
   defineComponent: typeof defineComponent;
   defineStyle: <const Given extends Style<Types["assets"]>>(style: Given) => Readonly<Given>;
@@ -1392,6 +1448,9 @@ declare function defineGame<Types extends GameTypes>(): {
     bus?: string;
   }) => SfxDescriptor;
   play: typeof play;
+  Frames: Narrowed<FramesValue, Partial<Omit<FramesValue, "keys">> & {
+    keys?: readonly Types["assets"][];
+  }>;
   defineScene: DefineScene<Types["assets"], BundlesOf<Types>>;
   defineBundles: DefineBundles<BundlesOf<Types>>;
   load: LoadBundles<BundlesOf<Types>>;
@@ -1415,14 +1474,14 @@ declare function defineGame<Types extends GameTypes>(): {
 };
 /**
  * The screen plugins, in dependency order. A game with a screen spreads them into `plugins`;
- * a headless test leaves them out. V2: `world`, `renderer`, `input`, `assets`, `scenes`. V3 appends `anim`, `i18n`, `text`, `ui`; `audio` stays opt-in: `[...screen, audioPlugin]`.
+ * a headless test leaves them out. V2: `world`, `renderer`, `input`, `assets`, `scenes`. V3 appends `anim`, `i18n`, `text`, `ui`; `audio`, `effects` and `platform` stay opt-in: `[...screen, effectsPlugin, audioPlugin, platformPlugin]`.
  *
  * @example
  * ```ts
  * createApp({ plugins: [...screen, boardFeature], pluginConfigs: { renderer: { mount: "#game" } } });
  * ```
  */
-declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world", Config$7, State$6, Api$5, {
+declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world", Config$7, State$7, Api$5, {
   "world:reconciled": {
     mode: "play" | "direct";
     projections: number;
@@ -1434,12 +1493,12 @@ declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world"
     hintsRouted: number;
     hintsDropped: number;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"renderer", Config$6, State$5, Api$4, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"renderer", Config$5, State$5, Api$3, {
   "renderer:device-lost": {
     kind: "webgpu" | "webgl";
     reason: string;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"input", Config$10, State$9, InputApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"assets", Config$8, State$7, Api$6, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"input", Config$11, State$10, InputApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"assets", Config$9, State$8, Api$6, {
   "assets:bundle-loaded": {
     bundle: string;
     tier: Tier;
@@ -1458,13 +1517,13 @@ declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world"
     reason: "budget" | "request";
     keys: readonly string[];
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$14, ScenesApi, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$16, ScenesApi, {
   "scenes:changed": {
     from: string | undefined;
     to: string;
     music: string | undefined;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"anim", Config$13, State$12, AnimApi, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"anim", Config$12, State$11, AnimApi, {
   "anim:mark": {
     animation: string;
     mark: string;
@@ -1472,10 +1531,10 @@ declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world"
   "anim:finished": {
     animation: string;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"i18n", Config$9, State$8, I18nApi, {
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"i18n", Config$10, State$9, I18nApi, {
   "i18n:locale-changed": {
     locale: string;
   };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"text", Config$11, State$10, TextApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"ui", Config$12, State$11, UiApi, {}> & Record<never, never>];
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"text", Config$13, State$12, TextApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"ui", Config$14, State$13, UiApi, {}> & Record<never, never>];
 //#endregion
-export { types_d_exports as Anim, Animation, types_d_exports$1 as Assets, types_d_exports$2 as Audio, Box, types_d_exports$3 as Clock, type DescriptionNode, Display, Draggable, DropTarget, Exiting, types_d_exports$4 as Flow, Held, Hovered, types_d_exports$5 as I18n, types_d_exports$6 as Input, Layer, types_d_exports$7 as Lifecycle, LocalWrite, types_d_exports$8 as Model, NineSlice, Order, Parent, Pointer, PointerOver, Pressable, Pressed, types_d_exports$9 as Renderer, SaveUnreadableError, types_d_exports$10 as Scenes, Shape, Sprite, Swipeable, Tappable, Text, types_d_exports$11 as TextTypes, types_d_exports$12 as Time, Touchable, Transform, Tree, types_d_exports$13 as Ui, types_d_exports$14 as World, animPlugin, assetsPlugin, audioPlugin, clockPlugin, component, createApp, createPlugin, defineAnimation, defineBundles, defineComponent, defineFeature, defineGame, defineMotion, defineScene, defineStyle, defineTextStyles, defineTokens, exit, external, flowPlugin, frames, guide, haptic, hint, i18nPlugin, inputPlugin, label, lifecyclePlugin, load, mark, modelPlugin, music, mut, parallel, play, popup, projection, rendererPlugin, resolve, resource, scenesPlugin, schedule, screen, sequence, set, sfx, slot, spawn, spawned, sprite, stagger, system, tag, textPlugin, timePlugin, to, tr, tween, type, uiPlugin, use, wait, worldPlugin };
+export { Alpha, types_d_exports as Anim, Animation, types_d_exports$1 as Assets, types_d_exports$2 as Audio, type BackResult, Blur, Box, types_d_exports$3 as Clock, ColorMatrix, type DescriptionNode, Displacement, Display, Draggable, DropTarget, types_d_exports$4 as Effects, Emitter, Exiting, types_d_exports$5 as Flow, Frames, Glow, HAPTIC_KINDS, type HapticKind, Held, Hovered, types_d_exports$6 as I18n, types_d_exports$7 as Input, Layer, types_d_exports$8 as Lifecycle, LocalWrite, types_d_exports$9 as Model, NineSlice, Noise, Order, Outline, Parent, types_d_exports$10 as Platform, type PlatformProvider, Pointer, PointerOver, Pressable, Pressed, types_d_exports$11 as Renderer, SaveUnreadableError, types_d_exports$12 as Scenes, Shape, Sprite, Swipeable, Tappable, Text, types_d_exports$13 as TextTypes, types_d_exports$14 as Time, Touchable, Transform, Tree, types_d_exports$15 as Ui, types_d_exports$16 as World, animPlugin, assetsPlugin, audioPlugin, clockPlugin, component, createApp, createPlugin, defineAnimation, defineBundles, defineComponent, defineEmitter, defineFeature, defineFilter, defineGame, defineMotion, defineScene, defineStyle, defineTextStyles, defineTokens, effectsPlugin, exit, external, flowPlugin, frames, guide, haptic, hint, i18nPlugin, inputPlugin, label, lifecyclePlugin, load, mark, modelPlugin, music, mut, parallel, platformPlugin, play, popup, projection, rendererPlugin, resolve, resource, scenesPlugin, schedule, screen, sequence, set, sfx, slot, spawn, spawned, sprite, stagger, system, tag, textPlugin, timePlugin, to, tr, tween, type, uiPlugin, use, wait, worldPlugin };