@moku-labs/game 0.14.11 → 0.14.13

package/dist/{types-kNiV7iFj.d.mts → types-GHE4J5Uf.d.mts}

@@ -1,9 +1,91 @@
-import { A as Api$2, B as ComponentType, F as AnyComponent, H as Entity, It as TypeTag, L as AnyComponentValue, Lt as Descriptor, R as ComponentHandle, Sn as Require, Xt as Json, Yt as Events$2, at as NumericFields, ct as TrackOptions, dn as Events$3, dt as Api$1, et as Ease, h as Api$5, hn as Api, it as MotionHandle, lt as TrackSegment, nt as LayerSpec, q as Owner, qt as Api$4, s as Events$4, t as Api$3, tt as LayerSort, xn as Events$5 } from "./types-BT9S_Lo2.mjs";
-import { A as InputApi, c as UiNode, i as Finding, n as ElementChange, o as JsxState, q as I18nApi, r as ElementMotion, rt as StylesState, x as TextApi } from "./types-BZa187kz.mjs";
+import { A as PixiSprite, Ar as Api$1, Br as Require, Er as Events$5, Jn as Descriptor, Kt as AnyComponentValue, O as PixiFilter, T as Api$4, Wt as AnyComponent, Yt as ComponentType, Zt as Entity, _n as TrackOptions, _t as FilterSlotInputs, bn as Api$2, fn as MotionHandle, gn as ReducedMotion, gt as FilterSlot, j as PixiTexture, k as PixiModule, ln as Ease, lr as Events$3, pn as NumericFields, qn as TypeTag, qt as ComponentHandle, s as Events$1, sr as Api$6, t as Api$5, ur as Json, v as Events$4, vn as TrackSegment, xt as FilterCache, yt as Point, zr as Events$2, zt as Api$3 } from "./types-BGcda5Le.mjs";
+import { I as I18nApi, J as StylesState, S as TextApi, c as UiNode, i as Finding, j as InputApi, n as ElementChange, o as JsxState, r as ElementMotion } from "./types-7GXcXxxv.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
 
+//#region src/plugins/debug/types.d.ts
+declare namespace types_d_exports$4 {
+  export { Api, OverlayApi, OverlayMode };
+}
+/**
+ * @file debug plugin — type definitions: the overlay call.
+ */
+/**
+ * The two visible modes of the editor's overlay: the small pill or the full card.
+ */
+type OverlayMode = "pill" | "card";
+/**
+ * The editor's overlay, from the game: open it, close it, toggle it, ask whether it shows. Every call is a no-op that
+ * answers `false` on a page without the agent (a release build, a test): no import of the editor, no guard needed.
+ */
+type OverlayApi = {
+  /**
+   * Shows the overlay: the card, or the pill with `{ mode: "pill" }`.
+   *
+   * @param options - How the overlay shows.
+   * @param options.mode - `"card"` (the default) or `"pill"`.
+   * @returns True when an overlay took the call; false on a page without the agent.
+   * @example
+   * ```ts
+   * // A game's own "?" button of its settings sheet opens the overlay of a debug build.
+   * app.debug.overlay.open(); // true on `moku-game build --debug`; false on the store build
+   * app.debug.overlay.open({ mode: "pill" }); // true: the small pill
+   * ```
+   */
+  open(options?: {
+    mode?: OverlayMode;
+  }): boolean;
+  /**
+   * Hides the overlay.
+   *
+   * @returns True when an overlay took the call; false without the agent.
+   * @example
+   * ```ts
+   * app.debug.overlay.close(); // true; app.debug.overlay.isOpen() is false after it
+   * ```
+   */
+  close(): boolean;
+  /**
+   * Switches between hidden and the last visible mode.
+   *
+   * @returns True when an overlay took the call; false without the agent.
+   * @example
+   * ```ts
+   * // A game binds a three-finger tap of its own to the overlay.
+   * app.debug.overlay.toggle(); // true: shown (the card, or the pill if the pill was the last mode)
+   * ```
+   */
+  toggle(): boolean;
+  /**
+   * Tells whether the overlay shows, as the pill or the card.
+   *
+   * @returns True while it shows; false when hidden and without the agent.
+   * @example
+   * ```ts
+   * app.debug.overlay.open({ mode: "pill" });
+   * app.debug.overlay.isOpen(); // true
+   * ```
+   */
+  isOpen(): boolean;
+};
+/**
+ * The `debug` plugin's API: the overlay call.
+ */
+type Api = {
+  /**
+   * The editor's overlay. Usable anywhere the app is; a no-op without the agent. The ui tag `DebugTrigger` is one
+   * helper on top of it.
+   *
+   * @example
+   * ```ts
+   * // ui's DebugTrigger, after five taps:
+   * ctx.require(debugPlugin).overlay.open(); // true on a debug build
+   * ```
+   */
+  overlay: OverlayApi;
+};
+//#endregion
 //#region src/plugins/anim/tween/types.d.ts
 /**
  * One running track: the numeric fields of one component of one entity moving from the values
@@ -16,7 +98,8 @@ import { Node, Yoga } from "yoga-layout/load";
  *   id: 1, entity: 1_048_576, component: Transform, to: { x: 200 },
  *   keys: { x: "1048576:Transform:x" }, ms: 350, ease: "out", delayMs: 0, elapsed: 0,
  *   from: undefined, muted: () => new Set(), additive: false, driven: false, bornFrame: 4,
- *   ended: false, segments: undefined, repeatsLeft: 0, held: false, masked: new Set()
+ *   ended: false, segments: undefined, repeatsLeft: 0, held: false, masked: new Set(), keep: false,
+ *   reveals: "place"
  * };
  * ```
  */
@@ -60,7 +143,14 @@ type Track = {
    * When such a field is given back, the track adds to the value it finds there and not to the
    * base it kept. Empty for a track that owns its fields.
    */
-  masked: Set<string>;
+  masked: Set<string>; /** Started with `reduced: "keep"`: reduced motion neither shortens nor holds it. */
+  readonly keep: boolean;
+  /**
+   * What the track writes that could show its view again, handed to `renderer.sync.loopsHeld` by an endless track
+   * (spec 26 R1.7.4): `"alpha"`, `"place"` (where the view is or how large), `"both"`, or `undefined` for a write
+   * that cannot (a tint, a fill colour). Computed once when the track is made.
+   */
+  readonly reveals: "alpha" | "place" | "both" | undefined;
 };
 /**
  * A motion handle that can also be advanced by hand: what the timeline cursor needs, so a track
@@ -178,6 +268,8 @@ declare function mark(name: string): Step;
  * @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.
+ * @param options.reduced - `"keep"` plays the track at its length under reduced motion, a fade
+ *   for one; `"cut"` (the default) lands it at once.
  * @returns The tween step.
  * @example
  * ```ts
@@ -202,6 +294,7 @@ declare function tween<Value extends object>(target: Target, component: Componen
   delayMs?: number;
   additive?: boolean;
   space?: "local" | "root";
+  reduced?: ReducedMotion;
 }): Step;
 /**
  * Writes a component patch at once. Any field may be written, not only the numeric ones. The
@@ -392,7 +485,8 @@ type SfxDescriptor = {
     readonly key: string;
     readonly bus: string;
   };
-  readonly cosmetic: true;
+  readonly cosmetic: true; /** Never set: `await fx(sfx(...))` resolves nothing. */
+  readonly $result?: () => void;
 };
 /**
  * One haptic tick a device can play: the impact, selection and notification families of Tauri.
@@ -420,7 +514,8 @@ type HapticDescriptor = {
   readonly payload: {
     readonly kind: HapticKind;
   };
-  readonly cosmetic: true;
+  readonly cosmetic: true; /** Never set: `await fx(haptic(...))` resolves nothing. */
+  readonly $result?: () => void;
 };
 /**
  * The two descriptors `anim` owns. As a step, the descriptor is dispatched through
@@ -451,7 +546,8 @@ type PlayDescriptor = {
     readonly animation: string;
     readonly slots: Json;
   };
-  readonly cosmetic: true;
+  readonly cosmetic: true; /** Never set: `await fx(play(...))` resolves nothing. */
+  readonly $result?: () => void;
 };
 /**
  * One step of a choreography: plain frozen data with no callback inside, so a step tree can be
@@ -484,7 +580,8 @@ type Step = {
   readonly ease: Ease;
   readonly delayMs: number;
   readonly additive: boolean; /** `"root"`: the `Transform` fields are a root pose, turned local when the track starts. */
-  readonly space: "local" | "root";
+  readonly space: "local" | "root"; /** `"keep"`: reduced motion plays the track as written; `"cut"` lands it at once. */
+  readonly reduced: ReducedMotion;
 } | {
   readonly kind: "set";
   readonly target: Target;
@@ -625,20 +722,22 @@ type TimelineRuntime = {
 };
 /**
  * One running timeline: its cursor, the marks it reached, the entities it counts on, the entities
- * it spawned and despawns at its end, and the resolver of its `done` promise.
+ * its key targets named at its start, the entities it spawned and despawns at its end, and the
+ * resolver of its `done` promise.
  */
 type RunningTimeline = {
   readonly id: number;
   readonly animation: string;
   readonly cursor: Cursor;
   readonly marks: string[];
-  readonly entities: readonly Entity[]; /** The entities its `spawn` steps made, by spawn id. Despawned when the timeline ends. */
+  readonly entities: readonly Entity[]; /** The entities its `{ projection, key }` targets named when it started, by target key. */
+  readonly targets: ReadonlyMap<string, Entity>; /** The entities its `spawn` steps made, by spawn id. Despawned when the timeline ends. */
   readonly spawned: Map<string, Entity>;
   readonly resolve: () => void;
   ended: boolean;
 };
 declare namespace types_d_exports$3 {
-  export { AnimApi, AnimCtx, AnimPlayerValue, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config$3 as Config, Cursor, Deps$3 as Deps, ErasedFields, Events$1 as Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice$3 as KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State$3 as State, Step, StepMotion, Target, TimelineRuntime, Track };
+  export { AnimApi, AnimCtx, AnimPlayerValue, AnimationDefinition, AnimationSpec, AnyAnimationDefinition, BuildTools, Config$3 as Config, Cursor, Deps$3 as Deps, ErasedFields, Events, ExternalPlayer, FrameLoop, FramesValue, FxStep, HapticDescriptor, HapticKind, KernelSlice$3 as KernelSlice, MarkListener, MotionKeyframe, PlayDescriptor, PlayHandle, Pose, RunningTimeline, SfxDescriptor, SlotRecord, SlotTags, SlotValue, SlotValues, State$3 as 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
@@ -806,7 +905,7 @@ type MarkListener = (animation: string, mark: string) => void;
  * }); // a reached mark("done") step logs { mark: "done" }
  * ```
  */
-type Events$1 = {
+type Events = {
   /** A `mark` step was reached, or jumped by `finish()`. */"anim:mark": {
     animation: string;
     mark: string;
@@ -931,6 +1030,12 @@ type State$3 = {
    */
   frameMutes: Map<Entity, () => void>; /** Removers of the `onAdded` and `onRemoved` hooks on `Frames`. */
   offFrames: Array<() => void>;
+  /**
+   * The renderer's `sync.loopsHeld`, bound in `onStart`: an endless loop of an entity it answers true for writes
+   * nothing while its clock runs on (spec 22 O9), told what the loop reveals (spec 26 R1.7). `undefined` before the
+   * start and after the stop: nothing is held.
+   */
+  loopsHeld: ((entity: Entity, reveals?: "alpha" | "place" | "both") => boolean) | undefined;
 };
 /**
  * anim plugin API, `app.anim`: play a choreography, end everything, count what runs and listen
@@ -1112,9 +1217,9 @@ type AnimPlayerValue = {
  * `tween` in `space: "root"` local with the pure `localPoseOf` of the same module.
  */
 type Deps$3 = {
-  time: Api;
-  flow: Api$1;
-  world: Api$2;
+  time: Api$1;
+  flow: Api$2;
+  world: Api$3;
 };
 /**
  * What the kernel context offers before the deps are attached.
@@ -1123,7 +1228,7 @@ type Deps$3 = {
  * row 8), so the own events reach the context the kernel hands the factories and `emit` is the
  * kernel's own, anim-typed one. No member of the context is cast.
  */
-type KernelSlice$3 = PluginCtx<Config$3, State$3, Events$1> & {
+type KernelSlice$3 = PluginCtx<Config$3, State$3, Events> & {
   readonly global: object;
   readonly log: Log.LogApi;
   readonly require: Require;
@@ -1134,297 +1239,1010 @@ type KernelSlice$3 = PluginCtx<Config$3, State$3, Events$1> & {
 type AnimCtx = KernelSlice$3 & {
   readonly deps: Deps$3;
 };
-declare namespace types_d_exports$2 {
-  export { AnySceneProjection, CheckedProjections, Config$2 as Config, DefineScene, Deps$2 as Deps, Events, KernelSlice$2 as KernelSlice, LayerMap, RunContext, SceneDefinition, SceneLayer, SceneOwner, SceneProjection, SceneSpec, ScenesApi, ScenesCtx, SortRule, State$2 as State, UiLayer };
-}
+//#endregion
+//#region src/plugins/effects/filters/types.d.ts
 /**
- * How a layer orders what is drawn in it. The scene's name for the rule `world` stores.
+ * 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
- * const sort: SortRule = "y";
+ * const uniforms: Record<string, UniformDeclaration> = { amount: 0.5, color: { color: 0xffd700 }, offset: [2, 2] };
  * ```
  */
-type SortRule = LayerSort;
+type UniformDeclaration = number | {
+  readonly color: number;
+} | readonly [number, number] | readonly [number, number, number] | readonly [number, number, number, number];
 /**
- * What a scene declares about its layers: the key is the layer name, the order of the keys is
- * draw order, bottom first. An omitted `sort` means `"none"`.
+ * The component field a uniform declaration becomes: a number for a number and for a colour, a
+ * list of numbers for a tuple.
  *
  * @example
  * ```ts
- * const layers: LayerMap = { background: {}, cells: {}, items: { sort: "y" }, lifted: {} };
+ * type Amount = UniformValue<0.5>; // number
  * ```
  */
-type LayerMap = Record<string, {
-  sort?: SortRule;
-}>;
+type UniformValue<Declaration> = Declaration extends number ? number : Declaration extends {
+  readonly color: number;
+} ? number : readonly number[];
 /**
- * The name of the layer every scene gets on top of the layers it declared, where popups and the
- * HUD are mounted. A scene that declares it keeps the place it wrote it in.
+ * The value of a filter component made by `defineFilter`: one field per uniform, then `enabled`
+ * and `order`.
  *
  * @example
  * ```ts
- * const layer: UiLayer = "ui";
+ * type TintValue = FilterValueOf<{ amount: number; color: { color: number } }>;
+ * // { amount: number; color: number; enabled: boolean; order: number }
  * ```
  */
-type UiLayer = "ui";
+type FilterValueOf<Uniforms extends Record<string, UniformDeclaration>> = { -readonly [Name in keyof Uniforms]: UniformValue<Uniforms[Name]> } & {
+  enabled: boolean;
+  order: number;
+};
 /**
- * The layer names the projections of a scene may use: the keys the scene declared and the
- * appended `ui`, which is there whether the scene wrote it or not.
+ * A rectangle in the filtered entity's own units — the space its box, its hit box and its children's positions are in
+ * (reference units for a view at the root without scale): x, y, width, height.
  *
  * @example
  * ```ts
- * const layer: SceneLayer<{ cells: Record<never, never> }> = "ui"; // or "cells"
+ * // A lens disc of reach 88 around (195, 189): the 176 × 176 box it can draw in.
+ * const area: FilterArea = [107, 101, 176, 176];
  * ```
  */
-type SceneLayer<Layers extends LayerMap> = (keyof Layers & string) | UiLayer;
+type FilterArea = readonly [x: number, y: number, width: number, height: number];
 /**
- * Any projection as a scene reads it. `projection()` widens `lift` to `string` when the author
- * declared none, so this is the loosest shape `defineScene` accepts.
+ * 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: AnySceneProjection = { name: "board.items", layer: "items", lift: "lifted" };
+ * // A Memory Missing's frost: the body reads a blurred copy of the scene through sampleBlur(uv).
+ * const Frost = defineFilter("Frost", {
+ *   wgsl: FROST_WGSL,
+ *   glsl: FROST_GLSL,
+ *   uniforms: { view: [0, 0, 1], rectA: [0, 0, 0, 0], strength: 16, vivid: 1.2 },
+ *   inputs: { blur: { stages: [FrostBox4, FrostHalf, FrostGauss], chain: frostChain } },
+ *   fallback: FrostVeil
+ * });
+ * Frost.filter.fallback?.id; // "FrostVeil"
  * ```
  */
-type AnySceneProjection = {
+type FilterSpec<Uniforms extends Record<string, UniformDeclaration>> = {
+  /** 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;
+  /**
+   * Second textures the body reads, by name: `blur` declares `sampleBlur(uv)` in the WGSL and the GLSL, with the
+   * texture, its sampler and two uniforms the engine fills. Leave `passes` out: the engine counts them. Default none.
+   */
+  readonly inputs?: Readonly<Record<string, FilterInput<FilterValueOf<Uniforms>>>>;
+  /**
+   * What draws instead when the filter is broken (its shader or a stage does not compile on the device, its apply
+   * throws, its chain fails): another filter over a subset of its uniforms, with the same value. Default none: a broken
+   * filter leaves its view unfiltered.
+   */
+  readonly fallback?: FilterStage;
+  /**
+   * What the renderer may do with a view this filter draws on, while nothing it depends on changes: `"local"` (the
+   * default) keeps it as a picture, also while the view moves; `"placed"` keeps it with its canvas origin, for a body
+   * that reads where it is drawn through `canvasPixel(uv)` (a body that calls the helper is placed by itself); set
+   * `false` for a body whose look depends on where the view is drawn in a way the engine cannot see (a time read from
+   * a texture, a hash of the screen position): the view is then drawn live in every frame. A body that reads
+   * `uGlobalFrame`, `@builtin(position)`, `gl_FragCoord`, `uOutputTexture` or the origin of `uOutputFrame` and
+   * declares nothing is drawn live as well, and a dev build warns once: declare `cache: false`.
+   */
+  readonly cache?: "local" | "placed" | false;
+  /**
+   * The rectangle outside of which this filter draws nothing, in the filtered entity's own units, from the component's
+   * value; `undefined` for "the view's bounds" (the default). Outside it Pixi draws nothing of the view at all — neither
+   * the filter nor the view's own content — so declare it only for a filter whose output is transparent there. A view
+   * with several enabled filters gets the union; a view with an enabled filter that declares no area gets none. Called
+   * only when the value changed.
+   */
+  readonly area?: (value: Readonly<FilterValueOf<Uniforms>>) => FilterArea | undefined;
+};
+/**
+ * How one uniform travels to the GPU: its name, its WGSL type and the form it was declared in.
+ *
+ * @example
+ * ```ts
+ * const spec: UniformSpec = { name: "color", type: "vec3<f32>", form: "color", size: 3 };
+ * ```
+ */
+type UniformSpec = {
   readonly name: string;
-  readonly layer: string;
-  readonly lift?: string;
+  readonly type: "f32" | "vec2<f32>" | "vec3<f32>" | "vec4<f32>";
+  readonly form: "number" | "color" | "vector";
+  readonly size: number;
 };
 /**
- * The three fields of a `ProjectionSpec` a scene reads, with both layers checked against the
- * layers the scene declares. It is what a wrong `layer` or `lift` is reported against.
+ * 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, the
+ * padding, the second textures the body reads and the filter drawn in its place when it is broken.
  *
  * @example
  * ```ts
- * const spec: SceneProjection<"items" | "lifted"> = { name: "board.items", layer: "items" };
+ * 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"]
+ * Tint.filter.inputs.length; // 0: it reads no second texture
+ * Tint.filter.cache; // "local": a still view under it is drawn from a picture
  * ```
  */
-type SceneProjection<Layer extends string> = {
+type FilterDefinition = {
+  readonly id: string; /** The assembled WGSL: the engine's header, the uniform struct, the input bindings, the body. */
+  readonly source: string; /** The assembled GLSL ES 3.0: the engine's header, one `uniform` per uniform, the inputs, the body. */
+  readonly glsl: string;
+  readonly uniforms: readonly UniformSpec[];
+  readonly passes: number;
+  readonly padding: number | string; /** The second textures the body reads, in declaration order; empty for a filter with none. */
+  readonly inputs: readonly FilterInputDefinition[]; /** What draws in its place when it is broken: another definition over a subset of its uniforms. */
+  readonly fallback: FilterDefinition | undefined; /** What the kept-picture cache may do with it: the worst of its declaration, its body and its stages' bodies. */
+  readonly cache: FilterCache;
+  /**
+   * The engine's `keptOrigin` uniform (`vec2<f32>`) of a body that calls `canvasPixel(uv)`, kept out of `uniforms`;
+   * `undefined` for any other body.
+   */
+  readonly origin: UniformSpec | undefined; /** The rectangle outside of which the filter draws nothing, from the value; present only when the spec gave one. */
+  readonly area?: (value: Readonly<FilterFields>) => FilterArea | undefined;
+};
+/**
+ * A filter a chain may draw: any component `defineFilter` made. Listed in an input's `stages` and named by its steps.
+ * A built-in Pixi-core kind (`Blur`, `ColorMatrix`, …) has no `filter` and cannot be a stage.
+ *
+ * @example
+ * ```ts
+ * const FrostGauss = defineFilter("FrostGauss", { wgsl: gaussWgsl, glsl: gaussGlsl, uniforms: { dir: [0, 0], sigma: 0 } });
+ * const stages: readonly FilterStage[] = [FrostBox4, FrostHalf, FrostGauss];
+ * stages.map(stage => stage.filter.id); // ["FrostBox4", "FrostHalf", "FrostGauss"]
+ * ```
+ */
+type FilterStage = {
+  readonly componentName: string;
+  readonly defaults: object;
+  readonly filter: FilterDefinition;
+};
+/**
+ * One step of a chain: the stage that draws, the share of the input's resolution it draws at, and the stage uniforms
+ * of this step. A uniform the step leaves out takes the stage's default. A colour is a `0xrrggbb` number.
+ *
+ * @example
+ * ```ts
+ * // A Gaussian along x at an eighth of the resolution of the view's input.
+ * const step: FilterStep = { stage: FrostGauss, scale: 1 / 8, uniforms: { dir: [1, 0], sigma: 4.66 } };
+ * ```
+ */
+type FilterStep = {
+  readonly stage: FilterStage; /** Above 0 and at most 1: the target of this step has `scale` × the resolution of the view's input. */
+  readonly scale: number;
+  readonly uniforms?: Readonly<Record<string, number | readonly number[]>>;
+};
+/**
+ * What a chain is told besides the value: the real pixels per CSS pixel of the texture the view is drawn into (the
+ * canvas resolution for a view at the top, less under a filter of lower resolution).
+ *
+ * @example
+ * ```ts
+ * // The owner's phone at maxResolution 3: 16 units of blur are 37 real pixels, an eighth is enough.
+ * frostChain({ ...Frost().value, strength: 16, view: [0, 0, 384 / 390] }, { resolution: 2.8125 }).map(step => step.scale);
+ * // [0.25, 0.125, 0.125, 0.125]
+ * ```
+ */
+type FilterChainContext = {
+  readonly resolution: number;
+};
+/**
+ * A second texture the body of a filter reads, named by its key in `inputs`: `blur` gives the body
+ * `sampleBlur(uv)`. `chain` returns the steps that draw it from the view's own input, each from the one before;
+ * the body reads the last one. `stages` lists every filter the chain may name: they are checked on the device and
+ * warmed up before the first draw, and a step naming another one is refused. The chain runs again only when a uniform
+ * of the value or the resolution changed, never per frame; it may return `[]`, and the body then reads the view's own
+ * input.
+ *
+ * @example
+ * ```ts
+ * const input: FilterInput<{ strength: number; enabled: boolean; order: number }> = {
+ *   stages: [FrostHalf, FrostGauss],
+ *   chain: (value, { resolution }) => [
+ *     { stage: FrostHalf, scale: 1 / 2 },
+ *     { stage: FrostGauss, scale: 1 / 2, uniforms: { dir: [1, 0], sigma: (value.strength * resolution) / 2 } },
+ *     { stage: FrostGauss, scale: 1 / 2, uniforms: { dir: [0, 1], sigma: (value.strength * resolution) / 2 } }
+ *   ]
+ * };
+ * ```
+ */
+type FilterInput<Value> = {
+  readonly stages: readonly FilterStage[];
+  /**
+   * The steps of the second texture for this value and resolution. Pure: no state, no randomness; the context object
+   * is the engine's and valid during the call only.
+   *
+   * @param value - The stored value of the filter component.
+   * @param context - The resolution of the texture the view is drawn into.
+   * @returns The steps in draw order, at most 16.
+   * @example
+   * ```ts
+   * // A quarter is enough at one real pixel per CSS pixel: the box, then the Gaussian along x and along y.
+   * Frost.filter.inputs[0]?.chain({ ...Frost().value, strength: 16, view: [0, 0, 1] }, { resolution: 1 }).length; // 3
+   * ```
+   */
+  chain(value: Readonly<Value>, context: FilterChainContext): readonly FilterStep[];
+};
+/**
+ * An input as `defineFilter` stored it: the names the engine declared for it in both shader languages, its two
+ * uniforms, its stages and its chain.
+ *
+ * @example
+ * ```ts
+ * const [blur] = Frost.filter.inputs;
+ * [blur?.texture, blur?.sampler, blur?.scale.name, blur?.clamp.name, blur?.sample];
+ * // ["blurTexture", "blurSampler", "blurScale", "blurClamp", "sampleBlur"]
+ * ```
+ */
+type FilterInputDefinition = {
   readonly name: string;
-  readonly layer: Layer;
-  readonly lift?: Layer;
+  readonly texture: string;
+  readonly sampler: string;
+  readonly scale: UniformSpec;
+  readonly clamp: UniformSpec;
+  readonly sample: string;
+  readonly stages: readonly FilterStage[];
+  readonly chain: FilterInput<FilterFields>["chain"];
 };
 /**
- * Checks the `lift` of one projection. A projection built without a `lift` carries the widened
- * `string` of `projection()`, which is the one lift that is always accepted.
+ * A filter component type: the `component()` of its id, with the filter definition attached. Its
+ * numeric fields are tweenable like any component.
+ *
+ * @example
+ * ```ts
+ * const Tint: FilterComponent<{ amount: number; enabled: boolean; order: number }> =
+ *   defineFilter("fx.tint", { wgsl: tintWgsl, glsl: tintGlsl, uniforms: { amount: 0 } });
+ * Tint.componentName; // "fx.tint"
+ * ```
+ */
+type FilterComponent<Value extends object> = ComponentType<Value> & {
+  readonly filter: FilterDefinition;
+};
+/**
+ * One field of a stored filter value: a number, a switch, an asset key or a vector.
+ *
+ * @example
+ * ```ts
+ * const field: FilterField = 0.5;
+ * ```
  */
-type CheckedLift<Layer extends string, Spec> = Spec extends {
-  readonly lift?: infer Lift;
-} ? string extends Exclude<Lift, undefined> ? Spec : Exclude<Lift, undefined> extends Layer ? Spec : SceneProjection<Layer> : Spec;
+type FilterField = number | boolean | string | readonly number[];
 /**
- * Checks one projection of a scene: first its `layer`, then its `lift`. A projection that fails
- * becomes `SceneProjection<Layer>`, so the compiler prints the layer names it accepts.
+ * The stored value of any filter component, with the kind erased: the filter sync reads every
+ * kind through it.
  */
-type CheckedProjection<Layer extends string, Spec> = Spec extends {
-  readonly layer: infer Declared;
-} ? Declared extends Layer ? CheckedLift<Layer, Spec> : SceneProjection<Layer> : SceneProjection<Layer>;
+type FilterFields = {
+  readonly enabled: boolean;
+  readonly order: number;
+  readonly [field: string]: FilterField;
+};
 /**
- * Checking type: validates the projections of a scene one by one against its layer names, so the
- * error sits on the projection that is wrong and not on the whole list.
+ * `Glow`: a soft halo of `color` around the opaque pixels of the view.
  *
  * @example
  * ```ts
- * type Checked = CheckedProjections<"items", readonly [{ name: "board.items"; layer: "items" }]>;
+ * const value: GlowValue = { strength: 2, distance: 10, color: 0xffffff, alpha: 1, enabled: true, order: 0 };
  * ```
  */
-type CheckedProjections<Layer extends string, List> = { readonly [Index in keyof List]: CheckedProjection<Layer, List[Index]> };
+type GlowValue = {
+  strength: number;
+  distance: number;
+  color: number;
+  alpha: number;
+  enabled: boolean;
+  order: number;
+};
+/**
+ * `Outline`: a ring of `thickness` pixels in `color` around the opaque pixels of the view.
+ *
+ * @example
+ * ```ts
+ * const value: OutlineValue = { thickness: 2, color: 0x000000, alpha: 1, enabled: true, order: 0 };
+ * ```
+ */
+type OutlineValue = {
+  thickness: number;
+  color: number;
+  alpha: number;
+  enabled: boolean;
+  order: number;
+};
+/**
+ * `Blur`: Pixi's blur. `quality: 0` means `config.blur.quality`; `resolution: 0` means
+ * `config.blur.phoneResolution` on a phone, otherwise 1.
+ *
+ * @example
+ * ```ts
+ * const value: BlurValue = { strength: 8, quality: 0, resolution: 0, repeatEdgePixels: true, enabled: true, order: 0 };
+ * ```
+ */
+type BlurValue = {
+  strength: number;
+  quality: number;
+  resolution: number;
+  repeatEdgePixels: boolean;
+  enabled: boolean;
+  order: number;
+};
+/**
+ * `ColorMatrix`: brightness, saturation, contrast, hue and grayscale composed in that order.
+ * Every default is the identity.
+ *
+ * @example
+ * ```ts
+ * const value: ColorMatrixValue = { brightness: 1, saturation: 0, contrast: 0, hue: 0, grayscale: 1, enabled: true, order: 0 };
+ * ```
+ */
+type ColorMatrixValue = {
+  brightness: number;
+  saturation: number;
+  contrast: number;
+  hue: number;
+  grayscale: number;
+  enabled: boolean;
+  order: number;
+};
+/**
+ * `Noise`: Pixi's noise with its seed always given, so two runs draw the same grain.
+ *
+ * @example
+ * ```ts
+ * const value: NoiseValue = { amount: 0.5, seed: 7, enabled: true, order: 0 };
+ * ```
+ */
+type NoiseValue = {
+  amount: number;
+  seed: number;
+  enabled: boolean;
+  order: number;
+};
+/**
+ * `Displacement`: Pixi's displacement over the texture of an asset key.
+ *
+ * @example
+ * ```ts
+ * const value: DisplacementValue = { map: "fx.ripple", scaleX: 20, scaleY: 20, enabled: true, order: 0 };
+ * ```
+ */
+type DisplacementValue = {
+  map: string;
+  scaleX: number;
+  scaleY: number;
+  enabled: boolean;
+  order: number;
+};
 /**
- * What the author passes to `defineScene`. The layer names come from the keys of `layers` plus
- * the appended `ui`; `NoInfer` keeps `projections` out of that inference, so a wrong name is
- * reported on the projection and never widens the layer union. `music` is an asset key of the
- * game, narrowed to its audio keys once the scanner splits them.
+ * `Alpha`: Pixi's alpha over the whole subtree, as one layer.
  *
  * @example
  * ```ts
- * const spec: SceneSpec<{ items: Record<never, never> }, readonly [], string, "board"> = {
- *   bundle: "board",
- *   layers: { items: {} },
- *   projections: []
+ * const value: AlphaValue = { alpha: 0.5, enabled: true, order: 0 };
+ * ```
+ */
+type AlphaValue = {
+  alpha: number;
+  enabled: boolean;
+  order: number;
+};
+/**
+ * The five built-in kinds drawn by a Pixi core filter.
+ *
+ * @example
+ * ```ts
+ * const kind: CoreKind = "blur";
+ * ```
+ */
+type CoreKind = "blur" | "colorMatrix" | "noise" | "displacement" | "alpha";
+/**
+ * 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";
+  readonly definition: FilterDefinition;
+} | {
+  readonly source: "core";
+  readonly core: CoreKind;
+};
+/**
+ * A filter kind before it is registered: its id, its component and its source.
+ */
+type KindEntry = KindSource & {
+  readonly id: string;
+  readonly component: ComponentHandle<FilterFields>;
+};
+/**
+ * One registered filter kind. `index` is the registration order: the built-ins first, then the
+ * filters of every feature in feature order.
+ */
+type FilterKind = KindEntry & {
+  readonly index: number;
+};
+/**
+ * The values of the uniform group of one of our filter instances: a number per `f32`, a vector
+ * per colour and tuple. Written where they differ from the stored value.
+ */
+type UniformValues = Record<string, number | Float32Array>;
+/**
+ * The uniform group of one of our filter instances, as the instance writes it.
+ */
+type FilterUniforms = {
+  readonly uniforms: UniformValues;
+};
+/**
+ * The Pixi object of one kind on one view, with the passes one apply of it costs now: what the
+ * builders of `instance.ts` make before the instance gets its sort keys. A Pixi-core kind keeps
+ * the fields its setters were last given, `applied`, so an equal value calls no setter.
+ */
+type FilterBody = {
+  readonly kind: "wgsl";
+  readonly filter: PixiFilter;
+  readonly group: FilterUniforms | undefined;
+  readonly definition: FilterDefinition;
+  passes: number; /** The chains and their places; `undefined` for a definition without inputs. Set once, by `createFilter`. */
+  inputs: InputsState | undefined; /** The dev mark drawn after the fallback by a stand-in (E5.4); `undefined` otherwise. */
+  readonly mark: OursBody | undefined; /** The definition's last area answer, filled in place; `some: false` for `undefined` (B4). */
+  readonly area: AreaBox; /** The value changed since the area was last asked: the next sync asks the definition again. */
+  areaStale: boolean;
+} | {
+  readonly kind: "blur";
+  readonly filter: InstanceType<PixiModule["BlurFilter"]>; /** The fields the setters were last given; compared before a write. */
+  readonly applied: Record<string, FilterField>;
+  passes: number;
+} | {
+  readonly kind: "colorMatrix";
+  readonly filter: InstanceType<PixiModule["ColorMatrixFilter"]>; /** The fields the setters were last given; compared before a write. */
+  readonly applied: Record<string, FilterField>;
+  passes: number;
+} | {
+  readonly kind: "noise";
+  readonly filter: InstanceType<PixiModule["NoiseFilter"]>; /** The fields the setters were last given; compared before a write. */
+  readonly applied: Record<string, FilterField>;
+  passes: number;
+} | {
+  readonly kind: "displacement";
+  readonly filter: InstanceType<PixiModule["DisplacementFilter"]>;
+  readonly sprite: PixiSprite; /** The fields the setters were last given; compared before a write. */
+  readonly applied: Record<string, FilterField>; /** The asset key the map sprite shows now. */
+  map: string;
+  passes: number;
+} | {
+  readonly kind: "alpha";
+  readonly filter: InstanceType<PixiModule["AlphaFilter"]>; /** The fields the setters were last given; compared before a write. */
+  readonly applied: Record<string, FilterField>;
+  passes: number;
+};
+/**
+ * A probe of the warm-up (spec 27 F4): the Pixi filter handed to `renderer.sync.filters.warm`, and its teardown.
+ */
+type WarmProbe = {
+  readonly filter: PixiFilter;
+  destroy(): void;
+};
+/**
+ * A filter area as the filter sync keeps it, written in place: the four numbers, and whether there is one.
+ */
+type AreaBox = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  some: boolean;
+};
+/**
+ * The instance of one kind on one view: its Pixi object, and what it sorts by on the view, the
+ * `order` of its component (written every frame) and the `index` of its kind. The instance is
+ * the object the builder made, never a copy: a closure made while building (the apply guard)
+ * reads and writes the same fields the filter sync does.
+ */
+type FilterInstance = FilterBody & {
+  order: number;
+  readonly index: number; /** True once the instance broke (its apply threw, its chain failed): it stays broken until it is retired. */
+  broken: boolean; /** The value the filter sync handed over last: the chain and a stand-in are built from it. */
+  value: Readonly<FilterFields>; /** The kind this instance draws for; a stand-in carries the id of the kind it stands in for. */
+  readonly kindId: string; /** True for an instance that draws in place of a broken kind or instance (E5). */
+  readonly standIn: boolean; /** A stand-in built while this broken instance was drawing; the next sync puts it in its place. */
+  replacement: FilterInstance | undefined;
+};
+/**
+ * One of our bodies: a `Filter` over the assembled programs, the kind of every place of a chain and of a mark.
+ */
+type OursBody = Extract<FilterBody, {
+  kind: "wgsl";
+}>;
+/** One place of a chain: the Pixi filter that draws the stage there, and the share of the resolution it draws at. */
+type Place = {
+  readonly definition: FilterDefinition;
+  readonly body: OursBody;
+  scale: number;
+};
+/**
+ * The chains of one instance of a filter with inputs: what draws each second texture, and the seam spec 23 keeps
+ * pictures through.
+ */
+type InputsState = {
+  /** A uniform of the value changed since the last evaluation (set by `writeFilter`). */stale: boolean; /** The resolution of the last evaluation. */
+  resolution: number; /** Changes whenever what the stages draw changes; 1 after the first evaluation. */
+  version: number; /** The object `chain` receives, reused: its `resolution` is written before each call. */
+  readonly context: {
+    resolution: number;
+  }; /** Per input, its places in draw order (each with the scale of its step). */
+  readonly places: Place[][]; /** Bodies of places that left the chain, destroyed by the next sync. */
+  readonly retired: OursBody[]; /** Pooled textures taken by the running apply; emptied in its `finally`. One array, reused. */
+  readonly taken: PixiTexture[]; /** The options object handed to `TexturePool.getOptimalTexture`, reused. */
+  readonly request: {
+    width: number;
+    height: number;
+    resolution: number;
+  }; /** Results lent by spec 23: while set, the apply draws the main body only, over them. */
+  held: readonly PixiTexture[] | undefined; /** The slot seam, a frozen object replaced when a place is built or dropped. */
+  slot: FilterSlotInputs;
+};
+/**
+ * Where the shader check of every definition a kind can draw stands, in every build: one run per start of the
+ * plugin.
+ */
+type CheckState = {
+  /** Bumped by `stopEffects`: an answer of an earlier run is ignored. */run: number; /** The checks were started on the running backend. */
+  started: boolean; /** Where each definition stands. */
+  status: WeakMap<FilterDefinition, "pending" | "ok" | "broken">; /** Definitions still pending. */
+  waiting: number; /** Definitions started, for the `effects:checks` line. */
+  checked: number; /** Definitions that failed, for the `effects:checks` line. */
+  failed: number; /** GLSL compiles in flight under `KHR_parallel_shader_compile`. */
+  gl: Array<{
+    definition: FilterDefinition;
+    shader: WebGLShader;
+  }>; /** `performance.now()` when the checks started, for the `effects:checks` line. */
+  startedAt: number; /** Resolves when `started` and `waiting === 0`. */
+  settled: Promise<void>; /** Resolves `settled`. */
+  resolve: () => void;
+};
+/**
+ * What the filter sync keeps for one entity: the kinds it carries, one instance per kind, the
+ * instances waiting to be destroyed after the next assignment, the slots last handed to
+ * `renderer.sync.filters.set`, the core kinds whose component changed this frame, the
+ * instances of this frame in their sorted order (one array, reused every frame), and the one
+ * `renderer.invalidate` call a visible filter write of the frame makes.
+ */
+type FilteredView = {
+  readonly kinds: Set<string>;
+  readonly instances: Map<string, FilterInstance>;
+  readonly retired: FilterInstance[];
+  assigned: readonly FilterSlot[];
+  readonly changed: Set<string>;
+  readonly placed: FilterInstance[]; /** True once `renderer.invalidate` was called for this view in the current frame. */
+  signalled: boolean; /** Calls `renderer.invalidate(entity)` once per frame for this view, before the write; made once with the record. */
+  readonly signal: () => void; /** The area last handed to `renderer.sync.filters.area`, written in place (B4). */
+  readonly areaSent: AreaBox; /** The `enabled` switches of the placed instances when the area was last judged, one bit each in placed order. */
+  areaMask: number;
+};
+//#endregion
+//#region src/plugins/effects/particles/types.d.ts
+/**
+ * An inclusive `[min, max]` range; every particle draws its own value from it.
+ *
+ * @example
+ * ```ts
+ * const lifeMs: Range = [500, 900];
+ * ```
+ */
+type Range = readonly [min: number, max: number];
+/**
+ * A value over the life of a particle, linear from its birth (`from`) to its death (`to`).
+ *
+ * @example
+ * ```ts
+ * const shrink: Curve = { from: 1, to: 0.2 };
+ * ```
+ */
+type Curve = {
+  readonly from: number;
+  readonly to: number;
+};
+/**
+ * Where a particle is born, around the origin of its emitter, in reference units. `circle` is
+ * uniform over the disc, `ring` uniform between `radius − width / 2` and `radius + width / 2`,
+ * `rect` uniform over the centred box.
+ *
+ * @example
+ * ```ts
+ * const burstRing: Shape = { kind: "ring", radius: 48, width: 16 };
+ * ```
+ */
+type Shape = {
+  readonly kind: "point";
+} | {
+  readonly kind: "circle";
+  readonly radius: number;
+} | {
+  readonly kind: "rect";
+  readonly w: number;
+  readonly h: number;
+} | {
+  readonly kind: "ring";
+  readonly radius: number;
+  readonly width: number;
+};
+/**
+ * A particle effect as data, what `defineEmitter` takes. Every field is optional except
+ * `textures` and exactly one of `burst` and `rate`. Speeds are reference units per second, angles
+ * degrees with 0 to the right and 90 down, spins radians per second.
+ *
+ * @example
+ * ```ts
+ * const stars: EmitterConfig = {
+ *   textures: ["fx.star", "fx.sparkle"], burst: 40, lifeMs: [500, 900], speed: [300, 700],
+ *   gravity: 900, drag: 0.2, shape: { kind: "circle", radius: 24 }, alpha: { from: 1, to: 0 }
  * };
  * ```
  */
-type SceneSpec<Layers extends LayerMap, Projections extends readonly AnySceneProjection[], Asset extends string, Bundle extends string> = {
-  bundle: Bundle;
-  layers: Layers;
-  projections: Projections & NoInfer<CheckedProjections<SceneLayer<Layers>, Projections>>;
-  music?: Asset;
+type EmitterConfig = {
+  /** 1 to 16 asset keys of one atlas page; a particle picks one at random. */readonly textures: readonly string[]; /** Particles emitted once, when the component appears or its `effect` changes. */
+  readonly burst?: number; /** Particles per second while `active` is true and the entity lives. */
+  readonly rate?: number; /** Life of a particle in milliseconds. Default `[600, 1000]`. */
+  readonly lifeMs?: Range; /** Start speed in reference units per second. Default `[0, 0]`. */
+  readonly speed?: Range; /** Start direction in degrees, 0 right, 90 down. Default `[0, 360]`. */
+  readonly angle?: Range; /** Downward acceleration in reference units per second². Default `0`. */
+  readonly gravity?: number; /** Velocity lost per second, 0..1: `v *= (1 − drag) ^ seconds`. Default `0`. */
+  readonly drag?: number; /** Spin in radians per second. Default `[0, 0]`. */
+  readonly spin?: Range; /** Where particles are born around the origin. Default `{ kind: "point" }`. */
+  readonly shape?: Shape; /** Scale over life. Default `{ from: 1, to: 1 }`. */
+  readonly scale?: Curve; /** Alpha over life, 0..1. Default `{ from: 1, to: 1 }`. */
+  readonly alpha?: Curve; /** Tint over life, `0xrrggbb`, linear per channel. Default white to white. */
+  readonly tint?: Curve; /** `"world"`: particles outlive the entity. `"local"`: they move and die with it. Default `"world"`. */
+  readonly space?: "world" | "local"; /** Milliseconds simulated before the first frame, for streams, 0..5000. Default `0`. */
+  readonly prewarmMs?: number; /** Hard ceiling of live particles of one instance, 1..5000. Default `256`. */
+  readonly maxParticles?: number; /** Blend mode of the particle container. Default `"normal"`. */
+  readonly blend?: "normal" | "add";
 };
 /**
- * The signature of `defineScene` bound to the asset and bundle keys of one game.
- * `defineGame<Types>()` returns it; the loose export accepts any string.
+ * An `EmitterConfig` with every default filled in. `burst` and `rate` stay as given: exactly one
+ * of them is present.
  *
  * @example
  * ```ts
- * const defineGameScene: DefineScene<"board.music", "board"> = defineScene;
+ * defineEmitter("fx.steam", { textures: ["fx.puff"], rate: 12 }).config.lifeMs; // [600, 1000]
  * ```
  */
-type DefineScene<Asset extends string, Bundle extends string> = <Layers extends LayerMap, const Projections extends readonly AnySceneProjection[]>(id: string, scene: SceneSpec<Layers, Projections, Asset, Bundle>) => SceneDefinition;
+type ResolvedEmitterConfig = Required<Omit<EmitterConfig, "burst" | "rate">> & Pick<EmitterConfig, "burst" | "rate">;
 /**
- * A scene as `defineScene` returns it: plain frozen data, ready for the `scenes` key of a feature.
+ * A particle effect as `defineEmitter` returns it: frozen, registered through the `emitters` key
+ * of a feature and started by an `Emitter` component that names its id.
  *
  * @example
  * ```ts
- * // What defineScene("board", { bundle: "board", layers: { items: { sort: "y" } }, projections: [] })
- * // returns: { id: "board", bundle: "board", music: undefined,
- * //   layers: [{ name: "items", sort: "y" }, { name: "ui", sort: "none" }], projections: [] }
+ * const steam: EmitterDefinition = defineEmitter("fx.steam", { textures: ["fx.puff"], rate: 12 });
+ * steam.config.rate; // 12
  * ```
  */
-type SceneDefinition = {
+type EmitterDefinition = {
   readonly id: string;
-  readonly bundle: string;
-  readonly music: string | undefined; /** Draw order, bottom first. */
-  readonly layers: readonly LayerSpec[]; /** Names of the projections the scene mounts. */
-  readonly projections: readonly string[];
+  readonly config: ResolvedEmitterConfig;
 };
 /**
- * The one owner every mount of this plugin carries. One is enough: one scene is mounted at a
- * time, and `unmount` is what flushes.
+ * The value of the `Emitter` component: which effect runs on the entity and whether a stream
+ * emits. `""` draws nothing.
  *
  * @example
  * ```ts
- * const owner: SceneOwner = { kind: "plugin", name: "scenes" };
+ * const value: EmitterValue = { effect: "fx.steam", active: true };
  * ```
  */
-type SceneOwner = Owner & {
-  kind: "plugin";
-  name: "scenes";
+type EmitterValue = {
+  effect: string;
+  active: boolean;
+};
+/**
+ * The cosmetic random source of one instance: xorshift32 over its own seed, never `Math.random`
+ * and never the model's rng.
+ */
+type Rng = {
+  /** The next number in `[0, 1)`. */next(): number; /** An integer in `[0, count)`. */
+  int(count: number): number; /** A number in `[min, max]`. */
+  between(min: number, max: number): number;
+};
+/**
+ * A Pixi particle container: what one emitter instance draws in.
+ */
+type PixiParticleContainer = InstanceType<PixiModule["ParticleContainer"]>;
+/**
+ * One particle of a container, as the container keeps it.
+ */
+type PixiParticle = PixiParticleContainer["particleChildren"][number];
+/**
+ * What one effect id bakes to on first use: the 64-entry curve tables, the reach rectangle's half
+ * side and the resolved textures. Dropped when a bundle with one of its textures leaves.
+ */
+type BakedEmitter = {
+  readonly id: string;
+  readonly config: ResolvedEmitterConfig; /** Scale per 1/64 of the life. */
+  readonly scaleTable: Float32Array; /** Alpha per 1/64 of the life, 0..1. */
+  readonly alphaTable: Float32Array; /** Tint per 1/64 of the life, packed as Pixi's `0xbbggrr`. */
+  readonly tintTable: Uint32Array; /** Half side of the box no particle leaves, in reference units. */
+  readonly reach: number;
+  readonly textures: readonly PixiTexture[]; /** The texture source of the first texture: every texture of the effect samples it. */
+  readonly source: PixiTexture["source"] | undefined; /** The largest side of the textures, in pixels. */
+  readonly maxSide: number;
+};
+/**
+ * The per-particle numbers a Pixi particle has no field for, one entry per live particle, in the
+ * order of `particleChildren`.
+ */
+type BornFields = {
+  readonly age: Float32Array;
+  readonly life: Float32Array;
+  readonly vx: Float32Array;
+  readonly vy: Float32Array;
+  readonly spin: Float32Array;
+  readonly variant: Float32Array;
+};
+/**
+ * One running effect: its container, the plugin-owned entity that carries it, the particle pool
+ * and the numbers the step needs.
+ */
+type EmitterInstance = {
+  readonly id: string;
+  readonly baked: BakedEmitter; /** The entity whose `Emitter` started it. */
+  readonly host: Entity; /** The plugin-owned entity whose `Display` is the container. */
+  readonly entity: Entity;
+  readonly container: PixiParticleContainer; /** Retired particles, reused before a new one is made. */
+  readonly pool: PixiParticle[];
+  readonly born: BornFields; /** Fraction of a particle owed to the next frame of a stream. */
+  carry: number;
+  readonly rng: Rng; /** The point the container was placed at, in root space (world space only). */
+  readonly origin: Readonly<Point>;
+  readonly space: "world" | "local"; /** Pixi's particle class, from the module the renderer loaded. */
+  readonly particleClass: PixiModule["Particle"];
 };
+declare namespace types_d_exports$2 {
+  export { AlphaValue, AssetsReplaced$1 as AssetsReplaced, BlurValue, BundleUnloaded$1 as BundleUnloaded, ColorMatrixValue, Config$2 as Config, CoreKind, Curve, Deps$2 as Deps, DisplacementValue, EffectsApi, EffectsCtx, EffectsDiagnostics, EffectsStats, EmitterConfig, EmitterDefinition, EmitterValue, FilterArea, FilterCache, FilterChainContext, FilterComponent, FilterDefinition, FilterInput, FilterInputDefinition, FilterSpec, FilterStage, FilterStep, FilterValueOf, GlowValue, HotSwap, KernelSlice$2 as KernelSlice, NoiseValue, OutlineValue, Range, ResolvedEmitterConfig, Shape, State$2 as State, UniformDeclaration, UniformSpec, UniformValue };
+}
 /**
- * scenes plugin config: none. A scene is data in a feature, and a transition effect is V3 work
- * of `anim`, so a key here would have no reader.
+ * effects plugin config. `maxParticles` here is the global warning line; the `maxParticles` of an
+ * emitter config caps one instance.
  *
  * @example
  * ```ts
- * const config: Config = {};
+ * createApp({
+ *   plugins: [...screen, effectsPlugin],
+ *   pluginConfigs: { effects: { maxPasses: 16, phone: false } }
+ * });
  * ```
  */
-type Config$2 = Record<string, never>;
+type Config$2 = {
+  /** Live particles over all instances above which one dev warning fires per crossing. */maxParticles: number; /** Render passes per frame above which one dev warning fires per crossing. */
+  maxPasses: number; /** Whether this device is a phone. `"auto"`: a coarse pointer and a short side of at most 820 CSS px, read once in `onStart`. */
+  phone: boolean | "auto";
+  /**
+   * What a `Blur` with `quality: 0` and `resolution: 0` resolves to. Shallow merge: a game that
+   * sets `blur` gives both fields.
+   */
+  blur: {
+    quality: number;
+    phoneResolution: number;
+  };
+};
 /**
- * scenes plugin state.
+ * effects plugin state: the particle half, the filter half, and what both share.
  */
 type State$2 = {
-  /** Scene id to its declaration, filled in `onStart` from `flow.features`. */scenes: Map<string, SceneDefinition>; /** Id of the scene that is mounted now. */
-  current: string | undefined;
+  /** Resolved in `onStart`. */phone: boolean; /** The `emitters` of every feature, read in `onStart`. */
+  emitters: Map<string, EmitterDefinition>; /** Per effect id, built on first use. */
+  baked: Map<string, BakedEmitter>; /** Host entity to its running instance. */
+  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 shader or one of whose stages failed the check on the running backend, in every build. */
+  broken: Set<string>; /** Filter kinds whose main definition and every stage answered ok: a kind's status is a set lookup once settled. */
+  ready: Set<string>; /** The filter kinds, built-ins first, then the filters of every feature. */
+  kinds: Map<string, FilterKind>; /** The shader check of every definition a kind can draw, in every build. */
+  checks: CheckState; /** 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. */
+  over: {
+    particles: boolean;
+    passes: boolean;
+    fullScreen: boolean;
+  }; /** The teardown closure, the two systems and the world hooks. */
+  removers: Array<() => void>;
+  /**
+   * The switches of a debug build: the kind ids in registration order (frozen, filled in `onStart`), the kinds
+   * turned off, and those as a frozen list in the order of `kinds`.
+   */
+  diagnostics: {
+    kinds: readonly string[];
+    off: Set<string>;
+    offList: readonly string[];
+  };
   /**
-   * The scene the next node without its own `scene` mounts, at a rest node or at a transit node
-   * in live mode: the one a transit node named in fast mode, or the one the restore door expected
-   * with `expect`. A rest node clears it; a transit node clears it only when it took it; an over
-   * node takes it and clears it, whatever is mounted, except an over transit node of a fast walk,
-   * which leaves it alone.
+   * The warm-up hand-over (spec 27 F4): started at the first frame with a ready host, the Pixi-core kinds noted then,
+   * and the probes handed to `renderer.sync.filters.warm`, kept until the app stops.
    */
-  pending: string | undefined;
-  owner: SceneOwner; /** The remover of the `onEnter` callback: set in `onStart`, run in `onStop`. */
-  teardown: (() => void) | undefined;
+  warm: {
+    started: boolean;
+    core: string[];
+    probes: WarmProbe[];
+  };
 };
 /**
- * scenes plugin events.
+ * What `app.effects.stats()` answers: live particles, running emitter instances, filter instances
+ * on views, and the render passes of the frame as the renderer counts them.
  *
  * @example
  * ```ts
- * // A game plugin starts the music of the scene the graph switched to.
- * createPlugin("music", {
- *   depends: [scenesPlugin],
- *   hooks: ctx => ({ "scenes:changed": ({ music }) => ctx.log.info("scene music", { music }) })
- * }); // entering the board logs { music: "board.theme" }
+ * const stats: EffectsStats = { particles: 120, emitters: 3, filters: 25, renderPasses: 49 };
  * ```
  */
-type Events = {
-  /** The mounted scene changed. */"scenes:changed": {
-    from: string | undefined;
-    to: string;
-    music: string | undefined;
-  };
+type EffectsStats = {
+  /** Live particles over every instance and orphan after the last step. */particles: number; /** Running instances plus the orphans still flying. */
+  emitters: number; /** Filter instances over every view; the stages of a filter's inputs are counted in `renderPasses`, not here. */
+  filters: number; /** `renderer.sync.renderPasses()`, read at call time. */
+  renderPasses: number;
 };
 /**
- * scenes plugin API, `app.scenes`. A scene is switched by the graph, never by a call, so the
- * plugin answers one question and takes one order, for the restore door.
+ * effects plugin API, `app.effects`. Everything a game does with effects is data on entities;
+ * the API only counts.
  *
  * @example
  * ```ts
- * // A headless test walks from the menu onto the board and asks what is mounted.
- * await app.flow.walk([{ at: "home", intent: "play" }]);
- * app.scenes.current(); // "board"
+ * // A test waits for a merge burst to land before it compares the board.
+ * while (app.effects.stats().particles > 0) app.time.step(16);
+ * app.effects.stats().particles; // 0
  * ```
  */
-type ScenesApi = {
+type EffectsApi = {
   /**
-   * The id of the mounted scene.
+   * Counts what runs now. `renderPasses` is the renderer's own number, read at call time; the
+   * others are the plugin's. Headless every number is 0.
    *
-   * @returns The scene id, `undefined` before the first switch and after the app stopped.
+   * @returns A fresh object: live particles, emitter instances with orphans, filter instances
+   *   and render passes.
    * @example
    * ```ts
-   * // A dev overlay writes the scene next to the frame counter.
-   * app.scenes.current(); // "board", or undefined while the first bundle still loads
+   * // After the board rests: one steam stream, 24 enabled glows on 24 views, one disabled blur.
+   * app.effects.stats();
+   * // { particles: 18, emitters: 1, filters: 25, renderPasses: 49 }: 1 + 24 × (1 + 1), the disabled blur costs 0
    * ```
    */
-  current(): string | undefined;
-  /**
-   * Names the scene the next node without its own `scene` mounts. A rest node reads it, and so
-   * does a transit node in live mode; a transit node of a fast walk leaves it for the rest point.
-   * The restore door calls it with the scene of a bookmark, so a bookmark at a popup comes back
-   * with the scene under it, also when the popup is a transit node that waits for its answer:
-   * the scene of such a popup is mounted before `flow.restore` resolves.
-   * An over node takes the expected scene too, whatever is mounted, so a popup bookmark restored
-   * on a page that shows another scene switches to the scene of the bookmark. With nothing
-   * expected an over node never switches. An over transit node of a fast walk mounts nothing and
-   * keeps the record.
+  stats(): EffectsStats;
+  /**
+   * Switches of a debug build: filter kinds turned off by hand, to measure what a kind costs on the device. Acts on
+   * a page with the agent flag (a debug build, the dev page); elsewhere `disable` and `enable` change nothing. An off
+   * kind keeps its instances: `stats().filters` still counts them, `renderPasses` drops.
    *
-   * @param id - Id of a scene a feature declared.
-   * @throws {Error} For an id no feature declared, also before `onStart` filled the registry.
    * @example
    * ```ts
-   * // A fresh page restores a bookmark taken at the Settings popup over Home, a transit node
-   * // that waits for its answer.
-   * app.scenes.expect("home");
-   * await app.flow.restore(bookmark); // resolves when the popup's gate is open
-   * app.scenes.current(); // "home"
+   * // A game's overlay toggle "Glow": the frame without any glow, then with it again.
+   * app.effects.diagnostics.disable("effects.glow"); // true
+   * app.effects.diagnostics.enable("effects.glow"); // true
    * ```
    */
-  expect(id: string): void;
+  diagnostics: EffectsDiagnostics;
+};
+/**
+ * Switches of a debug build: filter kinds turned off by hand, to measure what a kind costs on the device. Acts on
+ * a page with the agent flag (a debug build, the dev page); elsewhere `disable` and `enable` change nothing.
+ *
+ * @example
+ * ```ts
+ * // A game's overlay toggle "Glow" (H4.4): the frame without any glow, then with it again.
+ * app.effects.diagnostics.disable("effects.glow"); // true
+ * app.effects.diagnostics.enable("effects.glow"); // true
+ * ```
+ */
+type EffectsDiagnostics = {
+  /**
+   * The filter kinds this app knows, in registration order: the seven built-ins, then the `filters` of every
+   * feature. The same frozen array on every call; empty before start. Every build.
+   *
+   * @returns The kind ids.
+   * @example
+   * ```ts
+   * // A game with the frost filter of its casefile feature, after start.
+   * app.effects.diagnostics.kinds();
+   * // ["effects.glow", "effects.outline", "effects.blur", "effects.colorMatrix", "effects.noise",
+   * //  "effects.displacement", "effects.alpha", "casefile.frost"]
+   * ```
+   */
+  kinds(): readonly string[];
+  /**
+   * Turns a filter kind off: from the next frame no view draws it (no apply, no render pass), while its instances
+   * stay and are still written, so `enable` shows the current look at once. Agent pages only.
+   *
+   * @param kind - A kind id of `kinds()`.
+   * @returns True when the kind is known and now off; false for an unknown kind, and on a page without the agent
+   *   flag, where nothing changes.
+   * @example
+   * ```ts
+   * // The owner measures the board without the glow of its four cards (one glow pass each).
+   * app.effects.diagnostics.disable("effects.glow"); // true
+   * app.time.step(16);
+   * app.effects.stats().renderPasses; // 9, down from 13
+   * app.effects.diagnostics.disable("fx.nope"); // false, and one warning effects:diagnostics-unknown
+   * ```
+   */
+  disable(kind: string): boolean;
+  /**
+   * Turns a filter kind on again: from the next frame its views draw it with their current values.
+   *
+   * @param kind - A kind id of `kinds()`.
+   * @returns True when the kind is known and now on; false for an unknown kind and without the agent flag.
+   * @example
+   * ```ts
+   * app.effects.diagnostics.enable("effects.glow"); // true
+   * app.time.step(16);
+   * app.effects.stats().renderPasses; // 13
+   * ```
+   */
+  enable(kind: string): boolean;
+  /**
+   * The kinds turned off now, in registration order. The same frozen array until the next change; empty without
+   * the agent flag.
+   *
+   * @returns The kind ids.
+   * @example
+   * ```ts
+   * app.effects.diagnostics.disable("casefile.frost");
+   * app.effects.diagnostics.disable("effects.glow");
+   * app.effects.diagnostics.disabled(); // ["effects.glow", "casefile.frost"]
+   * ```
+   */
+  disabled(): readonly string[];
 };
 /**
  * Resolved dependency APIs.
  */
 type Deps$2 = {
-  flow: Api$1;
-  world: Api$2;
-  assets: Api$3;
-  time: Api;
+  flow: Api$2;
+  world: Api$3;
+  renderer: Api$4;
+  assets: Api$5;
+  anim: AnimApi;
 };
 /**
- * What the kernel context offers before the deps are attached.
- *
- * `index.ts` writes `events` with an annotated `register` (core spec `14-EVENT-REGISTRATION.md`
- * row 8), so the own event reaches the context the kernel hands the factories and `emit` is the
- * kernel's own, scenes-typed one. No member of the context is cast.
+ * What the kernel context offers before the deps are attached. `effects` owns no event, so
+ * `emit` is the kernel's and never called here.
  */
-type KernelSlice$2 = PluginCtx<Config$2, State$2, Events> & {
+type KernelSlice$2 = PluginCtx<Config$2, State$2> & {
   readonly global: object;
   readonly log: Log.LogApi;
   readonly require: Require;
 };
 /**
- * Domain context shared by the files of the plugin.
+ * Domain context shared by both modules: the kernel slice plus the resolved deps.
  */
-type ScenesCtx = KernelSlice$2 & {
+type EffectsCtx = KernelSlice$2 & {
   readonly deps: Deps$2;
 };
 /**
- * The mode and the abort signal `flow.onEnter` hands every callback.
- *
- * @example
- * ```ts
- * const run: RunContext = { mode: "live", signal: new AbortController().signal };
- * ```
+ * Payload of the `assets:bundle-unloaded` hook: `keys` names every texture that is gone.
  */
-type RunContext = {
-  mode: "live" | "fast";
-  signal: AbortSignal;
-};
+type BundleUnloaded$1 = Events$1["assets:bundle-unloaded"];
+/**
+ * Payload of the `assets:replaced` hook: `keys` names every asset a dev hot swap gave new bytes.
+ */
+type AssetsReplaced$1 = Events$1["assets:replaced"];
+/**
+ * Payload of the global `ui:hot-swap` hook: the saved file and its new exports.
+ */
+type HotSwap = Events$2["ui:hot-swap"];
 declare namespace types_d_exports$1 {
-  export { AssetsReplaced, AudioApi, AudioContextLike, AudioCtx, AudioSessionLike, AudioSessionType, BundleUnloaded, Bus, BusState, Config$1 as Config, Deps$1 as Deps, KernelSlice$1 as KernelSlice, LifecycleChanged, ModelCommitted, MusicDescriptor, MusicMode, MusicOptions, MusicRequest, MusicSwitch, MusicTrack, RetiringTrack, SceneChanged, SfxRequest, SoundEntry, State$1 as State, StreamTrack, Volumes };
+  export { AssetsReplaced, AudioApi, AudioContextLike, AudioCtx, AudioSessionLike, AudioSessionType, BundleUnloaded, Bus, BusState, Config$1 as Config, Deps$1 as Deps, KernelSlice$1 as KernelSlice, LifecycleChanged, ModelCommitted, MusicDescriptor, MusicMode, MusicOptions, MusicRequest, MusicSwitch, MusicTrack, RetiringTrack, SceneChanged, SfxRequest, SoundEntry, State$1 as State, StreamTrack, Volumes, VolumesFor };
 }
 /**
  * The three volume buses. `master` carries the whole game, `music` the scene track, `sfx` every
@@ -1464,14 +2282,14 @@ type MusicOptions = {
 };
 /**
  * `music` bound to the audio asset keys of one game. `defineGame` returns it through `audioFor`;
- * the loose export accepts any string.
+ * the loose export accepts any string. The descriptor resolves nothing.
  *
  * @example
  * ```ts
  * const gameMusic: MusicDescriptor<"board.theme"> = music;
  * ```
  */
-type MusicDescriptor<Asset extends string> = (key: Asset | null, options?: MusicOptions) => Descriptor;
+type MusicDescriptor<Asset extends string> = (key: Asset | null, options?: MusicOptions) => Descriptor<void>;
 /**
  * Reads the player's volume choice out of the committed player state. Every bus it names is
  * applied; the ones it leaves out keep the value they had.
@@ -1482,6 +2300,17 @@ type MusicDescriptor<Asset extends string> = (key: Asset | null, options?: Music
  * ```
  */
 type Volumes = (player: Json) => Partial<Record<Bus, number>>;
+/**
+ * `Volumes`, written against the player type of one game: `defineGame` hands it as `volumes`, so
+ * the callback reads the game's player with no cast. The same function at run time.
+ *
+ * @example
+ * ```ts
+ * // index.ts of a game: `volumes` comes from the kit, so `player` is the game's Player.
+ * pluginConfigs: { audio: { volumes: volumes(player => ({ music: player.settings.music })) } }
+ * ```
+ */
+type VolumesFor<Player> = (read: (player: Player) => Partial<Record<Bus, number>>) => Volumes;
 /**
  * How a music track is played. `"decode"`: one AudioBuffer per track, gapless, about 58 MB per
  * 150 s at 48 kHz. `"stream"`: an `<audio>` element on a `blob:` URL of the bytes `assets` holds,
@@ -1554,10 +2383,11 @@ type RetiringTrack = {
  *
  * @example
  * ```ts
+ * // `volumes` comes from the game's `defineGame` kit, so `player` is the game's Player.
  * createApp({
  *   plugins: [...screen, audioPlugin],
  *   pluginConfigs: {
- *     audio: { musicFadeMs: 400, music: "stream", session: "playback", volumes: player => player.settings.audio }
+ *     audio: { musicFadeMs: 400, music: "stream", session: "playback", volumes: volumes(player => player.settings.audio) }
  *   }
  * });
  * ```
@@ -1754,6 +2584,9 @@ type AudioApi = {
    * and a music switch to the track that already plays are not in it. Empty while
    * `config.journal` is 0, the default, and after the app stopped.
    *
+   * No copy and no live view: the list and its entries are never written. Every new sound replaces the plugin's list
+   * with a new frozen one, so a list read earlier keeps what it held, and a caller cannot change the journal through it.
+   *
    * @returns The journal, frozen; a later sound replaces the list and leaves this one as it was.
    * @example
    * ```ts
@@ -1770,10 +2603,10 @@ type AudioApi = {
  * Resolved dependency APIs.
  */
 type Deps$1 = {
-  flow: Api$1;
-  assets: Api$3;
-  model: Api$4;
-  time: Api;
+  flow: Api$2;
+  assets: Api$5;
+  model: Api$6;
+  time: Api$1;
 };
 /**
  * What the kernel context offers before the deps are attached.
@@ -1794,23 +2627,23 @@ type AudioCtx = KernelSlice$1 & {
 /**
  * Payload of the `model:committed` hook: the source of every volume a game sets.
  */
-type ModelCommitted = Events$2["model:committed"];
+type ModelCommitted = Events$3["model:committed"];
 /**
  * Payload of the `scenes:changed` hook: `music` is the track the next scene declared.
  */
-type SceneChanged = Events["scenes:changed"];
+type SceneChanged = Events$4["scenes:changed"];
 /**
  * Payload of the `lifecycle:changed` hook: the pause that holds every bus at zero.
  */
-type LifecycleChanged = Events$3["lifecycle:changed"];
+type LifecycleChanged = Events$5["lifecycle:changed"];
 /**
  * Payload of the `assets:bundle-unloaded` hook: `keys` names every decoded sound that is gone.
  */
-type BundleUnloaded = Events$4["assets:bundle-unloaded"];
+type BundleUnloaded = Events$1["assets:bundle-unloaded"];
 /**
  * Payload of the `assets:replaced` hook: `keys` names every asset a dev hot swap gave new bytes.
  */
-type AssetsReplaced = Events$4["assets:replaced"];
+type AssetsReplaced = Events$1["assets:replaced"];
 /**
  * What one play of a sound asks for: the key and the bus the sound goes to.
  */
@@ -1840,7 +2673,8 @@ type LayoutState = {
   scrollStart: {
     pointerY: number;
     offset: number;
-  };
+  }; /** One line of the `body` style as the icons were last measured with it; none before that. */
+  iconLine: number | undefined;
   order: number;
   cleanups: Array<() => void>;
 };
@@ -1949,10 +2783,11 @@ type State = {
  */
 type Deps = {
   anim: AnimApi;
-  time: Api;
-  flow: Api$1;
-  world: Api$2;
-  renderer: Api$5;
+  debug: Api;
+  time: Api$1;
+  flow: Api$2;
+  world: Api$3;
+  renderer: Api$4;
   input: InputApi;
   i18n: I18nApi;
   text: TextApi;
@@ -1962,7 +2797,7 @@ type Deps = {
  *
  * `ui` owns no event of its own; `emit` sends the global `ui:hot-swap` of the dev hot swap.
  */
-type KernelSlice = PluginCtx<Config, State, Events$5> & {
+type KernelSlice = PluginCtx<Config, State, Events$2> & {
   readonly global: object;
   readonly log: Log.LogApi;
   readonly require: Require;
@@ -2061,4 +2896,4 @@ type UiApi = {
   fill(key: string, value: string): boolean;
 };
 //#endregion
-export { SfxDescriptor as A, sequence as B, Config$3 as C, Target as D, State$3 as E, frames as F, stagger as G, sfx as H, haptic as I, wait as J, tween as K, mark as L, HAPTIC_KINDS as M, defineAnimation as N, types_d_exports$3 as O, external as P, parallel as R, AnimPlayerValue as S, MotionKeyframe as T, spawn as U, set as V, spawned as W, SceneSpec as _, AudioApi as a, types_d_exports$2 as b, MusicDescriptor as c, State$1 as d, types_d_exports$1 as f, SceneDefinition as g, LayerMap as h, types_d_exports as i, Step as j, HapticKind as k, MusicOptions as l, DefineScene as m, State as n, AudioContextLike as o, AnySceneProjection as p, use as q, UiApi as r, Config$1 as s, Config as t, SoundEntry as u, ScenesApi as v, FramesValue as w, AnimApi as x, State$2 as y, play as z };
+export { sequence as $, GlowValue as A, Target as B, BlurValue as C, FilterComponent as D, FilterArea as E, AnimPlayerValue as F, HAPTIC_KINDS as G, HapticKind as H, Config$3 as I, frames as J, defineAnimation as K, FramesValue as L, OutlineValue as M, UniformDeclaration as N, FilterSpec as O, AnimApi as P, play as Q, MotionKeyframe as R, AlphaValue as S, DisplacementValue as T, SfxDescriptor as U, types_d_exports$3 as V, Step as W, mark as X, haptic as Y, parallel as Z, State$2 as _, AudioApi as a, tween as at, EmitterDefinition as b, MusicDescriptor as c, OverlayApi as ct, State$1 as d, set as et, VolumesFor as f, EffectsStats as g, EffectsApi as h, types_d_exports as i, stagger as it, NoiseValue as j, FilterValueOf as k, MusicOptions as l, types_d_exports$4 as lt, Config$2 as m, State as n, spawn as nt, AudioContextLike as o, use as ot, types_d_exports$1 as p, external as q, UiApi as r, spawned as rt, Config$1 as s, wait as st, Config as t, sfx as tt, SoundEntry as u, types_d_exports$2 as v, ColorMatrixValue as w, EmitterValue as x, EmitterConfig as y, State$3 as z };