@moku-labs/game 0.0.1 → 0.0.3

package/dist/index.d.mts

@@ -1,23 +1,224 @@
-import { A as Patch, B as PauseReason, C as State, D as Root, E as Json, F as StoreApi, G as State$4, H as types_d_exports$2, I as RngApi, J as Events, K as types_d_exports$4, O as State$3, P as SaveUnreadableError, R as Api$2, T as Config$3, U as Api$3, V as State$2, W as Config$4, _ as GuideOptions, a as Kit, b as Api, c as exit, d as type, f as FeatureDescription, g as Descriptor, i as GameTypes, k as types_d_exports$3, l as slot, n as Config$1, o as State$1, q as Config$5, r as FeaturePlugin, s as types_d_exports$1, t as Api$1, u as to, v as Hint, w as types_d_exports, x as Config, z as Config$2 } from "./types-BfsmUzLC.mjs";
+import { $t as types_d_exports$3, At as Json, B as Mut, Bt as StoreApi, Ct as Config$5, D as ProjectionMotion, E as NumericFields, Et as types_d_exports$13, F as ComponentHandle, G as SystemDefinition, I as ComponentType, J as BundlesOf, Jt as types_d_exports$8, K as TagType, Kt as PauseReason, L as ComponentValue, Mt as State$3, Nt as types_d_exports$9, O as ProjectionSpec, Ot as Config$3, P as AnyComponentValue, Pt as Patch, Q as GameTypes, Qt as State, 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$2, X as EmitterIdOf, Xt as Config, Y as Config$1, Yt as Api, Z as FeaturePlugin, _ as State$6, at as slot, b as DescriptionNode, bt as Hint, c as types_d_exports$10, ct as FeatureDescription, en as Config$7, et as State$1, g as Config$6, gt as SceneIdOf, h as Api$5, it as exit, jt as Root, m as ViewportSize, n as Config$4, nt as types_d_exports$5, ot as to, q as Api$1, qt as State$2, rt as defineFlow, s as State$4, st as type, t as Api$3, tn as Events, tt as TextStylesOf, ut as DefineNode, v as types_d_exports$15, vt as Descriptor, wt as State$5, x as Ease, yt as GuideOptions } from "./types-Cjf3ywai.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-DgwbzDLP.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$9, R as State$8, S as NineSlice, T as Shape, U as State$9, V as Config$10, 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-C0SLQsx0.mjs";
+import { C as Point, D as TextStyles, E as TextStyleInput, O as TextValue, S as Config$12, T as TextApi, _ as Step, a as Config$11, b as UiApi, c as SlotTags, d as Target, f as types_d_exports, g as SfxDescriptor, h as PlayDescriptor, i as BuildTools, k as types_d_exports$12, l as SlotValues, m as HapticDescriptor, n as AnimationDefinition, o as FramesValue, p as ExternalPlayer, r as AnimationSpec, s as MotionKeyframe, t as AnimApi, u as State$10, v as Config$13, w as State$11, x as types_d_exports$14, y as State$12 } from "./types-KlE_GL1z.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$15, h as types_d_exports$11, i as MusicOptions, j as GlowValue, k as FilterSpec, l as DefineScene, m as State$15, 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, w as AlphaValue, x as EmitterConfig, y as State$14 } from "./types-BTycq8_Z.mjs";
 
+//#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`, `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>;
+/**
+ * What `label` takes: the two things every label needs, and the anchor that has a default.
+ *
+ * @example
+ * ```ts
+ * const options: LabelOptions = { text: "+5", style: "board.float", at: { x: 90, y: 180 } };
+ * ```
+ */
+type LabelOptions = {
+  text: string | Message;
+  style: string;
+  at: Point;
+  anchor?: Point;
+};
+/**
+ * Bundles the two components a label needs, so a projection `view` reads as one line. The anchor
+ * is the point of the block that sits on the transform.
+ *
+ * @param options - The text, its style, where it sits, and which point of it sits there.
+ * @returns The `Text` and the `Transform` value, in that order.
+ * @example
+ * ```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 }, alpha: 1, resolved: "" }),
+ * //  Transform({ x: 90, y: 180, rotation: 0, scale: 1 })]
+ * ```
+ */
+declare function label(options: LabelOptions): [ComponentValue<TextValue>, ComponentValue<TransformValue>];
+/**
+ * Declares the text styles of a feature. The result goes under the `textStyles` key of the
+ * feature description, and `text` reads it in `onStart`.
+ *
+ * @param map - Style name to what that style looks like.
+ * @returns The registration a feature carries.
+ * @throws {Error} When a style names a wrap that is not a width and not `"none"`.
+ * @example
+ * ```ts
+ * defineTextStyles({ "hud.digits": { font: "ui.font-digits", size: 40, fill: 0xffe082 } });
+ * // { kind: "textStyles", map: { "hud.digits": { font: "ui.font-digits", bold: undefined,
+ * //   italic: undefined, size: 40, fill: 0xffe082, stroke: 0x000000, strokeWidth: 0,
+ * //   letterSpacing: 0, align: "left", wrap: "none", digits: false, shadow: undefined } } }
+ * ```
+ */
+declare function defineTextStyles(map: Record<string, TextStyleInput>): TextStyles;
+//#endregion
+//#region src/plugins/world/projection/define.d.ts
+/**
+ * Types a projection: keyed items of the model turned into entities. `Item` is inferred from the
+ * return of `from` and reaches `key`, `view` and every motion hook; `layer` and `lift` stay
+ * literal, so `defineScene` can check them against the layers of the scene.
+ *
+ * @param spec - Name, layer, optional lift layer, `from`, `key`, `view` and the motion hooks.
+ * @returns The same spec, typed.
+ * @example
+ * ```ts
+ * const boardItems = projection({
+ *   name: "board.items",
+ *   layer: "items",
+ *   from: (player: { items: { id: string }[] }) => player.items,
+ *   key: item => item.id,
+ *   view: () => []
+ * });
+ * boardItems.layer; // "items", the literal type, not string
+ * ```
+ */
+declare function projection<const LayerName extends string, const LiftName extends string, Item, Player = Json, Session = Json>(spec: ProjectionSpec<Item, LayerName, LiftName, Player, Session>): ProjectionSpec<Item, LayerName, LiftName, Player, Session>;
+/**
+ * The projection helper bound to one game's `player` and `session`.
+ *
+ * @example
+ * ```ts
+ * const bound: ProjectionFor<{ coins: number }, {}> = projection;
+ * ```
+ */
+type ProjectionFor<Player, Session> = <const LayerName extends string, const LiftName extends string, Item>(spec: ProjectionSpec<Item, LayerName, LiftName, Player, Session>) => ProjectionSpec<Item, LayerName, LiftName, Player, Session>;
+//#endregion
+//#region src/plugins/anim/index.d.ts
+/**
+ * Anim plugin: `app.anim.play(animation, slots)`, `app.anim.finishAll()`,
+ * `app.anim.setReducedMotion(on)`.
+ *
+ * @example
+ * ```ts
+ * // Animation is text: a module next to the feature, played by a node or by a test.
+ * const coinsFly = defineAnimation("hud.coinsFly", {
+ *   slots: { from: type<Target>(), to: type<Target>() },
+ *   build: ({ from, to }, { at }) =>
+ *     sequence(
+ *       tween(from, Transform, { x: at(to).x, y: at(to).y }, { ms: 600, ease: "inCubic" }),
+ *       mark("landed")
+ *     )
+ * });
+ *
+ * const app = createApp({ plugins: [...screen, animPlugin, hudFeature] });
+ *
+ * app.anim.play(coinsFly, { from: purse, to: counter }).marks(); // []: the first frame is next
+ * ```
+ */
+declare const animPlugin: import("@moku-labs/core").PluginInstance<"anim", Config$11, State$10, AnimApi, {
+  "anim:mark": {
+    animation: string;
+    mark: string;
+  };
+  "anim:finished": {
+    animation: string;
+  };
+}> & Record<never, never>;
+//#endregion
+//#region src/plugins/assets/index.d.ts
+/**
+ * Assets plugin: `app.assets.load(bundle)`, `app.assets.texture(key)`, `app.assets.usage()`.
+ *
+ * @example
+ * ```ts
+ * // A game names its manifest; the graph decides from there what is loaded and when.
+ * const app = createApp({
+ *   plugins: [...screen, boardFeature],
+ *   pluginConfigs: { assets: { manifest: "/assets/manifest.json", textureBudgetMb: 192 } }
+ * });
+ *
+ * await app.start();
+ * app.assets.usage().textureMb; // 0.188, the boot tier
+ * ```
+ */
+declare const assetsPlugin: import("@moku-labs/core").PluginInstance<"assets", Config$8, State$7, Api$6, {
+  "assets:bundle-loaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: LoadReason;
+  };
+  "assets:bundle-progress": {
+    bundle: string;
+    loaded: number;
+    total: number;
+  };
+  "assets:bundle-unloaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: "budget" | "request";
+    keys: readonly string[];
+  };
+}> & Record<never, never>;
+//#endregion
+//#region src/plugins/audio/index.d.ts
+/**
+ * Audio plugin: `app.audio`, the handlers of the effect kinds `sfx` and `music`, and the three
+ * buses a game drives from its player state.
+ *
+ * @example
+ * ```ts
+ * // A game composes it next to the screen set and points it at the player's settings.
+ * createApp({
+ *   plugins: [...screen, audioPlugin, settingsFeature],
+ *   pluginConfigs: { audio: { volumes: player => player.settings.audio } }
+ * });
+ * ```
+ */
+declare const audioPlugin: import("@moku-labs/core").PluginInstance<"audio", Config$14, State$13, AudioApi, {}> & Record<never, never>;
+//#endregion
 //#region src/plugins/clock/index.d.ts
 /**
  * Clock plugin: `app.clock.now()`, `app.clock.scheduleAt(moment)`, `app.clock.onElapsed(fn)`.
  *
  * @example
  * ```ts
- * ctx.require(clockPlugin).scheduleAt(nextDue);
+ * // A game plugin that needs trusted time declares the dependency and asks for the API.
+ * const energyPlugin = createPlugin("energy", {
+ *   depends: [clockPlugin],
+ *   api: ctx => ({ fullAt: (missing: number) => ctx.require(clockPlugin).now() + missing * 60_000 })
+ * });
  * ```
  */
 declare const clockPlugin: import("@moku-labs/core").PluginInstance<"clock", Config, State, 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$15, State$14, EffectsApi, {}> & Record<never, never>;
+//#endregion
 //#region src/plugins/flow/index.d.ts
 /**
  * Flow plugin: `app.flow.run()`, `app.flow.gate.answer(...)`, `app.flow.fx.handle(...)`.
  *
  * @example
  * ```ts
- * createApp({ pluginConfigs: { flow: { mainFlow } }, onStart: startGraph });
+ * // The game starts the graph itself: an awaited loop in onStart would never let start() resolve.
+ * createApp({
+ *   pluginConfigs: { flow: { mainFlow, safeNode: "home" } },
+ *   onStart: ctx => {
+ *     ctx.flow.run().catch(showFatal);
+ *   }
+ * });
  * ```
  */
 declare const flowPlugin: import("@moku-labs/core").PluginInstance<"flow", Config$1, State$1, Api$1, {
@@ -46,13 +247,59 @@ declare const flowPlugin: import("@moku-labs/core").PluginInstance<"flow", Confi
   };
 }> & Record<never, never>;
 //#endregion
+//#region src/plugins/i18n/index.d.ts
+/**
+ * I18n plugin: `app.i18n.format(tr("hud.orders", { n: 3 }))`, and `tr` for the game.
+ *
+ * @example
+ * ```ts
+ * // A feature ships its compiled modules; the settings screen switches between them.
+ * export const hudFeature = defineFeature("hud", {
+ *   projections: [hud],
+ *   strings: { ru: ruStrings, en: () => import("./generated/strings.en") }
+ * });
+ *
+ * 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, {
+  "i18n:locale-changed": {
+    locale: string;
+  };
+}> & Record<never, never>;
+//#endregion
+//#region src/plugins/input/index.d.ts
+/**
+ * Input plugin: `app.input.tap(target)`, `app.input.drag(from, to)`.
+ *
+ * @example
+ * ```ts
+ * // A view declares its behaviour; the engine owns the drag and the way home.
+ * const boardItems = projection({
+ *   name: "board.items",
+ *   layer: "items",
+ *   from: (player: Player) => player.items,
+ *   key: (item: Item) => item.id,
+ *   view: (item: Item) => [
+ *     Draggable({ payload: { from: item.cell } }),
+ *     DropTarget({ intent: "merge", payload: { to: item.cell } })
+ *   ]
+ * });
+ * ```
+ */
+declare const inputPlugin: import("@moku-labs/core").PluginInstance<"input", Config$10, State$9, InputApi, {}> & Record<never, never>;
+//#endregion
 //#region src/plugins/lifecycle/index.d.ts
 /**
  * Lifecycle plugin: `app.lifecycle.push(reason)`, `app.lifecycle.pop(reason)`.
  *
  * @example
  * ```ts
- * ctx.require(lifecyclePlugin).push("background");
+ * // A game plugin that reacts to the pause declares the dependency and hooks the event.
+ * const musicPlugin = createPlugin("music", {
+ *   depends: [lifecyclePlugin],
+ *   hooks: () => ({ "lifecycle:changed": ({ paused }) => music.setMuted(paused) })
+ * });
  * ```
  */
 declare const lifecyclePlugin: import("@moku-labs/core").PluginInstance<"lifecycle", Config$2, State$2, Api$2, {
@@ -71,7 +318,13 @@ declare const lifecyclePlugin: import("@moku-labs/core").PluginInstance<"lifecyc
  *
  * @example
  * ```ts
- * const transaction = ctx.require(modelPlugin).store.begin();
+ * // A game plugin that draws from committed state declares the dependency and reads the snapshot.
+ * const hudPlugin = createPlugin("hud", {
+ *   depends: [modelPlugin],
+ *   hooks: ctx => ({
+ *     "model:committed": () => drawCoins(ctx.require(modelPlugin).store.snapshot().player)
+ *   })
+ * });
  * ```
  */
 declare const modelPlugin: import("@moku-labs/core").PluginInstance<"model", Config$3, State$3, {
@@ -84,16 +337,132 @@ declare const modelPlugin: import("@moku-labs/core").PluginInstance<"model", Con
   };
 }> & Record<never, never>;
 //#endregion
+//#region src/plugins/renderer/index.d.ts
+/**
+ * Renderer plugin: `app.renderer.host.ready()`, `app.renderer.viewport.size()`,
+ * `app.renderer.sync.hitTest(...)`.
+ *
+ * @example
+ * ```ts
+ * // A game with a screen names the element the canvas goes into. Nothing else is configured.
+ * const app = createApp({
+ *   plugins: [...screen, boardFeature],
+ *   pluginConfigs: { renderer: { mount: "#game" } }
+ * });
+ *
+ * await app.start();
+ * app.renderer.host.kind(); // "webgpu" in Chrome, "webgl" on an older device
+ * ```
+ */
+declare const rendererPlugin: import("@moku-labs/core").PluginInstance<"renderer", Config$4, State$4, Api$3, {
+  "renderer:device-lost": {
+    kind: "webgpu" | "webgl";
+    reason: string;
+  };
+}> & Record<never, never>;
+//#endregion
+//#region src/plugins/scenes/index.d.ts
+/**
+ * Scenes plugin: `app.scenes.current()`, and `defineScene` for the game.
+ *
+ * @example
+ * ```ts
+ * // features/board/view/scene.ts, and the node that shows it.
+ * export const boardScene = defineScene("board", {
+ *   bundle: "board",
+ *   layers: { cells: {}, items: { sort: "y" }, lifted: {} },
+ *   projections: [boardCells, boardItems]
+ * });
+ *
+ * export const awaitIntent = defineNode({ scene: "board", rest: true, outcomes: { merge: type() } });
+ * ```
+ */
+declare const scenesPlugin: import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$15, ScenesApi, {
+  "scenes:changed": {
+    from: string | undefined;
+    to: string;
+    music: string | undefined;
+  };
+}> & Record<never, never>;
+//#endregion
+//#region src/plugins/text/index.d.ts
+/**
+ * Text plugin: `app.text.measure(...)`, the `Text` component and the helpers `label` and
+ * `defineTextStyles` a game writes.
+ *
+ * @example
+ * ```ts
+ * // A feature brings its styles; a projection puts a label over an item.
+ * export const hudStyles = defineTextStyles({
+ *   "hud.digits": { font: "ui.font-digits", size: 40, fill: 0xffe082, digits: true }
+ * });
+ *
+ * const app = createApp({ plugins: [...screen, hudFeature] });
+ *
+ * app.text.styles(); // ["body", "digits", "hud.digits"]
+ * ```
+ */
+declare const textPlugin: import("@moku-labs/core").PluginInstance<"text", Config$12, State$11, TextApi, {}> & Record<never, never>;
+//#endregion
 //#region src/plugins/time/index.d.ts
 /**
  * Time plugin: `app.time.onFrame(phase, fn)`, `app.time.step(dt)`.
  *
  * @example
  * ```ts
- * ctx.require(timePlugin).onFrame("animate", advanceTweens);
+ * // A game plugin with frame work declares the dependency and registers a callback on start.
+ * const sparklePlugin = createPlugin("sparkle", {
+ *   depends: [timePlugin],
+ *   onStart: ctx => void ctx.require(timePlugin).onFrame("animate", time => advance(time.delta))
+ * });
  * ```
  */
-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$5, State$5, Api$4, {}> & 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`.
+ *
+ * @example
+ * ```ts
+ * // A headless test reads the HUD and taps the button the popup opened.
+ * const app = createApp({ plugins: [...screen, uiPlugin, hudFeature] });
+ *
+ * app.ui.tree().type; // "row"
+ * app.input.tap(app.ui.find("claim") ?? 0);
+ * ```
+ */
+declare const uiPlugin: import("@moku-labs/core").PluginInstance<"ui", Config$13, State$12, UiApi, {}> & Record<never, never>;
+//#endregion
+//#region src/plugins/world/index.d.ts
+/**
+ * World plugin: `app.world.ecs.query(...)`, `app.world.projection.mount(...)`.
+ *
+ * @example
+ * ```ts
+ * // A test drives the screen without a browser: mount, commit, step frames.
+ * const app = createApp({ plugins: [worldPlugin, boardFeature] });
+ *
+ * app.world.projection.setLayers([{ name: "items", sort: "y" }]);
+ * app.world.projection.mount(["board.items"], { kind: "plugin", name: "test" });
+ * app.world.projection.entityOf("board.items", "i7"); // 1048576
+ * ```
+ */
+declare const worldPlugin: import("@moku-labs/core").PluginInstance<"world", Config$6, State$6, Api$5, {
+  "world:reconciled": {
+    mode: "play" | "direct";
+    projections: number;
+    entered: number;
+    changed: number;
+    exited: number;
+    revived: number;
+    queued: number;
+    hintsRouted: number;
+    hintsDropped: number;
+  };
+}> & Record<never, never>;
 //#endregion
 //#region src/plugins/flow/feature.d.ts
 /**
@@ -107,10 +476,12 @@ declare const timePlugin: import("@moku-labs/core").PluginInstance<"time", Confi
  * @throws {Error} When the name is reserved or belongs to an engine plugin.
  * @example
  * ```ts
- * export const boardFeature = defineFeature("board", {
- *   flows: [boardFlow],
- *   contribute: { afterWin: { flow: rewardFlow, order: 10 } }
+ * // The reward popup is a feature: the main flow only declares slot("afterOrder").
+ * export const rewardFeature = defineFeature("reward", {
+ *   flows: [rewardFlow],
+ *   contribute: { afterOrder: { flow: rewardFlow, order: 10 } }
  * });
+ * createApp({ plugins: [rewardFeature] }); // a headless test passes rewardFeature.logicOnly
  * ```
  */
 declare function defineFeature(name: string, description: FeatureDescription): FeaturePlugin;
@@ -125,7 +496,9 @@ declare function defineFeature(name: string, description: FeatureDescription): F
  * @returns The hint as plain data.
  * @example
  * ```ts
+ * // Inside a node body: sparkle on the merged cell, shown once the edge has committed.
  * fx.emit(hint("sparkle", { cell: "c3" }));
+ * // hint("sparkle", { cell: "c3" }) is { kind: "sparkle", payload: { cell: "c3" }, hint: true }
  * ```
  */
 declare function hint(kind: string, payload?: Json): Hint;
@@ -138,74 +511,910 @@ declare function hint(kind: string, payload?: Json): Hint;
  * @returns The descriptor a node awaits.
  * @example
  * ```ts
- * await fx(schedule(rules.nextDue(player, tables)));
+ * // Inside a node body, after the rules changed a timer: ask for the next `elapsed`.
+ * await fx(schedule(1_790_000_060_000)); // payload: { moment: 1790000060000 }
+ * await fx(schedule(undefined)); // payload: {}, the pending timer is cancelled
  * ```
  */
 declare function schedule(moment: number | undefined): Descriptor;
 /**
  * Creates the tutorial descriptor: it narrows the gate to one answer until the node exits. Its
- * visual part (highlight, hand, text) is handled by `ui` later. The highlight list is copied, so
- * a later change of the caller's array cannot reach the descriptor.
+ * visual part (`target`, highlight, hand, text) is drawn by `ui`, which dims the screen and cuts
+ * a hole over the target element. The highlight list and the target are copied, so a later change
+ * of the caller's objects cannot reach the descriptor.
  *
  * @param options - The allowed answer and the visual hints.
  * @returns The descriptor a node awaits.
  * @example
  * ```ts
- * await fx(guide({ allow: { intent: "merge", payload: { from: "c2", to: "c3" } }, hand: "drag" }));
+ * // A tutorial node: the popup lists two intents, the guide lets only "ok" through.
+ * await fx(guide({ allow: { intent: "ok" }, target: { projection: "hud", key: "play" } }));
+ * await fx({ kind: "popup", answers: ["ok", "cancel"] });
+ * // app.flow.gate.answer({ intent: "cancel" }) is false until the node exits
  * ```
  */
 declare function guide(options: GuideOptions): Descriptor;
 //#endregion
-//#region src/teardown.d.ts
+//#region src/plugins/world/ecs/define.d.ts
+/**
+ * Declares a component type. The defaults give the TypeScript type, the JSON shape and the
+ * inspector schema; the name is the storage key and the key of `motion.change`.
+ *
+ * @param name - Storage name, unique per world.
+ * @param defaults - Every field with its default value. Plain JSON only.
+ * @param options - The fields a plugin owns: a projection view neither writes nor corrects them.
+ * @param options.owned - Names of the owned fields.
+ * @returns A callable component type.
+ * @example
+ * ```ts
+ * const Item = component("Item", { kind: "", level: 1 });
+ * Item({ level: 2 }); // { type: Item, value: { kind: "", level: 2 } }
+ * Item({ level: 2 }).type.componentName; // "Item", the storage key
+ *
+ * // A caption whose drawn string is written by the plugin that draws it.
+ * const Caption = component("Caption", { text: "", shown: "" }, { owned: ["shown"] });
+ * Caption.owned; // ["shown"]
+ * ```
+ */
+declare function component<Value extends object>(name: string, defaults: Value, options?: {
+  owned?: ReadonlyArray<keyof Value & string>;
+}): ComponentType<Value>;
 /**
- * @file Teardown registry — the single allowlisted module-scope state of the package.
+ * Declares a tag: a component with no data, stored as `true`.
+ *
+ * @param name - Storage name, unique per world.
+ * @returns A callable tag type.
+ * @example
+ * ```ts
+ * const Held = tag("Held");
+ * Held(); // { type: Held, value: true }
+ * Held().type.componentName; // "Held"
+ * ```
  */
+declare function tag(name: string): TagType;
 /**
- * Function that frees one plugin's resources.
+ * Declares a resource: one mutable object per world, created from a deep clone of the defaults
+ * on first read.
  *
+ * @param name - Storage name, unique per world.
+ * @param defaults - The value a fresh world starts with.
+ * @returns The resource type.
  * @example
  * ```ts
- * const dispose: Disposer = () => cancelAnimationFrame(handle);
+ * const Pointer = resource("Pointer", { x: 0, y: 0, down: false });
+ * Pointer.defaults; // { x: 0, y: 0, down: false }
  * ```
  */
-type Disposer = () => void | Promise<void>;
+declare function resource<Value extends object>(name: string, defaults: Value): ResourceType<Value>;
 /**
- * Registers a disposer for one plugin of one app. A second call with the same key replaces the first.
+ * Marks a query term as written. The only effect is change detection: every entity the query
+ * yields is marked changed for this component.
  *
- * @param global - The app's frozen global config object, used as identity.
- * @param key - Plugin name.
- * @param dispose - Function that frees the plugin's resources.
+ * @param componentType - The component the system writes.
+ * @returns The marked term.
  * @example
  * ```ts
- * teardown.register(ctx.global, "time", stopLoop);
+ * const Transform = component("Transform", { x: 0, y: 0 });
+ * mut(Transform).kind; // "mut"
  * ```
  */
-declare function register(global: object, key: string, dispose: Disposer): void;
+declare function mut<Value extends object>(componentType: ComponentHandle<Value>): Mut<Value>;
 /**
- * Runs and removes the disposer of one plugin. A missing key is a no-op.
- * A throwing disposer is reported and never rethrown, so one plugin cannot block the stop of the others.
+ * Types a system definition. It returns the same plain object; the work is the type, which reads
+ * the query tuple and types the first argument of `run`.
  *
- * @param global - The app's global config object.
- * @param key - Plugin name.
- * @returns Resolves when the disposer has finished.
+ * @param definition - Name, phase, query and the run function.
+ * @returns The same definition, typed.
  * @example
  * ```ts
- * await teardown.run(global, "time");
+ * const Transform = component("Transform", { x: 0, y: 0 });
+ * const drift = system({
+ *   name: "drift",
+ *   phase: "animate",
+ *   query: [mut(Transform)],
+ *   run: entities => {
+ *     for (const [, transform] of entities) transform.x += 1;
+ *   }
+ * });
+ * drift.phase; // "animate"
  * ```
  */
-declare function run(global: object, key: string): Promise<void>;
+declare function system<const Terms extends readonly QueryTerm[]>(definition: SystemDefinition<Terms>): SystemDefinition<Terms>;
+/**
+ * The layer a view is drawn in. Written only by the projection; a `view` that returns it is
+ * logged and the value ignored.
+ */
+declare const Layer: ComponentType<{
+  name: string;
+}>;
+/**
+ * Explicit draw order inside a layer sorted by `"order"`.
+ */
+declare const Order: ComponentType<{
+  value: number;
+}>;
+/**
+ * The view is in the despawn queue: still drawn, never hit-tested.
+ */
+declare const Exiting: TagType;
 /**
- * Teardown registry keyed by `ctx.global`.
+ * The element description of a screen: a projection whose `view` returns one node gets it wrapped
+ * as this component, and `ui` reconciles the node into child entities. The node is a foreign
+ * object, so the world diffs it by identity and `snapshot()` leaves it out.
+ */
+declare const Tree: ComponentType<{
+  node: DescriptionNode;
+}>;
+//#endregion
+//#region src/plugins/input/components.d.ts
+/**
+ * A gesture that names an intent. `payload` is a plain JSON object of model keys, never an
+ * entity id: the flow graph reads it as the payload of the answer.
  *
  * @example
  * ```ts
- * onStop: ({ global }) => teardown.run(global, "time")
+ * const value: IntentValue = { intent: "merge", payload: { to: "c3" } };
  * ```
  */
-declare const teardown: {
-  register: typeof register;
-  run: typeof run;
+type IntentValue = {
+  intent: string;
+  payload: Json;
 };
+/**
+ * A view that can be carried. It names no intent: the drop target does.
+ *
+ * @example
+ * ```ts
+ * const value: CarryValue = { payload: { from: "c2" } };
+ * ```
+ */
+type CarryValue = {
+  payload: Json;
+};
+/**
+ * Where the one pointer is, in reference units. `justPressed` and `justReleased` are true for
+ * exactly one frame.
+ *
+ * @example
+ * ```ts
+ * const value: PointerValue = {
+ *   x: 540, y: 960, down: true, justPressed: false, justReleased: false
+ * };
+ * ```
+ */
+type PointerValue = {
+  x: number;
+  y: number;
+  down: boolean;
+  justPressed: boolean;
+  justReleased: boolean;
+};
+/**
+ * A tap on this view answers `{ intent, payload }`.
+ */
+declare const Tappable: ComponentType<IntentValue>;
+/**
+ * A long press on this view answers `{ intent, payload }`.
+ */
+declare const Pressable: ComponentType<IntentValue>;
+/**
+ * This view can be carried by the finger. It names no intent; the drop target does.
+ */
+declare const Draggable: ComponentType<CarryValue>;
+/**
+ * A drop on this view answers THIS intent, with the carried payload merged under it.
+ */
+declare const DropTarget: ComponentType<IntentValue>;
+/**
+ * A swipe on this view answers `{ intent, payload: { ...payload, direction } }`.
+ */
+declare const Swipeable: ComponentType<IntentValue>;
+/**
+ * Takes a press without naming a gesture: the hit test accepts a view that carries only this tag,
+ * and a tap on it runs the `onTap` listeners and answers nothing. `ui` tags the buttons that
+ * write local state and name no intent.
+ */
+declare const Touchable: TagType;
+/**
+ * On the carried view, from grab to release.
+ */
+declare const Held: TagType;
+/**
+ * On the topmost drop target under the finger during a drag. At most one, never the held view.
+ */
+declare const Hovered: TagType;
+/**
+ * On the pressed view, from pointer down until a tap, a long press, a grab, a swipe or a cancel.
+ */
+declare const Pressed: TagType;
+/**
+ * On the topmost view a press would take, while a mouse or a pen moves over it with no press. At
+ * most one view carries it, and a touch never hovers. A touch sample, a pointer cancel, the pointer
+ * leaving the canvas and a paused world take it away. `ui` reads it as `is.hover`. It is not
+ * `Hovered`, which marks the drop target under a drag.
+ */
+declare const PointerOver: TagType;
+/**
+ * Where the one pointer is, in reference units. Written once per frame by the frame step.
+ */
+declare const Pointer: ResourceType<PointerValue>;
+//#endregion
+//#region src/plugins/assets/bundles.d.ts
+/**
+ * Declares the bundles of one feature. The map is copied, so a later change of the caller's
+ * 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.
+ * @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.
+ * export const boardAssets = defineBundles({
+ *   board: { tier: "scene" },
+ *   "board.chains": { tier: "lazy", files: ["chains/*.png"] }
+ * });
+ * ```
+ */
+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.
+ *
+ * @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 }
+ * await fx(load(["board", "ui"])); // both, in that order
+ * ```
+ */
+declare function load(bundle: string | readonly string[]): Descriptor;
+//#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
+ * 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.
+ *
+ * @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.
+ * @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.
+ * @example
+ * ```ts
+ * // features/board/view/scene.ts of a game.
+ * export const boardScene = defineScene("board", {
+ *   bundle: "board",
+ *   layers: { background: {}, cells: {}, items: { sort: "y" }, lifted: {} },
+ *   projections: [boardCells, boardItems]
+ * });
+ *
+ * boardScene.layers[2]; // { name: "items", sort: "y" }
+ * boardScene.layers[4]; // { name: "ui", sort: "none" }, appended for the HUD
+ * ```
+ */
+declare function defineScene<Layers extends LayerMap, const Projections extends readonly AnySceneProjection[]>(id: string, scene: SceneSpec<Layers, Projections, string, string>): SceneDefinition;
+//#endregion
+//#region src/plugins/anim/components.d.ts
+/**
+ * How many tracks and running timelines name this entity. Written by `anim` while something
+ * moves and removed at zero; the inspector and `ui.lint` read it, `anim` itself never does.
+ */
+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
+/**
+ * The display components a pure `defineMotion` can name. A hook has no context, so it can only
+ * reach the components `anim` itself imports: the four of `renderer` that carry numeric fields.
+ *
+ * @example
+ * ```ts
+ * type Fields = MotionComponents["Transform"]; // { x: number; y: number; rotation: number; scale: number }
+ * ```
+ */
+type MotionComponents = {
+  Transform: TransformValue;
+  Sprite: SpriteValue;
+  NineSlice: NineSliceValue;
+  Shape: ShapeValue;
+};
+/**
+ * One named pose: the numeric fields it gives each component it names.
+ *
+ * @example
+ * ```ts
+ * const hidden: MotionState = { Transform: { scale: 0.8 }, Shape: { alpha: 0 } };
+ * ```
+ */
+type MotionState = { readonly [Name in keyof MotionComponents]?: Readonly<Partial<NumericFields<MotionComponents[Name]>>> };
+/**
+ * What `defineMotion` is given: the named poses, the keyframe tracks, how long the way takes, and
+ * which hooks to build. `on.enter` and `on.exit` name a state or a track. For a track,
+ * `transition.ms` is the whole walk and each segment eases by its key, not by `transition.ease`.
+ *
+ * `loop.track` names a keyframe track that plays from the moment the element enters, forever,
+ * added over whatever else moves it: one cycle is `loop.ms` (default `transition.ms`), every
+ * Transform key is an offset from rest, and the last key repeats the first one. It is not part of
+ * the motion `enter` returns.
+ *
+ * @example
+ * ```ts
+ * const spec: MotionSpec = {
+ *   states: { hidden: { Transform: { scale: 0.8 } } },
+ *   keyframes: { dropIn: [{ at: 0, Transform: { dy: -780, scale: 0.8 } }, { at: 0.42, Transform: { dy: 14 } }] },
+ *   transition: { ms: 1000 },
+ *   on: { enter: "dropIn", exit: "hidden", change: ["Transform"] }
+ * };
+ * // An order card pops in over 250 ms and sways on its pin, one swing every 2400 ms.
+ * const orderCard: MotionSpec = {
+ *   states: { small: { Transform: { scale: 0.8 } } },
+ *   keyframes: { sway: [{ at: 0, Transform: { rotation: 0 } }, { at: 0.5, Transform: { rotation: 0.03 } }, { at: 1, Transform: { rotation: 0 } }] },
+ *   transition: { ms: 250 },
+ *   loop: { track: "sway", ms: 2400 },
+ *   on: { enter: "small" }
+ * };
+ * ```
+ */
+type MotionSpec = {
+  readonly states?: Readonly<Record<string, MotionState>>;
+  readonly keyframes?: Readonly<Record<string, readonly MotionKeyframe[]>>;
+  readonly transition?: {
+    readonly ms?: number;
+    readonly ease?: Ease;
+  };
+  readonly loop?: {
+    readonly track: string;
+    readonly ms?: number;
+  };
+  readonly on: {
+    readonly enter?: string;
+    readonly exit?: string;
+    readonly change?: readonly (keyof MotionComponents & string)[];
+  };
+};
+/**
+ * Builds the projection motion hooks of an element from named poses and keyframe tracks. The
+ * transition is resolved and every name is checked here, at definition time, so every track it
+ * starts carries a concrete duration and a wrong name fails where it is written. A `loop` builds
+ * the `loop` hook: `world` and `ui` play it wherever they play `enter`, so a projection view loops
+ * once it entered with motion, never 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.
+ *
+ * @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.
+ * @example
+ * ```ts
+ * const buttonMotion = defineMotion({
+ *   states: { hidden: { Transform: { scale: 0.8 }, Shape: { alpha: 0 } } },
+ *   transition: { ms: 150, ease: "out" },
+ *   on: { enter: "hidden", exit: "hidden", change: ["Transform"] }
+ * });
+ * buttonMotion.settle; // undefined
+ * ```
+ */
+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;
+/**
+ * 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.
+ *
+ * @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.
+ * @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
+ * ```
+ */
+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;
+/**
+ * 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.
+ *
+ * @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.
+ * @example
+ * ```ts
+ * set({ projection: "hud", key: "coins" }, Sprite, { texture: "hud.coin-gold" });
+ * // { kind: "set", patch: { texture: "hud.coin-gold" }, ... }
+ * ```
+ */
+declare function set<Value extends object>(target: Target, component: ComponentHandle<Value>, patch: Partial<Value>): Step;
+/**
+ * Plays a frame sprite: one texture key of the list per frame of `fps`, written into `Sprite`.
+ *
+ * @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, ... }
+ * ```
+ */
+declare function frames(target: Target, options: {
+  keys: readonly string[];
+  fps: number;
+  loop?: boolean;
+}): Step;
+/**
+ * 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)`.
+ *
+ * @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.
+ * @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 }
+ * ```
+ */
+declare function spawn(id: string, components: readonly AnyComponentValue[], options?: {
+  layer?: string;
+  order?: number;
+}): Step;
+/**
+ * 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.
+ *
+ * @param id - The id the `spawn` step was given.
+ * @returns The target.
+ * @example
+ * ```ts
+ * tween(spawned("coin1"), Transform, { x: 40, y: 120 }, { ms: 600, ease: "inCubic" });
+ * // { kind: "tween", target: { spawned: "coin1" }, ... }
+ * ```
+ */
+declare function spawned(id: string): {
+  spawned: string;
+};
+/**
+ * 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.
+ *
+ * @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 }
+ * ```
+ */
+declare function sfx(key: string, options?: {
+  bus?: string;
+}): SfxDescriptor;
+/**
+ * A haptic tick. `platform` owns the handler; a device without one stays still.
+ *
+ * @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 }
+ * ```
+ */
+declare function haptic(kind: string): HapticDescriptor;
+/**
+ * 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.
+ *
+ * @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.
+ * ```
+ */
+declare function external(_player: ExternalPlayer, _clip: string): never;
+/**
+ * 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`.
+ *
+ * @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", ... } }
+ * ```
+ */
+declare function use<Tags extends SlotTags>(animation: AnimationDefinition<Tags>, slots: SlotValues<Tags>, tools?: BuildTools): Step;
+/**
+ * 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.
+ *
+ * @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 }
+ * ```
+ */
+declare function play<Tags extends SlotTags>(animation: AnimationDefinition<Tags>, slots: SlotValues<Tags>): PlayDescriptor;
+/**
+ * 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.
+ *
+ * @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"
+ * ```
+ */
+declare function defineAnimation<Tags extends SlotTags>(id: string, spec: AnimationSpec<Tags>): AnimationDefinition<Tags>;
+//#endregion
+//#region src/plugins/i18n/tr.d.ts
+/**
+ * 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 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" }
+ * ```
+ */
+declare function tr(key: string, params?: Record<string, Argument>): Message;
+//#endregion
+//#region src/plugins/ui/styles/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.
+ *
+ * @param style - The style, with its `is` and `when` variants.
+ * @returns The same object, frozen.
+ * @example
+ * ```ts
+ * defineStyle({ direction: "row", gap: 12 }).gap; // 12
+ * ```
+ */
+declare function defineStyle<const Given extends Style>(style: Given): Readonly<Given>;
+//#endregion
+//#region src/plugins/ui/styles/resolve.d.ts
+/**
+ * The flags one element is resolved against: the viewport flags of the frame plus its own state.
+ *
+ * @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
+ * };
+ * ```
+ */
+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;
+//#endregion
+//#region src/plugins/audio/descriptors.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.
+ *
+ * @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
+ * // 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 music(key: string | null, options?: MusicOptions): Descriptor;
+//#endregion
+//#region src/plugins/effects/filters/builtins.d.ts
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // 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 const Glow: FilterComponent<GlowValue>;
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // The selected card is outlined in honey.
+ * Outline({ thickness: 4, color: 0xffc233 }).value; // { thickness: 4, color: 0xffc233, alpha: 1, enabled: true, order: 0 }
+ * ```
+ */
+declare const Outline: FilterComponent<OutlineValue>;
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // 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 const Blur: ComponentType<BlurValue>;
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // A locked card goes gray.
+ * ColorMatrix({ grayscale: 1 }).value.grayscale; // 1
+ * ```
+ */
+declare const ColorMatrix: ComponentType<ColorMatrixValue>;
+/**
+ * Pixi's noise. The seed is always given, never Pixi's random default, so two runs draw the same
+ * grain.
+ *
+ * @example
+ * ```ts
+ * Noise({ amount: 0.2, seed: 7 }).value; // { amount: 0.2, seed: 7, enabled: true, order: 0 }
+ * ```
+ */
+declare const Noise: ComponentType<NoiseValue>;
+/**
+ * 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.
+ *
+ * @example
+ * ```ts
+ * // Heat haze over the furnace.
+ * Displacement({ map: "fx.ripple", scaleX: 8, scaleY: 8 }).value.map; // "fx.ripple"
+ * ```
+ */
+declare const Displacement: ComponentType<DisplacementValue>;
+/**
+ * Pixi's alpha over a view and its subtree as one layer, so overlapping children do not show
+ * through each other.
+ *
+ * @example
+ * ```ts
+ * Alpha({ alpha: 0.5 }).value; // { alpha: 0.5, enabled: true, order: 0 }
+ * ```
+ */
+declare const Alpha: ComponentType<AlphaValue>;
+//#endregion
+//#region src/plugins/effects/filters/define.d.ts
+/**
+ * Turns a WGSL fragment body into a filter component type. The engine prepends the vertex stage,
+ * the input bindings and a `FilterUniforms` struct in declaration order, bound as `fu`. Every
+ * number uniform is a number field, so the existing `tween` drives it; a colour is one hex field
+ * sent as a `vec3<f32>`; 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 id - The filter id, also the component name; unique, and not one of the built-ins.
+ * @param spec - The body, 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 body has no `mainFragment`, a uniform is reserved,
+ *   badly named or of no known form, or the passes or the padding break their rules.
+ * @example
+ * ```ts
+ * // features/board/effects.ts: a gold tint a motion hook tweens on a merge.
+ * const Tint = defineFilter("fx.tint", { wgsl: tintBody, uniforms: { amount: 0, color: { color: 0xffd700 } } });
+ * Tint({ amount: 1 }).value; // { amount: 1, color: 0xffd700, enabled: true, order: 0 }
+ * Tint.filter.passes; // 1
+ * ```
+ */
+declare function defineFilter<Uniforms extends Record<string, UniformDeclaration> = Record<never, never>>(id: string, spec: FilterSpec<Uniforms>): FilterComponent<FilterValueOf<Uniforms>>;
+//#endregion
+//#region src/plugins/effects/particles/component.d.ts
+/**
+ * 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
+ * // 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 }
+ * ```
+ */
+declare const Emitter: ComponentType<EmitterValue>;
+//#endregion
+//#region src/plugins/effects/particles/define.d.ts
+/**
+ * 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 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
+ * // 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 defineEmitter(id: string, config: EmitterConfig): EmitterDefinition;
 //#endregion
 //#region src/index.d.ts
 /**
@@ -213,10 +1422,14 @@ declare const teardown: {
  *
  * @example
  * ```ts
- * const app = createApp({ plugins: [boardFeature] });
+ * // The entry point of a game. The graph is started by the game, never by the plugin.
+ * const app = createApp({
+ *   pluginConfigs: { flow: { mainFlow, safeNode: "home" } },
+ *   onStart: ctx => void ctx.flow.run().catch(error => ctx.log.error("game: failed", { error }))
+ * });
  * ```
  */
-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$7, Events, (import("@moku-labs/core").PluginInstance<"time", Config$5, State$5, Api$4, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$2, State$2, Api$2, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -256,7 +1469,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$7, Events, (import("@moku-labs/core").PluginInstance<"time", Config$5, State$5, Api$4, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$2, State$2, Api$2, {
   "lifecycle:changed": {
     reason: PauseReason;
     action: "push" | "pop";
@@ -302,26 +1515,155 @@ declare const createApp: <const ExtraPlugins extends readonly import("@moku-labs
  *
  * @example
  * ```ts
- * export const scorePlugin = createPlugin("score", { api: createScoreApi });
+ * // A game plugin that writes every edge of the graph to the log.
+ * export const edgeLog = createPlugin("edgeLog", {
+ *   depends: [flowPlugin],
+ *   hooks: ctx => ({ "flow:edge": ({ node, outcome }) => ctx.log.info("edge", { node, outcome }) })
+ * });
+ * ```
+ */
+declare const createPlugin: import("@moku-labs/core").BoundCreatePluginFunction<Config$7, 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>]>>;
+/**
+ * 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`, `strings`
+ *   and `emitters`.
+ * @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 } =
+ *   defineGame<{ player: Player; session: Session; assets: AssetKey; bundles: BundleKey; strings: StringTable }>();
  * ```
  */
-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 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>;
+  defineTokens: typeof defineTokens;
+  popup: <Properties extends object, Local extends object>(component: PopupComponent<Properties, Local>, props: Properties, options?: {
+    over?: string;
+  }) => Descriptor;
+  intrinsics: IntrinsicElementsFor<Types["assets"], TextStylesOf<Types>, Extract<keyof Types["strings"], string>>;
+  label: (options: Omit<LabelOptions, "style"> & {
+    style: TextStylesOf<Types>;
+  }) => ReturnType<typeof label>;
+  defineTextStyles: (map: Record<string, Omit<TextStyleInput, "bold" | "font" | "italic"> & {
+    font: Types["assets"];
+  } & {
+    bold?: Types["assets"];
+    italic?: Types["assets"];
+  }>) => TextStyles;
+  tr: TypedTr<Types["strings"]>;
+  defineAnimation: typeof defineAnimation;
+  frames: (target: Target, options: {
+    keys: readonly Types["assets"][];
+    fps: number;
+    loop?: boolean;
+  }) => Step;
+  sfx: (key: Types["assets"], options?: {
+    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>>;
+  sprite: (options: Omit<SpriteOptions, "texture"> & {
+    texture: Types["assets"];
+  }) => ReturnType<typeof sprite>;
+  Sprite: Narrowed<SpriteValue, Partial<Omit<SpriteValue, "texture">> & {
+    texture?: Types["assets"];
+  }>;
+  NineSlice: Narrowed<NineSliceValue, Partial<Omit<NineSliceValue, "texture">> & {
+    texture?: Types["assets"];
+  }>;
+  projection: ProjectionFor<Types["player"], Types["session"]>;
+  defineNode: DefineNode<{
+    player: Types["player"];
+    session: Types["session"];
+    scenes: SceneIdOf<Types>;
+  }>;
+  defineFlow: typeof defineFlow;
+  defineFeature: (name: string, description: FeatureDescription) => FeaturePlugin;
+};
 /**
- * Binds the authoring helpers to the types of one game: "createApp for a game". The binding is
- * type-only; at run time these are the same functions the plugins export. One line per helper,
- * no logic: anything a single plugin can own lives in that plugin.
+ * 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` and `effects` stay opt-in: `[...screen, audioPlugin, effectsPlugin]`.
  *
- * @returns The helpers typed with the game's `player` and `session`.
  * @example
  * ```ts
- * export const { defineNode, defineFlow, defineFeature } = defineGame<{
- *   player: Player;
- *   session: Session;
- *   assets: AssetKey;
- *   strings: StringTable;
- * }>();
+ * createApp({ plugins: [...screen, boardFeature], pluginConfigs: { renderer: { mount: "#game" } } });
  * ```
  */
-declare function defineGame<Types extends GameTypes>(): Kit<Types>;
+declare const screen: readonly [import("@moku-labs/core").PluginInstance<"world", Config$6, State$6, Api$5, {
+  "world:reconciled": {
+    mode: "play" | "direct";
+    projections: number;
+    entered: number;
+    changed: number;
+    exited: number;
+    revived: number;
+    queued: number;
+    hintsRouted: number;
+    hintsDropped: number;
+  };
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"renderer", Config$4, State$4, 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, {
+  "assets:bundle-loaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: LoadReason;
+  };
+  "assets:bundle-progress": {
+    bundle: string;
+    loaded: number;
+    total: number;
+  };
+  "assets:bundle-unloaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: "budget" | "request";
+    keys: readonly string[];
+  };
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"scenes", Record<string, never>, State$15, ScenesApi, {
+  "scenes:changed": {
+    from: string | undefined;
+    to: string;
+    music: string | undefined;
+  };
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"anim", Config$11, State$10, AnimApi, {
+  "anim:mark": {
+    animation: string;
+    mark: string;
+  };
+  "anim:finished": {
+    animation: string;
+  };
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"i18n", Config$9, State$8, I18nApi, {
+  "i18n:locale-changed": {
+    locale: string;
+  };
+}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"text", Config$12, State$11, TextApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"ui", Config$13, State$12, UiApi, {}> & Record<never, never>];
 //#endregion
-export { types_d_exports as Clock, types_d_exports$1 as Flow, types_d_exports$2 as Lifecycle, types_d_exports$3 as Model, SaveUnreadableError, types_d_exports$4 as Time, clockPlugin, createApp, createPlugin, defineFeature, defineGame, exit, flowPlugin, guide, hint, lifecyclePlugin, modelPlugin, schedule, slot, teardown, timePlugin, to, type };
+export { Alpha, types_d_exports as Anim, Animation, types_d_exports$1 as Assets, types_d_exports$2 as Audio, 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, 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, Pointer, PointerOver, Pressable, Pressed, types_d_exports$10 as Renderer, SaveUnreadableError, types_d_exports$11 as Scenes, Shape, Sprite, Swipeable, Tappable, Text, types_d_exports$12 as TextTypes, types_d_exports$13 as Time, Touchable, Transform, Tree, types_d_exports$14 as Ui, types_d_exports$15 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, 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 };