@moku-labs/game 0.15.1 → 0.15.3

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { Jn as AnyFlow, Kn as FeaturePlugin, br as Json, cr as Hint, er as NodeTable, fr as ClockSource, ir as Descriptor, lr as NodeFx, mr as FakeClock } from "./types-E2ykwIUO.mjs";
-import { t as createApp } from "./index-CCiTo1_3.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-CpdkyhaC.mjs";
-import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-B0mH9qYg.mjs";
+import { Jn as FeaturePlugin, Sr as Json, Xn as AnyFlow, dr as NodeFx, gr as FakeClock, mr as ClockSource, nr as NodeTable, or as Descriptor, ur as Hint } from "./types-DlC3Ytbj.mjs";
+import { t as createApp } from "./index-ByvWj9OX.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-BApuIqwq.mjs";
+import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-D0U5AXiK.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { nn as refuseStart, on as type, p as flattenFeatures, rn as exit, t as createApp } from "./src-CwVzErzN.mjs";
+import { an as exit, cn as type, in as refuseStart, m as flattenFeatures, t as createApp } from "./src-xChMXzwH.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { t as fakeClock } from "./fake-6mazmHK3.mjs";
 import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-BA6ffzqD.mjs";

package/dist/{types-D44EL4gT.d.mts → types-B0bmoyRT.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-DlC3Ytbj.mjs";
+import { t as HeadlessApp } from "./headless-D0U5AXiK.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{types-CpdkyhaC.d.mts → types-BApuIqwq.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-DlC3Ytbj.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-CsMLBPf-.mjs";
+import { H as TextKey, I as I18nApi, V as StringTable } from "./types-yLdzHyTl.mjs";
+import { ft as platformPlugin, i as screen, mt as PlatformProvider, t as createApp, wt as audioPlugin, xt as effectsPlugin } from "./index-ByvWj9OX.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{types-Bw-qLjFZ.d.mts → types-CsMLBPf-.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-DlC3Ytbj.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-yLdzHyTl.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,24 @@ 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 when a frame moves every field, one per track with every field of
+   * `to` in it: a frame fills it in place instead of building one. Rebuilt when the track loses a
+   * field.
+   */
+  patch: Record<string, unknown>;
+  /**
+   * The patch of a frame that moves only some fields (another writer holds one, or one stands
+   * still): exactly the fields `partialMoved` flags, filled in place by the next frame that moves
+   * the same ones and built again when they change, so a field the track lost, which never moves
+   * again, is never in it. `undefined` until the first such frame.
+   */
+  partial: Record<string, unknown> | undefined; /** The `moved` flags `partial` was built for, by slot. */
+  readonly partialMoved: Uint8Array;
 };
 /**
  * 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 +647,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 +747,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 +769,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 +1042,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 +1760,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 +1821,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 +1883,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 +2068,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 +2152,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;