@moku-labs/game 0.15.2 → 0.15.4

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-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-BHgJ1F6f.mjs";
-import { t as createApp } from "./index-w2uyRKkj.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-DEYQF_tT.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-D6BrEwCf.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-vjWgmPqS.mjs";
+import { t as createApp } from "./index-Cv5r0M9Y.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-VNoG7shY.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-oykCMFBV.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { in as exit, p as flattenFeatures, rn as refuseStart, sn as type, t as createApp } from "./src-Ca8W8Dvv.mjs";
+import { an as exit, cn as type, in as refuseStart, m as flattenFeatures, t as createApp } from "./src-tkKl-oCn.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-Bm7DVtA_.d.mts → types-B6YgPkY8.d.mts}

@@ -1,4 +1,4 @@
-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 { 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-vjWgmPqS.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

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

@@ -1,5 +1,5 @@
-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 { 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-vjWgmPqS.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-B6YgPkY8.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";
@@ -167,11 +167,19 @@ type Track = {
    */
   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.
+   * 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

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

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

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

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

package/dist/{types-BHgJ1F6f.d.mts → types-vjWgmPqS.d.mts}

@@ -3401,6 +3401,12 @@ type FeatureDescription = {
   textStyles?: FeatureTextStyles; /** Particle emitters the feature owns, read by `effects`. */
   emitters?: readonly FeatureEmitter[]; /** Filters the feature puts on its interface components, read by `effects`. */
   filters?: readonly FeatureFilter[];
+  /**
+   * The key of 0.15.3, removed: typed `never`, so a game that still writes it is told. A system
+   * now runs while its query has an entity, and `scenes` on `system()` limits it to some scenes:
+   * delete the key (world README, "When a system runs").
+   */
+  systemsRun?: never;
   [later: string]: unknown;
 };
 /**
@@ -5206,6 +5212,7 @@ type QueryTuple<Terms extends readonly QueryTerm[]> = [Entity, ...QueryValues<Te
  * const run = (entities: Iterable<[Entity]>, ctx: SystemContext): void => {
  *   ctx.res(Pointer).x = 0;
  *   ctx.time.delta; // 16
+ *   ctx.resumed; // false: the system ran in the frame before
  * };
  * ```
  */
@@ -5214,9 +5221,19 @@ type SystemContext = {
   res<Value extends object>(resource: ResourceType<Value>): Value;
   readonly snapshot: Snapshot;
   readonly time: Readonly<Time>;
+  /**
+   * True on the first run after one or more of this system's runs were skipped: its query had no entity, or none of
+   * its `scenes` was mounted or leaving. Nothing was kept for it while it slept: `world.changed()` holds this frame's
+   * changes only, so a system that caches what it drew, or remembers what it saw last, starts over from the
+   * components when this is true. False on every other run. Read it during the run.
+   */
+  readonly resumed: boolean;
 };
 /**
- * A system definition, typed over its query tuple.
+ * A system definition, typed over its query tuple. A system with a query runs only while its query
+ * can match: before each run the world looks at the store of every term, and when one of them holds
+ * no entity the run is skipped (no walk, no `mut()` mark, no timing). A system without a query
+ * always runs. `scenes` limits either kind to some scenes.
  *
  * @example
  * ```ts
@@ -5235,10 +5252,42 @@ type SystemDefinition<Terms extends readonly QueryTerm[]> = {
   readonly phase: WorldPhase;
   readonly query: Terms;
   /**
-   * Runs the system once a frame in its phase. `entities` walks the declared `query` once; every
-   * row it hands out is the same array, rewritten for the next row, so a row is valid until the
-   * next row. A system that keeps a row copies what it keeps: `const [entity, transform] = row`.
-   * `ecs.query()` called inside `run` hands out a new array per row.
+   * The scenes the system runs on: it runs only while one of them is mounted or leaving. A scene
+   * leaves from the switch that replaces it until nothing carries `Exiting` any more, so the exits
+   * of its JSX elements play to the end; any exit counts, also one of the next scene, so a leave may
+   * last longer than the scene's own exits. The next scene's entities already stand during a leave:
+   * a query that matches them too hands them to the system, so it writes only its own scene's
+   * entities. Left out, the system runs on every scene. Read once, when the system registers. A dev
+   * build throws at start for a name no feature declares as a scene. For a system without a query,
+   * or one whose entities stand on every screen.
+   *
+   * @example
+   * ```ts
+   * // features/board/world/systems/idle.ts: no query, so `scenes` alone keeps it to the board.
+   * const BoardIdle = resource("BoardIdle", { ms: 0 });
+   * export const idle = system({
+   *   name: "board.idle",
+   *   phase: "animate",
+   *   query: [],
+   *   scenes: ["board"],
+   *   run: (_rows, { res, time }) => {
+   *     res(BoardIdle).ms += time.delta;
+   *   }
+   * });
+   * // On the ward it is not run and BoardIdle.ms stands still. On the board it grows by each
+   * // frame's delta. After the switch to the ward it runs while the board's elements play their
+   * // exit, then not any more.
+   * ```
+   */
+  readonly scenes?: readonly string[];
+  /**
+   * Runs the system once a frame in its phase, unless it is skipped: a term of its `query` has no
+   * entity, or none of its `scenes` is mounted or leaving. `entities` walks the declared `query`
+   * once; every row it hands out is the same array, rewritten for the next row, so a row is valid
+   * until the next row. A system that keeps a row copies what it keeps:
+   * `const [entity, transform] = row`. `ecs.query()` called inside `run` hands out a new array per
+   * row. Work that must happen when the query has no entity (end a press, reset a resource) belongs
+   * in a system without a query.
    */
   run(entities: Iterable<QueryTuple<Terms>>, ctx: SystemContext): void;
 };
@@ -5293,24 +5342,45 @@ type SystemFor<Player, Session> = <const Terms extends readonly QueryTerm[]>(def
 type AnySystem = {
   readonly name: string;
   readonly phase: WorldPhase;
-  readonly query: readonly QueryTerm[]; /** As `SystemDefinition.run`: one row array per walk, valid until the next row. */
+  readonly query: readonly QueryTerm[]; /** As `SystemDefinition.scenes`: the scenes it runs on, every scene when left out. */
+  readonly scenes?: readonly string[]; /** As `SystemDefinition.run`: one row array per walk, valid until the next row. */
   run(entities: Iterable<readonly unknown[]>, ctx: SystemContext): void;
 };
+/** One component store, keyed by entity: a component's value, `true` for a tag. */
+type ComponentStore = Map<Entity, object | true>;
 /**
- * One registered system, the frame it was registered in, its query resolved once and the walk the
- * runner resets for every run. A system registered during a frame runs from the next frame on.
- * Spec 28 (deferred) extends it with the system's scope.
+ * One registered system, the frame it was registered in, its query resolved once, the walk the
+ * runner resets for every run, the stores its check reads and its scenes. A system registered
+ * during a frame runs from the next frame on. Module state: no game reads it.
  */
 type SystemEntry = {
   readonly definition: AnySystem;
   readonly frame: number;
   readonly plan: QueryPlan;
+  /**
+   * The store of each term, in term order, kept once it exists: a store lives as long as the
+   * systems of its world, so the check before a run reads sizes and looks nothing up.
+   * `undefined` for a term no entity carried yet.
+   */
+  readonly stores: Array<ComponentStore | undefined>; /** The scenes it runs on, read once at registration; `undefined` for every scene. */
+  readonly scenes: readonly string[] | undefined; /** Its last chance to run was skipped: the next run is told so with `resumed`. */
+  skipped: boolean;
   /**
    * The walk of the declared query, made at registration; `undefined` for an empty query, which
    * the runner never walks. An entry built without one gets it on its first run.
    */
   walk?: SystemWalk | undefined;
 };
+/**
+ * Which scene is mounted and which are still leaving, as `scenes` tells the world with
+ * `ecs.setScene`: what a system with `scenes` runs on. Changed at a scene switch only; a phase
+ * reads it.
+ */
+type SceneState$1 = {
+  /** The mounted scene, `undefined` before the first switch. */mounted: string | undefined; /** The scenes a switch replaced while something still carries `Exiting`, oldest first; no repeats. */
+  leaving: string[]; /** The scene ids the features declare, read at start for the dev check of `scenes`; `undefined` before. */
+  declared: ReadonlySet<string> | undefined;
+};
 /**
  * A structural change queued while a phase runs. Applied in call order when the phase ends.
  *
@@ -5363,7 +5433,8 @@ type PhaseContext = {
   /** The ecs API the systems of this world receive. */readonly world: EcsApi; /** The resource reader, one function per world. */
   readonly res: <Value extends object>(resource: ResourceType<Value>) => Value; /** The frozen model snapshot of the running frame. */
   snapshot: Snapshot; /** The running frame's `Time`. */
-  time: Readonly<Time>;
+  time: Readonly<Time>; /** Written before every run: the system's last chance to run before this one was skipped. */
+  resumed: boolean;
 };
 /**
  * The JSON kind of one component field, read from its default value: what the editor's component
@@ -5565,7 +5636,8 @@ type EcsState = {
   walkReported: boolean; /** The plans of `ecs.query()` by the type of their first term, made once per tuple of types. */
   queryPlans: Map<AnyComponentType, KnownPlan[]>; /** The entity lists of ended `ecs.query()` walks, taken by the next walks: no key copy per call. */
   walkLists: Entity[][]; /** How many entities were despawned since the world began: the sweep looks for dead elements when it moved. */
-  despawns: number;
+  despawns: number; /** The mounted scene and the leaving ones, for the systems with `scenes`. */
+  scene: SceneState$1;
 };
 /**
  * ecs module API, `app.world.ecs`: the screen as data. Plain-object components in one store per
@@ -5582,16 +5654,18 @@ type EcsState = {
 type EcsApi = {
   /**
    * Registers a system at the end of its phase list. A system registered during a frame runs
-   * from the next frame on.
+   * from the next frame on. In every frame the system is skipped while a term of its query has no
+   * entity, or while none of its `scenes` is mounted or leaving.
    *
    * @param definition - The system, built with `system()`.
    * @returns The remover; calling it twice is a no-op.
-   * @throws {Error} When a system of that name is already registered.
+   * @throws {Error} When a system of that name is already registered, and in a dev build after
+   *   start for a name in `scenes` that no feature declares as a scene.
    * @example
    * ```ts
    * // `text` registers its layout system when the plugin starts.
    * const world = ctx.require(worldPlugin);
-   * const off = world.ecs.system(measureLabels); // runs from the next frame
+   * const off = world.ecs.system(measureLabels); // runs from the next frame on which a label exists
    *
    * off(); // the plugin stops
    * ```
@@ -5897,6 +5971,24 @@ type EcsApi = {
    * ```
    */
   setMode(mode: WorldMode): void;
+  /**
+   * Tells the world which scene is mounted now, for the systems that list `scenes`. The scene
+   * mounted before it, and any scene still leaving, keep their systems running until nothing
+   * carries `Exiting` any more: the elements of their JSX views played their exit (the views themselves
+   * go at the switch). Each system reads it
+   * before its next run. The same scene again changes nothing. `scenes` calls it in the block that
+   * mounts a scene; a game never needs to.
+   *
+   * @param scene - The id of the scene now mounted.
+   * @example
+   * ```ts
+   * // scenes, in the block that replaces the ward with the board:
+   * ctx.require(worldPlugin).ecs.setScene("board");
+   * // In the next frame a system with scenes: ["board"] runs. One with scenes: ["ward"] runs
+   * // until the ward's elements played their exit, then sleeps.
+   * ```
+   */
+  setScene(scene: string): void;
   /**
    * The component type behind a name. A type registers itself on first use, so a name nobody
    * wrote, read or queried yet is unknown.
@@ -6800,6 +6892,12 @@ type KeptState = {
   verifySkipped: number; /** True while `bypass(true)` draws everything live for an extract. */
   bypassed: boolean; /** Render passes the last flush cost: the estimate `sync.renderPasses()` adds (P9.2). */
   flushPasses: number;
+  /**
+   * The frame `collect` read had no mark and no whole-frame reason: nothing a kept picture reads changed, so a kept
+   * record that owes nothing is drawn from its picture as it stands, without its step (E5). Set by `collect`, spent by
+   * the next flush.
+   */
+  calm: boolean;
 };
 //#endregion
 //#region src/plugins/renderer/viewport/types.d.ts
@@ -7900,6 +7998,12 @@ type SyncInternal = {
    */
   layerOf(entity: Entity): string | undefined; /** The overlays of this frame: modes, ranges, reasons, dims, HUD parts, and the pictures to take (spec 22). */
   stepOverlays(): void;
+  /**
+   * Hands Pixi again the filters of every view whose filters were switched on or off since they were written: Pixi
+   * holds only the enabled ones (E3). Run by the draw callback before anything reads the tree, so a switch is drawn in
+   * the frame it was made. Allocates nothing when no filter was switched.
+   */
+  stepFilters(): void;
   /**
    * The `Graphics` paths the engine drew since the last call (shapes, clip masks, nine-slice outlines), and zeroes the
    * count: the monitor's `stats().redraws` (spec 26 R2.3).
@@ -8229,14 +8333,16 @@ type SyncState = {
   overlay: OverlayState; /** `Graphics` paths drawn since the monitor last took them: shapes, clip masks, outlines (spec 26 R2.3). */
   redraws: number;
   /**
-   * Where the walk of `shown` stopped for the entities whose loops asked since the last sync pass (spec 26 R1.7.3):
-   * an entity with several endless loops is walked once a frame. Cleared by every pass, which may change the tree.
+   * Where the walk of `shown` stopped for the entities whose loops asked (spec 26 R1.7.3), at the `passesVersion` it
+   * was taken: an answer stands while the version does, so an entity with several endless loops is walked once, and a
+   * still board not at all (E4). One record per entity, made at its first ask, dropped with its view.
    */
-  held: Map<Entity, Unseen>;
+  held: Map<Entity, HeldUnseen>;
   /**
-   * Moves on with every change that may change the render passes of a frame: a filter set or forgotten, a node's
-   * `renderable` flipped, a view hung, wrapped or dropped (a pass that did work), a kept picture taken or let go, a
-   * write a plugin announced with `invalidate` (a filter switched on or off).
+   * Moves on with every change that may change the render passes of a frame or where a walk of `shown` stops: a filter
+   * set, forgotten or switched, a node's `renderable` flipped (every hidden reason, the alpha's too), a view hung,
+   * moved, wrapped or dropped (a pass that did work), a kept picture taken or let go, a HUD factor, a new viewport, a
+   * write a plugin announced with `invalidate`.
    */
   passesVersion: number; /** The filtered views' passes of `renderPassesOf`, counted at `passesVersion` `at` under `root`. */
   passes: PassCount; /** The name of the scene's HUD layer (`above: "overlays"`), kept with the layers; `undefined` without one. */
@@ -8256,6 +8362,11 @@ type OverdrawState = {
   matrix: PixiFilter | undefined;
   listeners: Array<(on: boolean) => void>;
 };
+/** Where the walk of `shown` stopped for one entity, and the `passesVersion` it was taken at. */
+type HeldUnseen = {
+  answer: Unseen;
+  at: number;
+};
 /**
  * The filtered views' part of the render passes, counted once and read every frame while nothing it reads changed: the
  * version and the root it was counted at, and every filter of the filter table with its `enabled` then (a plugin may
@@ -9193,9 +9304,9 @@ type HostState = {
    */
   uninstallPasses: (() => void) | undefined;
   /**
-   * Swaps Pixi's own bitmap text pipe back in. Set once per host state when the renderer's pipe,
-   * whose SDF shader applies the alpha once, went into Pixi's registry, so a restore reuses it;
-   * `undefined` while inert and when the module lacked the pieces.
+   * Swaps Pixi's own bitmap text and batch pipes back in and drops the SDF batcher. Set once per host state when the
+   * renderer's batched distance-field text went into Pixi's registry, so a restore reuses it; `undefined` while inert
+   * and when the module lacked the pieces.
    */
   uninstallSdfText: (() => void) | undefined;
   /**
@@ -10408,9 +10519,9 @@ declare namespace types_d_exports$2 {
  * the render textures and matrices the kept pictures are drawn with (an `AlphaFilter` runs their pre-pass), and the
  * extension registry with the seven classes the counting of a dev or debug build swaps
  * (the three WebGPU draw classes, the filter system, both texture systems and the batcher pipe whose `buildStart`
- * begins every instruction rebuild; production swaps the encoder alone, to count the passes) and the bitmap text
- * pipe `host` swaps for one whose SDF shader applies the alpha once (with the WGSL and GLSL shader
- * pieces it compiles that shader from). The module object
+ * begins every instruction rebuild; production swaps the encoder alone, to count the passes), and the pieces of
+ * batched distance-field text `host` installs: Pixi's `Batcher` with its geometry and buffers, the bitmap text pipe
+ * and the batcher pipe it subclasses, and the WGSL and GLSL shader pieces of the batch's SDF shader. The module object
  * never arrives through a static import: `config.loadPixi()` returns it, so a game without a screen carries no
  * Pixi in its bundle.
  *
@@ -10422,10 +10533,11 @@ declare namespace types_d_exports$2 {
  * pixi.FilterSystem.extension.name; // "filter"
  * pixi.BatcherPipe.extension.name; // "batch"
  * pixi.BitmapTextPipe.extension.name; // "bitmapText"
+ * pixi.ExtensionType.Batcher; // "batcher"
  * pixi.defaultFilterVert.startsWith("in vec2 aPosition;"); // true
  * ```
  */
-type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "BatcherPipe" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Bounds" | "Cache" | "ColorMatrixFilter" | "Container" | "DisplacementFilter" | "Filter" | "FilterSystem" | "GlProgram" | "GlTextureSystem" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "GpuTextureSystem" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "Rectangle" | "RenderGroupPipe" | "RenderTexture" | "Shader" | "Sprite" | "Texture" | "TexturePool" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "localUniformMSDFBit" | "localUniformMSDFBitGl" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
+type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "Batcher" | "BatcherPipe" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Bounds" | "Buffer" | "BufferUsage" | "Cache" | "ColorMatrixFilter" | "Container" | "DefaultBatcher" | "DisplacementFilter" | "ExtensionType" | "Filter" | "FilterSystem" | "Geometry" | "GlProgram" | "GlTextureSystem" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "GpuTextureSystem" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "Rectangle" | "RenderGroupPipe" | "RenderTexture" | "Shader" | "Sprite" | "Texture" | "TexturePool" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
 /**
  * One Pixi application: renderer, canvas and stage.
  */

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

@@ -1,9 +1,9 @@
-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";
+import { Ir as Api$3, T as Api, Zt as Api$1, yr as Api$2 } from "./types-vjWgmPqS.mjs";
+import { P as AnimApi, r as UiApi } from "./types-CiTr21gu.mjs";
+import { j as InputApi } from "./types-B6YgPkY8.mjs";
+import { r as Repro } from "./headless-oykCMFBV.mjs";
+import { a as InputOf, r as ControlApp } from "./types-DY_wOvUF.mjs";
+import { t as commands } from "./commands-CvWBaoEi.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-BvkKJOSz.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-B8ve4Qll.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/llms.txt

@@ -101,6 +101,7 @@ function defineFeature(name: string, description: FeatureDescription): FeaturePl
 //   contribute?: Record<string, { flow: AnyFlow; order: number; when?: (snapshot: Snapshot) => boolean }>;
 //   features?: readonly FeaturePlugin[];                       // sub-features, composed right after this one
 //   projections?, systems?, components?, scenes?, assets?;   // V2 keys, read by world, scenes and assets
+//   systemsRun?: never;                                        // the 0.15.3 key, removed: a system runs while its query has an entity
 //   animations?: readonly AnimationDefinition[];              // V3, read by anim
 //   ui?: readonly ComponentDefinition[];                      // V3, read by ui (defineComponent results)
 //   strings?: Record<locale, CompiledMessages | (() => Promise<unknown>)>;   // V3, read by i18n
@@ -527,6 +528,7 @@ The graph. Modules `runner`, `gate`, `inbox`, `fx`, `features`. Runner methods s
 - `app.assets`: `load(bundle)`, `unload(bundle)`, `isLoaded(bundle)`, `has(bundle)` (the manifest carries it, loaded or not), `texture(key)`, `font(key)`, `audio(key)`, `usage()`. Per bundle in a feature's `assets.ts`: `defineBundles({ ep01: { tier: "feature", release: "leave", mipmaps: ["items/**"] } })`. `release: "leave"` also unloads the bundle, with reason `"leave"`, at the next rest once nothing holds it: not pinned by the node entered, not named by the mounted scene, no node of its feature on the stack; a bundle the outgoing scene named leaves one rest later. The default `"budget"` leaves only under the texture budget. `mipmaps` (`true` or globs relative to `assets/`) uploads the textures with their full chain; such a texture stays loose in a pack. A sub-feature with resources gets its own bundles, named like its folder, with `dir` and `parent` in the manifest; a code-only one has none. `companions.add({ load(bundle), unload(bundle) })` adds what loads and unloads with every bundle; `i18n` adds the strings of a sub-feature that way, only when `assets` is composed. Events `assets:bundle-loaded`, `assets:bundle-progress`, `assets:bundle-unloaded` (`reason: "budget" | "request" | "leave"`), `assets:replaced` (dev). Config: `manifest`, `textureBudgetMb: 192`, `preloadDepth: 2`, `baseUrl`, `io`.
 - `resource(name, defaults)` clones plain JSON defaults into every world. `resource(name, () => value)` calls the factory once per world on first read, so the value may hold a `Map` or a function: `const Looks = resource("boardLooks", () => ({ shown: new Map<World.Entity, { look: string }>() }))`. A system keeps its own state there; `snapshot()` leaves a value that is not JSON out.
 - `Now` is the engine resource of the frame's moment: `world` writes `clock.now()` into it at start and first thing in every frame, headless too, so every system of a frame reads one moment: `const { now } = res(Now)`; a fake clock makes it exact. A system that shows time writes its component only when its picture changes. `snapshot().resources` holds `Now: { now }`. Reserved resource names: `Now`, `Pointer`, `AnimPlayer`, `UiCounters`; a game resource of one of them throws `[game] world: the resource name "Now" is the engine's (the frame's moment).`
+- When a system runs: before each run the world checks it. A system with a `query` is skipped while a term of its query has no entity (the smallest store among the terms is empty): no walk, no `mut()` mark, no timing. A system without a query always runs. `system({ ..., scenes: ["board"] })` runs only while one of those scenes is mounted or leaving: `scenes` calls `app.world.ecs.setScene(id)` at every switch, and the scene before leaves until nothing carries `Exiting` (the elements of its JSX views played their exit; the next scene's entities already stand then, so a `scenes` system writes only its own scene's entities). A dev build throws at start for a name in `scenes` no feature declares: `[game] System "board.idle" runs on the scene "bord", which no feature declares.` `ctx.resumed` is true on the first run after a skip (a cache or a remembered cue starts over then). The same for every system, the engine's included; 0 B a frame. A run with no rows does not happen any more: work a system did besides its rows (a hover, a drop or a press that ends, a resource reset, something that outlives its entities) goes to a system with `query: []` and `scenes`, reading its rows with `world.query()`. From 0.15.3: delete `systemsRun` from every feature (the type refuses it), rewrite the systems that work outside their rows, add `scenes` only to a system whose entities stand on every screen; `ecs.hold` and `ecs.isActive` are gone (a test asks `app.scenes.current()` or whether the system ran). World README, "When a system runs".
 - Motion hooks are told why they play: `enter(view, item, hint, cause)` and `exit(view, item, hint, cause)` get `World.MotionCause`, `"mount"` (the view comes or goes with its screen: a mount, an unmount, a load, a restore, a paused or fast world) or `"change"` (a commit). A world projection plays them only for `"change"`; `ui` plays them for both. `app.world.projection.causeOf(entity)` answers how a view came or how it is leaving, also in a removal hook of its despawn, until the next frame.
 - `app.world.projection.replace(spec)` swaps the spec of a registered projection; a mounted one runs its new `view` on the next frame. An unknown name throws. The caller is the dev hot swap.
 - `input`: one followed pointer. A finger that has not started a gesture (pressed, inside the tap slop, no long press, no trace) gives way to the next finger that goes down, wherever it rests, and its press is cancelled; a finger that started a gesture keeps it. `Pointer.id` is the followed `pointerId` (`-1` at rest): a system that measures the finger's travel starts over when it changes.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.15.2",
+  "version": "0.15.4",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": [