@moku-labs/game 0.15.1 → 0.15.2

package/dist/{types-G3ZAAsbd.d.mts → types-Bm7DVtA_.d.mts}

@@ -1,4 +1,4 @@
-import { An as Api$1, At as ViewportSize, Br as Api, Cn as NumericFields, Kt as TransformValue, Sn as MotionHandle, T as Api$3, Xr as Require, Yt as Api$2, _n as ChangeHook, an as ComponentType, bn as Motion, br as Json, cr as Hint, dr as Api$5, en as AnyComponent, gn as TagType, ir as Descriptor, kn as ViewHandle, nn as AnyComponentValue, s as Events$1, sn as Entity, t as Api$4, tn as AnyComponentType, ur as Answer, wn as ProjectionMotion, xn as MotionCause } from "./types-E2ykwIUO.mjs";
+import { Cn as MotionCause, En as ProjectionMotion, Hr as Api, Jt as TransformValue, Mn as Api$1, Mt as ViewportSize, Qr as Require, Sn as Motion, Sr as Json, T as Api$3, Tn as NumericFields, Zt as Api$2, fr as Answer, in as AnyComponentValue, jn as ViewHandle, ln as Entity, nn as AnyComponent, or as Descriptor, pr as Api$5, rn as AnyComponentType, s as Events$1, sn as ComponentType, t as Api$4, ur as Hint, vn as TagType, wn as MotionHandle, yn as ChangeHook } from "./types-BHgJ1F6f.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 
@@ -1630,11 +1630,6 @@ type DrawnLabel = {
 /**
  * A dev warning that is written once per key. Pure modules take it as an argument, so nothing
  * below the plugin context reaches the log itself.
- *
- * @example
- * ```ts
- * const warn: Warn = (key, message) => seen.has(key) || log.warn(message);
- * ```
  */
 type Warn = (key: string, message: string, data?: Record<string, unknown>) => void;
 /**
@@ -1651,18 +1646,21 @@ type LayoutOptions = {
 /**
  * What was resolved for one entity last, so the frame step knows whether anything moved. `unit`
  * is what the shown string of a bound label was built from: the rounded value for `"int"`, whole
- * seconds for a time format.
+ * seconds for a time format. `bindRef` is the bind object `bind` was keyed from, so the key is
+ * built once per attached bind and a frame compares one reference.
  *
  * @example
  * ```ts
+ * const left = bind(Countdown, "left", { format: "mm:ss" });
  * const seen: SeenText = {
- *   content: "", style: "digits", bind: "Countdown.left:mm:ss", locale: "ru", unit: 95
+ *   content: "", style: "digits", bindRef: left, bind: "Countdown.left:mm:ss", locale: "ru", unit: 95
  * };
  * ```
  */
 type SeenText = {
   content: unknown;
   style: string;
+  bindRef: TextBind | undefined;
   bind: string | undefined;
   locale: string;
   unit: number | undefined;
@@ -2483,6 +2481,8 @@ type PopupLink = {
  * popup (its open is an event), the cause of its projection view otherwise, `"mount"` after a
  * restore or a load. `slot` is the host element the root is laid out in (`undefined` for the
  * viewport), `slotRect` the content box it was last solved in, in the host's own units.
+ * `pending` is true while the solve running now still waits to lay the root out; `mountRoot`
+ * creates it `false`.
  */
 type Root = {
   entity: Entity;
@@ -2503,6 +2503,7 @@ type Root = {
     w: number;
     h: number;
   } | undefined;
+  pending?: boolean;
 };
 /**
  * Where the focus ring was last drawn: the layer and order of its root, the rect grown by the
@@ -2632,7 +2633,10 @@ type TextState = {
  * the element that hosts it; `fields` holds the text fields by entity. `hints` buffers the hints
  * released since the last frame step; `scrolls` holds the scroll containers; `windowRenders`
  * counts the re-renders of a windowed list its range made. `styled` and `written` count the style
- * passes and the write passes of the reconcile, for `UiCounters`.
+ * passes and the write passes of the reconcile, for `UiCounters`. `hostsVersion` moves on when a
+ * host came, went, became live or was patched, and when a view lost its `Parent` or its `Held`;
+ * `hostsSeen` and `membershipSeen` are that version and the world's membership version at the
+ * last full hosting step, which runs again only when one of them moved.
  */
 type JsxState = {
   components: Map<string, AnyComponentDefinition>;
@@ -2644,7 +2648,10 @@ type JsxState = {
   exiting: Set<Entity>;
   removing: Set<Entity>;
   hosts: Set<Entity>;
-  hosted: Map<Entity, Entity>; /** The host elements that became live in this solve: the solve hosts their views in the same frame (spec 16 U2). */
+  hosted: Map<Entity, Entity>;
+  hostsVersion: number;
+  hostsSeen: number;
+  membershipSeen: number; /** The host elements that became live in this solve: the solve hosts their views in the same frame (spec 16 U2). */
   risen: Set<Entity>; /** The views the full hosting step of this frame took back from their host; their removal lands at the flush. */
   released: Set<Entity>; /** The cause the elements entered by the diff running now take: the root's for its first build, else `"change"`. */
   building: MotionCause | undefined;

package/dist/{types-CpdkyhaC.d.mts → types-DEYQF_tT.d.mts}

@@ -1,7 +1,7 @@
-import { Ar as SnapshotOf, Dr as SaveDoc, E as Config$2, Er as ProviderCall, Jn as AnyFlow, Kn as FeaturePlugin, Mn as Config$1, Ot as Orientation, Tr as PlayerStateProvider, a as Config$3, br as Json, d as Manifest, fr as ClockSource, k as PixiModule, mr as FakeClock, n as AssetsIo, rr as TypeTag, vr as Config } from "./types-E2ykwIUO.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-Bw-qLjFZ.mjs";
-import { H as TextKey, I as I18nApi, V as StringTable } from "./types-G3ZAAsbd.mjs";
-import { Ct as audioPlugin, bt as effectsPlugin, dt as platformPlugin, i as screen, pt as PlatformProvider, t as createApp } from "./index-CCiTo1_3.mjs";
+import { At as Orientation, Dr as PlayerStateProvider, E as Config$2, Jn as FeaturePlugin, Mr as SnapshotOf, Or as ProviderCall, Pn as Config$1, Sr as Json, Xn as AnyFlow, a as Config$3, ar as TypeTag, br as Config, d as Manifest, gr as FakeClock, k as PixiModule, kr as SaveDoc, mr as ClockSource, n as AssetsIo } from "./types-BHgJ1F6f.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-fpFKYm6E.mjs";
+import { H as TextKey, I as I18nApi, V as StringTable } from "./types-Bm7DVtA_.mjs";
+import { Ct as audioPlugin, bt as effectsPlugin, dt as platformPlugin, i as screen, pt as PlatformProvider, t as createApp } from "./index-w2uyRKkj.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{types-Bw-qLjFZ.d.mts → types-fpFKYm6E.d.mts}

@@ -1,5 +1,5 @@
-import { A as PixiSprite, An as Api$2, Br as Api$1, Cn as NumericFields, Dn as TrackOptions, Dt as FilterSlotInputs, En as ReducedMotion, Et as FilterSlot, Ir as Events$5, O as PixiFilter, On as TrackSegment, Sn as MotionHandle, T as Api$4, Xr as Require, Yr as Events$2, Yt as Api$3, _r as Api$6, an as ComponentType, br as Json, en as AnyComponent, ir as Descriptor, j as PixiTexture, jt as FilterCache, k as PixiModule, kt as Point, nn as AnyComponentValue, rn as ComponentHandle, rr as TypeTag, s as Events$1, sn as Entity, t as Api$5, v as Events$4, yn as Ease, yr as Events$3 } from "./types-E2ykwIUO.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-G3ZAAsbd.mjs";
+import { A as PixiSprite, An as TrackSegment, Hr as Api$1, Mn as Api$2, Nt as FilterCache, O as PixiFilter, On as ReducedMotion, Ot as FilterSlot, Qr as Require, Rr as Events$5, Sr as Json, T as Api$4, Tn as NumericFields, Zr as Events$2, Zt as Api$3, an as ComponentHandle, ar as TypeTag, in as AnyComponentValue, j as PixiTexture, jt as Point, k as PixiModule, kn as TrackOptions, kt as FilterSlotInputs, ln as Entity, nn as AnyComponent, or as Descriptor, s as Events$1, sn as ComponentType, t as Api$5, v as Events$4, wn as MotionHandle, xn as Ease, xr as Events$3, yr as Api$6 } from "./types-BHgJ1F6f.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-Bm7DVtA_.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -91,22 +91,15 @@ type Api = {
  * One running track: the numeric fields of one component of one entity moving from the values
  * read at the end of the delay to the exact target, straight or through keyframe segments. A
  * track with repeats walks again from its first segment each time a run ends.
- *
- * @example
- * ```ts
- * const track: Track = {
- *   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(), keep: false,
- *   reveals: "place"
- * };
- * ```
  */
 type Track = {
   readonly id: number;
   readonly entity: Entity;
-  readonly component: AnyComponent; /** The target fields. Retarget deletes the fields a newer absolute track took over. */
+  readonly component: AnyComponent;
+  /**
+   * The target fields. Retarget deletes the fields a newer absolute track took over. A frame reads
+   * the slots (`names`, `targets`, `live`) instead.
+   */
   to: Record<string, number>;
   /**
    * The key of the owner, bases and offsets tables per field, built once when the track starts.
@@ -116,8 +109,30 @@ type Track = {
   readonly ms: number;
   readonly ease: Ease;
   readonly delayMs: number;
-  elapsed: number; /** Read when the delay ends, never earlier. */
-  from: Record<string, number> | undefined;
+  /**
+   * `[0]`: the milliseconds the track has run, its delay included; `[1]`: the normalised time of
+   * the write that runs. Cells and not fields, so a frame writes them in place: a double stored in
+   * an object field is a new heap number.
+   */
+  readonly clock: Float64Array; /** True once the start values are read, when the delay ends, never earlier. */
+  begun: boolean; /** The target fields in slot order: every field `to` held when the track started. */
+  readonly names: readonly string[]; /** The key of each slot: the strings of `keys`, by slot. */
+  readonly slotKeys: readonly string[]; /** The target of each slot. */
+  readonly targets: Float64Array; /** The start value of each slot, read when the delay ends. */
+  readonly starts: Float64Array; /** `1` while the track drives the slot, `0` once a newer absolute track took its field. */
+  readonly live: Uint8Array; /** `1` for a slot the frame that runs moved: a write of only some fields reads it. */
+  readonly moved: Uint8Array;
+  /**
+   * Per slot, the numbers of the write that runs: first what the slot contributes, then what the
+   * field reads, the base plus every offset. Kept here so no number crosses a call boxed.
+   */
+  readonly values: Float64Array;
+  /**
+   * Per slot, the value this track last left in the field or found there, `NaN` while unknown: at
+   * the start and while another writer holds the field. A frame whose value moved off it writes
+   * without reading the field back.
+   */
+  readonly seen: Float64Array;
   readonly muted: () => ReadonlySet<string>;
   readonly additive: boolean; /** True for a track a timeline step advances by hand; the frame step leaves it alone. */
   readonly driven: boolean; /** The frame step the track was born in. That step does not advance it a second time. */
@@ -151,16 +166,16 @@ type Track = {
    * that cannot (a tint, a fill colour). Computed once when the track is made.
    */
   readonly reveals: "alpha" | "place" | "both" | undefined;
+  /**
+   * The patch the track writes, one per track with every field of `to` in it: a frame fills it in
+   * place instead of building one. A field the frame leaves alone carries its stored value back.
+   * Rebuilt when the track loses a field.
+   */
+  patch: Record<string, unknown>;
 };
 /**
  * A motion handle that can also be advanced by hand: what the timeline cursor needs, so a track
  * born inside a frame step still consumes the remainder of that step's delta.
- *
- * @example
- * ```ts
- * const motion: StepMotion = { ...inert, advance: () => 0 };
- * motion.advance(16); // 0: nothing is left over
- * ```
  */
 type StepMotion = MotionHandle & {
   /**
@@ -624,8 +639,12 @@ type ExternalPlayer = {
 type Cursor = {
   readonly step: Step;
   readonly children: readonly Cursor[]; /** Position in a `sequence`, and the last written key of a `frames` step. */
-  index: number; /** Consumed milliseconds of a `wait` or a `frames` step. */
-  elapsed: number;
+  index: number;
+  /**
+   * `[0]`: the consumed milliseconds of a `wait` or a `frames` step. A cell and not a field, so a
+   * frame writes it in place: a double stored in an object field is a new heap number.
+   */
+  readonly clock: Float64Array;
   motion: StepMotion | undefined;
   started: boolean;
   ended: boolean; /** The entity a running `frames` step holds against its `Frames` loop, until the step ends. */
@@ -720,6 +739,18 @@ type TimelineRuntime = {
    */
   releaseFrames(entity: Entity): void;
 };
+/**
+ * What the cursor functions carry down the tree: the runtime, the animation id marks are
+ * reported under, the list of marks reached so far, the entities the timeline spawned, by id, and
+ * the entities its key targets named when it started.
+ */
+type CursorCtx = {
+  /** The runtime of the frame step that walks the tree now. */rt: TimelineRuntime; /** Swapped for the nested id while a `use` step walks its tree, and set back after. */
+  animation: string;
+  readonly marks: string[];
+  readonly spawned: Map<string, Entity>; /** The entities the key targets named when the timeline started, by target object. */
+  readonly targets: ReadonlyMap<Target, Entity>;
+};
 /**
  * One running timeline: its cursor, the marks it reached, the entities it counts on, the entities
  * its key targets named at its start, the entities it spawned and despawns at its end, and the
@@ -730,11 +761,12 @@ type RunningTimeline = {
   readonly animation: string;
   readonly cursor: Cursor;
   readonly marks: string[];
-  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 entities: readonly Entity[]; /** The entities its `{ projection, key }` targets named when it started, by target object. */
+  readonly targets: ReadonlyMap<Target, 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;
+  ended: boolean; /** The one cursor context of the timeline, made at its start and reused by every frame. */
+  readonly cctx: CursorCtx;
 };
 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, 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 };
@@ -1002,17 +1034,35 @@ type Config$3 = {
  * offsets accumulator, the running timelines and the animation registry.
  */
 type State$3 = {
-  /** The one track table. Insertion order is advance order. */tracks: Map<number, Track>; /** Ids of tracks and timelines. */
+  /** The one track table. Insertion order is advance order. */tracks: Map<number, Track>;
+  /**
+   * The tracks of the table in start order, as a dense list the frame step walks by index. An ended
+   * track stays in it until the next frame step drops it.
+   */
+  trackList: Track[]; /** Ids of tracks and timelines. */
   nextId: number; /** `"<entity>:<component>:<field>"` to the id of the absolute track that drives the field. */
-  owner: Map<string, number>; /** Per field key, the delta each additive track contributes. */
-  offsets: Map<string, Map<number, number>>; /** Per field key, the value the offsets are added to. Dropped when no track drives the field. */
-  bases: Map<string, number>;
+  owner: Map<string, number>;
+  /**
+   * Per field key, the delta each additive track contributes, in a one-number cell per track that
+   * a frame writes in place.
+   */
+  offsets: Map<string, Map<number, Float64Array>>;
+  /**
+   * Per field key, the value the offsets are added to, in a one-number cell a frame writes in
+   * place. Dropped when no track drives the field.
+   */
+  bases: Map<string, Float64Array>;
   /**
    * Per entity, its running additive tracks. `offsetsOf` of the driver reads it, so the cost of
    * one answer is the loops of that entity and not every track of the game.
    */
   additive: Map<Entity, Set<Track>>; /** The running timelines, by id. */
-  timelines: Map<number, RunningTimeline>; /** The `animations` of every feature, read in `onStart`. */
+  timelines: Map<number, RunningTimeline>;
+  /**
+   * The timelines in start order, as a dense list the frame step walks by index. An ended timeline
+   * stays in it until the next frame step drops it.
+   */
+  timelineList: RunningTimeline[]; /** The `animations` of every feature, read in `onStart`. */
   registry: Map<string, AnyAnimationDefinition>; /** `onMark` subscribers, in subscription order. */
   markListeners: Set<MarkListener>; /** Counter of the frame steps. A track born in the running step is not advanced by it. */
   frame: number; /** True while the track count is over `maxTracks`, so the warning is one per crossing. */
@@ -1702,29 +1752,34 @@ type FilterBody = {
 } | {
   readonly kind: "blur";
   readonly filter: InstanceType<PixiModule["BlurFilter"]>; /** The fields the setters were last given; compared before a write. */
-  readonly applied: Record<string, FilterField>;
+  readonly applied: Record<string, FilterField>; /** The keys of `applied`, listed once: a compare walks them by index, with no `Object.keys` per frame. */
+  readonly fields: readonly string[];
   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>;
+  readonly applied: Record<string, FilterField>; /** The keys of `applied`, listed once: a compare walks them by index, with no `Object.keys` per frame. */
+  readonly fields: readonly string[];
   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>;
+  readonly applied: Record<string, FilterField>; /** The keys of `applied`, listed once: a compare walks them by index, with no `Object.keys` per frame. */
+  readonly fields: readonly string[];
   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. */
+  readonly applied: Record<string, FilterField>; /** The keys of `applied`, listed once: a compare walks them by index, with no `Object.keys` per frame. */
+  readonly fields: readonly string[]; /** 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>;
+  readonly applied: Record<string, FilterField>; /** The keys of `applied`, listed once: a compare walks them by index, with no `Object.keys` per frame. */
+  readonly fields: readonly string[];
   passes: number;
 };
 /**
@@ -1758,6 +1813,11 @@ type FilterInstance = FilterBody & {
   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;
+  /**
+   * The entity of the view it draws on, set when the filter sync takes it in; 0 for a warm-up probe. A break inside a
+   * render tells the renderer about this view (`renderer.invalidate`) before it switches the filter off.
+   */
+  entity: Entity;
 };
 /**
  * One of our bodies: a `Filter` over the assembled programs, the kind of every place of a chain and of a mark.
@@ -1815,21 +1875,48 @@ type CheckState = {
 /**
  * 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.
+ * `renderer.sync.filters.set`, the run in which each core kind's component last changed, the
+ * instances of this frame in their sorted order (one array, reused every frame), the one
+ * `renderer.invalidate` call a visible filter write of the frame makes, and whether the next run
+ * syncs it.
  */
 type FilteredView = {
+  /** The entity the record is kept for. */readonly entity: Entity;
   readonly kinds: Set<string>;
   readonly instances: Map<string, FilterInstance>;
   readonly retired: FilterInstance[];
   assigned: readonly FilterSlot[];
-  readonly changed: Set<string>;
+  /**
+   * Per kind `index`, the run of the filter sync in which its component was last seen changed; read only for a
+   * Pixi-core kind, which is written only in such a run. A number per kind, so marking allocates nothing.
+   */
+  readonly marks: number[];
   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;
+  /**
+   * The next run of the filter sync brings the view up to date: a filter component of it changed, came or left, its
+   * map was retired, a kind of it still waits for its instance, or a chain left places to destroy.
+   */
+  dirty: boolean; /** Forgotten: out of `State.views`; the next run drops it from `State.viewList`. */
+  gone: boolean;
+};
+/**
+ * Where the filter sync stands between two runs. It syncs only the views marked dirty, and judges the full-screen
+ * budget only when something it depends on moved.
+ */
+type FilterSyncState = {
+  /** The current run, counted from 1: a core kind's change mark holds the run it was made in. */round: number;
+  /**
+   * Every view syncs at the next run: a debug switch turned a kind off or on, or a filter broke or ran its chains at a
+   * new resolution inside a render, where the view it belongs to is not known.
+   */
+  all: boolean; /** A view was marked dirty or forgotten since the last walk: the next run walks the dense list, otherwise it skips it. */
+  pending: boolean; /** The viewport width the full-screen budget was last judged at; -1 before the first judgement. */
+  width: number; /** The viewport height the full-screen budget was last judged at; -1 before the first judgement. */
+  height: number;
 };
 //#endregion
 //#region src/plugins/effects/particles/types.d.ts
@@ -1973,7 +2060,12 @@ type BakedEmitter = {
   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 tintTable: Uint32Array;
+  /**
+   * The colour a particle is drawn with per 1/64 of the life, packed as Pixi's `0xaabbggrr`: the tint under the alpha
+   * byte. Read straight from the table every frame: a number above the small integers handed back by a call is boxed.
+   */
+  readonly colorTable: 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. */
@@ -2052,7 +2144,14 @@ type State$2 = {
   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"`. */
+  views: Map<Entity, FilteredView>;
+  /**
+   * The records of `views` in the order they were first seen: the dense list the filter sync walks by index. A
+   * forgotten record stays, `gone`, until the next run drops it.
+   */
+  viewList: FilteredView[]; /** The filter kinds in registration order, one per `index`: the change sets the filter sync reads, by index. */
+  kindList: FilterKind[]; /** Where the filter sync stands between two runs. */
+  filterSync: FilterSyncState; /** 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;

package/dist/{types-D44EL4gT.d.mts → types-jiWJhLPE.d.mts}

@@ -1,5 +1,5 @@
-import { br as Json, kr as Snapshot } from "./types-E2ykwIUO.mjs";
-import { t as HeadlessApp } from "./headless-B0mH9qYg.mjs";
+import { Sr as Json, jr as Snapshot } from "./types-BHgJ1F6f.mjs";
+import { t as HeadlessApp } from "./headless-D6BrEwCf.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{visual-DoHwXeQi.d.mts → visual-BvkKJOSz.d.mts}

@@ -1,9 +1,9 @@
-import { Pr as Api$3, T as Api, Yt as Api$1, _r as Api$2 } from "./types-E2ykwIUO.mjs";
-import { P as AnimApi, r as UiApi } from "./types-Bw-qLjFZ.mjs";
-import { j as InputApi } from "./types-G3ZAAsbd.mjs";
-import { r as Repro } from "./headless-B0mH9qYg.mjs";
-import { a as InputOf, r as ControlApp } from "./types-D44EL4gT.mjs";
-import { t as commands } from "./commands-BynjWVVy.mjs";
+import { Ir as Api$3, T as Api, Zt as Api$1, yr as Api$2 } from "./types-BHgJ1F6f.mjs";
+import { P as AnimApi, r as UiApi } from "./types-fpFKYm6E.mjs";
+import { j as InputApi } from "./types-Bm7DVtA_.mjs";
+import { r as Repro } from "./headless-D6BrEwCf.mjs";
+import { a as InputOf, r as ControlApp } from "./types-jiWJhLPE.mjs";
+import { t as commands } from "./commands-C_GccOFq.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */

package/dist/visual.d.mts

@@ -1,2 +1,2 @@
-import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-DoHwXeQi.mjs";
+import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-BvkKJOSz.mjs";
 export { type CheckpointResult, type VisualApp, type VisualOptions, type VisualPage, type VisualRenderer, type VisualReport, type VisualSetup, type VisualStart, type VisualStep, type VisualTest, type VisualTestResult, type VisualTolerance, defineVisualTest, parseVisualArgv, runVisualTests };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": [
@@ -102,10 +102,12 @@
     "lint:fix": "biome check --write . && eslint --fix .",
     "format": "biome format --write .",
     "typecheck": "tsc --noEmit && tsc --noEmit -p tests/fixtures/episodes-game",
-    "test": "bun --bun vitest run",
+    "test": "bun --bun vitest run --project unit --project integration",
     "test:unit": "bun --bun vitest run --project unit",
     "test:integration": "bun --bun vitest run --project integration",
     "test:coverage": "bun --bun vitest run --project unit --project integration --coverage",
+    "test:perf": "node ./node_modules/vitest/vitest.mjs run --project perf",
+    "bench:perf": "node ./node_modules/vitest/vitest.mjs bench --run --project perf",
     "build": "tsdown",
     "mini:pack": "bun tests/fixtures/moku-game.ts pack --root tests/fixtures/mini-game",
     "mini:dev": "bun tests/fixtures/moku-game.ts dev --root tests/fixtures/mini-game",