@moku-labs/game 0.0.3 → 0.2.0

package/dist/{types-KlE_GL1z.d.mts → types-CqkrEY06.d.mts}

@@ -1,6 +1,6 @@
-import { A as TrackSegment, At as Json, I as ComponentType, M as AnyComponent, P as AnyComponentValue, R as Entity, St as Api, T as MotionHandle, _t as TypeTag, h as Api$2, k as TrackOptions, nn as Require, q as Api$1, t as Api$3, x as Ease } from "./types-Cjf3ywai.mjs";
-import { o as Events$1, t as Api$4 } from "./types-DgwbzDLP.mjs";
-import { F as Events$2, H as InputApi, I as I18nApi, L as Message, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-C0SLQsx0.mjs";
+import { A as TrackSegment, At as Json, E as NumericFields, F as ComponentHandle, I as ComponentType, M as AnyComponent, P as AnyComponentValue, R as Entity, St as Api, T as MotionHandle, _t as TypeTag, h as Api$2, k as TrackOptions, nn as Require, q as Api$1, t as Api$3, x as Ease } from "./types-BZ1OLf24.mjs";
+import { o as Events$1, t as Api$4 } from "./types-C47fKNcn.mjs";
+import { F as Events$2, H as InputApi, I as I18nApi, L as Message, c as UiNode, i as Finding, n as ElementChange, o as JsxState, r as ElementMotion, v as StylesState } from "./types-X9jXjka3.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -739,6 +739,286 @@ type StepMotion = MotionHandle & {
   advance(deltaMs: number): number;
 };
 //#endregion
+//#region src/plugins/anim/timeline/steps.d.ts
+/**
+ * Every haptic tick `haptic(kind)` takes, in one frozen list: the three impacts, the selection
+ * tick and the three notifications. `platform` checks a kind against it before it plays one.
+ *
+ * @example
+ * ```ts
+ * HAPTIC_KINDS.includes("light"); // true
+ * ```
+ */
+declare const HAPTIC_KINDS: readonly ["light", "medium", "heavy", "selection", "success", "warning", "error"];
+/**
+ * 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, one of `HAPTIC_KINDS`, 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: HapticKind): 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/anim/timeline/types.d.ts
 /**
  * The value of the component a step names, with its shape erased: the value type of
@@ -771,6 +1051,16 @@ type SfxDescriptor = {
   };
   readonly cosmetic: true;
 };
+/**
+ * One haptic tick a device can play: the impact, selection and notification families of Tauri.
+ * `HAPTIC_KINDS` lists the same seven at runtime.
+ *
+ * @example
+ * ```ts
+ * const kind: HapticKind = "success";
+ * ```
+ */
+type HapticKind = (typeof HAPTIC_KINDS)[number];
 /**
  * A haptic tick, owned by `anim` and handled by `platform`. Like `sfx` it is a descriptor and a
  * timeline step at once.
@@ -785,7 +1075,7 @@ type SfxDescriptor = {
 type HapticDescriptor = {
   readonly kind: "haptic";
   readonly payload: {
-    readonly kind: string;
+    readonly kind: HapticKind;
   };
   readonly cosmetic: true;
 };
@@ -1005,7 +1295,7 @@ type RunningTimeline = {
   ended: boolean;
 };
 declare namespace types_d_exports {
-  export { AnimApi, AnimCtx, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config, Cursor, Deps, ErasedFields, Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State, Step, StepMotion, Target, TimelineRuntime, Track };
+  export { AnimApi, AnimCtx, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config, Cursor, Deps, ErasedFields, Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State, Step, StepMotion, Target, TimelineRuntime, Track };
 }
 /**
  * What a step and a slot are pointed at: the projection key of a live view or of an element a
@@ -1441,4 +1731,4 @@ type AnimCtx = KernelSlice & {
   readonly deps: Deps;
 };
 //#endregion
-export { Point as C, TextStyles as D, TextStyleInput as E, TextValue as O, Config$2 as S, TextApi as T, Step as _, Config as a, UiApi as b, SlotTags as c, Target as d, types_d_exports as f, SfxDescriptor as g, PlayDescriptor as h, BuildTools as i, types_d_exports$2 as k, SlotValues as l, HapticDescriptor as m, AnimationDefinition as n, FramesValue as o, ExternalPlayer as p, AnimationSpec as r, MotionKeyframe as s, AnimApi as t, State as u, Config$1 as v, State$2 as w, types_d_exports$1 as x, State$1 as y };
+export { UiApi as A, spawned as C, wait as D, use as E, TextApi as F, TextStyleInput as I, TextStyles as L, Config$2 as M, Point as N, Config$1 as O, State$2 as P, TextValue as R, spawn as S, tween as T, parallel as _, State as a, set as b, HapticKind as c, HAPTIC_KINDS as d, defineAnimation as f, mark as g, haptic as h, MotionKeyframe as i, types_d_exports$1 as j, State$1 as k, SfxDescriptor as l, frames as m, Config as n, Target as o, external as p, FramesValue as r, types_d_exports as s, AnimApi as t, Step as u, play as v, stagger as w, sfx as x, sequence as y, types_d_exports$2 as z };

package/dist/{types-BTycq8_Z.d.mts → types-CxZy7Pi4.d.mts}

@@ -1,13 +1,14 @@
-import { At as Json, C as LayerSpec, Dt as Api$4, F as ComponentHandle, Gt as Events$2, H as Owner, I as ComponentType, R as Entity, S as LayerSort, St as Api$3, a as PixiSprite, d as FilterSlot, h as Api$1, i as PixiModule, kt as Events$1, nn as Require, o as PixiTexture, p as Point, q as Api, r as PixiFilter, t as Api$2, vt as Descriptor } from "./types-Cjf3ywai.mjs";
-import { o as Events$3, t as Api$5 } from "./types-DgwbzDLP.mjs";
-import { t as AnimApi } from "./types-KlE_GL1z.mjs";
+import { At as Json, C as LayerSpec, Dt as Api$4, F as ComponentHandle, Gt as Events$2, H as Owner, I as ComponentType, R as Entity, S as LayerSort, St as Api$3, a as PixiSprite, d as FilterSlot, h as Api$1, i as PixiModule, kt as Events$1, nn as Require, o as PixiTexture, p as Point, q as Api, r as PixiFilter, t as Api$2, vt as Descriptor } from "./types-BZ1OLf24.mjs";
+import { o as Events$3, t as Api$5 } from "./types-C47fKNcn.mjs";
+import { t as AnimApi } from "./types-CqkrEY06.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
 //#region src/plugins/effects/filters/types.d.ts
 /**
- * One uniform of a custom filter, as declared: a number is an `f32`, `{ color }` a `0xrrggbb`
- * hex sent as a `vec3<f32>`, a tuple of 2 to 4 numbers a `vecN<f32>`.
+ * One uniform of a custom filter, as declared: a number is an `f32` (`float` in GLSL), `{ color }`
+ * a `0xrrggbb` hex sent as a `vec3<f32>` (`vec3`), a tuple of 2 to 4 numbers a `vecN<f32>`
+ * (`vecN`).
  *
  * @example
  * ```ts
@@ -44,19 +45,28 @@ type FilterValueOf<Uniforms extends Record<string, UniformDeclaration>> = { -rea
   order: number;
 };
 /**
- * What `defineFilter` takes besides the id. `wgsl` is the fragment body only; the engine
- * prepends the vertex stage, the input bindings and the `FilterUniforms` struct.
+ * What `defineFilter` takes besides the id. Both bodies are required, so the filter draws on
+ * WebGPU and on the WebGL fallback: `wgsl` is the WGSL fragment body only, the engine prepends the
+ * vertex stage, the input bindings and the `FilterUniforms` struct; `glsl` is its GLSL ES 3.0 twin
+ * over the same uniform names, the engine prepends the version, the inputs, `finalColor` and one
+ * `uniform` per declared uniform.
  *
  * @example
  * ```ts
  * const spec: FilterSpec<{ amount: number }> = {
  *   wgsl: "@fragment fn mainFragment(@location(0) uv: vec2<f32>) -> @location(0) vec4<f32> { return textureSample(uTexture, uSampler, uv) * fu.amount; }",
+ *   glsl: "void main() { finalColor = texture(uTexture, vTextureCoord) * amount; }",
  *   uniforms: { amount: 1 }
  * };
  * ```
  */
 type FilterSpec<Uniforms extends Record<string, UniformDeclaration>> = {
-  /** The fragment body: `fn mainFragment` and its helpers, without the engine's header. */readonly wgsl: string; /** The uniforms in struct order. Default `{}`. */
+  /** The WGSL fragment body: `fn mainFragment` and its helpers, without the engine's header. */readonly wgsl: string;
+  /**
+   * The GLSL ES 3.0 fragment body: `void main()`, which sets `finalColor`, and its helpers, without
+   * the engine's header. It reads each uniform under its bare name: `amount`, not `fu.amount`.
+   */
+  readonly glsl: string; /** The uniforms in struct order. Default `{}`. */
   readonly uniforms?: Uniforms; /** Render passes one apply of the filter costs, an integer of at least 1. Default `1`. */
   readonly passes?: number; /** Pixels around the view's bounds, or the name of a number uniform whose live value they are. Default `0`. */
   readonly padding?: number | string;
@@ -76,18 +86,21 @@ type UniformSpec = {
   readonly size: number;
 };
 /**
- * The filter a component made by `defineFilter` carries: the assembled WGSL, the uniforms in
- * struct order, the passes one apply costs and the padding.
+ * The filter a component made by `defineFilter` carries: the assembled WGSL in `source`, the
+ * assembled GLSL in `glsl`, the uniforms in struct order, the passes one apply costs and the
+ * padding.
  *
  * @example
  * ```ts
- * Tint.filter.passes; // 1
+ * Tint.filter.source.includes("fn mainFragment"); // true: the WGSL, drawn on WebGPU
+ * Tint.filter.glsl.startsWith("#version 300 es"); // true: the GLSL, drawn on WebGL
  * Tint.filter.uniforms.map(uniform => uniform.name); // ["amount", "color"]
  * ```
  */
 type FilterDefinition = {
-  readonly id: string;
-  readonly source: string;
+  readonly id: string; /** The assembled WGSL: the engine's header, the uniform struct, the body. */
+  readonly source: string; /** The assembled GLSL ES 3.0: the engine's header, one `uniform` per uniform, the body. */
+  readonly glsl: string;
   readonly uniforms: readonly UniformSpec[];
   readonly passes: number;
   readonly padding: number | string;
@@ -99,7 +112,7 @@ type FilterDefinition = {
  * @example
  * ```ts
  * const Tint: FilterComponent<{ amount: number; enabled: boolean; order: number }> =
- *   defineFilter("fx.tint", { wgsl: tintBody, uniforms: { amount: 0 } });
+ *   defineFilter("fx.tint", { wgsl: tintWgsl, glsl: tintGlsl, uniforms: { amount: 0 } });
  * Tint.componentName; // "fx.tint"
  * ```
  */
@@ -242,7 +255,8 @@ type AlphaValue = {
  */
 type CoreKind = "blur" | "colorMatrix" | "noise" | "displacement" | "alpha";
 /**
- * Where a filter kind comes from: our or a game's WGSL, or a Pixi core filter.
+ * Where a filter kind comes from: our or a game's shaders (`"wgsl"`, with the GLSL twin beside
+ * it), or a Pixi core filter.
  */
 type KindSource = {
   readonly source: "wgsl";
@@ -547,9 +561,9 @@ type State$2 = {
   instances: Map<Entity, EmitterInstance>; /** World-space instances whose host left, stepped until empty. */
   orphans: Set<EmitterInstance>; /** Ordinal of the next instance: the cosmetic seed. */
   seedCounter: number; /** Live particles after the last step. */
-  particles: number; /** Filter kinds whose WGSL failed the dev check. */
+  particles: number; /** Filter kinds whose shader failed the dev check on the running backend. */
   broken: Set<string>; /** The filter kinds, built-ins first, then the filters of every feature. */
-  kinds: Map<string, FilterKind>; /** The dev WGSL check per kind; `broken` holds the failed ones. */
+  kinds: Map<string, FilterKind>; /** The dev shader check per kind; `broken` holds the failed ones. */
   checks: Map<string, "pending" | "ok">; /** Entity to the filters the sync keeps for it. */
   views: Map<Entity, FilteredView>; /** Keys of the one-shot warnings: `"emitter:fx.x"`, `"texture:board.cell"`, `"atlas:fx.x"`. */
   warned: Set<string>; /** Whether each budget warning is in force, so a crossing warns once. */

package/dist/{types-D0uYTTC3.d.mts → types-DmhTHRVW.d.mts}

@@ -1,4 +1,4 @@
-import { At as Json, Ht as RngState, St as Api, ft as FlowState, ht as RouteStep, pt as JournalEntry, q as Api$1, xt as Answer, zt as Snapshot } from "./types-Cjf3ywai.mjs";
+import { At as Json, Ht as RngState, St as Api, ft as FlowState, ht as RouteStep, pt as JournalEntry, q as Api$1, xt as Answer, zt as Snapshot } from "./types-BZ1OLf24.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/headless.d.ts

package/dist/{types-C0SLQsx0.d.mts → types-X9jXjka3.d.mts}

@@ -1,4 +1,4 @@
-import { At as Json, D as ProjectionMotion, I as ComponentType, L as ComponentValue, N as AnyComponentType, P as AnyComponentValue, R as Entity, St as Api, T as MotionHandle, bt as Hint, h as Api$2, j as ViewHandle, m as ViewportSize, nn as Require, p as Point$1, q as Api$1, t as Api$3, vt as Descriptor, w as Motion, y as ChangeHook } from "./types-Cjf3ywai.mjs";
+import { At as Json, D as ProjectionMotion, I as ComponentType, L as ComponentValue, N as AnyComponentType, P as AnyComponentValue, R as Entity, St as Api, T as MotionHandle, bt as Hint, h as Api$2, j as ViewHandle, m as ViewportSize, nn as Require, p as Point$1, q as Api$1, t as Api$3, vt as Descriptor, w as Motion, y as ChangeHook } from "./types-BZ1OLf24.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/fonts/LICENSE.txt

@@ -0,0 +1,105 @@
+The MSDF body font of this folder is built from a Google Font released under the SIL Open Font
+License 1.1. The licence text follows.
+
+- font-body.fnt, font-body.png: Pangolin Regular (Pangolin-Regular.ttf).
+
+================================================================================
+
+Pangolin
+
+================================================================================
+
+
+Copyright 2016 The Pangolin Project Authors (https://github.com/googlefonts/pangolin)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.