@moku-labs/game 0.2.0 → 0.3.0

package/dist/{types-BZ1OLf24.d.mts → types-Dy1xB68L.d.mts}

@@ -10,7 +10,7 @@ import { AnyPluginInstance, PluginCtx } from "@moku-labs/core";
  * createApp({ config: { orientation: "portrait", referenceSide: 1080, referenceLong: 2100 } });
  * ```
  */
-type Config$7 = {
+type Config$8 = {
   /** Screen orientation the game is designed for. */orientation: "portrait" | "landscape"; /** Short side of the reference resolution in pixels. */
   referenceSide: number;
   /**
@@ -29,7 +29,7 @@ type Config$7 = {
 /**
  * Global events. Empty: every event belongs to a plugin.
  */
-type Events$5 = Record<never, never>;
+type Events$6 = Record<never, never>;
 /**
  * Public API type of a plugin instance, read from its phantom carrier.
  * Mirrors the kernel's non-exported `ExtractPluginApi`.
@@ -58,8 +58,8 @@ type Require = <Plugin extends {
     readonly events: Record<string, unknown>;
   };
 }>(plugin: Plugin) => ApiOf<Plugin>;
-declare namespace types_d_exports$6 {
-  export { Api$6 as Api, ClockCtx, ClockSource, Config$6 as Config, Elapsed, FakeClock, State$6 as State };
+declare namespace types_d_exports$7 {
+  export { Api$7 as Api, ClockCtx, ClockSource, Config$7 as Config, Elapsed, FakeClock, State$7 as State };
 }
 /**
  * Source of time and timers. The system source is the default; a game passes its own when time
@@ -160,7 +160,7 @@ type Elapsed = {
  * createApp({ pluginConfigs: { clock: { source: fakeClock(1000) } } });
  * ```
  */
-type Config$6 = {
+type Config$7 = {
   /**
    * Time source. `undefined` means the system source: `Date.now` and `setTimeout`.
    */
@@ -169,7 +169,7 @@ type Config$6 = {
 /**
  * clock plugin state.
  */
-type State$6 = {
+type State$7 = {
   source: ClockSource;
   last: number;
   dueAt: number | undefined;
@@ -190,7 +190,7 @@ type State$6 = {
  * app.clock.scheduleAt(nextRefillAt(app.clock.now()));
  * ```
  */
-type Api$6 = {
+type Api$7 = {
   /**
    * Reads trusted time. It never decreases, whatever the device clock does, so a player who sets
    * the clock back gains nothing.
@@ -262,11 +262,11 @@ type Api$6 = {
 /**
  * Domain context of the clock plugin.
  */
-type ClockCtx = PluginCtx<Config$6, State$6> & {
+type ClockCtx = PluginCtx<Config$7, State$7> & {
   readonly global: object;
 };
-declare namespace types_d_exports$5 {
-  export { Api$5 as Api, Config$5 as Config, Events$4 as Events, LifecycleCtx, PauseReason, State$5 as State };
+declare namespace types_d_exports$6 {
+  export { Api$6 as Api, Config$6 as Config, Events$5 as Events, LifecycleCtx, PauseReason, State$6 as State };
 }
 /**
  * Why the game is paused. The named reasons are the engine's own; any other string is allowed.
@@ -289,7 +289,7 @@ type PauseReason = "background" | "devtools" | "system-dialog" | "device-lost" |
  * };
  * ```
  */
-type Events$4 = {
+type Events$5 = {
   /**
    * The pause stack changed. `reason` and `action` say what changed; `resumed` is true only on
    * the change that emptied the stack.
@@ -310,11 +310,11 @@ type Events$4 = {
  * const config: Config = {};
  * ```
  */
-type Config$5 = Record<string, never>;
+type Config$6 = Record<string, never>;
 /**
  * lifecycle plugin state: the pause reasons in insertion order, no duplicates.
  */
-type State$5 = {
+type State$6 = {
   reasons: PauseReason[];
 };
 /**
@@ -331,7 +331,7 @@ type State$5 = {
  * app.lifecycle.pop("ad"); // time resumes
  * ```
  */
-type Api$5 = {
+type Api$6 = {
   /**
    * Pushes a reason why the game is paused. A reason already on the stack is ignored, so two
    * plugins pausing for the same reason never pause twice.
@@ -390,7 +390,7 @@ type Api$5 = {
  * `index.ts` writes `events` with an annotated `register` (core spec `14` row 8), so the own event
  * reaches a factory passed by direct reference.
  */
-type LifecycleCtx = PluginCtx<Config$5, State$5, Events$4> & {
+type LifecycleCtx = PluginCtx<Config$6, State$6, Events$5> & {
   readonly require: Require;
 };
 //#endregion
@@ -960,8 +960,8 @@ declare class SaveUnreadableError extends Error {
    */
   constructor(savedVersion: number, schemaVersion: number, cause: unknown);
 }
-declare namespace types_d_exports$4 {
-  export { Api$4 as Api, CommitResult, Config$4 as Config, Events$3 as Events, Json, Migration, ModelCtx, Patch, PlayerStateProvider, ProviderCall, RngApi, RngState, RngStream, RngView, Root, SaveDoc, Snapshot, State$4 as State, StoreApi, Transaction };
+declare namespace types_d_exports$5 {
+  export { Api$5 as Api, CommitResult, Config$5 as Config, Events$4 as Events, Json, Migration, ModelCtx, Patch, PlayerStateProvider, ProviderCall, RngApi, RngState, RngStream, RngView, Root, SaveDoc, Snapshot, State$5 as State, StoreApi, Transaction };
 }
 /**
  * Plain JSON value. Everything in state is JSON.
@@ -992,7 +992,7 @@ type Root = "player" | "session" | "rng";
  * const payload: Events["model:committed"] = { roots: ["player", "rng"], cause: "edge" };
  * ```
  */
-type Events$3 = {
+type Events$4 = {
   /** Committed state changed. Projections reconcile from the snapshot. */"model:committed": {
     roots: readonly Root[];
     cause: "edge" | "rollback" | "restore" | "load";
@@ -1006,7 +1006,7 @@ type Events$3 = {
  * createApp({ pluginConfigs: { model: { initialPlayer: { coins: 0 }, seed: 42 } } });
  * ```
  */
-type Config$4 = {
+type Config$5 = {
   /** The save seam. `undefined`: an in-memory provider, nothing is persisted. */playerProvider: PlayerStateProvider | undefined; /** Player state of a new player. Deep-cloned. */
   initialPlayer: Json; /** Session state at every start. Deep-cloned. */
   initialSession: Json; /** "from-save": a new player gets a random seed once; a number fixes it (tests). */
@@ -1018,7 +1018,7 @@ type Config$4 = {
  * model plugin state: one branch per module.
  *
  */
-type State$4 = {
+type State$5 = {
   store: StoreState;
   rng: Record<string, never>;
 };
@@ -1031,7 +1031,7 @@ type State$4 = {
  * app.model.rng.peek("chest:42"); // undefined: this chest was never opened
  * ```
  */
-type Api$4 = {
+type Api$5 = {
   store: StoreApi;
   rng: RngApi;
 };
@@ -1040,12 +1040,12 @@ type Api$4 = {
  * an annotated `register` (core spec `14` row 8), so the own event reaches a factory passed by
  * direct reference.
  */
-type ModelCtx = PluginCtx<Config$4, State$4, Events$3> & {
+type ModelCtx = PluginCtx<Config$5, State$5, Events$4> & {
   readonly global: object;
   readonly log: Log.LogApi;
 };
-declare namespace types_d_exports$3 {
-  export { Api$3 as Api, Config$3 as Config, FrameCallback, Phase, State$3 as State, Time, TimeCtx };
+declare namespace types_d_exports$4 {
+  export { Api$4 as Api, Config$4 as Config, FrameCallback, Phase, State$4 as State, Time, TimeCtx };
 }
 /**
  * Frame phases, in call order.
@@ -1089,7 +1089,7 @@ type FrameCallback = (time: Readonly<Time>) => void;
  * createApp({ pluginConfigs: { time: { maxFps: 30 } } });
  * ```
  */
-type Config$3 = {
+type Config$4 = {
   /**
    * Frame rate cap. The default is 60. 120 is for WebViews that really deliver 120 Hz frames:
    * Android today; WKWebView on iOS and macOS is capped at 60 by WebKit (bug 294338).
@@ -1112,7 +1112,7 @@ type Config$3 = {
 /**
  * time plugin state.
  */
-type State$3 = {
+type State$4 = {
   callbacks: Record<Phase, FrameCallback[]>;
   /**
    * Scratch array of a frame: the six callback lists as they were when the frame started.
@@ -1155,7 +1155,7 @@ type State$3 = {
  * off();
  * ```
  */
-type Api$3 = {
+type Api$4 = {
   /**
    * Registers a frame callback. Callbacks of one phase run in registration order; a callback
    * registered during a frame runs from the next frame on.
@@ -1279,7 +1279,7 @@ type Api$3 = {
 /**
  * Domain context of the time plugin.
  */
-type TimeCtx = PluginCtx<Config$3, State$3> & {
+type TimeCtx = PluginCtx<Config$4, State$4> & {
   readonly global: object;
   readonly log: Log.LogApi;
 };
@@ -2723,8 +2723,8 @@ declare function to<const TargetName extends string, Payload, Output>(target: Ta
  * ```
  */
 declare function slot(name: string): SlotNode;
-declare namespace types_d_exports$2 {
-  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$2 as Api, Bookmark, BundlesOf, CheckedEdges, Config$2 as Config, Contribution, DefineNode, Deps$2 as Deps, Descriptor, Edges, EmitterIdOf, EnterCallback, Events$2 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeaturesApi, FlowCtx, FlowDefinition, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, InboxApi, JournalEntry, KernelSlice$2 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, OutcomeTags, Position, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$2 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
+declare namespace types_d_exports$3 {
+  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$3 as Config, Contribution, DefineNode, Deps$3 as Deps, Descriptor, Edges, EmitterIdOf, EnterCallback, Events$3 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeaturesApi, FlowCtx, FlowDefinition, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, InboxApi, JournalEntry, KernelSlice$3 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, OutcomeTags, Position, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$3 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
 }
 /**
  * flow plugin events.
@@ -2738,7 +2738,7 @@ declare namespace types_d_exports$2 {
  * }); // the play button on "home" logs { node: "home", outcome: "play" }
  * ```
  */
-type Events$2 = {
+type Events$3 = {
   /** An edge was taken and its state committed. */"flow:edge": {
     flow: string;
     node: string;
@@ -2771,7 +2771,7 @@ type Events$2 = {
  * createApp({ pluginConfigs: { flow: { mainFlow, safeNode: "home" } } });
  * ```
  */
-type Config$2 = {
+type Config$3 = {
   /** The top-level flow. Required before `run()`. */mainFlow: AnyFlow | undefined; /** Path of the checkpoint entered after a failed retry. `undefined`: the main flow's `start`. */
   safeNode: string | undefined; /** Retries of a failed transition before going to `safeNode`. */
   retries: number; /** How long `onStop` waits for the active node to settle after abort, in real milliseconds. */
@@ -2781,7 +2781,7 @@ type Config$2 = {
 /**
  * flow plugin state: one branch per module.
  */
-type State$2 = {
+type State$3 = {
   features: FeaturesState;
   fx: FxState;
   gate: GateState;
@@ -2800,7 +2800,7 @@ type State$2 = {
  * app.flow.inbox.post({ type: "purchased" }); // the shop SDK: waits for a node that lists it
  * ```
  */
-type Api$2 = RunnerApi & {
+type Api$3 = RunnerApi & {
   gate: GateApi;
   inbox: InboxApi;
   fx: FxApi;
@@ -2810,17 +2810,17 @@ type Api$2 = RunnerApi & {
  * The APIs flow requires from below (`time`, `model`, `clock`), resolved once in `onInit` and
  * shared by the runner, gate, inbox and fx.
  */
-type Deps$2 = {
-  time: Api$3;
-  model: Api$4;
-  clock: Api$6;
+type Deps$3 = {
+  time: Api$4;
+  model: Api$5;
+  clock: Api$7;
 };
 /**
  * What the kernel context offers before the deps are attached. `emit` is the kernel's: `index.ts`
  * writes `events` with an annotated `register` (core spec `14` row 8), so the own events reach a
  * factory passed by direct reference (`api`, `hooks`, `onInit`, `onStart`).
  */
-type KernelSlice$2 = PluginCtx<Config$2, State$2, Events$2> & {
+type KernelSlice$3 = PluginCtx<Config$3, State$3, Events$3> & {
   readonly global: object;
   readonly log: Log.LogApi;
   readonly require: Require;
@@ -2828,13 +2828,13 @@ type KernelSlice$2 = PluginCtx<Config$2, State$2, Events$2> & {
 /**
  * Domain context shared by the modules.
  */
-type FlowCtx = KernelSlice$2 & {
-  readonly deps: Deps$2;
+type FlowCtx = KernelSlice$3 & {
+  readonly deps: Deps$3;
 };
 /**
  * Payload of the one event flow listens to.
  */
-type LifecycleChanged = Events$4["lifecycle:changed"];
+type LifecycleChanged = Events$5["lifecycle:changed"];
 /**
  * The bound of the `strings` slot of `GameTypes`: the key-to-parameters table every game's
  * generated `strings.ts` exports, whatever its keys. `i18n` reads the keys and the parameters;
@@ -2947,1608 +2947,1801 @@ type Position = {
   waiting: readonly string[];
 };
 //#endregion
-//#region src/plugins/world/ecs/types.d.ts
+//#region src/plugins/world/projection/types.d.ts
 /**
- * Entity id: `generation * 2 ** 20 + index`, a safe integer. A freed index comes back with a
- * higher generation, so an id is never silently reused.
+ * How a layer orders the entities drawn in it.
  *
  * @example
  * ```ts
- * const entity: Entity = 1_048_576; // generation 1, index 0
+ * const sort: LayerSort = "y";
  * ```
  */
-type Entity = number;
+type LayerSort = "none" | "y" | "order";
 /**
- * Who owns an entity. Every `spawn` names one, so `despawnOwnedBy` can free exactly one owner's
- * entities and `snapshot()` can say where an entity came from.
+ * One named layer of a scene. The order of the list is draw order.
  *
  * @example
  * ```ts
- * const owner: Owner = { kind: "projection", name: "board.items" };
+ * const layer: LayerSpec = { name: "items", sort: "y" };
  * ```
  */
-type Owner = {
-  kind: "projection" | "node" | "plugin";
+type LayerSpec = {
   name: string;
+  sort: LayerSort;
 };
 /**
- * One entity as `snapshot()` reads it: its id and the two halves of the id, its owner, every
- * component value that is plain JSON, and the names of the ones that are not.
+ * Easing of a tween: one of the named curves the driver knows, or a function that gets the
+ * normalised time and returns the eased fraction.
  *
  * @example
  * ```ts
- * const entity: EntitySnapshot = {
- *   id: 1_048_576, index: 0, generation: 1, owner: { kind: "projection", name: "board.items" },
- *   components: { Layer: { name: "items" } }, skipped: ["Display"]
- * };
+ * const ease: Ease = "outBack";
  * ```
  */
-type EntitySnapshot = {
-  id: Entity;
-  index: number;
-  generation: number;
-  owner: Owner;
-  components: Record<string, Json>;
-  skipped: string[];
-};
+type Ease = "linear" | "in" | "out" | "inOut" | "inCubic" | "outCubic" | "inOutCubic" | "inBack" | "outBack" | ((t: number) => number);
 /**
- * The whole world as plain JSON: the effective mode, every entity sorted by index and every
- * resource that is JSON.
+ * What every motion returns: it can be finished, cancelled and asked whether it still runs.
+ * V3 `anim` hands out the same shape.
  *
  * @example
  * ```ts
- * const empty: WorldSnapshot = { mode: "live", entities: [], resources: {} };
+ * const handle: MotionHandle = view.toRest(Transform);
+ * handle.active(); // true until the last frame wrote the exact target
  * ```
  */
-type WorldSnapshot = {
-  mode: WorldMode;
-  entities: EntitySnapshot[];
-  resources: Record<string, Json>;
+type MotionHandle = {
+  finish(): void;
+  cancel(): void;
+  active(): boolean;
 };
 /**
- * The four phases systems run in, in frame order.
+ * What a motion hook returns. `void` means the hook wrote the component directly.
  *
  * @example
  * ```ts
- * const phase: WorldPhase = "animate";
+ * const motion: Motion = undefined; // the hook called view.set and is already done
  * ```
  */
-type WorldPhase = "input" | "animate" | "layout" | "sync";
+type Motion = MotionHandle | void;
 /**
- * World mode. `"paused"` and `"fast"` skip the phases `input`, `animate` and `layout`; phase
- * `sync` runs in every mode.
+ * Only the numeric fields of a component value: what a tween can interpolate.
  *
  * @example
  * ```ts
- * const mode: WorldMode = "fast";
+ * type Numbers = NumericFields<{ x: number; texture: string }>; // { x: number }
  * ```
  */
-type WorldMode = "live" | "paused" | "fast";
+type NumericFields<Value extends object> = { [Key in keyof Value as Value[Key] extends number ? Key : never]: Value[Key] };
 /**
- * One component value ready to be written: the storage key and the frozen data.
+ * One keyframe segment of a track: the fraction of the track's `ms` it ends at (`0..1`), the
+ * curve it eases with (the track's `ease` when left out) and the numeric fields it reaches. A
+ * field it does not name holds where the segment before left it.
  *
  * @example
  * ```ts
- * const value: ComponentValue<{ level: number }> = { type: Item, value: { level: 2 } };
+ * // The swing of a popup board: past the rest pose at 42 % of the track, then home.
+ * const segments: TrackSegment[] = [
+ *   { at: 0.42, ease: "out", to: { y: 974, rotation: 0.087 } },
+ *   { at: 1, ease: "inOut", to: { y: 960, rotation: 0 } }
+ * ];
  * ```
  */
-type ComponentValue<Value extends object> = {
-  readonly type: ComponentType<Value>;
-  readonly value: Readonly<Value>;
+type TrackSegment = {
+  at: number;
+  ease?: Ease;
+  to: Record<string, number>;
 };
 /**
- * A tag value. A tag carries no data and is stored as `true`.
+ * Options of `ViewHandle.tween`. An additive tween adds its delta over the value the absolute
+ * writer of the field holds, instead of owning the field. `segments` turns the tween into a
+ * keyframe walk: the segments run one after another over `ms` on one clock, and `to` is where the
+ * last one ends. `repeat` runs the walk again from its first segment when it ends: a number
+ * counts the extra runs, `"forever"` never ends. The world passes it to the driver unchanged;
+ * without a driver the target is written once.
  *
  * @example
  * ```ts
- * const held: TagValue = { type: Held, value: true };
+ * const options: TweenOptions = { ms: 350, ease: "out", delayMs: 40 };
+ * const walk: TweenOptions = { ms: 1000, segments: [{ at: 0.42, to: { y: 974 } }, { at: 1, to: { y: 960 } }] };
+ * const sway: TweenOptions = { ms: 2400, additive: true, repeat: "forever", segments: [{ at: 0.5, to: { rotation: 0.05 } }, { at: 1, to: { rotation: 0 } }] };
  * ```
  */
-type TagValue = {
-  readonly type: TagType;
-  readonly value: true;
+type TweenOptions = {
+  ms: number;
+  ease?: Ease;
+  delayMs?: number;
+  additive?: boolean;
+  segments?: readonly TrackSegment[];
+  repeat?: number | "forever";
 };
 /**
- * Any component or tag value, as `spawn` and `view` return them.
+ * Options of `ViewHandle.toRest`. Defaults: the plugin's `settleMs` and ease `"out"`. `delayMs`
+ * lets a hook wait, for example for a flight to land, before the view comes home.
  *
  * @example
  * ```ts
- * const values: AnyComponentValue[] = [Held()];
+ * const options: RestOptions = { ms: 200, delayMs: 120 };
  * ```
  */
-type AnyComponentValue = {
-  readonly type: AnyComponentType;
-  readonly value: object | true;
+type RestOptions = {
+  ms?: number;
+  ease?: Ease;
+  delayMs?: number;
 };
 /**
- * A component type whose value shape is erased to a plain record: what the projection writes when
- * it only knows the component by name.
+ * What the driver is told about one track: how long it runs, how it eases, how long it waits,
+ * whether it adds to the field or owns it, and the keyframe segments it walks. A track with
+ * segments walks them over `ms` on one clock and claims every field a segment names; its target
+ * `to` is the last segment's target. A track with `repeat` starts its walk again when it ends
+ * (a number counts the extra runs, `"forever"` never ends); the instant driver ignores it and
+ * writes the end pose once.
  *
  * @example
  * ```ts
- * const erased: AnyComponent = component("Transform", { x: 0, y: 0 }) as AnyComponent;
- * erased.componentName; // "Transform"
+ * const options: TrackOptions = { ms: 250, ease: "outBack", delayMs: 0, additive: false };
+ * const walk: TrackOptions = { ms: 1000, segments: [{ at: 0.42, to: { y: 974 } }, { at: 1, to: { y: 960 } }] };
+ * const twice: TrackOptions = { ms: 400, ease: "inOut", delayMs: 0, additive: true, repeat: 1 };
  * ```
  */
-type AnyComponent = ComponentType<Record<string, unknown>>;
+type TrackOptions = {
+  ms: number;
+  ease?: Ease;
+  delayMs?: number;
+  additive?: boolean;
+  segments?: readonly TrackSegment[];
+  repeat?: number | "forever";
+};
 /**
- * A component type made by `component()`: callable to build a value, and carrying the storage
- * name plus the defaults that give the TypeScript type, the JSON shape and the inspector schema.
+ * The tween engine behind `ViewHandle.tween`, `toRest` and `all`. `anim` installs one with
+ * `setDriver`; without it the world writes every target at once.
+ *
+ * A track reads its start values when its delay ends, writes the exact target on its last frame
+ * and goes through `ecs.set`, so `changed()` sees it. Muted fields are never written, also not on
+ * `finish()`.
  *
  * @example
  * ```ts
- * const Item: ComponentType<{ kind: string; level: number }> = component("Item", {
- *   kind: "",
- *   level: 1
- * });
- * Item({ level: 2 }); // { type: Item, value: { kind: "", level: 2 } }
- * Item.owned; // []: a projection view writes every field
+ * // `anim` hands the world its own tween core in `onStart`.
+ * const driver: TweenDriver = { track: startTrack, cancelAll: cancelTracksOf };
+ * const off = ctx.require(worldPlugin).projection.setDriver(driver);
+ *
+ * off(); // `anim` stopped: the world writes instantly again
  * ```
  */
-type ComponentType<Value extends object> = {
-  (patch?: Partial<Value>): ComponentValue<Value>;
-  readonly componentName: string;
-  readonly defaults: Readonly<Value>;
-  readonly kind: "component"; /** Fields a plugin writes and a projection view never does, so a view never corrects them. */
-  readonly owned: readonly string[];
+type TweenDriver = {
+  /**
+   * Starts one track on one component of one entity.
+   *
+   * @param entity - The entity to animate.
+   * @param component - The component to animate.
+   * @param to - The numeric target fields.
+   * @param options - Duration, easing, delay and the additive flag.
+   * @param muted - The fields another writer owns, read at every write.
+   * @returns The motion handle of the track.
+   */
+  track(entity: Entity, component: AnyComponent, to: Record<string, number>, options: TrackOptions, muted: () => ReadonlySet<string>): MotionHandle;
+  /**
+   * Ends every track of one entity. Called when a view despawns and on every flush.
+   *
+   * @param entity - The entity whose tracks end.
+   */
+  cancelAll(entity: Entity): void;
 };
 /**
- * A tag type made by `tag()`: a component with no data.
+ * One node of an element description, as `ui` builds it. The world never imports `ui`: it knows
+ * the shape structurally, carries it in `Tree` and hands it back unchanged.
  *
  * @example
  * ```ts
- * const Held: TagType = tag("Held");
- * Held(); // { type: Held, value: true }
+ * const node: DescriptionNode = { type: "box", props: { gap: 8 }, children: [] };
  * ```
  */
-type TagType = {
-  (): TagValue;
-  readonly componentName: string;
-  readonly kind: "tag";
+type DescriptionNode = {
+  type: string;
+  key?: string;
+  props: object;
+  children: readonly unknown[];
 };
 /**
- * What the world stores about a component or tag type, independent of its data type.
+ * What one `view(item)` call returns: the components of the item, or one description node that
+ * the world wraps as `Tree`.
  *
  * @example
  * ```ts
- * const registered: AnyComponentType = { componentName: "Held", kind: "tag" };
+ * const components: ViewOutput = [Level({ level: 2 })];
  * ```
  */
-type AnyComponentType = {
-  readonly componentName: string;
-  readonly kind: "component" | "tag";
-};
+type ViewOutput = readonly AnyComponentValue[] | DescriptionNode;
 /**
- * What the ECS needs from a component type to read and write its store: the name and the
- * defaults, never the call signature. A component bound to a game's keys by a `…For` binder
- * (`Narrowed`) is the same object with a narrower call, so it passes here unchanged.
+ * What a motion hook is handed: the one view it animates. A view never holds a reference to
+ * another view — `peer` answers with the other key's item, never with its entity.
  *
  * @example
  * ```ts
- * const ref: ComponentHandle<{ x: number }> = component("Pos", { x: 0 });
- * ref.defaults; // { x: 0 }
+ * const enter = (view: ViewHandle<Item>, item: Item): Motion => {
+ *   view.set(Transform, { scale: 0 });
+ *   return view.toRest(Transform, { ms: 250 });
+ * };
  * ```
  */
-type ComponentHandle<Value extends object> = {
-  readonly componentName: string;
-  readonly defaults: Readonly<Value>;
-  readonly kind: "component";
+type ViewHandle<Item> = {
+  readonly entity: Entity;
+  readonly key: string;
+  get<Value extends object>(component: ComponentType<Value>): Readonly<Value> | undefined;
+  rest<Value extends object>(component: ComponentType<Value>): Readonly<Value> | undefined;
+  set<Value extends object>(component: ComponentType<Value>, patch: Partial<Value>): void;
+  tween<Value extends object>(component: ComponentType<Value>, to: Partial<NumericFields<Value>>, options: TweenOptions): MotionHandle;
+  toRest<Value extends object>(component: ComponentType<Value>, options?: RestOptions): MotionHandle;
+  all(handles: readonly Motion[]): MotionHandle;
+  peer(key: string): Item | undefined;
 };
 /**
- * A component type whose call signature takes a narrower patch: the same object, the same
- * store, the compiler refuses what the game's generated keys do not know.
+ * One `motion.change` hook, keyed by component name. `previous` and `next` are both passed, so a
+ * rollback that lowers a level can pick another motion than a level-up.
  *
  * @example
  * ```ts
- * const Sprite: Narrowed<{ texture: string }, { texture?: "board.cell" }> = component("Sprite", { texture: "" });
- * Sprite({ texture: "board.cell" }).value.texture; // "board.cell"
+ * const slide: ChangeHook<Item> = view => view.toRest(Transform, { ms: 350 });
  * ```
  */
-type Narrowed<Value extends object, Patch> = Omit<ComponentType<Value>, never> & ((patch?: Patch) => ComponentValue<Value>);
+type ChangeHook<Item> = (view: ViewHandle<Item>, previous: Item, next: Item, hint?: Hint) => Motion;
 /**
- * A resource type made by `resource()`: one mutable object per world, created from a deep clone
- * of the defaults on first read.
+ * The `change` table of a projection: one hook per component name.
  *
  * @example
  * ```ts
- * const Pointer: ResourceType<{ x: number; y: number }> = resource("Pointer", { x: 0, y: 0 });
- * Pointer.resourceName; // "Pointer"
+ * const change: ChangeHooks<Item> = { Transform: view => view.toRest(Transform) };
  * ```
  */
-type ResourceType<Value extends object> = {
-  readonly resourceName: string;
-  readonly defaults: Readonly<Value>;
+type ChangeHooks<Item> = {
+  readonly [component: string]: ChangeHook<Item>;
 };
 /**
- * A query term marked as written by `mut()`. Its only effect is change detection.
+ * The motion hooks of a projection. Every one is optional; without a hook the component diff is
+ * written directly. `loop` starts what moves a view for its whole life (an additive sway, a spin):
+ * it is played wherever `enter` plays, next to it, and its motion is kept apart from the view's
+ * other motions, so a change never cancels it; it ends when the view dies.
  *
  * @example
  * ```ts
- * const written: Mut<{ x: number }> = mut(Transform);
- * written.kind; // "mut"
+ * const motion: ProjectionMotion<Item> = {
+ *   change: { Transform: view => view.toRest(Transform, { ms: 350 }) }
+ * };
+ * // An order card that sways forever once it entered.
+ * const swaying: ProjectionMotion<Item> = {
+ *   loop: view =>
+ *     view.tween(Transform, { rotation: 0.05 }, { ms: 1200, additive: true, repeat: "forever" })
+ * };
  * ```
  */
-type Mut<Value extends object> = {
-  readonly kind: "mut";
-  readonly of: ComponentHandle<Value>;
+type ProjectionMotion<Item> = {
+  enter?(view: ViewHandle<Item>, item: Item, hint?: Hint): Motion;
+  loop?(view: ViewHandle<Item>): Motion;
+  exit?(view: ViewHandle<Item>, item: Item, hint?: Hint): Motion;
+  readonly change?: ChangeHooks<Item>;
+  settle?(view: ViewHandle<Item>, components: readonly string[]): Motion;
 };
 /**
- * A `mut()` term with its data type erased, as the world stores it.
+ * The motion hooks with the item type erased, as the world stores them.
  *
  * @example
  * ```ts
- * const term: AnyMut = { kind: "mut", of: { componentName: "Transform", kind: "component" } };
+ * const stored: AnyProjectionMotion = { change: {} };
  * ```
  */
-type AnyMut = {
-  readonly kind: "mut";
-  readonly of: AnyComponentType;
+type AnyProjectionMotion = {
+  enter?(view: ViewHandle<unknown>, item: unknown, hint?: Hint): Motion;
+  loop?(view: ViewHandle<unknown>): Motion;
+  exit?(view: ViewHandle<unknown>, item: unknown, hint?: Hint): Motion;
+  readonly change?: ChangeHooks<never>;
+  settle?(view: ViewHandle<unknown>, components: readonly string[]): Motion;
 };
 /**
- * One term of a query: a component type, a tag type, or a `mut()` of a component type.
+ * One projection: keyed items of the model turned into entities. `Item` is inferred from the
+ * return of `from`; `layer` and `lift` keep their literal types so a scene can check them.
  *
  * @example
  * ```ts
- * const terms: QueryTerm[] = [mut(Transform), Sprite, Held];
+ * const spec: ProjectionSpec<Item, "items", "lifted", Player, Session> = {
+ *   name: "board.items",
+ *   layer: "items",
+ *   lift: "lifted",
+ *   from: player => player.board.items,
+ *   key: item => item.id,
+ *   view: item => [Item({ level: item.level })]
+ * };
  * ```
  */
-type QueryTerm = AnyComponentType | AnyMut;
+type ProjectionSpec<Item, LayerName extends string, LiftName extends string, Player, Session> = {
+  readonly name: string;
+  readonly layer: LayerName;
+  readonly lift?: LiftName;
+  from(player: Player, session: Session): readonly Item[] | Item; /** Omitted when `from` returns one plain object: the key is then the name of the projection. */
+  key?(item: Item): string;
+  view(item: Item): ViewOutput;
+  readonly motion?: ProjectionMotion<Item>;
+};
 /**
- * The value a query yields for one term: writable for `mut()`, `true` for a tag, read-only for a
- * plain component.
+ * A projection spec with its item and layer types erased, as the world stores it.
  *
  * @example
  * ```ts
- * type Written = ValueOf<Mut<{ x: number }>>; // { x: number }
+ * const stored: AnyProjectionSpec = {
+ *   name: "board.items",
+ *   layer: "items",
+ *   from: () => [],
+ *   key: () => "",
+ *   view: () => []
+ * };
  * ```
  */
-type ValueOf<Term> = Term extends Mut<infer Value> ? Value : Term extends TagType ? true : Term extends ComponentHandle<infer Value> ? Readonly<Value> : never;
+type AnyProjectionSpec = {
+  readonly name: string;
+  readonly layer: string;
+  readonly lift?: string;
+  from(player: Json, session: Json): unknown;
+  key?(item: unknown): string;
+  view(item: unknown): ViewOutput;
+  readonly motion?: AnyProjectionMotion;
+};
 /**
- * The value part of a query row, one entry per term, in term order.
+ * Why a reconcile runs. Merged over the frame; the cause table decides play or direct.
  *
  * @example
  * ```ts
- * type Values = QueryValues<[TagType]>; // [true]
+ * const cause: Cause = "edge";
  * ```
  */
-type QueryValues<Terms extends readonly QueryTerm[]> = { -readonly [Index in keyof Terms]: ValueOf<Terms[Index]> };
+type Cause = "edge" | "rollback" | "restore" | "load" | "mount" | "rerun";
 /**
- * One row a query yields: the entity, then one value per term.
+ * One live or exiting view: the entity of one key of one projection, its rest pose and the
+ * motions that still run on it.
  *
  * @example
  * ```ts
- * type Row = QueryTuple<[ComponentType<{ x: number }>]>; // [Entity, Readonly<{ x: number }>]
+ * const view: View = {
+ *   entity: 1_048_576,
+ *   projection: "board.items",
+ *   key: "i7",
+ *   item: { id: "i7" },
+ *   rest: new Map(),
+ *   handles: [],
+ *   lifted: false,
+ *   dropWhenStill: false,
+ *   exiting: false
+ * };
  * ```
  */
-type QueryTuple<Terms extends readonly QueryTerm[]> = [Entity, ...QueryValues<Terms>];
+type View$1 = {
+  entity: Entity;
+  projection: string;
+  key: string;
+  item: unknown; /** The last output of `view(item)`, by component name: what the picture equals at rest. */
+  rest: Map<string, AnyComponentValue>;
+  handles: MotionHandle[];
+  lifted: boolean; /** `lift(false)` is waiting for the last motion to end. */
+  dropWhenStill: boolean;
+  exiting: boolean;
+};
 /**
- * What a system receives next to its entities: the world, the mutable resources, the frozen model
- * snapshot of the frame and the frame's `Time`. A system may read pure game rules; it never
- * writes the model.
+ * One mounted projection: its owner, the live views by key, the despawn queue and the items of
+ * the last reconcile.
  *
  * @example
  * ```ts
- * const run = (entities: Iterable<[Entity]>, ctx: SystemContext): void => {
- *   ctx.res(Pointer).x = 0;
- *   ctx.time.delta; // 16
+ * const mounted: Mounted = {
+ *   owner: { kind: "projection", name: "board.items" },
+ *   live: new Map(),
+ *   queue: [],
+ *   items: new Map()
  * };
  * ```
  */
-type SystemContext = {
-  readonly world: EcsApi;
-  res<Value extends object>(resource: ResourceType<Value>): Value;
-  readonly snapshot: Snapshot;
-  readonly time: Readonly<Time>;
+type Mounted = {
+  owner: Owner;
+  live: Map<string, View$1>;
+  queue: View$1[];
+  items: Map<string, unknown>;
 };
 /**
- * A system definition, typed over its query tuple.
+ * One track the projection started on the driver. The world keeps the component name and the
+ * handle, so it knows which components are driven without knowing how the driver runs them.
  *
  * @example
  * ```ts
- * const bob: SystemDefinition<[ComponentType<{ y: number }>]> = {
- *   name: "bob",
- *   phase: "animate",
- *   query: [Transform],
- *   run: entities => {
- *     for (const [, transform] of entities) transform.y; // read-only
- *   }
- * };
+ * const track: Track = { entity: 1_048_576, component: "Transform", handle: flight };
+ * track.handle.active(); // true while the flight runs
  * ```
  */
-type SystemDefinition<Terms extends readonly QueryTerm[]> = {
-  readonly name: string;
-  readonly phase: WorldPhase;
-  readonly query: Terms;
-  run(entities: Iterable<QueryTuple<Terms>>, ctx: SystemContext): void;
+type Track = {
+  entity: Entity;
+  component: string;
+  handle: MotionHandle;
 };
 /**
- * A system with its query tuple erased, as the world stores it.
+ * The rest pose of one entity, by component name: the last output of `view(item)` for a view, or
+ * what `setRest` recorded for an element another plugin owns.
+ */
+type RestPose = Map<string, AnyComponentValue>;
+/**
+ * Where a keyed element lives: a plugin above registered it with `registerKey`, so `entityOf`
+ * and `keyOf` answer for it next to the views.
  *
  * @example
  * ```ts
- * const entry: AnySystem = { name: "bob", phase: "animate", query: [], run: () => {} };
+ * const key: ProjectionKey = { projection: "hud", key: "coins" };
  * ```
  */
-type AnySystem = {
-  readonly name: string;
-  readonly phase: WorldPhase;
-  readonly query: readonly QueryTerm[];
-  run(entities: Iterable<readonly unknown[]>, ctx: SystemContext): void;
+type ProjectionKey = {
+  projection: string;
+  key: string;
 };
 /**
- * One registered system and the frame it was registered in. A system registered during a frame
- * runs from the next frame on.
+ * What the next reconcile has to do: why it runs, which roots changed and whether `view` is
+ * forced for every item.
  *
  * @example
  * ```ts
- * const entry: SystemEntry = { definition: bobSystem, frame: 12 };
+ * const dirty: Dirty = { causes: ["edge"], roots: new Set(["player"]), force: false };
  * ```
  */
-type SystemEntry = {
-  readonly definition: AnySystem;
-  readonly frame: number;
+type Dirty = {
+  causes: Cause[];
+  roots: Set<Root>;
+  force: boolean;
 };
 /**
- * A structural change queued while a phase runs. Applied in call order when the phase ends.
+ * projection module state.
+ */
+type ProjectionState = {
+  specs: Map<string, AnyProjectionSpec>;
+  layers: readonly LayerSpec[];
+  mounted: Map<string, Mounted>;
+  byEntity: Map<Entity, View$1>;
+  dirty: Dirty | undefined;
+  hints: Hint[]; /** The tracks the projection started, with the handle that says whether they still run. */
+  tracks: Track[]; /** The tween engine `anim` installed, or `undefined`: then every target is written at once. */
+  driver: TweenDriver | undefined; /** The rest pose of an entity that is not a view, recorded by its owner through `setRest`. */
+  rests: Map<Entity, RestPose>; /** Projection name to key to the entity a plugin above registered under it. */
+  keys: Map<string, Map<string, Entity>>; /** The reverse of `keys`, so `keyOf` answers for a registered element too. */
+  keysByEntity: Map<Entity, ProjectionKey>; /** Entity to component name to the fields another writer owns. */
+  mutes: Map<Entity, Map<string, Set<string>>>;
+  offHints: Array<() => void>;
+};
+/**
+ * projection module API, `app.world.projection`: the bridge from the model to entities.
  *
  * @example
  * ```ts
- * const command: Command = { kind: "remove", entity: 1_048_576, component: "Held" };
+ * // A test mounts the board and asks which entity carries one model key.
+ * app.world.projection.mount(["board.items"], { kind: "plugin", name: "test" });
+ * app.world.projection.entityOf("board.items", "i7"); // 1048576
  * ```
  */
-type Command = {
-  kind: "attach";
-  entity: Entity;
-  components: readonly AnyComponentValue[];
-} | {
-  kind: "despawn";
-  entity: Entity;
-} | {
-  kind: "despawnOwnedBy";
-  owner: Owner;
-} | {
-  kind: "add";
-  entity: Entity;
-  value: AnyComponentValue;
-} | {
-  kind: "remove";
-  entity: Entity;
-  component: string;
-};
-/**
- * A structural listener registered with `onAdded` or `onRemoved`.
- *
- * @example
- * ```ts
- * const hook: StructuralHook = (entity, value) => void entity + String(value);
- * ```
- */
-type StructuralHook = (entity: Entity, value: unknown) => void;
-/**
- * The frozen model snapshot of one frame, kept so four phases read it once.
- *
- * @example
- * ```ts
- * const cached: FrameSnapshot = { frame: 12, snapshot: { player: {}, session: {}, rng: rngState } };
- * ```
- */
-type FrameSnapshot = {
-  frame: number;
-  snapshot: Snapshot;
-};
-/**
- * ecs module state.
- */
-type EcsState = {
-  generations: number[];
-  free: number[];
-  owners: Map<Entity, Owner>; /** Key is `"kind:name"` of the owner. */
-  byOwner: Map<string, Set<Entity>>;
-  types: Map<string, AnyComponentType>;
-  stores: Map<string, Map<Entity, object | true>>;
-  resources: Map<string, object>;
-  systems: Record<WorldPhase, SystemEntry[]>;
-  running: WorldPhase | undefined;
-  commands: Command[];
-  changed: Map<string, Set<Entity>>;
-  added: Map<string, StructuralHook[]>;
-  removed: Map<string, StructuralHook[]>;
-  ownerLeft: Array<(owner: Owner) => void>;
-  mode: WorldMode;
-  offFrame: Array<() => void>;
-  frameSnapshot: FrameSnapshot | undefined;
-};
-/**
- * ecs module API, `app.world.ecs`: the screen as data. Plain-object components in one store per
- * component type, generational entity ids, a mandatory owner, a command buffer applied between
- * phases, coarse change detection and fixed phases driven by `time`.
- *
- * @example
- * ```ts
- * // A test owns its entities and reads them back.
- * const entity = app.world.ecs.spawn({ kind: "plugin", name: "test" }, [Transform({ x: 10 })]);
- * app.world.ecs.get(entity, Transform); // { x: 10, y: 0, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
- * ```
- */
-type EcsApi = {
+type ProjectionApi = {
   /**
-   * Registers a system at the end of its phase list. A system registered during a frame runs
-   * from the next frame on.
+   * Stores a projection spec. Nothing is drawn until `mount`.
    *
-   * @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.
+   * @param spec - The projection, built with `projection()`.
+   * @throws {Error} When a projection of that name is already registered.
    * @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
-   *
-   * off(); // the plugin stops
+   * // A test registers one projection by hand instead of composing a feature.
+   * app.world.projection.register(boardItems);
+   * app.world.projection.entityOf("board.items", "i7"); // undefined: nothing is mounted yet
    * ```
    */
-  system(definition: AnySystem): () => void;
+  register(spec: AnyProjectionSpec): void;
   /**
-   * Creates an entity. The id is reserved and returned at once, also inside a phase, where the
-   * components are attached when the phase ends.
+   * Stores the layer list of the scene. The order of the list is draw order; every call stores a
+   * new frozen array.
    *
-   * @param owner - Who owns the entity. Required by the type.
-   * @param components - Component and tag values the entity starts with.
-   * @returns The new entity id.
+   * @param list - The layers, in draw order.
    * @example
    * ```ts
-   * // `ui` spawns a popup entity it owns, so closing the node frees it in one call.
-   * const entity = app.world.ecs.spawn({ kind: "node", name: "reward" }, [
-   *   Transform({ x: 540, y: 960 })
+   * // `scenes` switches to the board scene.
+   * const world = ctx.require(worldPlugin);
+   * world.projection.setLayers([
+   *   { name: "board", sort: "none" },
+   *   { name: "items", sort: "y" },
+   *   { name: "lifted", sort: "none" }
    * ]);
-   * app.world.ecs.has(entity, Transform); // true
    * ```
    */
-  spawn(owner: Owner, components: readonly AnyComponentValue[]): Entity;
+  setLayers(list: ReadonlyArray<LayerSpec>): void;
   /**
-   * Removes every component of an entity, each firing `onRemoved`, frees the index and bumps the
-   * generation. A stale id is a no-op.
+   * The current layer list, empty before the first `setLayers`. A new list is a new reference, so
+   * a reader compares by identity.
    *
-   * @param entity - The entity to remove.
+   * @returns The layers, in draw order.
    * @example
    * ```ts
-   * // `ui` closes the popup it spawned. Asking again answers with the empty world.
-   * app.world.ecs.despawn(popup);
-   * app.world.ecs.has(popup, Transform); // false
+   * // `renderer.sync` rebuilds its containers only when the scene really changed.
+   * const current = app.world.projection.layers();
+   * if (current !== lastLayers) rebuildContainers(current); // [{ name: "board", sort: "none" }, ...]
    * ```
    */
-  despawn(entity: Entity): void;
+  layers(): ReadonlyArray<LayerSpec>;
   /**
-   * Despawns exactly the entities of one owner and tells `projection` that the owner left.
+   * Marks projections mounted under an owner and reconciles them at once, direct: a scene brings
+   * its own transition. Nothing is mounted when the call throws.
    *
-   * @param owner - The owner whose entities go.
+   * @param names - Names of the projections to mount.
+   * @param owner - Who owns the entities of these projections.
+   * @throws {Error} For an unknown name, or a `layer` or `lift` the scene does not declare.
    * @example
    * ```ts
-   * // A test cleans up after itself without touching the projections of the game.
-   * app.world.ecs.despawnOwnedBy({ kind: "plugin", name: "test" });
-   * app.world.ecs.snapshot(); // { mode: "live", entities: [], resources: {} }
+   * // `scenes` mounts the projections of the board scene it just switched to.
+   * const world = ctx.require(worldPlugin);
+   * world.projection.mount(["board.cells", "board.items"], { kind: "plugin", name: "scenes" });
+   * world.projection.entityOf("board.items", "i7"); // 1048576, the picture is already there
    * ```
    */
-  despawnOwnedBy(owner: Owner): void;
+  mount(names: readonly string[], owner: Owner): void;
   /**
-   * Reads a component value. A stale id or a missing component gives `undefined`.
+   * Unmounts projections: every motion of their views is finished, and the live views and the
+   * despawn queue are despawned in the same call.
    *
-   * @param entity - The entity to read.
-   * @param component - The component type.
-   * @returns The stored value, read-only, or `undefined`.
+   * @param names - Names of the projections to unmount.
    * @example
    * ```ts
-   * // `input` asks whether the entity under the finger may be dragged.
+   * // `scenes` leaves the board scene.
    * const world = ctx.require(worldPlugin);
-   * world.ecs.get(hit, Draggable); // { payload: { id: "i7" } }
-   * world.ecs.get(hit, DropTarget); // undefined: this item takes no drop
+   * world.projection.unmount(["board.cells", "board.items"]);
+   * world.projection.entityOf("board.items", "i7"); // undefined
    * ```
    */
-  get<Value extends object>(entity: Entity, component: ComponentHandle<Value>): Readonly<Value> | undefined;
+  unmount(names: readonly string[]): void;
   /**
-   * Shallow-merges a patch into a stored component and marks the entity changed for it. Never
-   * queued: a `set` inside a phase is visible to the next system of that phase.
+   * A drop with no commit: cancels the view's motions and plays settle for every loose component.
+   * In mode `paused` or `fast` the rest pose is written at once. No-op for an entity that is not
+   * a live view.
    *
-   * @param entity - The entity to write.
-   * @param component - The component type.
-   * @param patch - The fields to overwrite.
-   * @throws {Error} When the entity is stale or does not carry the component.
+   * @param entity - The entity of the view that was dropped.
    * @example
    * ```ts
-   * // `input` moves the held view with the finger.
+   * // `input` released the finger over nothing, so the gate refused the answer.
    * const world = ctx.require(worldPlugin);
-   * world.ecs.set(held, Transform, { x: 420, y: 810 });
-   * world.ecs.get(held, Transform); // { x: 420, y: 810, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+   * world.projection.settle(held); // the item glides back to its cell over settleMs
    * ```
    */
-  set<Value extends object>(entity: Entity, component: ComponentHandle<Value>, patch: Partial<Value>): void;
+  settle(entity: Entity): void;
   /**
-   * Adds a component value. On an entity that already carries it the value is replaced and the
-   * entity is marked changed; no `onAdded` fires.
+   * Hands a set of fields to another writer. Tracks never write them, also not on `finish()`.
    *
-   * @param entity - The entity to write.
-   * @param value - The component or tag value, built by calling its type.
+   * @param entity - The entity of the view.
+   * @param component - The component whose fields are taken over.
+   * @param fields - The field names the caller owns.
+   * @returns The remover; safe after the entity left, and a no-op when called twice.
    * @example
    * ```ts
-   * // `text` gives the label entity its display object once the atlas is there.
+   * // `input` owns the position of the held view while the finger drags it.
    * const world = ctx.require(worldPlugin);
-   * world.ecs.add(label, Display({ object: bitmapText }));
-   * world.ecs.has(label, Display); // true
+   * const release = world.projection.mute(held, Transform, ["x", "y"]);
+   *
+   * release(); // the finger let go
    * ```
    */
-  add(entity: Entity, value: AnyComponentValue): void;
+  mute(entity: Entity, component: ComponentType<object>, fields: readonly string[]): () => void;
   /**
-   * Removes a component. Fires `onRemoved` when the entity carried it.
+   * Moves a view into or out of its projection's `lift` layer. `lift(entity, false)` on a view
+   * that still moves takes effect when its last motion ends, so a settling view stays above the
+   * board until it is home.
    *
-   * @param entity - The entity to write.
-   * @param component - The component or tag type to drop.
+   * @param entity - The entity of the view.
+   * @param on - True to lift, false to drop back.
    * @example
    * ```ts
-   * // `text` drops the display object when the label leaves the screen.
+   * // `input` lifts the item the finger picked up so it draws above the board.
    * const world = ctx.require(worldPlugin);
-   * world.ecs.remove(label, Display);
-   * world.ecs.has(label, Display); // false
+   * world.projection.lift(held, true);
+   *
+   * world.projection.lift(held, false); // on release: takes effect when the settle motion ends
    * ```
    */
-  remove(entity: Entity, component: AnyComponentType): void;
+  lift(entity: Entity, on: boolean): void;
   /**
-   * Tells whether an entity carries a component or tag. False for a stale id.
+   * The projection and key of an entity. Also answers for a view in the despawn queue and for an
+   * element registered with `registerKey`.
    *
-   * @param entity - The entity to read.
-   * @param component - The component or tag type.
-   * @returns True when the entity carries it.
+   * @param entity - The entity to ask about.
+   * @returns The projection name and the key, or `undefined`.
    * @example
    * ```ts
-   * // `input` never hit-tests a view that is on its way out.
-   * const world = ctx.require(worldPlugin);
-   * world.ecs.has(candidate, Exiting); // true while the merge animation plays
+   * // `renderer.sync` labels its display objects for the inspector.
+   * app.world.projection.keyOf(1_048_576); // { projection: "board.items", key: "i7" }
+   * app.world.projection.keyOf(42); // undefined: not a view
    * ```
    */
-  has(entity: Entity, component: AnyComponentType): boolean;
+  keyOf(entity: Entity): ProjectionKey | undefined;
   /**
-   * Adds a tag. Structural and idempotent.
+   * The components a motion still drives on an entity: its running tracks, in start order, each
+   * name once. An entity no motion drives answers `[]`: a resting view, an entity that is not a
+   * view, a stale id. Every call hands out a new array.
    *
-   * @param entity - The entity to write.
-   * @param tagType - The tag type.
+   * @param entity - The entity to ask about.
+   * @returns The component names, or `[]`.
    * @example
    * ```ts
-   * // `input` marks the view under the finger while the drag runs.
-   * const world = ctx.require(worldPlugin);
-   * world.ecs.tag(dragged, Held);
-   * world.ecs.has(dragged, Held); // true
+   * // The editor explains a coin in flight: its Transform still tweens, its Sprite rests.
+   * app.world.projection.motionsOf(coin); // ["Transform"]
+   * app.time.step(400);
+   * app.world.projection.motionsOf(coin); // []
    * ```
    */
-  tag(entity: Entity, tagType: TagType): void;
+  motionsOf(entity: Entity): readonly string[];
   /**
-   * Removes a tag. Structural and idempotent.
+   * The rest value of one component of an entity: what a view holds when nothing animates it, or
+   * what `setRest` recorded for an element. Read-only and owner-free, so a plugin that owns no
+   * entity can aim at one.
    *
-   * @param entity - The entity to write.
-   * @param tagType - The tag type.
+   * @param entity - A projection view or a registered element.
+   * @param component - The component whose rest value is asked.
+   * @returns The rest value, or `undefined` when the entity has none recorded.
    * @example
    * ```ts
-   * // `input` releases the view on pointer up.
+   * // `anim` builds a coin flight toward the counter: `at(target)` is the counter's rest pose.
    * const world = ctx.require(worldPlugin);
-   * world.ecs.untag(dragged, Held);
-   * world.ecs.has(dragged, Held); // false
+   * const counter = world.projection.entityOf("hud", "coins") ?? 0;
+   *
+   * world.projection.restOf(counter, Transform); // { x: 40, y: 120, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
    * ```
    */
-  untag(entity: Entity, tagType: TagType): void;
+  restOf<Value extends object>(entity: Entity, component: ComponentType<Value>): Value | undefined;
   /**
-   * Walks the store of the FIRST term in insertion order and keeps the entities that carry every
-   * term. Deterministic. A `mut()` term marks every yielded entity changed for that component.
+   * The entity of one key of one projection: a live view, never the despawn queue, or an element
+   * a plugin above registered under that key.
    *
-   * @param terms - Component types, tag types and `mut()` terms.
-   * @returns The matching rows: the entity and one value per term.
+   * @param projection - Name of the projection.
+   * @param key - The model key.
+   * @returns The entity, or `undefined`.
    * @example
    * ```ts
-   * // `renderer.sync` walks every sprite that has a place on the screen.
-   * for (const [entity, sprite, transform] of app.world.ecs.query(Sprite, Transform)) {
-   *   display.get(entity)?.position.set(transform.x, transform.y);
-   *   sprite.texture; // "board.item-red-1"
-   * }
+   * // `input` resolves the target of a scripted drag.
+   * const world = ctx.require(worldPlugin);
+   * world.projection.entityOf("board.items", "i7"); // 1048576
+   * world.projection.entityOf("board.items", "gone"); // undefined
    * ```
    */
-  query<const Terms extends readonly QueryTerm[]>(...terms: Terms): Iterable<QueryTuple<Terms>>;
+  entityOf(projection: string, key: string): Entity | undefined;
   /**
-   * Returns the one mutable value of a resource, created from a deep clone of its defaults on
-   * first read.
+   * The live view entities of a mounted projection, in the order of its model keys. A view that
+   * plays its exit is left out, and so is an element registered with `registerKey`. Every call
+   * hands out a new array.
    *
-   * @param resourceType - The resource type.
-   * @returns The mutable resource value.
+   * @param name - Name of the projection.
+   * @returns The entities, or `[]` when the projection is not mounted.
    * @example
    * ```ts
-   * // `input` writes the pointer once per frame; every game system reads the same object.
+   * // `ui` hosts the board inside a slot and parents every board item to it on reconcile.
    * const world = ctx.require(worldPlugin);
-   * const pointer = world.ecs.resource(Pointer);
-   * pointer.down = true;
+   * world.projection.entitiesOf("board.items"); // [1048580, 1048581]
+   * world.projection.entitiesOf("shop.items"); // []: not mounted
    * ```
    */
-  resource<Value extends object>(resourceType: ResourceType<Value>): Value;
+  entitiesOf(name: string): readonly Entity[];
   /**
-   * Registers a listener for the moment a component is added, called when the structural change
-   * is applied. A throwing listener is logged and the others still run.
+   * Installs the tween engine every `ViewHandle.tween`, `toRest` and `all` then runs on. Without
+   * one the world writes every target at once and hands back an inactive handle.
    *
-   * @param component - The component type to watch.
-   * @param fn - Called with the entity and the stored value.
-   * @returns The remover; calling it twice is a no-op.
+   * @param driver - The engine that runs the tracks.
+   * @returns The remover; it puts the instant writes back.
    * @example
    * ```ts
-   * // `renderer.sync` creates a Pixi object for every new sprite.
+   * // `anim` installs its tween core when it starts and takes it back when it stops.
    * const world = ctx.require(worldPlugin);
-   * const off = world.ecs.onAdded(Sprite, (entity, sprite) => {
-   *   objects.set(entity, makeSprite(sprite.texture));
-   * });
+   * ctx.state.removeDriver = world.projection.setDriver(createDriver(ctx, ctx.state));
    *
-   * off(); // the renderer stops
+   * ctx.state.removeDriver(); // onStop: motions are instant again
    * ```
    */
-  onAdded<Value extends object>(component: ComponentHandle<Value>, fn: (entity: Entity, value: Readonly<Value>) => void): () => void;
+  setDriver(driver: TweenDriver): () => void;
   /**
-   * Registers a listener for the moment a tag is added: `tag` on an entity without it, or a spawn
-   * that carries it. A tag has no value, so the listener gets the entity only.
+   * A view handle for an entity that is not a projection view, so an element another plugin owns
+   * can be animated the same way. `set`, `get`, `tween`, `toRest` and `all` work; `rest` answers
+   * what `setRest` recorded; `peer` answers `undefined`.
    *
-   * @param tagType - The tag type to watch.
-   * @param fn - Called with the entity that got the tag.
-   * @returns The remover; calling it twice is a no-op.
+   * @param entity - The entity of the element.
+   * @param owner - Who is asking; without it only the kind of the owner is checked.
+   * @returns The handle, or `undefined` for a projection view and for a foreign entity.
    * @example
    * ```ts
-   * // `ui` shows the pressed look while `input` holds the `Pressed` tag on a button.
+   * // `ui` plays the `motion` prop of an element it owns.
    * const world = ctx.require(worldPlugin);
-   * const off = world.ecs.onAdded(Pressed, entity => markPointer(entity, "pressed", true));
+   * const handle = world.projection.viewOf(button, { kind: "plugin", name: "ui" });
    *
-   * world.ecs.tag(button, Pressed); // markPointer(button, "pressed", true)
-   * off(); // ui stops
+   * handle?.tween(Transform, { scale: 1.1 }, { ms: 120, ease: "outBack" });
    * ```
    */
-  onAdded(tagType: TagType, fn: (entity: Entity) => void): () => void;
+  viewOf(entity: Entity, owner: Owner): ViewHandle<unknown> | undefined;
   /**
-   * Registers a listener for the moment a component is removed.
+   * Records what one component of an element looks like at rest, so `toRest` knows where home is.
    *
-   * @param component - The component type to watch.
-   * @param fn - Called with the entity and the value it had.
-   * @returns The remover; calling it twice is a no-op.
+   * @param entity - The entity of the element.
+   * @param component - The component whose rest value is recorded.
+   * @param value - The value the element holds when nothing animates.
    * @example
    * ```ts
-   * // `renderer.sync` destroys the Pixi object of a sprite that left.
+   * // `ui` laid the coin counter out and tells the world where it belongs.
    * const world = ctx.require(worldPlugin);
-   * const off = world.ecs.onRemoved(Sprite, entity => {
-   *   objects.get(entity)?.destroy();
-   *   objects.delete(entity);
-   * });
+   * world.projection.setRest(counter, Transform, { x: 40, y: 120, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } });
    *
-   * off(); // the renderer stops
+   * world.projection.viewOf(counter, { kind: "plugin", name: "ui" })?.rest(Transform); // { x: 40, y: 120, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
    * ```
    */
-  onRemoved<Value extends object>(component: ComponentHandle<Value>, fn: (entity: Entity, value: Readonly<Value>) => void): () => void;
+  setRest<Value extends object>(entity: Entity, component: ComponentType<Value>, value: Value): void;
   /**
-   * Registers a listener for the moment a tag is removed: `untag` on an entity that had it, or a
-   * despawn. The listener gets the entity only.
+   * Gives an entity a projection and key of its own, so `entityOf` and `keyOf` answer for it next
+   * to the live views. That is how an element becomes a target for `anim`, `input` and `guide`.
    *
-   * @param tagType - The tag type to watch.
-   * @param fn - Called with the entity that lost the tag.
-   * @returns The remover; calling it twice is a no-op.
+   * @param projection - Name the element is addressed under.
+   * @param key - Key the element is addressed under.
+   * @param entity - The entity of the element.
+   * @returns The remover; it drops the key again.
+   * @throws {Error} When a live view of that projection already holds the key.
    * @example
    * ```ts
-   * // `ui` drops the pressed look when `input` releases the button.
+   * // `ui` publishes the coin counter of the HUD.
    * const world = ctx.require(worldPlugin);
-   * const off = world.ecs.onRemoved(Pressed, entity => markPointer(entity, "pressed", false));
+   * const drop = world.projection.registerKey("hud", "coins", counter);
    *
-   * world.ecs.untag(button, Pressed); // markPointer(button, "pressed", false)
-   * off(); // ui stops
+   * world.projection.entityOf("hud", "coins"); // the entity of the counter
+   * drop(); // the element left the screen
    * ```
    */
-  onRemoved(tagType: TagType, fn: (entity: Entity) => void): () => void;
+  registerKey(projection: string, key: string, entity: Entity): () => void;
   /**
-   * The coarse change set of the frame, cleared in `time` phase `signals` after every `sync`
-   * system ran.
+   * Marks every mounted projection dirty and forces `view` for every item, so the next frame
+   * rebuilds the picture directly.
    *
-   * @param component - The component type to ask about.
-   * @returns The entities marked changed for it this frame.
    * @example
    * ```ts
-   * // `renderer.sync` moves only what moved.
-   * for (const entity of app.world.ecs.changed(Transform)) {
-   *   const transform = app.world.ecs.get(entity, Transform);
-   *   display.get(entity)?.position.set(transform?.x ?? 0, transform?.y ?? 0);
-   * }
+   * // `i18n` switched the locale: every label has to be projected again.
+   * const world = ctx.require(worldPlugin);
+   * world.projection.rerunAll(); // the next frame writes the new strings with no motion
    * ```
    */
-  changed(component: AnyComponentType): Iterable<Entity>;
+  rerunAll(): void;
+};
+/**
+ * projection methods the plugin root drives from the frame and the hooks. Not public.
+ */
+type ProjectionInternal = {
   /**
-   * The effective mode: `"fast"` while the flow walks fast, otherwise the stored one.
+   * Records a commit. In fast mode it reconciles at once, direct.
    *
-   * @returns The mode the frame runs in.
-   * @example
-   * ```ts
-   * // A test checks that a fast walk froze the tweens.
-   * app.flow.setMode("fast");
-   * app.world.ecs.mode(); // "fast", even though setMode was never called on the world
-   * ```
+   * @param roots - The state roots the commit touched.
+   * @param cause - Why the commit happened.
    */
-  mode(): WorldMode;
+  markDirty(roots: readonly Root[], cause: Cause): void;
   /**
-   * Stores the world mode. `"fast"` finishes every motion and flushes every despawn queue at once.
-   *
-   * @param mode - The new stored mode.
-   * @example
-   * ```ts
-   * // A headless test wants the final picture without stepping frames.
-   * app.world.ecs.setMode("fast");
-   * app.world.ecs.mode(); // "fast"
-   * ```
+   * Reconciles when the world is dirty. Runs at the start of `time` phase `input`.
    */
-  setMode(mode: WorldMode): void;
+  reconcileIfDirty(): 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.
-   *
-   * @param name - The storage name of the component.
-   * @returns The type, or `undefined` when the world never met it.
-   * @example
-   * ```ts
-   * // `text` resolves the component a label binds its number to.
-   * const world = ctx.require(worldPlugin);
-   * const type = world.ecs.typeOf("Coins"); // the Coins component, registered when it was written
-   * const pose = type === undefined ? undefined : world.ecs.get(counter, type);
-   *
-   * pose?.amount; // 120
-   * ```
+   * Empties the hint buffer. Runs once per frame, reconcile or not.
    */
-  typeOf(name: string): AnyComponent | undefined;
+  dropHints(): void;
   /**
-   * The owner of an entity, which is also the liveness check: a stale id has none, also after its
-   * index came back with a new generation. `projection` asks before it hands out a view handle for
-   * an entity another plugin owns; `renderer` asks before it forgets the filters of an entity whose
-   * visual left.
+   * Buffers one released hint.
    *
-   * @param entity - The entity to ask about.
-   * @returns The owner, or `undefined` when the id is stale.
-   * @example
-   * ```ts
-   * // renderer forgets the filter slots of an entity only after it despawned
-   * const ecs = ctx.require(worldPlugin).ecs;
-   * ecs.ownerOf(button); // { kind: "projection", name: "hud" }
-   * ecs.despawn(button);
-   * ecs.ownerOf(button); // undefined
-   * ```
+   * @param hint - The hint `flow.fx` released after a commit.
    */
-  ownerOf(entity: Entity): Owner | undefined;
+  pushHint(hint: Hint): void;
   /**
-   * The whole world as plain JSON, sorted by entity index. A component value that is not JSON is
-   * left out and its name is listed in `skipped`.
-   *
-   * @returns The world as JSON: the mode, the entities and the resources.
-   * @example
-   * ```ts
-   * // A test asserts what the board holds after the first reconcile.
-   * app.world.ecs.snapshot();
-   * // { mode: "live", entities: [{ id: 1048576, index: 0, generation: 1,
-   * //   owner: { kind: "projection", name: "board.items" },
-   * //   components: { Layer: { name: "items" } }, skipped: [] }], resources: {} }
-   * ```
+   * Sweeps the views whose motions ended: the despawn queue, the convergence check and the
+   * pending drops. The tracks themselves are advanced by the driver.
    */
-  snapshot(): WorldSnapshot;
-};
-/**
- * ecs methods the plugin root calls: frame phases, the owner listener, the clears. Not public.
- */
-type EcsInternal = {
+  sweep(): void;
   /**
-   * Registers a listener for `despawnOwnedBy`, so `projection` can drop the views of an owner
-   * that left.
-   *
-   * @param fn - Called with the owner whose entities were despawned.
-   * @returns The remover.
+   * Finishes every motion and flushes every despawn queue. Called when the mode turns `fast`.
    */
-  onOwnerLeft(fn: (owner: Owner) => void): () => void;
+  flushAll(): void;
   /**
-   * Runs the systems of one phase, then flushes the command buffer.
+   * Drops the views of a projection whose owner despawned its entities.
    *
-   * @param phase - The phase to run.
-   * @param time - The frame's `Time`.
-   */
-  runPhase(phase: WorldPhase, time: Readonly<Time>): void;
-  /**
-   * Applies the queued structural commands in call order.
-   */
-  flush(): void;
-  /**
-   * Clears every change set. Called in `time` phase `signals`.
+   * @param owner - The owner that left.
    */
-  clearChanges(): void;
+  ownerLeft(owner: Owner): void;
   /**
-   * Drops every entity, component, resource, system and hook.
+   * Drops every view, track, mute and spec.
    */
   clear(): void;
 };
 //#endregion
-//#region src/plugins/world/projection/types.d.ts
+//#region src/plugins/world/ecs/types.d.ts
 /**
- * How a layer orders the entities drawn in it.
+ * Entity id: `generation * 2 ** 20 + index`, a safe integer. A freed index comes back with a
+ * higher generation, so an id is never silently reused.
  *
  * @example
  * ```ts
- * const sort: LayerSort = "y";
+ * const entity: Entity = 1_048_576; // generation 1, index 0
  * ```
  */
-type LayerSort = "none" | "y" | "order";
+type Entity = number;
 /**
- * One named layer of a scene. The order of the list is draw order.
+ * Who owns an entity. Every `spawn` names one, so `despawnOwnedBy` can free exactly one owner's
+ * entities and `snapshot()` can say where an entity came from.
  *
  * @example
  * ```ts
- * const layer: LayerSpec = { name: "items", sort: "y" };
+ * const owner: Owner = { kind: "projection", name: "board.items" };
  * ```
  */
-type LayerSpec = {
+type Owner = {
+  kind: "projection" | "node" | "plugin";
   name: string;
-  sort: LayerSort;
 };
 /**
- * Easing of a tween: one of the named curves the driver knows, or a function that gets the
- * normalised time and returns the eased fraction.
+ * One entity as `snapshot()` reads it: its id and the two halves of the id, its owner, every
+ * component value that is plain JSON, and the names of the ones that are not.
  *
  * @example
  * ```ts
- * const ease: Ease = "outBack";
- * ```
- */
-type Ease = "linear" | "in" | "out" | "inOut" | "inCubic" | "outCubic" | "inOutCubic" | "inBack" | "outBack" | ((t: number) => number);
+ * const entity: EntitySnapshot = {
+ *   id: 1_048_576, index: 0, generation: 1, owner: { kind: "projection", name: "board.items" },
+ *   components: { Layer: { name: "items" } }, skipped: ["Display"]
+ * };
+ * ```
+ */
+type EntitySnapshot = {
+  id: Entity;
+  index: number;
+  generation: number;
+  owner: Owner;
+  components: Record<string, Json>;
+  skipped: string[];
+};
 /**
- * What every motion returns: it can be finished, cancelled and asked whether it still runs.
- * V3 `anim` hands out the same shape.
+ * The whole world as plain JSON: the effective mode, every entity sorted by index and every
+ * resource that is JSON.
  *
  * @example
  * ```ts
- * const handle: MotionHandle = view.toRest(Transform);
- * handle.active(); // true until the last frame wrote the exact target
+ * const empty: WorldSnapshot = { mode: "live", entities: [], resources: {} };
  * ```
  */
-type MotionHandle = {
-  finish(): void;
-  cancel(): void;
-  active(): boolean;
+type WorldSnapshot = {
+  mode: WorldMode;
+  entities: EntitySnapshot[];
+  resources: Record<string, Json>;
 };
 /**
- * What a motion hook returns. `void` means the hook wrote the component directly.
+ * The four phases systems run in, in frame order.
  *
  * @example
  * ```ts
- * const motion: Motion = undefined; // the hook called view.set and is already done
+ * const phase: WorldPhase = "animate";
  * ```
  */
-type Motion = MotionHandle | void;
+type WorldPhase = "input" | "animate" | "layout" | "sync";
 /**
- * Only the numeric fields of a component value: what a tween can interpolate.
+ * World mode. `"paused"` and `"fast"` skip the phases `input`, `animate` and `layout`; phase
+ * `sync` runs in every mode.
  *
  * @example
  * ```ts
- * type Numbers = NumericFields<{ x: number; texture: string }>; // { x: number }
+ * const mode: WorldMode = "fast";
  * ```
  */
-type NumericFields<Value extends object> = { [Key in keyof Value as Value[Key] extends number ? Key : never]: Value[Key] };
+type WorldMode = "live" | "paused" | "fast";
 /**
- * One keyframe segment of a track: the fraction of the track's `ms` it ends at (`0..1`), the
- * curve it eases with (the track's `ease` when left out) and the numeric fields it reaches. A
- * field it does not name holds where the segment before left it.
+ * One component value ready to be written: the storage key and the frozen data.
  *
  * @example
  * ```ts
- * // The swing of a popup board: past the rest pose at 42 % of the track, then home.
- * const segments: TrackSegment[] = [
- *   { at: 0.42, ease: "out", to: { y: 974, rotation: 0.087 } },
- *   { at: 1, ease: "inOut", to: { y: 960, rotation: 0 } }
- * ];
+ * const value: ComponentValue<{ level: number }> = { type: Item, value: { level: 2 } };
  * ```
  */
-type TrackSegment = {
-  at: number;
-  ease?: Ease;
-  to: Record<string, number>;
+type ComponentValue<Value extends object> = {
+  readonly type: ComponentType<Value>;
+  readonly value: Readonly<Value>;
 };
 /**
- * Options of `ViewHandle.tween`. An additive tween adds its delta over the value the absolute
- * writer of the field holds, instead of owning the field. `segments` turns the tween into a
- * keyframe walk: the segments run one after another over `ms` on one clock, and `to` is where the
- * last one ends. `repeat` runs the walk again from its first segment when it ends: a number
- * counts the extra runs, `"forever"` never ends. The world passes it to the driver unchanged;
- * without a driver the target is written once.
+ * A tag value. A tag carries no data and is stored as `true`.
  *
  * @example
  * ```ts
- * const options: TweenOptions = { ms: 350, ease: "out", delayMs: 40 };
- * const walk: TweenOptions = { ms: 1000, segments: [{ at: 0.42, to: { y: 974 } }, { at: 1, to: { y: 960 } }] };
- * const sway: TweenOptions = { ms: 2400, additive: true, repeat: "forever", segments: [{ at: 0.5, to: { rotation: 0.05 } }, { at: 1, to: { rotation: 0 } }] };
+ * const held: TagValue = { type: Held, value: true };
  * ```
  */
-type TweenOptions = {
-  ms: number;
-  ease?: Ease;
-  delayMs?: number;
-  additive?: boolean;
-  segments?: readonly TrackSegment[];
-  repeat?: number | "forever";
+type TagValue = {
+  readonly type: TagType;
+  readonly value: true;
 };
 /**
- * Options of `ViewHandle.toRest`. Defaults: the plugin's `settleMs` and ease `"out"`. `delayMs`
- * lets a hook wait, for example for a flight to land, before the view comes home.
+ * Any component or tag value, as `spawn` and `view` return them.
  *
  * @example
  * ```ts
- * const options: RestOptions = { ms: 200, delayMs: 120 };
+ * const values: AnyComponentValue[] = [Held()];
  * ```
  */
-type RestOptions = {
-  ms?: number;
-  ease?: Ease;
-  delayMs?: number;
+type AnyComponentValue = {
+  readonly type: AnyComponentType;
+  readonly value: object | true;
 };
 /**
- * What the driver is told about one track: how long it runs, how it eases, how long it waits,
- * whether it adds to the field or owns it, and the keyframe segments it walks. A track with
- * segments walks them over `ms` on one clock and claims every field a segment names; its target
- * `to` is the last segment's target. A track with `repeat` starts its walk again when it ends
- * (a number counts the extra runs, `"forever"` never ends); the instant driver ignores it and
- * writes the end pose once.
+ * A component type whose value shape is erased to a plain record: what the projection writes when
+ * it only knows the component by name.
  *
  * @example
  * ```ts
- * const options: TrackOptions = { ms: 250, ease: "outBack", delayMs: 0, additive: false };
- * const walk: TrackOptions = { ms: 1000, segments: [{ at: 0.42, to: { y: 974 } }, { at: 1, to: { y: 960 } }] };
- * const twice: TrackOptions = { ms: 400, ease: "inOut", delayMs: 0, additive: true, repeat: 1 };
+ * const erased: AnyComponent = component("Transform", { x: 0, y: 0 }) as AnyComponent;
+ * erased.componentName; // "Transform"
  * ```
  */
-type TrackOptions = {
-  ms: number;
-  ease?: Ease;
-  delayMs?: number;
-  additive?: boolean;
-  segments?: readonly TrackSegment[];
-  repeat?: number | "forever";
-};
+type AnyComponent = ComponentType<Record<string, unknown>>;
 /**
- * The tween engine behind `ViewHandle.tween`, `toRest` and `all`. `anim` installs one with
- * `setDriver`; without it the world writes every target at once.
- *
- * A track reads its start values when its delay ends, writes the exact target on its last frame
- * and goes through `ecs.set`, so `changed()` sees it. Muted fields are never written, also not on
- * `finish()`.
+ * A component type made by `component()`: callable to build a value, and carrying the storage
+ * name plus the defaults that give the TypeScript type, the JSON shape and the inspector schema.
  *
  * @example
  * ```ts
- * // `anim` hands the world its own tween core in `onStart`.
- * const driver: TweenDriver = { track: startTrack, cancelAll: cancelTracksOf };
- * const off = ctx.require(worldPlugin).projection.setDriver(driver);
- *
- * off(); // `anim` stopped: the world writes instantly again
+ * const Item: ComponentType<{ kind: string; level: number }> = component("Item", {
+ *   kind: "",
+ *   level: 1
+ * });
+ * Item({ level: 2 }); // { type: Item, value: { kind: "", level: 2 } }
+ * Item.owned; // []: a projection view writes every field
  * ```
  */
-type TweenDriver = {
-  /**
-   * Starts one track on one component of one entity.
-   *
-   * @param entity - The entity to animate.
-   * @param component - The component to animate.
-   * @param to - The numeric target fields.
-   * @param options - Duration, easing, delay and the additive flag.
-   * @param muted - The fields another writer owns, read at every write.
-   * @returns The motion handle of the track.
-   */
-  track(entity: Entity, component: AnyComponent, to: Record<string, number>, options: TrackOptions, muted: () => ReadonlySet<string>): MotionHandle;
-  /**
-   * Ends every track of one entity. Called when a view despawns and on every flush.
-   *
-   * @param entity - The entity whose tracks end.
-   */
-  cancelAll(entity: Entity): void;
+type ComponentType<Value extends object> = {
+  (patch?: Partial<Value>): ComponentValue<Value>;
+  readonly componentName: string;
+  readonly defaults: Readonly<Value>;
+  readonly kind: "component"; /** Fields a plugin writes and a projection view never does, so a view never corrects them. */
+  readonly owned: readonly string[];
 };
 /**
- * One node of an element description, as `ui` builds it. The world never imports `ui`: it knows
- * the shape structurally, carries it in `Tree` and hands it back unchanged.
+ * A tag type made by `tag()`: a component with no data.
  *
  * @example
  * ```ts
- * const node: DescriptionNode = { type: "box", props: { gap: 8 }, children: [] };
+ * const Held: TagType = tag("Held");
+ * Held(); // { type: Held, value: true }
  * ```
  */
-type DescriptionNode = {
-  type: string;
-  key?: string;
-  props: object;
-  children: readonly unknown[];
+type TagType = {
+  (): TagValue;
+  readonly componentName: string;
+  readonly kind: "tag";
 };
 /**
- * What one `view(item)` call returns: the components of the item, or one description node that
- * the world wraps as `Tree`.
+ * What the world stores about a component or tag type, independent of its data type.
  *
  * @example
  * ```ts
- * const components: ViewOutput = [Level({ level: 2 })];
+ * const registered: AnyComponentType = { componentName: "Held", kind: "tag" };
  * ```
  */
-type ViewOutput = readonly AnyComponentValue[] | DescriptionNode;
+type AnyComponentType = {
+  readonly componentName: string;
+  readonly kind: "component" | "tag";
+};
 /**
- * What a motion hook is handed: the one view it animates. A view never holds a reference to
- * another view — `peer` answers with the other key's item, never with its entity.
+ * What the ECS needs from a component type to read and write its store: the name and the
+ * defaults, never the call signature. A component bound to a game's keys by a `…For` binder
+ * (`Narrowed`) is the same object with a narrower call, so it passes here unchanged.
  *
  * @example
  * ```ts
- * const enter = (view: ViewHandle<Item>, item: Item): Motion => {
- *   view.set(Transform, { scale: 0 });
- *   return view.toRest(Transform, { ms: 250 });
- * };
+ * const ref: ComponentHandle<{ x: number }> = component("Pos", { x: 0 });
+ * ref.defaults; // { x: 0 }
  * ```
  */
-type ViewHandle<Item> = {
-  readonly entity: Entity;
-  readonly key: string;
-  get<Value extends object>(component: ComponentType<Value>): Readonly<Value> | undefined;
-  rest<Value extends object>(component: ComponentType<Value>): Readonly<Value> | undefined;
-  set<Value extends object>(component: ComponentType<Value>, patch: Partial<Value>): void;
-  tween<Value extends object>(component: ComponentType<Value>, to: Partial<NumericFields<Value>>, options: TweenOptions): MotionHandle;
-  toRest<Value extends object>(component: ComponentType<Value>, options?: RestOptions): MotionHandle;
-  all(handles: readonly Motion[]): MotionHandle;
-  peer(key: string): Item | undefined;
+type ComponentHandle<Value extends object> = {
+  readonly componentName: string;
+  readonly defaults: Readonly<Value>;
+  readonly kind: "component";
 };
 /**
- * One `motion.change` hook, keyed by component name. `previous` and `next` are both passed, so a
- * rollback that lowers a level can pick another motion than a level-up.
+ * A component type whose call signature takes a narrower patch: the same object, the same
+ * store, the compiler refuses what the game's generated keys do not know.
  *
  * @example
  * ```ts
- * const slide: ChangeHook<Item> = view => view.toRest(Transform, { ms: 350 });
+ * const Sprite: Narrowed<{ texture: string }, { texture?: "board.cell" }> = component("Sprite", { texture: "" });
+ * Sprite({ texture: "board.cell" }).value.texture; // "board.cell"
  * ```
  */
-type ChangeHook<Item> = (view: ViewHandle<Item>, previous: Item, next: Item, hint?: Hint) => Motion;
+type Narrowed<Value extends object, Patch> = Omit<ComponentType<Value>, never> & ((patch?: Patch) => ComponentValue<Value>);
 /**
- * The `change` table of a projection: one hook per component name.
+ * A resource type made by `resource()`: one mutable object per world, created from a deep clone
+ * of the defaults on first read.
  *
  * @example
  * ```ts
- * const change: ChangeHooks<Item> = { Transform: view => view.toRest(Transform) };
+ * const Pointer: ResourceType<{ x: number; y: number }> = resource("Pointer", { x: 0, y: 0 });
+ * Pointer.resourceName; // "Pointer"
  * ```
  */
-type ChangeHooks<Item> = {
-  readonly [component: string]: ChangeHook<Item>;
+type ResourceType<Value extends object> = {
+  readonly resourceName: string;
+  readonly defaults: Readonly<Value>;
 };
 /**
- * The motion hooks of a projection. Every one is optional; without a hook the component diff is
- * written directly. `loop` starts what moves a view for its whole life (an additive sway, a spin):
- * it is played wherever `enter` plays, next to it, and its motion is kept apart from the view's
- * other motions, so a change never cancels it; it ends when the view dies.
+ * A query term marked as written by `mut()`. Its only effect is change detection.
  *
  * @example
  * ```ts
- * const motion: ProjectionMotion<Item> = {
- *   change: { Transform: view => view.toRest(Transform, { ms: 350 }) }
- * };
- * // An order card that sways forever once it entered.
- * const swaying: ProjectionMotion<Item> = {
- *   loop: view =>
- *     view.tween(Transform, { rotation: 0.05 }, { ms: 1200, additive: true, repeat: "forever" })
- * };
+ * const written: Mut<{ x: number }> = mut(Transform);
+ * written.kind; // "mut"
  * ```
  */
-type ProjectionMotion<Item> = {
-  enter?(view: ViewHandle<Item>, item: Item, hint?: Hint): Motion;
-  loop?(view: ViewHandle<Item>): Motion;
-  exit?(view: ViewHandle<Item>, item: Item, hint?: Hint): Motion;
-  readonly change?: ChangeHooks<Item>;
-  settle?(view: ViewHandle<Item>, components: readonly string[]): Motion;
+type Mut<Value extends object> = {
+  readonly kind: "mut";
+  readonly of: ComponentHandle<Value>;
 };
 /**
- * The motion hooks with the item type erased, as the world stores them.
+ * A `mut()` term with its data type erased, as the world stores it.
  *
  * @example
  * ```ts
- * const stored: AnyProjectionMotion = { change: {} };
+ * const term: AnyMut = { kind: "mut", of: { componentName: "Transform", kind: "component" } };
  * ```
  */
-type AnyProjectionMotion = {
-  enter?(view: ViewHandle<unknown>, item: unknown, hint?: Hint): Motion;
-  loop?(view: ViewHandle<unknown>): Motion;
-  exit?(view: ViewHandle<unknown>, item: unknown, hint?: Hint): Motion;
-  readonly change?: ChangeHooks<never>;
-  settle?(view: ViewHandle<unknown>, components: readonly string[]): Motion;
+type AnyMut = {
+  readonly kind: "mut";
+  readonly of: AnyComponentType;
 };
 /**
- * One projection: keyed items of the model turned into entities. `Item` is inferred from the
- * return of `from`; `layer` and `lift` keep their literal types so a scene can check them.
+ * One term of a query: a component type, a tag type, or a `mut()` of a component type.
  *
  * @example
  * ```ts
- * const spec: ProjectionSpec<Item, "items", "lifted", Player, Session> = {
- *   name: "board.items",
- *   layer: "items",
- *   lift: "lifted",
- *   from: player => player.board.items,
- *   key: item => item.id,
- *   view: item => [Item({ level: item.level })]
+ * const terms: QueryTerm[] = [mut(Transform), Sprite, Held];
+ * ```
+ */
+type QueryTerm = AnyComponentType | AnyMut;
+/**
+ * The value a query yields for one term: writable for `mut()`, `true` for a tag, read-only for a
+ * plain component.
+ *
+ * @example
+ * ```ts
+ * type Written = ValueOf<Mut<{ x: number }>>; // { x: number }
+ * ```
+ */
+type ValueOf<Term> = Term extends Mut<infer Value> ? Value : Term extends TagType ? true : Term extends ComponentHandle<infer Value> ? Readonly<Value> : never;
+/**
+ * The value part of a query row, one entry per term, in term order.
+ *
+ * @example
+ * ```ts
+ * type Values = QueryValues<[TagType]>; // [true]
+ * ```
+ */
+type QueryValues<Terms extends readonly QueryTerm[]> = { -readonly [Index in keyof Terms]: ValueOf<Terms[Index]> };
+/**
+ * One row a query yields: the entity, then one value per term.
+ *
+ * @example
+ * ```ts
+ * type Row = QueryTuple<[ComponentType<{ x: number }>]>; // [Entity, Readonly<{ x: number }>]
+ * ```
+ */
+type QueryTuple<Terms extends readonly QueryTerm[]> = [Entity, ...QueryValues<Terms>];
+/**
+ * What a system receives next to its entities: the world, the mutable resources, the frozen model
+ * snapshot of the frame and the frame's `Time`. A system may read pure game rules; it never
+ * writes the model.
+ *
+ * @example
+ * ```ts
+ * const run = (entities: Iterable<[Entity]>, ctx: SystemContext): void => {
+ *   ctx.res(Pointer).x = 0;
+ *   ctx.time.delta; // 16
  * };
  * ```
  */
-type ProjectionSpec<Item, LayerName extends string, LiftName extends string, Player, Session> = {
-  readonly name: string;
-  readonly layer: LayerName;
-  readonly lift?: LiftName;
-  from(player: Player, session: Session): readonly Item[] | Item; /** Omitted when `from` returns one plain object: the key is then the name of the projection. */
-  key?(item: Item): string;
-  view(item: Item): ViewOutput;
-  readonly motion?: ProjectionMotion<Item>;
+type SystemContext = {
+  readonly world: EcsApi;
+  res<Value extends object>(resource: ResourceType<Value>): Value;
+  readonly snapshot: Snapshot;
+  readonly time: Readonly<Time>;
 };
 /**
- * A projection spec with its item and layer types erased, as the world stores it.
+ * A system definition, typed over its query tuple.
  *
  * @example
  * ```ts
- * const stored: AnyProjectionSpec = {
- *   name: "board.items",
- *   layer: "items",
- *   from: () => [],
- *   key: () => "",
- *   view: () => []
+ * const bob: SystemDefinition<[ComponentType<{ y: number }>]> = {
+ *   name: "bob",
+ *   phase: "animate",
+ *   query: [Transform],
+ *   run: entities => {
+ *     for (const [, transform] of entities) transform.y; // read-only
+ *   }
  * };
  * ```
  */
-type AnyProjectionSpec = {
+type SystemDefinition<Terms extends readonly QueryTerm[]> = {
   readonly name: string;
-  readonly layer: string;
-  readonly lift?: string;
-  from(player: Json, session: Json): unknown;
-  key?(item: unknown): string;
-  view(item: unknown): ViewOutput;
-  readonly motion?: AnyProjectionMotion;
+  readonly phase: WorldPhase;
+  readonly query: Terms;
+  run(entities: Iterable<QueryTuple<Terms>>, ctx: SystemContext): void;
 };
 /**
- * Why a reconcile runs. Merged over the frame; the cause table decides play or direct.
+ * A system with its query tuple erased, as the world stores it.
  *
  * @example
  * ```ts
- * const cause: Cause = "edge";
+ * const entry: AnySystem = { name: "bob", phase: "animate", query: [], run: () => {} };
  * ```
  */
-type Cause = "edge" | "rollback" | "restore" | "load" | "mount" | "rerun";
+type AnySystem = {
+  readonly name: string;
+  readonly phase: WorldPhase;
+  readonly query: readonly QueryTerm[];
+  run(entities: Iterable<readonly unknown[]>, ctx: SystemContext): void;
+};
 /**
- * One live or exiting view: the entity of one key of one projection, its rest pose and the
- * motions that still run on it.
+ * One registered system and the frame it was registered in. A system registered during a frame
+ * runs from the next frame on.
  *
  * @example
  * ```ts
- * const view: View = {
- *   entity: 1_048_576,
- *   projection: "board.items",
- *   key: "i7",
- *   item: { id: "i7" },
- *   rest: new Map(),
- *   handles: [],
- *   lifted: false,
- *   dropWhenStill: false,
- *   exiting: false
- * };
+ * const entry: SystemEntry = { definition: bobSystem, frame: 12 };
  * ```
  */
-type View$1 = {
-  entity: Entity;
-  projection: string;
-  key: string;
-  item: unknown; /** The last output of `view(item)`, by component name: what the picture equals at rest. */
-  rest: Map<string, AnyComponentValue>;
-  handles: MotionHandle[];
-  lifted: boolean; /** `lift(false)` is waiting for the last motion to end. */
-  dropWhenStill: boolean;
-  exiting: boolean;
+type SystemEntry = {
+  readonly definition: AnySystem;
+  readonly frame: number;
 };
 /**
- * One mounted projection: its owner, the live views by key, the despawn queue and the items of
- * the last reconcile.
+ * A structural change queued while a phase runs. Applied in call order when the phase ends.
  *
  * @example
  * ```ts
- * const mounted: Mounted = {
- *   owner: { kind: "projection", name: "board.items" },
- *   live: new Map(),
- *   queue: [],
- *   items: new Map()
- * };
+ * const command: Command = { kind: "remove", entity: 1_048_576, component: "Held" };
  * ```
  */
-type Mounted = {
+type Command = {
+  kind: "attach";
+  entity: Entity;
+  components: readonly AnyComponentValue[];
+} | {
+  kind: "despawn";
+  entity: Entity;
+} | {
+  kind: "despawnOwnedBy";
   owner: Owner;
-  live: Map<string, View$1>;
-  queue: View$1[];
-  items: Map<string, unknown>;
+} | {
+  kind: "add";
+  entity: Entity;
+  value: AnyComponentValue;
+} | {
+  kind: "remove";
+  entity: Entity;
+  component: string;
 };
 /**
- * One track the projection started on the driver. The world keeps the component name and the
- * handle, so it knows which components are driven without knowing how the driver runs them.
+ * A structural listener registered with `onAdded` or `onRemoved`.
  *
  * @example
  * ```ts
- * const track: Track = { entity: 1_048_576, component: "Transform", handle: flight };
- * track.handle.active(); // true while the flight runs
+ * const hook: StructuralHook = (entity, value) => void entity + String(value);
  * ```
  */
-type Track = {
-  entity: Entity;
-  component: string;
-  handle: MotionHandle;
+type StructuralHook = (entity: Entity, value: unknown) => void;
+/**
+ * The frozen model snapshot of one frame, kept so four phases read it once.
+ *
+ * @example
+ * ```ts
+ * const cached: FrameSnapshot = { frame: 12, snapshot: { player: {}, session: {}, rng: rngState } };
+ * ```
+ */
+type FrameSnapshot = {
+  frame: number;
+  snapshot: Snapshot;
 };
 /**
- * The rest pose of one entity, by component name: the last output of `view(item)` for a view, or
- * what `setRest` recorded for an element another plugin owns.
+ * The JSON kind of one component field, read from its default value: what the editor's component
+ * palette shows next to the field name. A nested shape is not described; `defaults` carries it.
+ *
+ * @example
+ * ```ts
+ * const kinds: Record<string, FieldKind> = { x: "number", pivot: "object", tags: "array" };
+ * ```
  */
-type RestPose = Map<string, AnyComponentValue>;
+type FieldKind = "number" | "string" | "boolean" | "object" | "array" | "null";
 /**
- * Where a keyed element lives: a plugin above registered it with `registerKey`, so `entityOf`
- * and `keyOf` answer for it next to the views.
+ * One component or tag type the world met, as `ecs.schema()` lists it.
  *
  * @example
  * ```ts
- * const key: ProjectionKey = { projection: "hud", key: "coins" };
+ * const held: ComponentSchema = {
+ *   name: "Held", kind: "tag", json: true, fields: {}, defaults: true, owned: []
+ * };
+ * const display: ComponentSchema = {
+ *   name: "Display", kind: "component", json: false, fields: {}, defaults: null, owned: []
+ * };
  * ```
  */
-type ProjectionKey = {
-  projection: string;
-  key: string;
+type ComponentSchema = {
+  /** The storage name, `componentName`. */name: string;
+  kind: "component" | "tag"; /** False when the defaults are not JSON, as `Display`'s: `fields` is then `{}` and `defaults` `null`. */
+  json: boolean; /** Field name to the JSON kind of its default. */
+  fields: Record<string, FieldKind>; /** The defaults as JSON; `true` for a tag. */
+  defaults: Json; /** The fields a plugin writes and a view never does; `[]` for a tag. */
+  owned: readonly string[];
 };
 /**
- * What the next reconcile has to do: why it runs, which roots changed and whether `view` is
- * forced for every item.
+ * The first and the last value of one component inside a frame window. `null` on a side means
+ * the entity did not carry the component there: component values are objects or `true`, never
+ * `null`.
  *
  * @example
  * ```ts
- * const dirty: Dirty = { causes: ["edge"], roots: new Set(["player"]), force: false };
+ * const levelUp: ComponentChange = { from: { level: 2 }, to: { level: 3 } };
+ * const picked: ComponentChange = { from: null, to: true }; // the tag Held was added
  * ```
  */
-type Dirty = {
-  causes: Cause[];
-  roots: Set<Root>;
-  force: boolean;
+type ComponentChange = {
+  from: Json | null;
+  to: Json | null;
 };
 /**
- * projection module state.
+ * What happened to one entity between two frames: who owns it, where it lives now, whether it
+ * came, went or changed, and every component that really changed.
+ *
+ * @example
+ * ```ts
+ * const merged: EntityDiff = {
+ *   id: 1_048_577,
+ *   owner: { kind: "projection", name: "board.items" },
+ *   key: { projection: "board.items", key: "i7" },
+ *   change: "changed",
+ *   components: { Level: { from: { level: 2 }, to: { level: 3 } } }
+ * };
+ * ```
  */
-type ProjectionState = {
-  specs: Map<string, AnyProjectionSpec>;
-  layers: readonly LayerSpec[];
-  mounted: Map<string, Mounted>;
-  byEntity: Map<Entity, View$1>;
-  dirty: Dirty | undefined;
-  hints: Hint[]; /** The tracks the projection started, with the handle that says whether they still run. */
-  tracks: Track[]; /** The tween engine `anim` installed, or `undefined`: then every target is written at once. */
-  driver: TweenDriver | undefined; /** The rest pose of an entity that is not a view, recorded by its owner through `setRest`. */
-  rests: Map<Entity, RestPose>; /** Projection name to key to the entity a plugin above registered under it. */
-  keys: Map<string, Map<string, Entity>>; /** The reverse of `keys`, so `keyOf` answers for a registered element too. */
-  keysByEntity: Map<Entity, ProjectionKey>; /** Entity to component name to the fields another writer owns. */
-  mutes: Map<Entity, Map<string, Set<string>>>;
-  offHints: Array<() => void>;
+type EntityDiff = {
+  id: Entity;
+  owner: Owner; /** The live address at read time; `undefined` once the entity is gone, or when it has no key. */
+  key: ProjectionKey | undefined;
+  change: "spawned" | "despawned" | "changed";
+  components: Record<string, ComponentChange>;
 };
 /**
- * projection module API, `app.world.projection`: the bridge from the model to entities.
+ * What changed between the world at the end of frame `from` and the world at the end of frame
+ * `to`, as `ecs.diff` answers it. The entities are sorted by id.
  *
  * @example
  * ```ts
- * // A test mounts the board and asks which entity carries one model key.
- * app.world.projection.mount(["board.items"], { kind: "plugin", name: "test" });
- * app.world.projection.entityOf("board.items", "i7"); // 1048576
+ * const quiet: FrameDiff = { from: 120, to: 180, entities: [] };
  * ```
  */
-type ProjectionApi = {
-  /**
-   * Stores a projection spec. Nothing is drawn until `mount`.
-   *
-   * @param spec - The projection, built with `projection()`.
-   * @throws {Error} When a projection of that name is already registered.
-   * @example
-   * ```ts
-   * // A test registers one projection by hand instead of composing a feature.
-   * app.world.projection.register(boardItems);
-   * app.world.projection.entityOf("board.items", "i7"); // undefined: nothing is mounted yet
-   * ```
-   */
-  register(spec: AnyProjectionSpec): void;
-  /**
-   * Stores the layer list of the scene. The order of the list is draw order; every call stores a
-   * new frozen array.
+type FrameDiff = {
+  from: number;
+  to: number;
+  entities: readonly EntityDiff[];
+};
+/**
+ * One record of the frame history: one component of one entity, before and after. `null` means
+ * absent, so a spawn records `from: null` and a despawn `to: null`.
+ *
+ * @example
+ * ```ts
+ * const levelUp: HistoryChange = {
+ *   id: 1_048_577,
+ *   owner: { kind: "projection", name: "board.items" },
+ *   component: "Level",
+ *   from: { level: 2 },
+ *   to: { level: 3 }
+ * };
+ * ```
+ */
+type HistoryChange = {
+  id: Entity;
+  owner: Owner;
+  component: string;
+  from: Json | null;
+  to: Json | null;
+};
+/**
+ * The records of one frame, and the entities that frame spawned and despawned: a record alone
+ * cannot tell a spawn from a component added to a live entity.
+ *
+ * @example
+ * ```ts
+ * const quiet: HistorySlot = { frame: 96, changes: [], spawned: [], despawned: [] };
+ * ```
+ */
+type HistorySlot = {
+  frame: number;
+  changes: HistoryChange[];
+  spawned: Entity[];
+  despawned: Entity[];
+};
+/**
+ * The last recorded JSON of one live entity: its owner and its components by name.
+ */
+type ShadowEntry = {
+  owner: Owner;
+  components: Map<string, Json>;
+};
+/**
+ * The frame history of a dev build: one shadow copy of the world as JSON and a ring of the
+ * records of the last frames, one slot per frame at index `frame % HISTORY_FRAMES`.
+ */
+type History = {
+  /** The last recorded JSON of every live entity. */shadow: Map<Entity, ShadowEntry>; /** `HISTORY_FRAMES` long. */
+  slots: Array<HistorySlot | undefined>; /** The last frame recorded, `undefined` before the first one. */
+  newest: number | undefined; /** The frame the recording started on: the shadow is the world at its end. */
+  started: number | undefined;
+};
+/**
+ * ecs module state.
+ */
+type EcsState = {
+  generations: number[];
+  free: number[];
+  owners: Map<Entity, Owner>; /** Key is `"kind:name"` of the owner. */
+  byOwner: Map<string, Set<Entity>>;
+  types: Map<string, AnyComponentType>;
+  stores: Map<string, Map<Entity, object | true>>;
+  resources: Map<string, object>;
+  systems: Record<WorldPhase, SystemEntry[]>;
+  running: WorldPhase | undefined;
+  commands: Command[];
+  changed: Map<string, Set<Entity>>;
+  added: Map<string, StructuralHook[]>;
+  removed: Map<string, StructuralHook[]>;
+  ownerLeft: Array<(owner: Owner) => void>;
+  mode: WorldMode;
+  offFrame: Array<() => void>;
+  frameSnapshot: FrameSnapshot | undefined; /** The frame history: dev builds only, from the first frame on; `undefined` before it. */
+  history: History | undefined;
+};
+/**
+ * ecs module API, `app.world.ecs`: the screen as data. Plain-object components in one store per
+ * component type, generational entity ids, a mandatory owner, a command buffer applied between
+ * phases, coarse change detection and fixed phases driven by `time`.
+ *
+ * @example
+ * ```ts
+ * // A test owns its entities and reads them back.
+ * const entity = app.world.ecs.spawn({ kind: "plugin", name: "test" }, [Transform({ x: 10 })]);
+ * app.world.ecs.get(entity, Transform); // { x: 10, y: 0, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+ * ```
+ */
+type EcsApi = {
+  /**
+   * Registers a system at the end of its phase list. A system registered during a frame runs
+   * from the next frame on.
    *
-   * @param list - The layers, in draw order.
+   * @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.
    * @example
    * ```ts
-   * // `scenes` switches to the board scene.
+   * // `text` registers its layout system when the plugin starts.
    * const world = ctx.require(worldPlugin);
-   * world.projection.setLayers([
-   *   { name: "board", sort: "none" },
-   *   { name: "items", sort: "y" },
-   *   { name: "lifted", sort: "none" }
-   * ]);
+   * const off = world.ecs.system(measureLabels); // runs from the next frame
+   *
+   * off(); // the plugin stops
    * ```
    */
-  setLayers(list: ReadonlyArray<LayerSpec>): void;
+  system(definition: AnySystem): () => void;
   /**
-   * The current layer list, empty before the first `setLayers`. A new list is a new reference, so
-   * a reader compares by identity.
+   * Creates an entity. The id is reserved and returned at once, also inside a phase, where the
+   * components are attached when the phase ends.
    *
-   * @returns The layers, in draw order.
+   * @param owner - Who owns the entity. Required by the type.
+   * @param components - Component and tag values the entity starts with.
+   * @returns The new entity id.
    * @example
    * ```ts
-   * // `renderer.sync` rebuilds its containers only when the scene really changed.
-   * const current = app.world.projection.layers();
-   * if (current !== lastLayers) rebuildContainers(current); // [{ name: "board", sort: "none" }, ...]
+   * // `ui` spawns a popup entity it owns, so closing the node frees it in one call.
+   * const entity = app.world.ecs.spawn({ kind: "node", name: "reward" }, [
+   *   Transform({ x: 540, y: 960 })
+   * ]);
+   * app.world.ecs.has(entity, Transform); // true
    * ```
    */
-  layers(): ReadonlyArray<LayerSpec>;
+  spawn(owner: Owner, components: readonly AnyComponentValue[]): Entity;
   /**
-   * Marks projections mounted under an owner and reconciles them at once, direct: a scene brings
-   * its own transition. Nothing is mounted when the call throws.
+   * Removes every component of an entity, each firing `onRemoved`, frees the index and bumps the
+   * generation. A stale id is a no-op.
    *
-   * @param names - Names of the projections to mount.
-   * @param owner - Who owns the entities of these projections.
-   * @throws {Error} For an unknown name, or a `layer` or `lift` the scene does not declare.
+   * @param entity - The entity to remove.
    * @example
    * ```ts
-   * // `scenes` mounts the projections of the board scene it just switched to.
-   * const world = ctx.require(worldPlugin);
-   * world.projection.mount(["board.cells", "board.items"], { kind: "plugin", name: "scenes" });
-   * world.projection.entityOf("board.items", "i7"); // 1048576, the picture is already there
+   * // `ui` closes the popup it spawned. Asking again answers with the empty world.
+   * app.world.ecs.despawn(popup);
+   * app.world.ecs.has(popup, Transform); // false
    * ```
    */
-  mount(names: readonly string[], owner: Owner): void;
+  despawn(entity: Entity): void;
   /**
-   * Unmounts projections: every motion of their views is finished, and the live views and the
-   * despawn queue are despawned in the same call.
+   * Despawns exactly the entities of one owner and tells `projection` that the owner left.
    *
-   * @param names - Names of the projections to unmount.
+   * @param owner - The owner whose entities go.
    * @example
    * ```ts
-   * // `scenes` leaves the board scene.
-   * const world = ctx.require(worldPlugin);
-   * world.projection.unmount(["board.cells", "board.items"]);
-   * world.projection.entityOf("board.items", "i7"); // undefined
+   * // A test cleans up after itself without touching the projections of the game.
+   * app.world.ecs.despawnOwnedBy({ kind: "plugin", name: "test" });
+   * app.world.ecs.snapshot(); // { mode: "live", entities: [], resources: {} }
    * ```
    */
-  unmount(names: readonly string[]): void;
+  despawnOwnedBy(owner: Owner): void;
   /**
-   * A drop with no commit: cancels the view's motions and plays settle for every loose component.
-   * In mode `paused` or `fast` the rest pose is written at once. No-op for an entity that is not
-   * a live view.
+   * Reads a component value. A stale id or a missing component gives `undefined`.
    *
-   * @param entity - The entity of the view that was dropped.
+   * @param entity - The entity to read.
+   * @param component - The component type.
+   * @returns The stored value, read-only, or `undefined`.
    * @example
    * ```ts
-   * // `input` released the finger over nothing, so the gate refused the answer.
+   * // `input` asks whether the entity under the finger may be dragged.
    * const world = ctx.require(worldPlugin);
-   * world.projection.settle(held); // the item glides back to its cell over settleMs
+   * world.ecs.get(hit, Draggable); // { payload: { id: "i7" } }
+   * world.ecs.get(hit, DropTarget); // undefined: this item takes no drop
    * ```
    */
-  settle(entity: Entity): void;
+  get<Value extends object>(entity: Entity, component: ComponentHandle<Value>): Readonly<Value> | undefined;
   /**
-   * Hands a set of fields to another writer. Tracks never write them, also not on `finish()`.
+   * Shallow-merges a patch into a stored component and marks the entity changed for it. Never
+   * queued: a `set` inside a phase is visible to the next system of that phase.
    *
-   * @param entity - The entity of the view.
-   * @param component - The component whose fields are taken over.
-   * @param fields - The field names the caller owns.
-   * @returns The remover; safe after the entity left, and a no-op when called twice.
+   * @param entity - The entity to write.
+   * @param component - The component type.
+   * @param patch - The fields to overwrite.
+   * @throws {Error} When the entity is stale or does not carry the component.
    * @example
    * ```ts
-   * // `input` owns the position of the held view while the finger drags it.
+   * // `input` moves the held view with the finger.
    * const world = ctx.require(worldPlugin);
-   * const release = world.projection.mute(held, Transform, ["x", "y"]);
-   *
-   * release(); // the finger let go
+   * world.ecs.set(held, Transform, { x: 420, y: 810 });
+   * world.ecs.get(held, Transform); // { x: 420, y: 810, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
    * ```
    */
-  mute(entity: Entity, component: ComponentType<object>, fields: readonly string[]): () => void;
+  set<Value extends object>(entity: Entity, component: ComponentHandle<Value>, patch: Partial<Value>): void;
   /**
-   * Moves a view into or out of its projection's `lift` layer. `lift(entity, false)` on a view
-   * that still moves takes effect when its last motion ends, so a settling view stays above the
-   * board until it is home.
+   * Adds a component value. On an entity that already carries it the value is replaced and the
+   * entity is marked changed; no `onAdded` fires.
    *
-   * @param entity - The entity of the view.
-   * @param on - True to lift, false to drop back.
+   * @param entity - The entity to write.
+   * @param value - The component or tag value, built by calling its type.
    * @example
    * ```ts
-   * // `input` lifts the item the finger picked up so it draws above the board.
+   * // `text` gives the label entity its display object once the atlas is there.
    * const world = ctx.require(worldPlugin);
-   * world.projection.lift(held, true);
-   *
-   * world.projection.lift(held, false); // on release: takes effect when the settle motion ends
+   * world.ecs.add(label, Display({ object: bitmapText }));
+   * world.ecs.has(label, Display); // true
    * ```
    */
-  lift(entity: Entity, on: boolean): void;
+  add(entity: Entity, value: AnyComponentValue): void;
   /**
-   * The projection and key of an entity. Also answers for a view in the despawn queue and for an
-   * element registered with `registerKey`.
+   * Removes a component. Fires `onRemoved` when the entity carried it.
    *
-   * @param entity - The entity to ask about.
-   * @returns The projection name and the key, or `undefined`.
+   * @param entity - The entity to write.
+   * @param component - The component or tag type to drop.
    * @example
    * ```ts
-   * // `renderer.sync` labels its display objects for the inspector.
-   * app.world.projection.keyOf(1_048_576); // { projection: "board.items", key: "i7" }
-   * app.world.projection.keyOf(42); // undefined: not a view
+   * // `text` drops the display object when the label leaves the screen.
+   * const world = ctx.require(worldPlugin);
+   * world.ecs.remove(label, Display);
+   * world.ecs.has(label, Display); // false
    * ```
    */
-  keyOf(entity: Entity): ProjectionKey | undefined;
+  remove(entity: Entity, component: AnyComponentType): void;
   /**
-   * The rest value of one component of an entity: what a view holds when nothing animates it, or
-   * what `setRest` recorded for an element. Read-only and owner-free, so a plugin that owns no
-   * entity can aim at one.
+   * Tells whether an entity carries a component or tag. False for a stale id.
    *
-   * @param entity - A projection view or a registered element.
-   * @param component - The component whose rest value is asked.
-   * @returns The rest value, or `undefined` when the entity has none recorded.
+   * @param entity - The entity to read.
+   * @param component - The component or tag type.
+   * @returns True when the entity carries it.
    * @example
    * ```ts
-   * // `anim` builds a coin flight toward the counter: `at(target)` is the counter's rest pose.
+   * // `input` never hit-tests a view that is on its way out.
    * const world = ctx.require(worldPlugin);
-   * const counter = world.projection.entityOf("hud", "coins") ?? 0;
-   *
-   * world.projection.restOf(counter, Transform); // { x: 40, y: 120, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+   * world.ecs.has(candidate, Exiting); // true while the merge animation plays
    * ```
    */
-  restOf<Value extends object>(entity: Entity, component: ComponentType<Value>): Value | undefined;
+  has(entity: Entity, component: AnyComponentType): boolean;
   /**
-   * The entity of one key of one projection: a live view, never the despawn queue, or an element
-   * a plugin above registered under that key.
+   * Adds a tag. Structural and idempotent.
    *
-   * @param projection - Name of the projection.
-   * @param key - The model key.
-   * @returns The entity, or `undefined`.
+   * @param entity - The entity to write.
+   * @param tagType - The tag type.
    * @example
    * ```ts
-   * // `input` resolves the target of a scripted drag.
+   * // `input` marks the view under the finger while the drag runs.
    * const world = ctx.require(worldPlugin);
-   * world.projection.entityOf("board.items", "i7"); // 1048576
-   * world.projection.entityOf("board.items", "gone"); // undefined
+   * world.ecs.tag(dragged, Held);
+   * world.ecs.has(dragged, Held); // true
    * ```
    */
-  entityOf(projection: string, key: string): Entity | undefined;
+  tag(entity: Entity, tagType: TagType): void;
   /**
-   * The live view entities of a mounted projection, in the order of its model keys. A view that
-   * plays its exit is left out, and so is an element registered with `registerKey`. Every call
-   * hands out a new array.
+   * Removes a tag. Structural and idempotent.
    *
-   * @param name - Name of the projection.
-   * @returns The entities, or `[]` when the projection is not mounted.
+   * @param entity - The entity to write.
+   * @param tagType - The tag type.
    * @example
    * ```ts
-   * // `ui` hosts the board inside a slot and parents every board item to it on reconcile.
+   * // `input` releases the view on pointer up.
    * const world = ctx.require(worldPlugin);
-   * world.projection.entitiesOf("board.items"); // [1048580, 1048581]
-   * world.projection.entitiesOf("shop.items"); // []: not mounted
+   * world.ecs.untag(dragged, Held);
+   * world.ecs.has(dragged, Held); // false
    * ```
    */
-  entitiesOf(name: string): readonly Entity[];
+  untag(entity: Entity, tagType: TagType): void;
   /**
-   * Installs the tween engine every `ViewHandle.tween`, `toRest` and `all` then runs on. Without
-   * one the world writes every target at once and hands back an inactive handle.
+   * Walks the store of the FIRST term in insertion order and keeps the entities that carry every
+   * term. Deterministic. A `mut()` term marks every yielded entity changed for that component.
    *
-   * @param driver - The engine that runs the tracks.
-   * @returns The remover; it puts the instant writes back.
+   * @param terms - Component types, tag types and `mut()` terms.
+   * @returns The matching rows: the entity and one value per term.
    * @example
    * ```ts
-   * // `anim` installs its tween core when it starts and takes it back when it stops.
-   * const world = ctx.require(worldPlugin);
-   * ctx.state.removeDriver = world.projection.setDriver(createDriver(ctx, ctx.state));
+   * // `renderer.sync` walks every sprite that has a place on the screen.
+   * for (const [entity, sprite, transform] of app.world.ecs.query(Sprite, Transform)) {
+   *   display.get(entity)?.position.set(transform.x, transform.y);
+   *   sprite.texture; // "board.item-red-1"
+   * }
+   * ```
+   */
+  query<const Terms extends readonly QueryTerm[]>(...terms: Terms): Iterable<QueryTuple<Terms>>;
+  /**
+   * Returns the one mutable value of a resource, created from a deep clone of its defaults on
+   * first read.
    *
-   * ctx.state.removeDriver(); // onStop: motions are instant again
+   * @param resourceType - The resource type.
+   * @returns The mutable resource value.
+   * @example
+   * ```ts
+   * // `input` writes the pointer once per frame; every game system reads the same object.
+   * const world = ctx.require(worldPlugin);
+   * const pointer = world.ecs.resource(Pointer);
+   * pointer.down = true;
    * ```
    */
-  setDriver(driver: TweenDriver): () => void;
+  resource<Value extends object>(resourceType: ResourceType<Value>): Value;
   /**
-   * A view handle for an entity that is not a projection view, so an element another plugin owns
-   * can be animated the same way. `set`, `get`, `tween`, `toRest` and `all` work; `rest` answers
-   * what `setRest` recorded; `peer` answers `undefined`.
+   * Registers a listener for the moment a component is added, called when the structural change
+   * is applied. A throwing listener is logged and the others still run.
    *
-   * @param entity - The entity of the element.
-   * @param owner - Who is asking; without it only the kind of the owner is checked.
-   * @returns The handle, or `undefined` for a projection view and for a foreign entity.
+   * @param component - The component type to watch.
+   * @param fn - Called with the entity and the stored value.
+   * @returns The remover; calling it twice is a no-op.
    * @example
    * ```ts
-   * // `ui` plays the `motion` prop of an element it owns.
+   * // `renderer.sync` creates a Pixi object for every new sprite.
    * const world = ctx.require(worldPlugin);
-   * const handle = world.projection.viewOf(button, { kind: "plugin", name: "ui" });
+   * const off = world.ecs.onAdded(Sprite, (entity, sprite) => {
+   *   objects.set(entity, makeSprite(sprite.texture));
+   * });
    *
-   * handle?.tween(Transform, { scale: 1.1 }, { ms: 120, ease: "outBack" });
+   * off(); // the renderer stops
    * ```
    */
-  viewOf(entity: Entity, owner: Owner): ViewHandle<unknown> | undefined;
+  onAdded<Value extends object>(component: ComponentHandle<Value>, fn: (entity: Entity, value: Readonly<Value>) => void): () => void;
   /**
-   * Records what one component of an element looks like at rest, so `toRest` knows where home is.
+   * Registers a listener for the moment a tag is added: `tag` on an entity without it, or a spawn
+   * that carries it. A tag has no value, so the listener gets the entity only.
    *
-   * @param entity - The entity of the element.
-   * @param component - The component whose rest value is recorded.
-   * @param value - The value the element holds when nothing animates.
+   * @param tagType - The tag type to watch.
+   * @param fn - Called with the entity that got the tag.
+   * @returns The remover; calling it twice is a no-op.
    * @example
    * ```ts
-   * // `ui` laid the coin counter out and tells the world where it belongs.
+   * // `ui` shows the pressed look while `input` holds the `Pressed` tag on a button.
    * const world = ctx.require(worldPlugin);
-   * world.projection.setRest(counter, Transform, { x: 40, y: 120, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } });
+   * const off = world.ecs.onAdded(Pressed, entity => markPointer(entity, "pressed", true));
    *
-   * world.projection.viewOf(counter, { kind: "plugin", name: "ui" })?.rest(Transform); // { x: 40, y: 120, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }
+   * world.ecs.tag(button, Pressed); // markPointer(button, "pressed", true)
+   * off(); // ui stops
    * ```
    */
-  setRest<Value extends object>(entity: Entity, component: ComponentType<Value>, value: Value): void;
+  onAdded(tagType: TagType, fn: (entity: Entity) => void): () => void;
   /**
-   * Gives an entity a projection and key of its own, so `entityOf` and `keyOf` answer for it next
-   * to the live views. That is how an element becomes a target for `anim`, `input` and `guide`.
+   * Registers a listener for the moment a component is removed.
    *
-   * @param projection - Name the element is addressed under.
-   * @param key - Key the element is addressed under.
-   * @param entity - The entity of the element.
-   * @returns The remover; it drops the key again.
-   * @throws {Error} When a live view of that projection already holds the key.
+   * @param component - The component type to watch.
+   * @param fn - Called with the entity and the value it had.
+   * @returns The remover; calling it twice is a no-op.
    * @example
    * ```ts
-   * // `ui` publishes the coin counter of the HUD.
+   * // `renderer.sync` destroys the Pixi object of a sprite that left.
    * const world = ctx.require(worldPlugin);
-   * const drop = world.projection.registerKey("hud", "coins", counter);
+   * const off = world.ecs.onRemoved(Sprite, entity => {
+   *   objects.get(entity)?.destroy();
+   *   objects.delete(entity);
+   * });
    *
-   * world.projection.entityOf("hud", "coins"); // the entity of the counter
-   * drop(); // the element left the screen
+   * off(); // the renderer stops
    * ```
    */
-  registerKey(projection: string, key: string, entity: Entity): () => void;
+  onRemoved<Value extends object>(component: ComponentHandle<Value>, fn: (entity: Entity, value: Readonly<Value>) => void): () => void;
   /**
-   * Marks every mounted projection dirty and forces `view` for every item, so the next frame
-   * rebuilds the picture directly.
+   * Registers a listener for the moment a tag is removed: `untag` on an entity that had it, or a
+   * despawn. The listener gets the entity only.
    *
+   * @param tagType - The tag type to watch.
+   * @param fn - Called with the entity that lost the tag.
+   * @returns The remover; calling it twice is a no-op.
    * @example
    * ```ts
-   * // `i18n` switched the locale: every label has to be projected again.
+   * // `ui` drops the pressed look when `input` releases the button.
    * const world = ctx.require(worldPlugin);
-   * world.projection.rerunAll(); // the next frame writes the new strings with no motion
+   * const off = world.ecs.onRemoved(Pressed, entity => markPointer(entity, "pressed", false));
+   *
+   * world.ecs.untag(button, Pressed); // markPointer(button, "pressed", false)
+   * off(); // ui stops
    * ```
    */
-  rerunAll(): void;
-};
-/**
- * projection methods the plugin root drives from the frame and the hooks. Not public.
- */
-type ProjectionInternal = {
+  onRemoved(tagType: TagType, fn: (entity: Entity) => void): () => void;
   /**
-   * Records a commit. In fast mode it reconciles at once, direct.
+   * The coarse change set of the frame, cleared in `time` phase `signals` after every `sync`
+   * system ran.
    *
-   * @param roots - The state roots the commit touched.
-   * @param cause - Why the commit happened.
+   * @param component - The component type to ask about.
+   * @returns The entities marked changed for it this frame.
+   * @example
+   * ```ts
+   * // `renderer.sync` moves only what moved.
+   * for (const entity of app.world.ecs.changed(Transform)) {
+   *   const transform = app.world.ecs.get(entity, Transform);
+   *   display.get(entity)?.position.set(transform?.x ?? 0, transform?.y ?? 0);
+   * }
+   * ```
    */
-  markDirty(roots: readonly Root[], cause: Cause): void;
+  changed(component: AnyComponentType): Iterable<Entity>;
   /**
-   * Reconciles when the world is dirty. Runs at the start of `time` phase `input`.
+   * The effective mode: `"fast"` while the flow walks fast, otherwise the stored one.
+   *
+   * @returns The mode the frame runs in.
+   * @example
+   * ```ts
+   * // A test checks that a fast walk froze the tweens.
+   * app.flow.setMode("fast");
+   * app.world.ecs.mode(); // "fast", even though setMode was never called on the world
+   * ```
    */
-  reconcileIfDirty(): void;
+  mode(): WorldMode;
   /**
-   * Empties the hint buffer. Runs once per frame, reconcile or not.
+   * Stores the world mode. `"fast"` finishes every motion and flushes every despawn queue at once.
+   *
+   * @param mode - The new stored mode.
+   * @example
+   * ```ts
+   * // A headless test wants the final picture without stepping frames.
+   * app.world.ecs.setMode("fast");
+   * app.world.ecs.mode(); // "fast"
+   * ```
    */
-  dropHints(): void;
+  setMode(mode: WorldMode): void;
   /**
-   * Buffers one released hint.
+   * The component type behind a name. A type registers itself on first use, so a name nobody
+   * wrote, read or queried yet is unknown.
    *
-   * @param hint - The hint `flow.fx` released after a commit.
+   * @param name - The storage name of the component.
+   * @returns The type, or `undefined` when the world never met it.
+   * @example
+   * ```ts
+   * // `text` resolves the component a label binds its number to.
+   * const world = ctx.require(worldPlugin);
+   * const type = world.ecs.typeOf("Coins"); // the Coins component, registered when it was written
+   * const pose = type === undefined ? undefined : world.ecs.get(counter, type);
+   *
+   * pose?.amount; // 120
+   * ```
    */
-  pushHint(hint: Hint): void;
+  typeOf(name: string): AnyComponent | undefined;
   /**
-   * Sweeps the views whose motions ended: the despawn queue, the convergence check and the
-   * pending drops. The tracks themselves are advanced by the driver.
+   * The owner of an entity, which is also the liveness check: a stale id has none, also after its
+   * index came back with a new generation. `projection` asks before it hands out a view handle for
+   * an entity another plugin owns; `renderer` asks before it forgets the filters of an entity whose
+   * visual left.
+   *
+   * @param entity - The entity to ask about.
+   * @returns The owner, or `undefined` when the id is stale.
+   * @example
+   * ```ts
+   * // renderer forgets the filter slots of an entity only after it despawned
+   * const ecs = ctx.require(worldPlugin).ecs;
+   * ecs.ownerOf(button); // { kind: "projection", name: "hud" }
+   * ecs.despawn(button);
+   * ecs.ownerOf(button); // undefined
+   * ```
    */
-  sweep(): void;
+  ownerOf(entity: Entity): Owner | undefined;
   /**
-   * Finishes every motion and flushes every despawn queue. Called when the mode turns `fast`.
+   * The whole world as plain JSON, sorted by entity index. A component value that is not JSON is
+   * left out and its name is listed in `skipped`.
+   *
+   * @returns The world as JSON: the mode, the entities and the resources.
+   * @example
+   * ```ts
+   * // A test asserts what the board holds after the first reconcile.
+   * app.world.ecs.snapshot();
+   * // { mode: "live", entities: [{ id: 1048576, index: 0, generation: 1,
+   * //   owner: { kind: "projection", name: "board.items" },
+   * //   components: { Layer: { name: "items" } }, skipped: [] }], resources: {} }
+   * ```
    */
-  flushAll(): void;
+  snapshot(): WorldSnapshot;
   /**
-   * Drops the views of a projection whose owner despawned its entities.
+   * What changed between the world at the end of frame `from` and the world at the end of frame
+   * `to`: one entry per entity, sorted by id, with the first and the last value of every
+   * component that really changed. A value that went and came back inside the window is left
+   * out, and so is an entity spawned and despawned inside it. Dev builds only: the world keeps
+   * the change records of the last 120 frames.
    *
-   * @param owner - The owner that left.
+   * @param from - The frame the window starts after.
+   * @param to - The last frame of the window.
+   * @returns The entities that changed, spawned or despawned in the window.
+   * @throws {Error} In a production build, for a frame outside the last 120, and when `from` is
+   *   after `to`.
+   * @example
+   * ```ts
+   * // The editor asks what the last second of play changed: item i7 merged up to level 3.
+   * app.world.ecs.diff(120, 180);
+   * // { from: 120, to: 180, entities: [{ id: 1048577,
+   * //   owner: { kind: "projection", name: "board.items" },
+   * //   key: { projection: "board.items", key: "i7" }, change: "changed",
+   * //   components: { Level: { from: { level: 2 }, to: { level: 3 } } } }] }
+   * ```
    */
-  ownerLeft(owner: Owner): void;
+  diff(from: number, to: number): FrameDiff;
   /**
-   * Drops every view, track, mute and spec.
+   * Every component and tag type the world met, sorted by name: its kind, whether its defaults
+   * are JSON, the JSON kind of each field, the defaults and the fields a plugin owns. A type
+   * registers on first use, so the list is what the world has met so far, not what the game
+   * declared. Every call builds a new list.
+   *
+   * @returns One entry per type.
+   * @example
+   * ```ts
+   * // The editor's component palette shows the fields of Transform.
+   * app.world.ecs.schema().find(entry => entry.name === "Transform");
+   * // { name: "Transform", kind: "component", json: true,
+   * //   fields: { x: "number", y: "number", rotation: "number", scale: "number", pivot: "object" },
+   * //   defaults: { x: 0, y: 0, rotation: 0, scale: 1, pivot: { x: 0, y: 0 } }, owned: [] }
+   * ```
+   */
+  schema(): readonly ComponentSchema[];
+};
+/**
+ * ecs methods the plugin root calls: frame phases, the owner listener, the clears. Not public.
+ */
+type EcsInternal = {
+  /**
+   * Registers a listener for `despawnOwnedBy`, so `projection` can drop the views of an owner
+   * that left.
+   *
+   * @param fn - Called with the owner whose entities were despawned.
+   * @returns The remover.
+   */
+  onOwnerLeft(fn: (owner: Owner) => void): () => void;
+  /**
+   * Runs the systems of one phase, then flushes the command buffer.
+   *
+   * @param phase - The phase to run.
+   * @param time - The frame's `Time`.
+   */
+  runPhase(phase: WorldPhase, time: Readonly<Time>): void;
+  /**
+   * Applies the queued structural commands in call order.
+   */
+  flush(): void;
+  /**
+   * Clears every change set. Called in `time` phase `signals`.
+   */
+  clearChanges(): void;
+  /**
+   * Drops every entity, component, resource, system and hook.
    */
   clear(): void;
 };
-declare namespace types_d_exports$1 {
-  export { AnyComponentType, AnyComponentValue, AnyProjectionSpec, AnySystem, Api$1 as Api, Cause, ChangeHook, ComponentHandle, ComponentType, ComponentValue, Config$1 as Config, Deps$1 as Deps, DescriptionNode, Ease, EcsApi, EcsModule, Entity, EntitySnapshot, Events$1 as Events, KernelSlice$1 as KernelSlice, LayerSort, LayerSpec, ModelCommitted, Motion, MotionHandle, Mut, Narrowed, NumericFields, Owner, ProjectionApi, ProjectionKey, ProjectionModule, ProjectionMotion, ProjectionSpec, QueryTerm, QueryTuple, ResourceType, RestOptions, State$1 as State, SystemContext, SystemDefinition, TagType, TrackOptions, TrackSegment, TweenDriver, TweenOptions, ViewHandle, ViewOutput, WorldCtx, WorldMode, WorldPhase, WorldSnapshot };
+declare namespace types_d_exports$2 {
+  export { AnyComponentType, AnyComponentValue, AnyProjectionSpec, AnySystem, Api$2 as Api, Cause, ChangeHook, ComponentHandle, ComponentSchema, ComponentType, ComponentValue, Config$2 as Config, Deps$2 as Deps, DescriptionNode, Ease, EcsApi, EcsModule, Entity, EntityDiff, EntitySnapshot, Events$2 as Events, Explained, FrameDiff, KernelSlice$2 as KernelSlice, LayerSort, LayerSpec, ModelCommitted, Motion, MotionHandle, Mut, Narrowed, NumericFields, Owner, ProjectionApi, ProjectionKey, ProjectionModule, ProjectionMotion, ProjectionSpec, QueryTerm, QueryTuple, ResourceType, RestOptions, State$2 as State, SystemContext, SystemDefinition, TagType, TrackOptions, TrackSegment, TweenDriver, TweenOptions, ViewHandle, ViewOutput, WorldCtx, WorldMode, WorldPhase, WorldSnapshot };
 }
 /**
  * world plugin events.
@@ -4562,7 +4755,7 @@ declare namespace types_d_exports$1 {
  * }); // one merge logs { mode: "play", entered: 0, changed: 1, exited: 1, ... }
  * ```
  */
-type Events$1 = {
+type Events$2 = {
   /** Dev only (config `reconciledEvent`). Counts of one reconcile. */"world:reconciled": {
     mode: "play" | "direct";
     projections: number;
@@ -4583,14 +4776,14 @@ type Events$1 = {
  * createApp({ pluginConfigs: { world: { settleMs: 250, reconciledEvent: true } } });
  * ```
  */
-type Config$1 = {
+type Config$2 = {
   /** Duration of the built-in settle motion, in game milliseconds. */settleMs: number; /** Emit `world:reconciled` after every reconcile. Off in production; tests and the editor turn it on. */
   reconciledEvent: boolean;
 };
 /**
  * world plugin state: one branch per module.
  */
-type State$1 = {
+type State$2 = {
   ecs: EcsState;
   projection: ProjectionState;
 };
@@ -4603,17 +4796,17 @@ type State$1 = {
  * app.world.projection.entityOf("board.items", "i7"); // 1048576
  * ```
  */
-type Api$1 = {
+type Api$2 = {
   ecs: EcsApi;
   projection: ProjectionApi;
 };
 /**
  * Resolved dependency APIs.
  */
-type Deps$1 = {
-  time: Api$3;
-  model: Api$4;
-  flow: Api$2;
+type Deps$2 = {
+  time: Api$4;
+  model: Api$5;
+  flow: Api$3;
 };
 /**
  * What the kernel context offers before the deps are attached.
@@ -4622,7 +4815,7 @@ type Deps$1 = {
  * row 8), so the own event reaches the context the kernel hands the factories and `emit` is the
  * kernel's own, world-typed one. No member of the context is cast.
  */
-type KernelSlice$1 = PluginCtx<Config$1, State$1, Events$1> & {
+type KernelSlice$2 = PluginCtx<Config$2, State$2, Events$2> & {
   readonly global: object;
   readonly log: Log.LogApi;
   readonly require: Require;
@@ -4630,13 +4823,37 @@ type KernelSlice$1 = PluginCtx<Config$1, State$1, Events$1> & {
 /**
  * Domain context shared by the two modules.
  */
-type WorldCtx = KernelSlice$1 & {
-  readonly deps: Deps$1;
+type WorldCtx = KernelSlice$2 & {
+  readonly deps: Deps$2;
 };
 /**
  * Payload of the one event world listens to.
  */
-type ModelCommitted = Events$3["model:committed"];
+type ModelCommitted = Events$4["model:committed"];
+/**
+ * One entity in full, as the `/inspect` source `game.explain` reads it: its row of
+ * `ecs.snapshot()`, its projection key and the components a motion still drives.
+ *
+ * @example
+ * ```ts
+ * const sliding: Explained = {
+ *   id: 1_048_577,
+ *   owner: { kind: "projection", name: "board.items" },
+ *   key: { projection: "board.items", key: "i7" },
+ *   components: { Layer: { name: "items" } },
+ *   skipped: ["Display"],
+ *   motions: ["Transform"]
+ * };
+ * ```
+ */
+type Explained = {
+  id: Entity;
+  owner: Owner; /** `projection.keyOf`: the view address, also for an element registered under a key. */
+  key: ProjectionKey | undefined; /** The JSON components, as `EntitySnapshot.components`. */
+  components: Record<string, Json>; /** The names of the components that are not JSON, as `EntitySnapshot.skipped`. */
+  skipped: string[]; /** `projection.motionsOf`: the components a running track drives, in start order. */
+  motions: readonly string[];
+};
 /**
  * Both halves of the `ecs` module: what a game calls and what `projection` gets injected.
  */
@@ -4833,11 +5050,21 @@ type HostInternal = {
    */
   render(): void;
   /**
-   * Draws the stage into a PNG over the whole canvas. A failed read is logged.
+   * Draws the stage into a PNG over the whole canvas. Every container in `hidden` is set
+   * `visible = false` around the synchronous render inside Pixi's extract and set back right after
+   * that call returns its promise, so no drawn frame sees it hidden. A failed read is logged.
    *
+   * @param hidden - The layer containers to leave out of the picture; `[]` for the whole stage.
    * @returns A PNG data URL, or `undefined` while nothing draws or when Pixi could not read it.
    */
-  extract(): Promise<string | undefined>;
+  extract(hidden: readonly PixiContainer[]): Promise<string | undefined>;
+  /**
+   * The resolution the application draws at: device pixels per CSS pixel, capped by
+   * `maxResolution`. A picture of the canvas is its CSS size times this.
+   *
+   * @returns The resolution; 1 while inert.
+   */
+  resolution(): number;
   /**
    * The texture sources the GPU holds and their estimated memory, read at call time.
    *
@@ -4862,7 +5089,7 @@ type HostInternal = {
  * const orientation: Orientation = "portrait";
  * ```
  */
-type Orientation = Config$7["orientation"];
+type Orientation = Config$8["orientation"];
 /**
  * A point in reference units.
  *
@@ -4980,10 +5207,9 @@ type ViewportApi = {
    *   units, since there is no canvas to place them on.
    * @example
    * ```ts
-   * // The `game.rect` source of the editor places Home's Play plank on the page. A 390x844
-   * // phone, the canvas at the top left: the scale is 390 / 1080.
-   * const renderer = ctx.require(rendererPlugin);
-   * renderer.viewport.toScreen({ x: 540, y: 960 }); // { x: 195, y: 346.666… }
+   * // The `game.locate` source places Home's Play plank on the page for an e2e script. A
+   * // 390x844 phone, the canvas at the top left: the scale is 390 / 1080.
+   * app.renderer.viewport.toScreen({ x: 540, y: 960 }); // { x: 195, y: 346.666… }
    * ```
    */
   toScreen(point: Point): Point;
@@ -5079,7 +5305,14 @@ type DisplayEntry = {
   removers: Array<() => void>;
 };
 /**
- * The rectangle a hit test checks, in the local space of the view: anchor already applied.
+ * A rectangle: the one a hit test checks, in the local space of the view with the anchor already
+ * applied, or the bounds of a view in reference units.
+ *
+ * @example
+ * ```ts
+ * // A 64 x 64 sprite with the default anchor, in its own units.
+ * const box: HitBox = { x: -32, y: -32, width: 64, height: 64 };
+ * ```
  */
 type HitBox = {
   x: number;
@@ -5149,7 +5382,7 @@ type TextureProvider = (key: string) => PixiTexture | undefined;
  * const borders: NineBorders = [12, 12, 12, 12];
  * ```
  */
-type NineBorders = readonly [number, number, number, number];
+type NineBorders$1 = readonly [number, number, number, number];
 /**
  * Options of `textures.create`.
  *
@@ -5158,8 +5391,8 @@ type NineBorders = readonly [number, number, number, number];
  * const options: CreateTextureOptions = { nine: [12, 12, 12, 12] };
  * ```
  */
-type CreateTextureOptions = {
-  nine?: NineBorders;
+type CreateTextureOptions$1 = {
+  nine?: NineBorders$1;
 };
 /**
  * Where `textures.slice` cuts a texture out of an atlas page, in page pixels. The manifest `atlas`
@@ -5221,7 +5454,7 @@ type TexturesApi = {
    * const texture = renderer.sync.textures.create(bitmap, { nine: [12, 12, 12, 12] });
    * ```
    */
-  create(image: ImageBitmap | HTMLImageElement, options?: CreateTextureOptions): PixiTexture;
+  create(image: ImageBitmap | HTMLImageElement, options?: CreateTextureOptions$1): PixiTexture;
   /**
    * Cuts a texture out of an atlas page, so `assets` never imports Pixi. The slice shares the
    * page's source: no pixel is copied, and the page keeps the GPU memory. A frame is measured
@@ -5244,7 +5477,7 @@ type TexturesApi = {
    * renderer.sync.textures.destroy(button); // the wrapper goes, the page's source stays
    * ```
    */
-  slice(page: PixiTexture, frame: SliceFrame, options?: CreateTextureOptions): PixiTexture;
+  slice(page: PixiTexture, frame: SliceFrame, options?: CreateTextureOptions$1): PixiTexture;
   /**
    * Destroys a texture and its source. A slice loses only its wrapper: the source belongs to its
    * page, which frees it. The crops of `"cover"` sprites cut from the texture go with it.
@@ -5483,6 +5716,54 @@ type SyncApi = {
    * ```
    */
   hitTest(x: number, y: number, accept: (entity: Entity) => boolean): Entity | undefined;
+  /**
+   * Every entity whose hit box holds the point, topmost first: the walk and the skip rules of
+   * `hitTest` (a hidden or fully transparent view, a point outside a clipping ancestor), with no
+   * filter, so the caller filters. `hitTest` stays the fast path of a pointer event: it stops at
+   * the first accepted hit.
+   *
+   * @param x - Reference x.
+   * @param y - Reference y.
+   * @returns The entities, topmost first, as a fresh array. Inert, and where nothing is drawn: `[]`.
+   * @example
+   * ```ts
+   * // The `game.at` door lists what lies under a point: a coin drawn over its board cell.
+   * app.renderer.sync.hitAll(540, 300); // [1048581, 1048576]
+   * app.renderer.sync.hitAll(20, 20); // []: nothing is drawn there
+   * ```
+   */
+  hitAll(x: number, y: number): readonly Entity[];
+  /**
+   * Where a view is drawn, in reference units: the axis-aligned bounds of the four corners of its
+   * hit box brought through its `Transform` and its `Parent` chain, rotation and scale included.
+   * Only a view the player can see has bounds, so a located element is one a click reaches.
+   *
+   * @param entity - The entity to place.
+   * @returns The bounds, a fresh object. `undefined` for an entity without a view, a view that
+   *   hangs in no tree, a view hidden or with an effective alpha of 0.01 or less on the way to the
+   *   root, and bounds without area. Inert: always `undefined`.
+   * @example
+   * ```ts
+   * // The `game.locate` door finds a 64 x 64 coin drawn at (540, 300) with the default anchor.
+   * app.renderer.sync.boundsOf(coin); // { x: 508, y: 268, width: 64, height: 64 }
+   * ```
+   */
+  boundsOf(entity: Entity): HitBox | undefined;
+  /**
+   * The very box `hitTest` tests for a view, in the entity's own units: the anchor applied, before
+   * the `Transform` and the `Parent` chain, so no rotation. `boundsOf` is this box brought to
+   * reference units.
+   *
+   * @param entity - The entity to ask about.
+   * @returns The box, a fresh object, or `undefined` for an entity without a view.
+   * @example
+   * ```ts
+   * // `input` fits the hit circle of a trace inside a cell: a 64 x 64 Sprite, default anchor.
+   * const renderer = ctx.require(rendererPlugin);
+   * renderer.sync.hitBoxOf(cell); // { x: -32, y: -32, width: 64, height: 64 }
+   * ```
+   */
+  hitBoxOf(entity: Entity): HitBox | undefined;
   /**
    * The texture registry `assets` drives.
    *
@@ -5603,6 +5884,21 @@ type SyncInternal = {
    * @returns The views of entities and the objects waiting in the pools.
    */
   counts(): SyncCounts;
+  /**
+   * The container of one layer of the scene, so `monitor` can leave a layer out of a picture.
+   *
+   * @param name - Layer name.
+   * @returns The container, or `undefined` for a name the scene does not declare and while inert.
+   */
+  layerContainer(name: string): PixiContainer | undefined;
+  /**
+   * The layer an entity is drawn in: the `Layer` of the root of its `Parent` chain, since a child
+   * draws with its parent. An entity without a parent names its own.
+   *
+   * @param entity - The entity.
+   * @returns The layer name, or `undefined` when the root of the chain has no `Layer`.
+   */
+  layerOf(entity: Entity): string | undefined;
 };
 /**
  * The display objects `sync` holds: views of entities and pooled objects.
@@ -5703,7 +5999,7 @@ type CountingClasses = {
 };
 /**
  * monitor module state: the open measuring window, the last closed one, and the captures that
- * wait for a frame.
+ * wait for a drawn frame.
  */
 type MonitorState = {
   /** Clock time at the start of the frame being drawn; `undefined` between frames. */frameStart: number | undefined; /** Clock time at the start of the last frame, the far end of the next interval. */
@@ -5713,8 +6009,8 @@ type MonitorState = {
   workMs: number; /** Frames finished in the open window. */
   frames: number; /** Frames per second of the last closed window. */
   fps: number; /** Mean frame work of the last closed window, in milliseconds. */
-  frameMs: number; /** Callers of `capture()` waiting for the next drawn frame. */
-  captures: Array<(url: string | undefined) => void>; /** The draws the dev counter saw; stays at 0 in a production build. */
+  frameMs: number; /** Captures waiting for a drawn frame, served in `end()`. */
+  captures: PictureRequest[]; /** The draws the dev counter saw; stays at 0 in a production build. */
   draws: DrawCounter;
 };
 /**
@@ -5750,17 +6046,43 @@ type MonitorApi = {
    * picture shows the state the game just reached; at once while the clock is paused, since no
    * frame comes then. Dev builds only: `__MOKU_GAME_DEV__` must be `true`.
    *
-   * @returns A `data:image/png;base64,…` URL. `undefined` in a production build, while inert, lost
-   *   or unsupported, and when Pixi could not read the frame (logged with `ctx.log.error`).
+   * The options draw on the picture after the extract, on an `OffscreenCanvas`; the game never
+   * shows any of it. `layers` hides the other layer containers for the extract alone. `legend`
+   * numbers every keyed view the player can see with a badge at the top-left corner of its rect,
+   * sorted by `rect.y` then `rect.x`, and lists them. `sheet` takes `frames` pictures `everyMs` of
+   * game time apart (while the clock is paused, by one `time.step(everyMs)` each) and lays them out
+   * in `ceil(sqrt(frames))` columns. `against` answers the pixel diff: red where a channel differs
+   * by more than 24, the current picture faded to grey elsewhere. `legend` combines with `against`;
+   * `sheet` combines with `layers` only.
+   *
+   * @param options - What to draw on the picture; a plain picture when left out.
+   * @returns `{ png }`, with `legend` when asked for. `undefined` in a production build, while
+   *   inert, lost or unsupported, and when Pixi could not read the frame (logged with
+   *   `ctx.log.error`).
+   * @throws {Error} When a layer is not in the scene or the list is empty, when a sheet is out of
+   *   2 to 12 frames every 1 to 5000 ms or comes with `legend` or `against`, when there is no
+   *   `OffscreenCanvas` for an option, when the two pictures of `against` differ in size, and when
+   *   game time stood still for 600 drawn frames of a sheet.
    * @example
    * ```ts
    * // The editor's capture button, on the dev page that set globalThis.__MOKU_GAME_DEV__ = true.
-   * const url = await app.renderer.capture(); // "data:image/png;base64,iVBORw0KGgo…"
+   * await app.renderer.capture(); // { png: "data:image/png;base64,iVBORw0KGgo…" }
    * // The same call in a production build.
    * await app.renderer.capture(); // undefined
    * ```
+   * @example
+   * ```ts
+   * // An agent finds the claim button of the HUD on a 1080 x 1920 canvas drawn at resolution 2.
+   * await app.renderer.capture({ legend: true });
+   * // { png: "data:image/png;base64,…", legend: [{ n: 1, projection: "hud", key: "claim", rect: { x: 1140, y: 2310, w: 567, h: 164 } }] }
+   * ```
+   * @example
+   * ```ts
+   * // The coin flight of a merge, six frames 100 ms apart: 3 columns and 2 rows on one picture.
+   * await app.renderer.capture({ sheet: { frames: 6, everyMs: 100 } }); // { png: "data:image/png;base64,…" }
+   * ```
    */
-  capture(): Promise<string | undefined>;
+  capture(options?: CaptureOptions): Promise<Captured | undefined>;
 };
 /**
  * monitor methods the frame drives. Not public.
@@ -5778,222 +6100,1049 @@ type MonitorInternal = {
   end(): void;
 };
 /**
- * What `monitor` gets injected: the modules it reads its counters from.
+ * What `monitor` gets injected: the modules it reads its counters from and places a legend with.
+ */
+type MonitorDeps = {
+  host: HostApi & HostInternal;
+  viewport: ViewportApi & ViewportInternal;
+  sync: SyncApi & SyncInternal;
+};
+/**
+ * A rectangle in picture pixels, from the top-left corner of the PNG: CSS pixels of the canvas
+ * times the resolution, so an agent draws on the picture with it.
+ *
+ * @example
+ * ```ts
+ * // The claim button of the HUD on a 1080 x 1920 canvas drawn at resolution 2.
+ * const rect: PictureRect = { x: 1140, y: 2310, w: 567, h: 164 };
+ * ```
+ */
+type PictureRect = {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+};
+/**
+ * One numbered view of a legend: the number on its badge, the projection and key that address
+ * it, and its rect on the picture.
+ *
+ * @example
+ * ```ts
+ * const entry: LegendEntry = {
+ *   n: 1, projection: "hud", key: "claim", rect: { x: 1140, y: 2310, w: 567, h: 164 }
+ * };
+ * ```
+ */
+type LegendEntry = {
+  n: number;
+  projection: string;
+  key: string;
+  rect: PictureRect;
+};
+/**
+ * What `capture()` draws on the picture. Every field is optional; none gives a plain picture.
+ *
+ * @example
+ * ```ts
+ * // The numbered board without the HUD over it.
+ * const options: CaptureOptions = { legend: true, layers: ["board", "items"] };
+ * // Six frames of a motion, 100 ms of game time apart.
+ * const sheet: CaptureOptions = { sheet: { frames: 6, everyMs: 100 } };
+ * ```
+ */
+type CaptureOptions = {
+  /** Number every keyed view on the picture and list them in `legend` of the answer. */legend?: boolean; /** Draw only these layers of the scene; a `Parent` child follows its parent's layer. */
+  layers?: readonly string[]; /** A contact sheet: 2 to 12 frames, every 1 to 5000 ms of game time. */
+  sheet?: {
+    frames: number;
+    everyMs: number;
+  }; /** A PNG data URL of an earlier capture: the answer is the pixel diff against it. */
+  against?: string;
+};
+/**
+ * What `capture()` answers: the picture, and the legend when it was asked for.
+ *
+ * @example
+ * ```ts
+ * const plain: Captured = { png: "data:image/png;base64,iVBORw0KGgo=" };
+ * const numbered: Captured = {
+ *   png: "data:image/png;base64,iVBORw0KGgo=",
+ *   legend: [{ n: 1, projection: "hud", key: "claim", rect: { x: 1140, y: 2310, w: 567, h: 164 } }]
+ * };
+ * ```
+ */
+type Captured = {
+  png: string;
+  legend?: readonly LegendEntry[];
+};
+/**
+ * The picture of one drawn frame, the legend measured on that same frame when it was asked for,
+ * and the game time of the frame. Not public.
+ */
+type Shot = {
+  png: string;
+  legend: LegendEntry[] | undefined;
+  elapsed: number;
+};
+/**
+ * A capture waiting for a drawn frame. Not public.
+ */
+type PictureRequest = {
+  /** The layers to draw; every layer when `undefined`. */layers: readonly string[] | undefined; /** True to measure the legend on the frame of the picture. */
+  legend: boolean; /** True when the frame just drawn is the one to take. A plain capture takes the next one. */
+  due: () => boolean; /** Takes the shot instead when the game pauses before that frame came: at once, or stepped. */
+  whilePaused: () => Promise<Shot | undefined>; /** Drawn frames that went by while `due` said no. */
+  waited: number; /** Hands the shot over; nothing when the renderer stopped first. */
+  resolve: (shot?: Shot) => void; /** Hands over why the shot cannot come. */
+  reject: (error: Error) => void;
+};
+declare namespace types_d_exports$1 {
+  export { Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$1 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, Deps$1 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$1 as Events, FilterSlot, FiltersApi, FontsApi, HitBox, HostApi, HostInternal, HostModule, HostState, KernelSlice$1 as KernelSlice, LayerEntry, LegendEntry, Modules, MonitorApi, MonitorDeps, MonitorInternal, MonitorModule, MonitorState, NineBorders$1 as NineBorders, Orientation, PictureRect, PixiApplication, PixiBitmapFont, PixiContainer, PixiFilter, PixiGraphics, PixiModule, PixiNineSliceSprite, PixiSprite, PixiTexture, Point, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, SliceFrame, State$1 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState };
+}
+/**
+ * The part of Pixi the engine uses: the classes `sync` builds views from (a `Rectangle` frames the
+ * crop of a `"cover"` sprite), the bitmap-font pieces `fonts.install` needs, the `BitmapText` a
+ * plugin above builds through `host.pixi()`, the filter and particle classes `effects` builds
+ * through it (a custom filter carries a `GpuProgram` and a `GlProgram` over `defaultFilterVert`),
+ * and the extension registry with the three WebGPU draw classes the dev draw-call
+ * counter swaps 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
+ * never arrives through a static import: `config.loadPixi()` returns it, so a game without a screen carries no
+ * Pixi in its bundle.
+ *
+ * @example
+ * ```ts
+ * const pixi: PixiModule = await import("pixi.js");
+ * pixi.Texture.WHITE.width; // 1
+ * pixi.GpuBatchAdaptor.extension.name; // "batch"
+ * pixi.BitmapTextPipe.extension.name; // "bitmapText"
+ * pixi.defaultFilterVert.startsWith("in vec2 aPosition;"); // true
+ * ```
+ */
+type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Cache" | "ColorMatrixFilter" | "Container" | "DisplacementFilter" | "Filter" | "GlProgram" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "Rectangle" | "Shader" | "Sprite" | "Texture" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "localUniformMSDFBit" | "localUniformMSDFBitGl" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
+/**
+ * One Pixi application: renderer, canvas and stage.
+ */
+type PixiApplication = InstanceType<PixiModule["Application"]>;
+/**
+ * A Pixi display object. `Sprite` and `NineSliceSprite` are containers too, so every view is one.
+ */
+type PixiContainer = InstanceType<PixiModule["Container"]>;
+/**
+ * A Pixi sprite.
+ */
+type PixiSprite = InstanceType<PixiModule["Sprite"]>;
+/**
+ * A Pixi nine-slice sprite.
+ */
+type PixiNineSliceSprite = InstanceType<PixiModule["NineSliceSprite"]>;
+/**
+ * A Pixi graphics object: what a `Shape` component is drawn with, and what clips its children.
+ */
+type PixiGraphics = InstanceType<PixiModule["Graphics"]>;
+/**
+ * A Pixi texture. `assets` owns its lifetime; the renderer only makes and destroys it on request.
+ */
+type PixiTexture = InstanceType<PixiModule["Texture"]>;
+/**
+ * A Pixi filter: what `effects` builds and `sync.filters.set` hangs on a view. `effects` owns
+ * the instance; the renderer only assigns it.
+ */
+type PixiFilter = InstanceType<PixiModule["Filter"]>;
+/**
+ * A bitmap font the renderer installed for a font asset key. One per key.
+ */
+type PixiBitmapFont = InstanceType<PixiModule["BitmapFont"]>;
+/**
+ * The parsed shape of a `.fnt` file: what `BitmapFont` is built from.
+ */
+type BitmapFontData = ConstructorParameters<PixiModule["BitmapFont"]>[0]["data"];
+/**
+ * Which backend the one application drew with, or `"none"` while it draws nothing.
+ *
+ * @example
+ * ```ts
+ * const kind: RendererKind = "webgpu";
+ * ```
+ */
+type RendererKind = "webgpu" | "webgl" | "none";
+/**
+ * renderer plugin events.
+ *
+ * @example
+ * ```ts
+ * // A game reports a lost GPU to its analytics; the pause itself is handled by `lifecycle`.
+ * createPlugin("gpuReport", {
+ *   depends: [rendererPlugin],
+ *   hooks: ctx => ({ "renderer:device-lost": ({ kind }) => ctx.log.warn("gpu-lost", { kind }) })
+ * }); // a lost WebGPU device logs { kind: "webgpu" }
+ * ```
+ */
+type Events$1 = {
+  /** The GPU device or the WebGL context was lost; the game is paused until the restore lands. */"renderer:device-lost": {
+    kind: "webgpu" | "webgl";
+    reason: string;
+  };
+};
+/**
+ * The two numbers that bound the shape of the drawn frame: allowed long side / short side.
+ *
+ * @example
+ * ```ts
+ * const aspect: AspectRange = { min: 4 / 3, max: 21 / 9 };
+ * ```
+ */
+type AspectRange = {
+  min: number;
+  max: number;
+};
+/**
+ * renderer plugin config.
+ *
+ * @example
+ * ```ts
+ * createApp({
+ *   plugins: [...screen],
+ *   pluginConfigs: { renderer: { mount: "#game", background: 0x101018, maxResolution: 2 } }
+ * });
+ * // A debug build of the fixture outlines every nine-slice from the first frame.
+ * createApp({ pluginConfigs: { renderer: { mount: "#game", debug: { nineSlice: true } } } });
+ * ```
+ */
+type Config$1 = {
+  /** Where the canvas goes: a selector or an element. `undefined` keeps the plugin inert. */mount: string | HTMLElement | undefined; /** Clear colour. Also the colour of the bars around the frame. */
+  background: number; /** Antialias the whole canvas. Off by default: pixel art and sprites do not need it. */
+  antialias: boolean; /** Cap of `devicePixelRatio`. Memory grows with its square. */
+  maxResolution: number; /** Passed to Pixi. Pixi falls back to WebGL by itself. */
+  preference: "webgpu" | "webgl"; /** Allowed long side / short side of the frame. A window outside it gets bars. */
+  aspect: AspectRange; /** Display objects kept in all pools together. */
+  poolLimit: number; /** Text of the unsupported-device screen. */
+  unsupportedMessage: string; /** Loader seam. Tests pass a fake module. */
+  loadPixi: () => Promise<PixiModule>; /** Debug drawing at start. `app.renderer.sync.debug` switches it while the game runs. */
+  debug: DebugSwitches;
+};
+/**
+ * renderer plugin state: one branch per module.
+ */
+type State$1 = {
+  host: HostState;
+  viewport: ViewportState;
+  sync: SyncState;
+  monitor: MonitorState;
+};
+/**
+ * renderer plugin API, `app.renderer`: grouped by module, and the two members of `monitor`,
+ * `stats()` and `capture()`, on the plugin itself.
+ *
+ * @example
+ * ```ts
+ * app.renderer.host.kind(); // "webgpu"
+ * app.renderer.viewport.size().width; // 1080, reference units
+ * app.renderer.sync.hitTest(540, 300, () => true); // 1048576
+ * app.renderer.stats().views; // 180
+ * app.renderer.stats().renderPasses; // 1: no filter on screen
+ * ```
+ */
+type Api$1 = {
+  host: HostApi;
+  viewport: ViewportApi;
+  sync: SyncApi;
+} & MonitorApi;
+/**
+ * One entity under a point of the page, what the `game.at` door answers: the entity, its owner,
+ * the projection and key that address it when it has them, and the layer its own `Layer` names
+ * (`undefined` for a `Parent` child, which draws in its parent's layer).
+ *
+ * @example
+ * ```ts
+ * // A coin of the board under the pointer.
+ * const under: Under = {
+ *   entity: 1_048_581, owner: { kind: "projection", name: "board.items" },
+ *   key: { projection: "board.items", key: "c7" }, layer: "items"
+ * };
+ * ```
+ */
+type Under = {
+  entity: Entity;
+  owner: Owner;
+  key: ProjectionKey | undefined;
+  layer: string | undefined;
+};
+/**
+ * Resolved dependency APIs. `clock` is the time source of the frame counters.
+ */
+type Deps$1 = {
+  time: Api$4;
+  lifecycle: Api$6;
+  world: Api$2;
+  clock: Api$7;
+};
+/**
+ * What the kernel context offers before the deps are attached.
+ *
+ * `emit` is the kernel's own: `index.ts` writes `events` with an annotated `register`
+ * (core spec `14-EVENT-REGISTRATION.md` row 8), so the plugin's own event reaches the pre-typed
+ * `api` factory and no member of this context is cast.
+ */
+type KernelSlice$1 = PluginCtx<Config$1, State$1, Events$1> & {
+  readonly global: Readonly<Config$8>;
+  readonly log: Log.LogApi;
+  readonly require: Require;
+};
+/**
+ * Domain context shared by the three modules.
+ */
+type RendererCtx = KernelSlice$1 & {
+  readonly deps: Deps$1;
+};
+/**
+ * Both halves of the `host` module: what a game calls and what the two modules above get injected.
+ */
+type HostModule = HostApi & HostInternal;
+/**
+ * Both halves of the `viewport` module: what a game calls and what `sync` and the frame drive.
+ */
+type ViewportModule = ViewportApi & ViewportInternal;
+/**
+ * Both halves of the `sync` module: what `input` and `assets` call and what the frame drives.
+ */
+type SyncModule = SyncApi & SyncInternal;
+/**
+ * Both halves of the `monitor` module: what a tool calls and what the frame drives.
+ */
+type MonitorModule = MonitorApi & MonitorInternal;
+/**
+ * The four modules in injection order.
+ */
+type Modules = {
+  host: HostModule;
+  viewport: ViewportModule;
+  sync: SyncModule;
+  monitor: MonitorModule;
+};
+/**
+ * What `onStop` receives: the frozen config and the plugin state, nothing else.
+ */
+type TeardownScope = {
+  readonly config: Readonly<Config$1>;
+  readonly state: State$1;
+};
+declare namespace types_d_exports {
+  export { Api, AssetKind, AssetsCtx, AssetsIo, AtlasFrame, AtlasPage, AudioAsset, AudioMime, BundleMap, BundleRecord, BundleSpec, BundleUsage, Config, CreateTextureOptions, DecodedImage, DefineBundles, Deps, Events, FetchResponse, FlowRest, FontAsset, FontPage, Inflight, KernelSlice, LoadBundles, LoadReason, LoadResult, LoadedAssets, LoadedFont, Manifest, ManifestBundle, ManifestFile, NineBorders, NineSlice, PreloadQueue, State, Texture, Tier, Usage };
+}
+/**
+ * When a bundle is loaded. `boot` and `core` stay for the whole session, `scene` and `feature`
+ * come and go with the graph, `lazy` is never preloaded.
+ *
+ * @example
+ * ```ts
+ * const tier: Tier = "scene";
+ * ```
+ */
+type Tier = "boot" | "core" | "scene" | "feature" | "lazy";
+/**
+ * What one file of a bundle is. A `.fnt` with its `.png` pages is one `font`, an `.mp3` or an
+ * `.m4a` is `audio`, everything else is a `texture`. A file of an older manifest that names no
+ * kind is a texture.
+ *
+ * @example
+ * ```ts
+ * const kind: AssetKind = "font";
+ * ```
+ */
+type AssetKind = "texture" | "font" | "audio";
+/**
+ * A GPU texture. `assets` owns its lifetime and never imports Pixi: `renderer` makes and destroys
+ * it, this plugin only says when.
+ */
+type Texture = PixiTexture;
+/**
+ * A decoded image, ready for the upload. `createImageBitmap` produces the first shape.
+ */
+type DecodedImage = ImageBitmap | HTMLImageElement;
+/**
+ * Nine-slice borders in pixels, in the order left, top, right, bottom.
+ *
+ * @example
+ * ```ts
+ * const borders: NineBorders = [48, 48, 48, 48];
+ * ```
+ */
+type NineBorders = readonly [number, number, number, number];
+/**
+ * Options of `io.createTexture`. Same shape as `renderer.sync.textures.create`.
+ *
+ * @example
+ * ```ts
+ * const options: CreateTextureOptions = { nine: [48, 48, 48, 48] };
+ * ```
+ */
+type CreateTextureOptions = {
+  nine?: NineBorders;
+};
+/**
+ * The part of a fetch response the plugin reads: the manifest is `json`, a texture is a `blob`,
+ * a font file is `text` and an audio file stays the raw `arrayBuffer`. The global `Response`
+ * fits it. `headers` gives the `content-type`: on `tauri://` a missing file comes back `200` with
+ * `index.html`, so `text/html` for a path that is not `.html` counts as missing.
+ */
+type FetchResponse = {
+  ok: boolean;
+  status: number;
+  headers: {
+    get(name: string): string | null;
+  };
+  json(): Promise<unknown>;
+  blob(): Promise<Blob>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+};
+/**
+ * The I/O seam: everything that leaves the plugin. `undefined` in the config means the browser
+ * pair plus `renderer.sync.textures`; a test passes a fake and nothing touches the network or a GPU.
+ *
+ * @example
+ * ```ts
+ * // A unit test serves two files from memory and counts the textures it handed out.
+ * const io: AssetsIo = {
+ *   fetch: async () => ({
+ *     ok: true,
+ *     status: 200,
+ *     headers: { get: () => null },
+ *     json: async () => ({}),
+ *     blob: async () => blob,
+ *     text: async () => 'info face="body"',
+ *     arrayBuffer: async () => new ArrayBuffer(8)
+ *   }),
+ *   decode: async () => bitmap,
+ *   createTexture: () => ({ id: "t1" }) as unknown as Texture,
+ *   sliceTexture: (page, frame) => ({ id: "s1", page, frame }) as unknown as Texture,
+ *   destroyTexture: texture => destroyed.push(texture)
+ * };
+ *
+ * createApp({ plugins: [...screen], pluginConfigs: { assets: { io, manifest } } });
+ * ```
+ */
+type AssetsIo = {
+  /**
+   * Fetches one URL: the manifest, or a file of a bundle.
+   *
+   * @param url - Absolute or root-relative URL.
+   * @param init - Carries the abort signal of the running load.
+   * @param init.signal - Aborts the request when the load is cancelled.
+   * @returns The response.
+   */
+  fetch(url: string, init: {
+    signal: AbortSignal;
+  }): Promise<FetchResponse>;
+  /**
+   * Decodes one image file.
+   *
+   * @param blob - The bytes of the file.
+   * @returns The decoded image.
+   */
+  decode(blob: Blob): Promise<DecodedImage>;
+  /**
+   * Uploads one decoded image to the GPU.
+   *
+   * @param image - The decoded image.
+   * @param options - `nine` becomes the default nine-slice borders of the texture.
+   * @returns The new texture.
+   */
+  createTexture(image: DecodedImage, options?: CreateTextureOptions): Texture;
+  /**
+   * Cuts the texture of one packed file out of its atlas page. The slice shares the page's
+   * source: no pixel is copied. Same shape as `renderer.sync.textures.slice`; the manifest's
+   * `atlas` frame is passed as it is.
+   *
+   * @param page - The page texture, made by `createTexture`.
+   * @param frame - Where the file lies on the page, in page pixels.
+   * @param options - `nine` becomes the default nine-slice borders of the slice.
+   * @returns The new texture over the page's source.
+   */
+  sliceTexture(page: Texture, frame: SliceFrame, options?: CreateTextureOptions): Texture;
+  /**
+   * Frees one texture. A page frees its source too; a slice frees only itself, so the slices of
+   * a bundle go first and its pages after them.
+   *
+   * @param texture - The texture to free.
+   */
+  destroyTexture(texture: Texture): void;
+};
+/**
+ * Nine-slice metadata of one file, as the scanner writes it. Always four numbers: the tags
+ * `{nine=N}`, `{nine=H,V}` and `{nine=L,T,R,B}` all land here.
+ *
+ * @example
+ * ```ts
+ * const nine: NineSlice = { left: 48, top: 48, right: 48, bottom: 48 };
+ * ```
+ */
+type NineSlice = {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+};
+/**
+ * Where a packed file lies: `page` is the id of a page of the same bundle, never a file name, and
+ * the frame is in page pixels. `width` and `height` equal the file's own, so its `nine` stays
+ * valid as it is. The packer writes it; the loader cuts the file out of the page.
+ *
+ * @example
+ * ```ts
+ * const frame: AtlasFrame = { page: "ui/main-0", x: 583, y: 595, width: 256, height: 128 };
+ * ```
+ */
+type AtlasFrame = {
+  page: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+/**
+ * One atlas page of a packed bundle. `id` is `<bundle>/<group>-<index>`, the name an `atlas`
+ * frame uses; `path` is the hashed WebP file, read like the `path` of a file. `mb` is
+ * `width × height × 4 / 1 048 576`: the page carries the cost of every file packed on it.
+ *
+ * @example
+ * ```ts
+ * const page: AtlasPage = {
+ *   id: "ui/main-0",
+ *   path: "ui/main-0-3b1d55a0c9.webp",
+ *   width: 966,
+ *   height: 1365,
+ *   mb: 5.03
+ * };
+ * ```
+ */
+type AtlasPage = {
+  id: string;
+  path: string;
+  width: number;
+  height: number;
+  mb: number;
+};
+/**
+ * One page image of a font. A page has no key of its own: it belongs to the `.fnt` file that
+ * names it, and is loaded and freed with it.
+ *
+ * @example
+ * ```ts
+ * const page: FontPage = {
+ *   path: "features/ui/assets/body_0.png",
+ *   width: 256,
+ *   height: 128,
+ *   mb: 0.125
+ * };
+ * ```
+ */
+type FontPage = {
+  path: string;
+  width: number;
+  height: number;
+  mb: number;
+};
+/**
+ * One file of a bundle. `mb` is what it costs: `width × height × 4` bytes for a texture, the sum
+ * of the pages for a font, the size of the file for audio, and `0` for a texture packed in an
+ * atlas, whose page carries the cost. `kind` is absent for a texture, which is what every
+ * manifest written before fonts and audio carries. A loose file has `path`; a packed texture has
+ * `atlas` and no `path`.
+ *
+ * @example
+ * ```ts
+ * // The dev manifest of the scanner: a loose file.
+ * const loose: ManifestFile = {
+ *   key: "ui.panel",
+ *   path: "features/ui/assets/panel{nine=48}.png",
+ *   width: 256,
+ *   height: 128,
+ *   mb: 0.125,
+ *   nine: { left: 48, top: 48, right: 48, bottom: 48 }
+ * };
+ *
+ * // The packed manifest: the same key, cut out of the page "ui/main-0".
+ * const packed: ManifestFile = {
+ *   key: "ui.panel",
+ *   width: 256,
+ *   height: 128,
+ *   mb: 0,
+ *   nine: { left: 48, top: 48, right: 48, bottom: 48 },
+ *   atlas: { page: "ui/main-0", x: 583, y: 595, width: 256, height: 128 }
+ * };
+ * ```
+ */
+type ManifestFile = {
+  key: string;
+  path?: string;
+  kind?: AssetKind;
+  width: number;
+  height: number;
+  mb: number;
+  pages?: readonly FontPage[];
+  nine?: NineSlice;
+  atlas?: AtlasFrame;
+};
+/**
+ * One bundle of the manifest: which feature owns it, when it loads and what it costs. `pages` is
+ * written by the packer only, sorted by id; `mb` is then its pages, its loose textures, its font
+ * pages and its audio bytes together.
+ *
+ * @example
+ * ```ts
+ * const bundle: ManifestBundle = { feature: "ui", tier: "core", mb: 0.125, files: [] };
+ * ```
  */
-type MonitorDeps = {
-  host: HostApi & HostInternal;
-  sync: SyncApi & SyncInternal;
+type ManifestBundle = {
+  feature: string;
+  tier: Tier;
+  mb: number;
+  pages?: readonly AtlasPage[];
+  files: readonly ManifestFile[];
 };
-declare namespace types_d_exports {
-  export { Api, AspectRange, BitmapFontData, Config, CountingClasses, CoverFrame, CreateTextureOptions, DebugApi, DebugSwitches, Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events, FilterSlot, FiltersApi, FontsApi, HitBox, HostApi, HostInternal, HostModule, HostState, KernelSlice, LayerEntry, Modules, MonitorApi, MonitorDeps, MonitorInternal, MonitorModule, MonitorState, NineBorders, Orientation, PixiApplication, PixiBitmapFont, PixiContainer, PixiFilter, PixiGraphics, PixiModule, PixiNineSliceSprite, PixiSprite, PixiTexture, Point, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, SliceFrame, State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState };
-}
 /**
- * The part of Pixi the engine uses: the classes `sync` builds views from (a `Rectangle` frames the
- * crop of a `"cover"` sprite), the bitmap-font pieces `fonts.install` needs, the `BitmapText` a
- * plugin above builds through `host.pixi()`, the filter and particle classes `effects` builds
- * through it (a custom filter carries a `GpuProgram` and a `GlProgram` over `defaultFilterVert`),
- * and the extension registry with the three WebGPU draw classes the dev draw-call
- * counter swaps 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
- * never arrives through a static import: `config.loadPixi()` returns it, so a game without a screen carries no
- * Pixi in its bundle.
+ * The manifest: the contract between the scanner, the packer, this plugin and the editor. Version
+ * `1` is the dev manifest of `bun run assets:keys`, version `2` the packed one of
+ * `bun run assets:pack`; the plugin reads both. Bundles are sorted by name, pages by id and files
+ * by key, so two runs on the same tree give the same bytes.
  *
  * @example
  * ```ts
- * const pixi: PixiModule = await import("pixi.js");
- * pixi.Texture.WHITE.width; // 1
- * pixi.GpuBatchAdaptor.extension.name; // "batch"
- * pixi.BitmapTextPipe.extension.name; // "bitmapText"
- * pixi.defaultFilterVert.startsWith("in vec2 aPosition;"); // true
+ * // A dev build: loose files, straight from the features.
+ * const manifest: Manifest = {
+ *   version: 1,
+ *   bundles: { ui: { feature: "ui", tier: "core", mb: 0, files: [] } }
+ * };
+ *
+ * createApp({ plugins: [...screen], pluginConfigs: { assets: { manifest } } });
+ *
+ * // The packed manifest of the same game: the panel is cut out of the page "ui/main-0".
+ * const page = { id: "ui/main-0", path: "ui/main-0-3b1d55a0c9.webp", width: 966, height: 1365, mb: 5.03 };
+ * const atlas = { page: "ui/main-0", x: 583, y: 595, width: 256, height: 128 };
+ * const panel = { key: "ui.panel", width: 256, height: 128, mb: 0, atlas };
+ * const packed: Manifest = {
+ *   version: 2,
+ *   bundles: { ui: { feature: "ui", tier: "core", mb: 5.03, pages: [page], files: [panel] } }
+ * };
  * ```
  */
-type PixiModule = Pick<typeof import("pixi.js"), "AlphaFilter" | "Application" | "BitmapFont" | "BitmapText" | "BitmapTextPipe" | "BlurFilter" | "Cache" | "ColorMatrixFilter" | "Container" | "DisplacementFilter" | "Filter" | "GlProgram" | "GpuBatchAdaptor" | "GpuEncoderSystem" | "GpuGraphicsAdaptor" | "GpuProgram" | "Graphics" | "Matrix" | "NineSliceSprite" | "NoiseFilter" | "Particle" | "ParticleContainer" | "Rectangle" | "Shader" | "Sprite" | "Texture" | "UniformGroup" | "bitmapFontTextParser" | "bitmapFontXMLStringParser" | "colorBit" | "colorBitGl" | "compileHighShaderGlProgram" | "compileHighShaderGpuProgram" | "defaultFilterVert" | "extensions" | "generateTextureBatchBit" | "generateTextureBatchBitGl" | "getBatchSamplersUniformGroup" | "localUniformMSDFBit" | "localUniformMSDFBitGl" | "mSDFBit" | "mSDFBitGl" | "roundPixelsBit" | "roundPixelsBitGl">;
+type Manifest = {
+  version: 1 | 2;
+  bundles: Readonly<Record<string, ManifestBundle>>;
+};
 /**
- * One Pixi application: renderer, canvas and stage.
+ * What a feature declares about one of its bundles. `files` are globs relative to the feature's
+ * `assets/`; a bundle with `files` takes those files out of the feature's default bundle.
+ *
+ * @example
+ * ```ts
+ * const spec: BundleSpec = { tier: "lazy", files: ["chains/*.png"] };
+ * ```
  */
-type PixiApplication = InstanceType<PixiModule["Application"]>;
+type BundleSpec = {
+  tier: Tier;
+  files?: readonly string[];
+};
 /**
- * A Pixi display object. `Sprite` and `NineSliceSprite` are containers too, so every view is one.
+ * What `defineBundles` returns: plain data the scanner and the plugin both read.
+ *
+ * @example
+ * ```ts
+ * const bundles: BundleMap = {
+ *   kind: "bundles",
+ *   map: { board: { tier: "scene" }, "board.chains": { tier: "lazy", files: ["chains/*.png"] } }
+ * };
+ * ```
  */
-type PixiContainer = InstanceType<PixiModule["Container"]>;
+type BundleMap<Key extends string = string> = {
+  kind: "bundles";
+  map: Partial<Record<Key, BundleSpec>>;
+};
 /**
- * A Pixi sprite.
+ * `defineBundles` bound to the bundle keys of one game. `defineGame` returns it, so a key that is
+ * not in `BundleKey` does not compile.
+ *
+ * @example
+ * ```ts
+ * const defineGameBundles: DefineBundles<"board" | "board.chains"> = defineBundles;
+ * ```
  */
-type PixiSprite = InstanceType<PixiModule["Sprite"]>;
+type DefineBundles<Key extends string> = (map: Partial<Record<Key, BundleSpec>>) => BundleMap<Key>;
 /**
- * A Pixi nine-slice sprite.
+ * The `load` descriptor helper bound to the bundle keys of one game.
+ *
+ * @example
+ * ```ts
+ * const loadGameBundle: LoadBundles<"board" | "board.chains"> = load;
+ * ```
  */
-type PixiNineSliceSprite = InstanceType<PixiModule["NineSliceSprite"]>;
+type LoadBundles<Key extends string> = (bundle: Key | readonly Key[]) => Descriptor;
 /**
- * A Pixi graphics object: what a `Shape` component is drawn with, and what clips its children.
+ * What the `load` effect resolves with, so a loading node can write its own progress.
+ *
+ * @example
+ * ```ts
+ * const result: LoadResult = { loaded: ["board.chains"], mb: 1.25 };
+ * ```
  */
-type PixiGraphics = InstanceType<PixiModule["Graphics"]>;
+type LoadResult = {
+  loaded: string[];
+  mb: number;
+};
 /**
- * A Pixi texture. `assets` owns its lifetime; the renderer only makes and destroys it on request.
+ * Why a bundle was loaded. It is the reason of the caller that started the load; a later waiter
+ * changes nothing.
+ *
+ * @example
+ * ```ts
+ * const reason: LoadReason = "enter";
+ * ```
  */
-type PixiTexture = InstanceType<PixiModule["Texture"]>;
+type LoadReason = "boot" | "enter" | "request" | "preload";
 /**
- * A Pixi filter: what `effects` builds and `sync.filters.set` hangs on a view. `effects` owns
- * the instance; the renderer only assigns it.
+ * The running load of one bundle. Every caller is a waiter; the last one to leave aborts it.
+ * `promise` never rejects: what broke waits in `error`, so a load nobody joined any more cannot
+ * become an unhandled rejection.
  */
-type PixiFilter = InstanceType<PixiModule["Filter"]>;
+type Inflight = {
+  promise: Promise<void>;
+  controller: AbortController;
+  waiters: number;
+  error: unknown;
+};
 /**
- * A bitmap font the renderer installed for a font asset key. One per key.
+ * A loaded font: the `.fnt` file as text and the page textures it names. `text` installs the
+ * first page in the renderer; every page is destroyed with the bundle.
+ *
+ * @example
+ * ```ts
+ * const font: FontAsset = { fnt: 'info face="body" size=32', texture };
+ * ```
  */
-type PixiBitmapFont = InstanceType<PixiModule["BitmapFont"]>;
+type FontAsset = {
+  fnt: string;
+  texture: Texture;
+};
 /**
- * The parsed shape of a `.fnt` file: what `BitmapFont` is built from.
+ * What the plugin keeps for a loaded font: the public pair plus every page, because a font of
+ * two pages owns two textures.
  */
-type BitmapFontData = ConstructorParameters<PixiModule["BitmapFont"]>[0]["data"];
+type LoadedFont = FontAsset & {
+  pages: readonly Texture[];
+};
 /**
- * Which backend the one application drew with, or `"none"` while it draws nothing.
+ * The container type of a sound, read from the extension of its file: `.mp3` is `"audio/mpeg"`,
+ * `.m4a` (AAC in an MP4 container) is `"audio/mp4"`. These are the two formats the scanner takes,
+ * and the two every browser and WebView decodes.
  *
  * @example
  * ```ts
- * const kind: RendererKind = "webgpu";
+ * const mime: AudioMime = "audio/mp4"; // the type of theme.m4a
  * ```
  */
-type RendererKind = "webgpu" | "webgl" | "none";
+type AudioMime = "audio/mpeg" | "audio/mp4";
 /**
- * renderer plugin events.
+ * A loaded sound: the bytes exactly as they were fetched, never decoded here, and the MIME type
+ * of their container. A `Blob` of the bytes needs the type: Safari does not sniff a typeless one.
  *
  * @example
  * ```ts
- * // A game reports a lost GPU to its analytics; the pause itself is handled by `lifecycle`.
- * createPlugin("gpuReport", {
- *   depends: [rendererPlugin],
- *   hooks: ctx => ({ "renderer:device-lost": ({ kind }) => ctx.log.warn("gpu-lost", { kind }) })
- * }); // a lost WebGPU device logs { kind: "webgpu" }
+ * const asset: AudioAsset = { bytes: new ArrayBuffer(12_288), mime: "audio/mpeg" }; // click.mp3
  * ```
  */
-type Events = {
-  /** The GPU device or the WebGL context was lost; the game is paused until the restore lands. */"renderer:device-lost": {
-    kind: "webgpu" | "webgl";
-    reason: string;
-  };
+type AudioAsset = {
+  bytes: ArrayBuffer;
+  mime: AudioMime;
 };
 /**
- * The two numbers that bound the shape of the drawn frame: allowed long side / short side.
- *
- * @example
- * ```ts
- * const aspect: AspectRange = { min: 4 / 3, max: 21 / 9 };
- * ```
+ * What one bundle brought: textures by asset key (a packed file's is a slice of its page), fonts
+ * with their pages, the undecoded sounds with their MIME types, and the atlas pages by page id. A
+ * running load fills the same four maps before they are published.
  */
-type AspectRange = {
-  min: number;
-  max: number;
+type LoadedAssets = {
+  textures: Map<string, Texture>;
+  fonts: Map<string, LoadedFont>;
+  audio: Map<string, AudioAsset>;
+  pages: Map<string, Texture>;
 };
 /**
- * renderer plugin config.
+ * What the plugin knows about one bundle. `lastUsed` is the value of `useCounter` at the last
+ * touch: a counter, never a clock.
+ */
+type BundleRecord = LoadedAssets & {
+  status: "idle" | "loading" | "loaded";
+  inflight: Inflight | undefined;
+  lastUsed: number;
+};
+/**
+ * The background preload. A new rest node replaces it and aborts the old controller.
+ */
+type PreloadQueue = {
+  bundles: string[];
+  controller: AbortController;
+};
+/**
+ * assets plugin config.
  *
  * @example
  * ```ts
  * createApp({
- *   plugins: [...screen],
- *   pluginConfigs: { renderer: { mount: "#game", background: 0x101018, maxResolution: 2 } }
+ *   plugins: [...screen, boardFeature],
+ *   pluginConfigs: { assets: { manifest: "/assets/manifest.json", textureBudgetMb: 192 } }
  * });
- * // A debug build of the fixture outlines every nine-slice from the first frame.
- * createApp({ pluginConfigs: { renderer: { mount: "#game", debug: { nineSlice: true } } } });
  * ```
  */
 type Config = {
-  /** Where the canvas goes: a selector or an element. `undefined` keeps the plugin inert. */mount: string | HTMLElement | undefined; /** Clear colour. Also the colour of the bars around the frame. */
-  background: number; /** Antialias the whole canvas. Off by default: pixel art and sprites do not need it. */
-  antialias: boolean; /** Cap of `devicePixelRatio`. Memory grows with its square. */
-  maxResolution: number; /** Passed to Pixi. Pixi falls back to WebGL by itself. */
-  preference: "webgpu" | "webgl"; /** Allowed long side / short side of the frame. A window outside it gets bars. */
-  aspect: AspectRange; /** Display objects kept in all pools together. */
-  poolLimit: number; /** Text of the unsupported-device screen. */
-  unsupportedMessage: string; /** Loader seam. Tests pass a fake module. */
-  loadPixi: () => Promise<PixiModule>; /** Debug drawing at start. `app.renderer.sync.debug` switches it while the game runs. */
-  debug: DebugSwitches;
+  /** URL of `manifest.json`, or the parsed manifest itself (tests, headless). `undefined`: an empty manifest. */manifest: string | Manifest | undefined; /** Texture memory budget in MB. */
+  textureBudgetMb: number; /** How many edges from a rest node the background preload looks ahead. `0` turns preload off. */
+  preloadDepth: number; /** Prefix of every file URL. The CDN seam. `undefined`: the folder of the manifest URL, or `"/"`. */
+  baseUrl: string | undefined; /** I/O seam. `undefined`: the browser pair plus `renderer.sync.textures`, or headless. */
+  io: AssetsIo | undefined;
 };
 /**
- * renderer plugin state: one branch per module.
+ * assets plugin state.
  */
 type State = {
-  host: HostState;
-  viewport: ViewportState;
-  sync: SyncState;
-  monitor: MonitorState;
+  /** `undefined` means headless: manifest only, no fetches, no textures. */io: AssetsIo | undefined; /** Empty until `onStart` read it. */
+  manifest: Manifest; /** Asset key to the bundle that carries it. */
+  bundleOfKey: Map<string, string>; /** Scene id to its bundle, read from the `scenes` key of `flow.features`. */
+  bundleOfScene: Map<string, string>; /** Flow id to the feature that owns it, read from the `flows` key of `flow.features`. */
+  featureOfFlow: Map<string, string>;
+  records: Map<string, BundleRecord>; /** Bundles of the node entered last. They are never unloaded. */
+  pinned: Set<string>; /** The bundle of the scene entered last. A node without `scene` keeps it. */
+  sceneBundle: string | undefined;
+  queue: PreloadQueue | undefined;
+  current: NodeInfo | undefined;
+  useCounter: number; /** Keys already reported missing, so one key warns and starts its background load once. */
+  warned: Set<string>; /** `onEnter`, the `load` handler and the texture provider. */
+  removers: Array<() => void>;
 };
 /**
- * renderer plugin API, `app.renderer`: grouped by module, and the two members of `monitor`,
- * `stats()` and `capture()`, on the plugin itself.
+ * What `usage()` reports about one loaded bundle.
  *
  * @example
  * ```ts
- * app.renderer.host.kind(); // "webgpu"
- * app.renderer.viewport.size().width; // 1080, reference units
- * app.renderer.sync.hitTest(540, 300, () => true); // 1048576
- * app.renderer.stats().views; // 180
- * app.renderer.stats().renderPasses; // 1: no filter on screen
+ * const entry: BundleUsage = { name: "board", tier: "scene", mb: 3.5, lastUsed: 12 };
  * ```
  */
-type Api = {
-  host: HostApi;
-  viewport: ViewportApi;
-  sync: SyncApi;
-} & MonitorApi;
-/**
- * Resolved dependency APIs. `clock` is the time source of the frame counters.
- */
-type Deps = {
-  time: Api$3;
-  lifecycle: Api$5;
-  world: Api$1;
-  clock: Api$6;
+type BundleUsage = {
+  name: string;
+  tier: Tier;
+  mb: number;
+  lastUsed: number;
 };
 /**
- * What the kernel context offers before the deps are attached.
+ * What `usage()` reports: the numbers a dev overlay and the tests read.
  *
- * `emit` is the kernel's own: `index.ts` writes `events` with an annotated `register`
- * (core spec `14-EVENT-REGISTRATION.md` row 8), so the plugin's own event reaches the pre-typed
- * `api` factory and no member of this context is cast.
+ * @example
+ * ```ts
+ * const report: Usage = { textureMb: 3.5, budgetMb: 192, bundles: [] };
+ * ```
  */
-type KernelSlice = PluginCtx<Config, State, Events> & {
-  readonly global: Readonly<Config$7>;
-  readonly log: Log.LogApi;
-  readonly require: Require;
+type Usage = {
+  textureMb: number;
+  budgetMb: number;
+  bundles: readonly BundleUsage[];
 };
 /**
- * Domain context shared by the three modules.
+ * assets plugin events.
+ *
+ * @example
+ * ```ts
+ * // A game reports every loaded bundle to its analytics.
+ * createPlugin("loadReport", {
+ *   depends: [assetsPlugin],
+ *   hooks: ctx => ({ "assets:bundle-loaded": ({ bundle, mb }) => ctx.log.info("loaded", { bundle, mb }) })
+ * }); // the board bundle logs { bundle: "board", mb: 3.5 }
+ *
+ * // A splash screen fills its loading bar file by file.
+ * createPlugin("loadingBar", {
+ *   depends: [assetsPlugin],
+ *   createState: () => ({ share: 0 }),
+ *   hooks: ctx => ({
+ *     "assets:bundle-progress": ({ loaded, total }) => {
+ *       ctx.state.share = loaded / total;
+ *     }
+ *   })
+ * }); // a board bundle of four files sets share to 0.25, 0.5, 0.75 and 1; bundle-loaded follows
+ * ```
  */
-type RendererCtx = KernelSlice & {
-  readonly deps: Deps;
+type Events = {
+  /** Every file of a bundle is a texture now. */"assets:bundle-loaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: LoadReason;
+  };
+  /**
+   * One more file of a running load settled. `loaded` counts the settled files (a font once, with
+   * its pages), `total` is the file count of the bundle; the last one of a load has
+   * `loaded === total` and comes before `assets:bundle-loaded`. An aborted load sends none.
+   */
+  "assets:bundle-progress": {
+    bundle: string;
+    loaded: number;
+    total: number;
+  }; /** The textures of a bundle were destroyed. `keys` names every asset that went with it. */
+  "assets:bundle-unloaded": {
+    bundle: string;
+    tier: Tier;
+    mb: number;
+    reason: "budget" | "request";
+    keys: readonly string[];
+  };
 };
 /**
- * Both halves of the `host` module: what a game calls and what the two modules above get injected.
- */
-type HostModule = HostApi & HostInternal;
-/**
- * Both halves of the `viewport` module: what a game calls and what `sync` and the frame drive.
+ * assets plugin API, `app.assets`. Bundles of textures by key: the graph decides when they arrive,
+ * the budget decides when they leave.
+ *
+ * @example
+ * ```ts
+ * // A loading node asks for a bundle and a game system asks for one texture of it.
+ * await app.assets.load("board");
+ * app.assets.texture("board.cell"); // the Pixi texture, once the bundle is there
+ * ```
  */
-type ViewportModule = ViewportApi & ViewportInternal;
+type Api = {
+  /**
+   * Loads every file of a bundle. An already loaded bundle resolves at once, a loading one joins
+   * the running load. Headless it resolves at once and touches nothing.
+   *
+   * @param bundle - Name of a bundle of the manifest.
+   * @returns A promise that resolves when every texture of the bundle exists.
+   * @throws {Error} When the manifest has no such bundle, and when a file fails to load.
+   * @example
+   * ```ts
+   * // A game plugin warms the bundle of a timed event before its popup can open.
+   * await app.assets.load("event.halloween");
+   * app.assets.isLoaded("event.halloween"); // true
+   * ```
+   */
+  load(bundle: string): Promise<void>;
+  /**
+   * Destroys the textures of a bundle and tells `renderer` that its keys are gone. A pinned
+   * bundle and the tiers `boot` and `core` are refused with a warning. A running load is aborted.
+   *
+   * @param bundle - Name of a loaded bundle.
+   * @example
+   * ```ts
+   * // The timed event ended: its textures go back to the GPU.
+   * app.assets.unload("event.halloween");
+   * app.assets.isLoaded("event.halloween"); // false
+   * ```
+   */
+  unload(bundle: string): void;
+  /**
+   * Tells whether every texture of a bundle exists. Headless every bundle of the manifest counts
+   * as loaded, so a headless game never waits for a loading screen.
+   *
+   * @param bundle - Name of a bundle of the manifest.
+   * @returns True when the bundle is loaded.
+   * @example
+   * ```ts
+   * // `scenes` skips its loading path when the bundle of the next scene is already there.
+   * if (!app.assets.isLoaded("board")) await app.assets.load("board");
+   * ```
+   */
+  isLoaded(bundle: string): boolean;
+  /**
+   * The texture of a loaded asset key. It touches the use counter of the bundle, which is what
+   * the LRU reads. A key of a bundle that is not loaded warns once, starts a background load and
+   * answers `undefined`; the sprites waiting for it are textured when that load lands. A key packed
+   * in an atlas answers its slice of the page, so a game never sees the difference.
+   *
+   * @param key - Asset key, as `generated/assets.ts` types it.
+   * @returns The texture, or `undefined` while the bundle is not loaded.
+   * @example
+   * ```ts
+   * // A game system builds one Pixi object by hand instead of using the Sprite component.
+   * const texture = app.assets.texture("board.cell"); // undefined until the board bundle lands
+   * ```
+   */
+  texture(key: string): Texture | undefined;
+  /**
+   * The font of a loaded asset key: the `.fnt` file as text and the texture of its first page.
+   * It touches the use counter of the bundle. A font of a bundle that is not loaded, a key of
+   * another kind and every headless run answer `undefined`.
+   *
+   * @param key - Asset key of a `.fnt` file, as `generated/assets.ts` types it in `FontKey`.
+   * @returns The font, or `undefined` while its bundle is not loaded.
+   * @example
+   * ```ts
+   * // `text` installs the font in the renderer when the bundle that carries it arrived.
+   * const font = app.assets.font("ui.body"); // { fnt: 'info face="body" size=32', texture }
+   *
+   * if (font !== undefined) app.renderer.sync.fonts.install("ui.body", font.fnt, font.texture);
+   * ```
+   */
+  font(key: string): FontAsset | undefined;
+  /**
+   * The sound of a loaded audio key: its bytes exactly as they were fetched (this plugin never
+   * decodes them) and the MIME type of its container, `"audio/mpeg"` for an `.mp3` and
+   * `"audio/mp4"` for an `.m4a`. A packed file keeps its extension, so it keeps its type. It
+   * touches the use counter of the bundle. A bundle that is not loaded, a key of another kind and
+   * every headless run answer `undefined`.
+   *
+   * @param key - Asset key of an `.mp3` or `.m4a` file, as `generated/assets.ts` types it in
+   *   `AudioKey`.
+   * @returns The bytes and their type, or `undefined` while its bundle is not loaded.
+   * @example
+   * ```ts
+   * // The audio plugin decodes a sound, or streams a long track from a blob: URL of its bytes.
+   * const asset = ctx.require(assetsPlugin).audio("ui.click");
+   * // { bytes: ArrayBuffer(12 288), mime: "audio/mpeg" }
+   * if (asset !== undefined) URL.createObjectURL(new Blob([asset.bytes], { type: asset.mime }));
+   * ```
+   */
+  audio(key: string): AudioAsset | undefined;
+  /**
+   * What the loaded bundles cost, sorted by name. `lastUsed` is the use counter, not a clock.
+   *
+   * @returns The used and allowed megabytes and one entry per loaded bundle.
+   * @example
+   * ```ts
+   * // A dev overlay draws the memory bar of the game.
+   * const { textureMb, budgetMb, bundles } = app.assets.usage();
+   * // textureMb: 3.5, budgetMb: 192, bundles: [{ name: "board", tier: "scene", mb: 3.5, lastUsed: 12 }]
+   * ```
+   */
+  usage(): Usage;
+};
 /**
- * Both halves of the `sync` module: what `input` and `assets` call and what the frame drives.
+ * Resolved dependency APIs.
  */
-type SyncModule = SyncApi & SyncInternal;
+type Deps = {
+  flow: Api$3;
+  renderer: Api$1;
+  time: Api$4;
+};
 /**
- * Both halves of the `monitor` module: what a tool calls and what the frame drives.
+ * What the kernel context offers before the deps are attached.
+ *
+ * `index.ts` writes `events` with an annotated `register` (core spec `14-EVENT-REGISTRATION.md`
+ * row 8), so the two own events reach the context the kernel hands the factories and `emit` is the
+ * kernel's own, assets-typed one. No member of the context is cast.
  */
-type MonitorModule = MonitorApi & MonitorInternal;
+type KernelSlice = PluginCtx<Config, State, Events> & {
+  readonly global: object;
+  readonly log: Log.LogApi;
+  readonly require: Require;
+};
 /**
- * The four modules in injection order.
+ * Domain context shared by the files of the plugin.
  */
-type Modules = {
-  host: HostModule;
-  viewport: ViewportModule;
-  sync: SyncModule;
-  monitor: MonitorModule;
+type AssetsCtx = KernelSlice & {
+  readonly deps: Deps;
 };
 /**
- * What `onStop` receives: the frozen config and the plugin state, nothing else.
+ * Payload of the one event assets listens to.
  */
-type TeardownScope = {
-  readonly config: Readonly<Config>;
-  readonly state: State;
+type FlowRest = {
+  path: string;
+  checkpoint: boolean;
 };
 //#endregion
-export { Position as $, types_d_exports$6 as $t, TrackSegment as A, Json as At, Mut as B, StoreApi as Bt, LayerSpec as C, Config$3 as Ct, ProjectionMotion as D, Api$4 as Dt, NumericFields as E, types_d_exports$3 as Et, ComponentHandle as F, PlayerStateProvider as Ft, SystemDefinition as G, Events$4 as Gt, Owner as H, RngState as Ht, ComponentType as I, ProviderCall as It, BundlesOf as J, types_d_exports$5 as Jt, TagType as K, PauseReason as Kt, ComponentValue as L, SaveDoc as Lt, AnyComponent as M, State$4 as Mt, AnyComponentType as N, types_d_exports$4 as Nt, ProjectionSpec as O, Config$4 as Ot, AnyComponentValue as P, Patch as Pt, GameTypes as Q, State$6 as Qt, Entity as R, SaveUnreadableError as Rt, LayerSort as S, Api$3 as St, MotionHandle as T, Time as Tt, QueryTerm as U, Api$5 as Ut, Narrowed as V, RngApi as Vt, ResourceType as W, Config$5 as Wt, EmitterIdOf as X, Config$6 as Xt, Config$2 as Y, Api$6 as Yt, FeaturePlugin as Z, FakeClock as Zt, State$1 as _, TypeTag as _t, PixiSprite as a, slot as at, DescriptionNode as b, Hint as bt, types_d_exports as c, FeatureDescription as ct, FilterSlot as d, FlowGraph as dt, Config$7 as en, State$2 as et, SliceFrame as f, FlowState as ft, Config$1 as g, SceneIdOf as gt, Api$1 as h, RouteStep as ht, PixiModule as i, exit as it, ViewHandle as j, Root as jt, TrackOptions as k, Events$3 as kt, RenderStats as l, Bookmark as lt, ViewportSize as m, NodeInfo as mt, Config as n, Require as nn, types_d_exports$2 as nt, PixiTexture as o, to as ot, Point as p, JournalEntry as pt, Api$2 as q, State$5 as qt, PixiFilter as r, defineFlow as rt, State as s, type as st, Api as t, Events$5 as tn, TextStylesOf as tt, DebugSwitches as u, DefineNode as ut, types_d_exports$1 as v, Descriptor as vt, Motion as w, State$3 as wt, Ease as x, Answer as xt, ChangeHook as y, GuideOptions as yt, EntitySnapshot as z, Snapshot as zt };
+export { Ease as $, SaveDoc as $t, Config$2 as A, JournalEntry as At, ComponentValue as B, State$4 as Bt, Captured as C, to as Ct, Point as D, DefineNode as Dt, FilterSlot as E, Bookmark as Et, AnyComponentType as F, GuideOptions as Ft, Narrowed as G, Events$4 as Gt, EntitySnapshot as H, types_d_exports$4 as Ht, AnyComponentValue as I, Hint as It, ResourceType as J, State$5 as Jt, Owner as K, Json as Kt, ComponentHandle as L, Answer as Lt, State$2 as M, SceneIdOf as Mt, types_d_exports$2 as N, TypeTag as Nt, ViewportSize as O, FlowGraph as Ot, AnyComponent as P, Descriptor as Pt, DescriptionNode as Q, ProviderCall as Qt, ComponentSchema as R, Api$4 as Rt, types_d_exports$1 as S, slot as St, DebugSwitches as T, FeatureDescription as Tt, FrameDiff as U, Api$5 as Ut, Entity as V, Time as Vt, Mut as W, Config$5 as Wt, TagType as X, Patch as Xt, SystemDefinition as Y, types_d_exports$5 as Yt, ChangeHook as Z, PlayerStateProvider as Zt, PixiModule as _, Events$6 as _n, State$3 as _t, DefineBundles as a, Api$6 as an, ProjectionMotion as at, State$1 as b, defineFlow as bt, LoadReason as c, PauseReason as cn, TrackSegment as ct, Tier as d, Api$7 as dn, BundlesOf as dt, SaveUnreadableError as en, LayerSort as et, Usage as f, Config$7 as fn, Config$3 as ft, PixiFilter as g, Config$8 as gn, Position as gt, Config$1 as h, types_d_exports$7 as hn, GameTypes as ht, Config as i, RngState as in, NumericFields as it, Explained as j, RouteStep as jt, Api$2 as k, FlowState as kt, Manifest as l, State$6 as ln, ViewHandle as lt, Api$1 as m, State$7 as mn, FeaturePlugin as mt, BundleMap as n, StoreApi as nn, Motion as nt, Events as o, Config$6 as on, ProjectionSpec as ot, types_d_exports as p, FakeClock as pn, EmitterIdOf as pt, QueryTerm as q, Root as qt, BundleSpec as r, RngApi as rn, MotionHandle as rt, LoadBundles as s, Events$5 as sn, TrackOptions as st, Api as t, Snapshot as tn, LayerSpec as tt, State as u, types_d_exports$6 as un, Api$3 as ut, PixiSprite as v, Require as vn, TextStylesOf as vt, RenderStats as w, type as wt, Under as x, exit as xt, PixiTexture as y, types_d_exports$3 as yt, ComponentType as z, Config$4 as zt };