@moku-labs/game 0.15.0 → 0.15.2

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

@@ -1,4 +1,4 @@
-import { Ar as Api, Br as Require, Gt as AnyComponentType, It as TransformValue, Jn as Descriptor, Kt as AnyComponentValue, Qn as Hint, T as Api$3, Wt as AnyComponent, Yt as ComponentType, Zt as Entity, bn as Api$1, bt as ViewportSize, dn as MotionCause, er as Answer, fn as MotionHandle, mn as ProjectionMotion, on as TagType, pn as NumericFields, s as Events$1, sn as ChangeHook, t as Api$4, tr as Api$5, un as Motion, ur as Json, yn as ViewHandle, zt as Api$2 } from "./types-BGcda5Le.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";
 
@@ -1211,6 +1211,25 @@ type InputApi = {
    * ```
    */
   cursor(): string;
+  /**
+   * How many listeners and controls are registered now: every `onTap`, `onPointer` and `onKey`
+   * listener and every `controls.add` registration whose remover has not run. The pointer and key
+   * listeners input itself opens on the canvas are not counted. A screen entered and left returns
+   * the count to where it was; a count that grows with every visit is a listener left behind. It
+   * reads four lengths and allocates nothing, so a monitor may call it every second.
+   *
+   * @returns The number of registered listeners and controls.
+   * @example
+   * ```ts
+   * // A test checks that a popup takes its Escape listener back when it closes.
+   * const before = app.input.listeners();
+   * const off = app.input.onKey(key => key.key === "Escape");
+   * app.input.listeners() - before; // 1
+   * off();
+   * app.input.listeners() - before; // 0
+   * ```
+   */
+  listeners(): number;
   /**
    * The components that make a view a control besides input's own: the cursor shows
    * `config.cursor.control` over a view that carries one of them.
@@ -1611,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;
 /**
@@ -1632,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;
@@ -2464,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;
@@ -2484,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
@@ -2613,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>;
@@ -2625,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-C73hbmxi.d.mts → types-DEYQF_tT.d.mts}

@@ -1,7 +1,7 @@
-import { E as Config$2, In as FeaturePlugin, Rn as AnyFlow, Sn as Config$1, _r as SaveDoc, a as Config$3, br as SnapshotOf, cr as Config, d as Manifest, gr as ProviderCall, hr as PlayerStateProvider, ir as FakeClock, k as PixiModule, n as AssetsIo, nr as ClockSource, qn as TypeTag, ur as Json, vt as Orientation } from "./types-BGcda5Le.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-GHE4J5Uf.mjs";
-import { H as TextKey, I as I18nApi, V as StringTable } from "./types-7GXcXxxv.mjs";
-import { St as audioPlugin, ft as PlatformProvider, i as screen, t as createApp, ut as platformPlugin, yt as effectsPlugin } from "./index-DedbED3T.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-GHE4J5Uf.d.mts → types-fpFKYm6E.d.mts}

@@ -1,5 +1,5 @@
-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 { 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-DngFQJro.d.mts → types-jiWJhLPE.d.mts}

@@ -1,5 +1,5 @@
-import { ur as Json, yr as Snapshot } from "./types-BGcda5Le.mjs";
-import { t as HeadlessApp } from "./headless-cFveciuY.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-_XhoGeIC.d.mts → visual-BvkKJOSz.d.mts}

@@ -1,9 +1,9 @@
-import { T as Api, sr as Api$2, wr as Api$3, zt as Api$1 } from "./types-BGcda5Le.mjs";
-import { P as AnimApi, r as UiApi } from "./types-GHE4J5Uf.mjs";
-import { j as InputApi } from "./types-7GXcXxxv.mjs";
-import { r as Repro } from "./headless-cFveciuY.mjs";
-import { a as InputOf, r as ControlApp } from "./types-DngFQJro.mjs";
-import { t as commands } from "./commands-DAETmK86.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-_XhoGeIC.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/dist/visual.mjs

@@ -1,5 +1,5 @@
-import { n as read, t as sources } from "./sources-Cdvb0rOS.mjs";
-import { n as commands, t as run } from "./run-BbipFRc6.mjs";
+import { n as read, t as sources } from "./sources-OvHvyeJS.mjs";
+import { n as commands, t as run } from "./run-C07NXds7.mjs";
 import path from "node:path";
 import { createBrandConsole } from "@moku-labs/common/cli";
 import { mkdir, readFile, writeFile } from "node:fs/promises";

package/dist/{watch-BEdrp80i.mjs → watch-BSgptowj.mjs}

@@ -161,7 +161,8 @@ const DEFINERS = [
 	"defineEmitter",
 	"defineTextStyles",
 	"defineStyle",
-	"defineComponent"
+	"defineComponent",
+	"system"
 ];
 /**
 * Whether a name is a definer whose calls make keys.
@@ -1859,6 +1860,11 @@ const ID_PREFIXES = {
 	defineEmitter: "emitter",
 	defineComponent: "component"
 };
+/** The key prefix of each definer that takes its id as the `name` of its first-argument options. */
+const NAME_PREFIXES = {
+	projection: "projection",
+	system: "system"
+};
 /**
 * The text of a string literal or a template without holes.
 *
@@ -2040,20 +2046,23 @@ function readIdCall(reading, call, definer, prefix) {
 	if (definer === "defineFlow") readTable(reading, call, id);
 }
 /**
-* Reads a projection: its key is its `name`, its line the `name` property.
+* Reads a definer named by its options, a projection or a system: its key is its `name`, its line
+* the `name` property.
 *
 * @param reading - The file being read.
 * @param call - The call.
+* @param definer - The definer.
+* @param prefix - The key prefix.
 */
-function readProjection(reading, call) {
+function readNameCall(reading, call, definer, prefix) {
 	const { typescript } = reading;
 	const spec = objectOf(typescript, call.arguments[0]);
 	const name = spec === void 0 ? void 0 : literalOf(typescript, propertyValue(typescript, spec, "name"));
 	if (name === void 0) {
-		unresolve(reading, "projection name is not a string literal");
+		unresolve(reading, `${definer} name is not a string literal`);
 		return;
 	}
-	define(reading, call, `projection:${name}`, name, { key: "name" });
+	define(reading, call, `${prefix}:${name}`, name, { key: "name" });
 }
 /**
 * Reads a text style table: every literal key is a key.
@@ -2174,8 +2183,9 @@ function readStyle(reading, call) {
 */
 function readCall(reading, call, definer) {
 	const prefix = ID_PREFIXES[definer];
+	const namePrefix = NAME_PREFIXES[definer];
 	if (prefix !== void 0) readIdCall(reading, call, definer, prefix);
-	if (definer === "projection") readProjection(reading, call);
+	if (namePrefix !== void 0) readNameCall(reading, call, definer, namePrefix);
 	if (definer === "defineTextStyles") readTextStyles(reading, call);
 	if (definer === "defineStyle") readStyle(reading, call);
 }