@moku-labs/game 0.8.0 → 0.10.0

package/dist/index.d.mts

@@ -1,1597 +1,6 @@
-import { $ as Events, A as Api$3, B as State$4, D as GuideOptions, E as Descriptor, H as Patch, I as Config$4, J as StoreApi, K as SaveUnreadableError, M as State$5, O as Hint, P as types_d_exports$14, Q as Config$3, R as Json, V as types_d_exports$9, Y as RngApi, Z as Api$2, a as FeaturePlugin, c as State$2, ct as Config$6, d as defineFlow, et as PauseReason, f as exit, g as FeatureDescription, h as type, i as EmitterIdOf, it as Config$1, j as Config$5, l as TextStylesOf, lt as Events$1, m as to, n as BundlesOf, nt as types_d_exports$8, o as GameTypes, ot as State$1, p as slot, r as Config$2, rt as Api, st as types_d_exports$3, t as Api$1, tt as State$3, u as types_d_exports$5, ut as Require, v as DefineNode, w as SceneIdOf, z as Root } from "./types-ERb2Y9U5.mjs";
-import { $ as Ease, A as Config$9, B as ComponentValue, G as Narrowed, J as ResourceType, L as ComponentHandle, M as State$8, N as types_d_exports$16, O as ViewportSize, Q as DescriptionNode, S as types_d_exports$11, W as Mut, X as TagType, Y as SystemDefinition, a as DefineBundles, at as ProjectionMotion, b as State$7, c as LoadReason, d as Tier, h as Config$8, i as Config$7, it as NumericFields, k as Api$6, m as Api$5, n as BundleMap, ot as ProjectionSpec, p as types_d_exports$1, q as QueryTerm, r as BundleSpec, s as LoadBundles, t as Api$4, u as State$6, z as ComponentType } from "./types-BWzCSRM2.mjs";
-import { $ as SpriteValue, A as TextStyleInput, B as types_d_exports$6, C as Config$12, D as TextApi, E as State$11, F as Config$10, G as Display, H as InputApi, I as I18nApi, J as Parent, K as NineSlice, L as Message, M as TextValue, N as types_d_exports$13, O as TextBind, P as Argument, Q as SpriteOptions, R as State$9, S as BindOptions, T as Point, U as State$10, V as Config$11, W as types_d_exports$7, X as ShapeValue, Y as Shape, Z as Sprite, _ as Style, b as defineComponent, d as popup, et as Transform, f as defineTokens, g as ResolvedStyle, h as IsFlags, j as TextStyles, k as TextFormat, l as Box, nt as sprite, p as IntrinsicElementsFor, q as NineSliceValue, s as PopupComponent, tt as TransformValue, u as LocalWrite, w as CountdownValue, x as BindField, y as WhenFlags, z as TypedTr } from "./types-DgdMLZnV.mjs";
-import { A as HAPTIC_KINDS, B as sfx, C as MotionKeyframe, D as HapticKind, E as types_d_exports, F as mark, G as use, H as spawned, I as parallel, K as wait, L as play, M as external, N as frames, O as SfxDescriptor, P as haptic, R as sequence, S as FramesValue, T as Target, U as stagger, V as spawn, W as tween, _ as State$15, b as AnimApi, c as AnySceneProjection, d as SceneDefinition, f as SceneSpec, g as Config$15, h as types_d_exports$12, i as MusicOptions, j as defineAnimation, k as Step, 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, v as UiApi, w as State$12, x as Config$13, y as types_d_exports$15, z as set } from "./types-DlgsfOmW.mjs";
-import { _ as NoiseValue, a as types_d_exports$4, c as EmitterValue, d as ColorMatrixValue, f as DisplacementValue, g as GlowValue, h as FilterValueOf, i as State$16, l as AlphaValue, m as FilterSpec, n as EffectsApi, o as EmitterConfig, p as FilterComponent, s as EmitterDefinition, t as Config$16, u as BlurValue, v as OutlineValue, y as UniformDeclaration } from "./types-DF5kkW-C.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`, `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>;
-/**
- * Shows a numeric component field of the label's own entity: read every frame, written to
- * `Text.resolved` only when the shown string changes. The field must hold a number; the format
- * is `"int"` (rounded) unless named. Reads the component's own name, so a renamed component
- * cannot drift from its label.
- *
- * @param component - The component whose field the label shows.
- * @param field - A numeric field of that component.
- * @param options - How the number is shown.
- * @returns The bind a `Text` carries.
- * @example
- * ```ts
- * const Counter = component("Counter", { value: 0 });
- *
- * bind(Counter, "value"); // { component: "Counter", field: "value", format: "int" }
- *
- * // The chest timer: the time left, as minutes and seconds.
- * Text({ style: "digits", bind: bind(Countdown, "left", { format: "mm:ss" }) });
- * // bind is { component: "Countdown", field: "left", format: "mm:ss" }; 95 s left shows "01:35"
- * ```
- */
-declare function bind<Value extends object>(component: ComponentHandle<Value>, field: BindField<Value>, options?: BindOptions): TextBind;
-/**
- * A moment to count down to. A game writes `until`, a moment of `clock` in epoch milliseconds;
- * `text` keeps `left` at the time that is left, computed from one `clock.now()` per frame on the
- * render side, and writes it only when the label bound to it changes. At zero both stay at zero.
- * Nothing of it reaches the save.
- *
- * @example
- * ```ts
- * // The chest of the board opens at a moment of the save; clock.now() is 1_790_000_000_000.
- * view: chest => [
- *   Countdown({ until: chest.opensAt }), // opensAt: 1_790_000_095_000
- *   Text({ style: "digits", bind: bind(Countdown, "left", { format: "mm:ss" }) })
- * ]
- * // after the frame that spawns it: Text.resolved is "01:35", Countdown.left is 95000
- * ```
- */
-declare const Countdown: ComponentType<CountdownValue>;
-/**
- * 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$13, State$12, 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$7, State$6, Api$4, {
-  "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
- * // 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$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$16, 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
- * // 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$2, State$2, Api$1, {
-  "flow:edge": {
-    flow: string;
-    node: string;
-    outcome: string;
-    payload: Json;
-    next: string;
-    patches: {
-      doc: Patch[];
-      session: Patch[];
-    };
-    index: number;
-    now: number;
-  };
-  "flow:rest": {
-    path: string;
-    checkpoint: boolean;
-  };
-  "flow:error": {
-    path: string;
-    error: unknown;
-    rolledBackTo: string;
-    retry: boolean;
-  };
-}> & 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$10, State$9, 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$11, State$10, InputApi, {}> & Record<never, never>;
-//#endregion
-//#region src/plugins/lifecycle/index.d.ts
-/**
- * Lifecycle plugin: `app.lifecycle.push(reason)`, `app.lifecycle.pop(reason)`.
- *
- * @example
- * ```ts
- * // 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$3, State$3, Api$2, {
-  "lifecycle:changed": {
-    reason: PauseReason;
-    action: "push" | "pop";
-    reasons: readonly PauseReason[];
-    paused: boolean;
-    resumed: boolean;
-  };
-}> & Record<never, never>;
-//#endregion
-//#region src/plugins/model/index.d.ts
-/**
- * Model plugin: `app.model.store`, `app.model.rng`.
- *
- * @example
- * ```ts
- * // 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$4, State$4, {
-  store: StoreApi;
-  rng: RngApi;
-}, {
-  "model:committed": {
-    roots: readonly Root[];
-    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
-/**
- * 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$8, State$7, Api$5, {
-  "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$14, 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
- * // 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$5, State$5, Api$3, {}> & 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$15, State$15, 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$9, State$8, Api$6, {
-  "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
-/**
- * Turns a feature description into a plugin that registers it with `flow.features` in `onInit`.
- * Throws for a name that is reserved or already a plugin. The plugin carries `logicOnly`: the
- * same plugin built from the V1 keys of the description, for headless tests.
- *
- * @param name - Feature name. Shares the namespace with plugin names.
- * @param description - What the feature brings: nodes, flows, slot contributions.
- * @returns The feature plugin, with its `logicOnly` twin.
- * @throws {Error} When the name is reserved or belongs to an engine plugin.
- * @example
- * ```ts
- * // 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;
-//#endregion
-//#region src/plugins/flow/fx/descriptors.d.ts
-/**
- * Creates a fire-and-forget cosmetic descriptor for `fx.emit`. It is dispatched only after the
- * commit of its transaction and dropped in fast mode.
- *
- * @param kind - Effect kind a handler is registered for.
- * @param payload - Plain JSON for the handler.
- * @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;
-/**
- * Creates the awaited effect that asks the clock for one `elapsed` at this moment. `undefined`
- * means nothing is due and leaves the `moment` key out, so the descriptor stays plain JSON. Its
- * handler runs in fast mode too.
- *
- * @param moment - Epoch milliseconds of the next due timer, or `undefined`.
- * @returns The descriptor a node awaits.
- * @example
- * ```ts
- * // 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 (`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
- * // 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/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>;
-/**
- * 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;
-/**
- * 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 Pointer = resource("Pointer", { x: 0, y: 0, down: false });
- * Pointer.defaults; // { x: 0, y: 0, down: false }
- * ```
- */
-declare function resource<Value extends object>(name: string, defaults: Value): ResourceType<Value>;
-/**
- * Marks a query term as written. The only effect is change detection: every entity the query
- * yields is marked changed for this component.
- *
- * @param componentType - The component the system writes.
- * @returns The marked term.
- * @example
- * ```ts
- * const Transform = component("Transform", { x: 0, y: 0 });
- * mut(Transform).kind; // "mut"
- * ```
- */
-declare function mut<Value extends object>(componentType: ComponentHandle<Value>): Mut<Value>;
-/**
- * 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 definition - Name, phase, query and the run function.
- * @returns The same definition, typed.
- * @example
- * ```ts
- * 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 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;
-/**
- * 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
- * const value: IntentValue = { intent: "merge", payload: { to: "c3" } };
- * ```
- */
-type IntentValue = {
-  intent: string;
-  payload: Json;
-};
-/**
- * A view that can be carried. It names no intent: the drop target does. `carry` lists the
- * projection keys of views of the same projection that ride along on top of it, such as the cards
- * that lie on a solitaire card.
- *
- * @example
- * ```ts
- * const value: CarryValue = { payload: { from: "c7" }, carry: ["c8", "c9"] };
- * ```
- */
-type CarryValue = {
-  payload: Json;
-  carry: readonly string[];
-};
-/**
- * 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. The views
- * whose keys `carry` lists hang under it from the grab to the release and fly home with it.
- */
-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>;
-/**
- * A finger drawn through views that carry this answers once, on the release:
- * `{ intent, payload: { path } }`, the payloads of the cells in the order the finger went through
- * them. Going back to the cell before the last takes the last one off. It wins over every other
- * gesture component on the same view.
- */
-declare const Traceable: 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 every view of the trace in progress, from the moment the finger reaches it until it backs
- * off it or the trace ends. A game system draws the line through them.
- */
-declare const Traced: 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/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`.
- * It takes 64 to 256 probes, by radius in physical pixels: about 3.5 physical pixels apart up to
- * a radius of 32 physical pixels. 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 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 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
- * // 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 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
-/**
- * Creates a game application.
- *
- * @example
- * ```ts
- * // 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$6, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$5, State$5, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$3, State$3, Api$2, {
-  "lifecycle:changed": {
-    reason: PauseReason;
-    action: "push" | "pop";
-    reasons: readonly PauseReason[];
-    paused: boolean;
-    resumed: boolean;
-  };
-}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"model", Config$4, State$4, {
-  store: StoreApi;
-  rng: RngApi;
-}, {
-  "model:committed": {
-    roots: readonly Root[];
-    cause: "edge" | "rollback" | "restore" | "load";
-  };
-}> & 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;
-    outcome: string;
-    payload: Json;
-    next: string;
-    patches: {
-      doc: Patch[];
-      session: Patch[];
-    };
-    index: number;
-    now: number;
-  };
-  "flow:rest": {
-    path: string;
-    checkpoint: boolean;
-  };
-  "flow:error": {
-    path: string;
-    error: unknown;
-    rolledBackTo: string;
-    retry: boolean;
-  };
-}> & Record<never, never>) | ExtraPlugins[number], [...ExtraPlugins], import("@moku-labs/core").CoreApisFromTuple<[import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi>, import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>]>, import("@moku-labs/core").CorePluginInstance<"log", import("@moku-labs/common/browser").LogConfig, import("@moku-labs/common/browser").LogState, import("@moku-labs/common/browser").LogApi> | import("@moku-labs/core").CorePluginInstance<"env", import("@moku-labs/common/browser").EnvConfig, import("@moku-labs/common/browser").EnvState, import("@moku-labs/common/browser").EnvApi>> | undefined) => import("@moku-labs/core").App<Config$6, Events$1, (import("@moku-labs/core").PluginInstance<"time", Config$5, State$5, Api$3, {}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"lifecycle", Config$3, State$3, Api$2, {
-  "lifecycle:changed": {
-    reason: PauseReason;
-    action: "push" | "pop";
-    reasons: readonly PauseReason[];
-    paused: boolean;
-    resumed: boolean;
-  };
-}> & Record<never, never>) | (import("@moku-labs/core").PluginInstance<"model", Config$4, State$4, {
-  store: StoreApi;
-  rng: RngApi;
-}, {
-  "model:committed": {
-    roots: readonly Root[];
-    cause: "edge" | "rollback" | "restore" | "load";
-  };
-}> & 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;
-    outcome: string;
-    payload: Json;
-    next: string;
-    patches: {
-      doc: Patch[];
-      session: Patch[];
-    };
-    index: number;
-    now: number;
-  };
-  "flow:rest": {
-    path: string;
-    checkpoint: boolean;
-  };
-  "flow:error": {
-    path: string;
-    error: unknown;
-    rolledBackTo: string;
-    retry: boolean;
-  };
-}> & Record<never, never>) | ExtraPlugins[number], 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>]>>;
-/**
- * Creates a game plugin.
- *
- * @example
- * ```ts
- * // 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$6, 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`, `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 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;
-};
-/**
- * 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`, `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$9, State$8, Api$6, {
-  "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$8, State$7, Api$5, {
-  "renderer:device-lost": {
-    kind: "webgpu" | "webgl";
-    reason: string;
-  };
-}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"input", Config$11, State$10, InputApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"assets", Config$7, State$6, Api$4, {
-  "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$14, 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, {
-  "anim:mark": {
-    animation: string;
-    mark: string;
-  };
-  "anim:finished": {
-    animation: string;
-  };
-}> & 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$12, State$11, TextApi, {}> & Record<never, never>, import("@moku-labs/core").PluginInstance<"ui", Config$15, State$15, UiApi, {}> & Record<never, never>];
-//#endregion
-export { Alpha, types_d_exports as Anim, Animation, types_d_exports$1 as Assets, types_d_exports$2 as Audio, type BackResult, type BindOptions, Blur, Box, types_d_exports$3 as Clock, ColorMatrix, Countdown, type CountdownValue, 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, type TextFormat, types_d_exports$13 as TextTypes, types_d_exports$14 as Time, Touchable, Traceable, Traced, Transform, Tree, types_d_exports$15 as Ui, types_d_exports$16 as World, animPlugin, assetsPlugin, audioPlugin, bind, 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 };
+import { $ as DescriptionNode, $t as types_d_exports$9, C as types_d_exports$11, Ct as slot, Kt as types_d_exports$3, P as types_d_exports$16, St as exit, Tt as type, bt as types_d_exports$5, in as SaveUnreadableError, m as types_d_exports$1, mn as types_d_exports$8, wt as to, yn as types_d_exports$14 } from "./types-ZQLYXo5X.mjs";
+import { B as sequence, F as frames, G as stagger, H as sfx, I as haptic, J as wait, K as tween, L as mark, M as HAPTIC_KINDS, N as defineAnimation, O as types_d_exports, P as external, R as parallel, U as spawn, V as set, W as spawned, b as types_d_exports$12, f as types_d_exports$2, i as types_d_exports$15, k as HapticKind, q as use, z as play } from "./types-BM4shh8K.mjs";
+import { a as types_d_exports$4 } from "./types-CefgYzFt.mjs";
+import { C as TextFormat, D as types_d_exports$13, H as Transform, I as Parent, L as Shape, M as types_d_exports$7, N as Display, O as defineComponent, P as NineSlice, W as sprite, Z as types_d_exports$6, d as popup, f as defineTokens, g as BindOptions, l as Box, u as LocalWrite, v as CountdownValue, z as Sprite } from "./types-BUwDHKXm.mjs";
+import { $ as uiPlugin, A as Pointer, B as Layer, C as defineScene, Ct as label, D as DropTarget, E as Draggable, F as Tappable, G as resource, H as Tree, I as Touchable, J as guide, K as system, L as Traceable, M as Pressable, N as Pressed, O as Held, P as Swipeable, Q as worldPlugin, R as Traced, S as Frames, St as defineTextStyles, T as load, U as component, V as Order, W as mut, X as schedule, Y as hint, Z as defineFeature, _ as defineStyle, _t as animPlugin, a as defineEmitter, at as BackResult, b as AnimPlayer, bt as Text, c as Alpha, ct as modelPlugin, d as Displacement, dt as i18nPlugin, et as timePlugin, f as Glow, ft as flowPlugin, g as resolve, gt as assetsPlugin, h as music, ht as audioPlugin, i as screen, it as platformPlugin, j as PointerOver, k as Hovered, l as Blur, lt as lifecyclePlugin, m as Outline, mt as clockPlugin, n as createPlugin, nt as scenesPlugin, o as Emitter, ot as PlatformProvider, p as Noise, pt as effectsPlugin, q as tag, r as defineGame, rt as rendererPlugin, s as defineFilter, st as types_d_exports$10, t as createApp, tt as textPlugin, u as ColorMatrix, ut as inputPlugin, v as tr, vt as projection, w as defineBundles, x as Animation, xt as bind, y as defineMotion, yt as Countdown, z as Exiting } from "./index-xxSxKJJW.mjs";
+export { Alpha, types_d_exports as Anim, AnimPlayer, Animation, types_d_exports$1 as Assets, types_d_exports$2 as Audio, type BackResult, type BindOptions, Blur, Box, types_d_exports$3 as Clock, ColorMatrix, Countdown, type CountdownValue, 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, type TextFormat, types_d_exports$13 as TextTypes, types_d_exports$14 as Time, Touchable, Traceable, Traced, Transform, Tree, types_d_exports$15 as Ui, types_d_exports$16 as World, animPlugin, assetsPlugin, audioPlugin, bind, 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 };