@moku-labs/game 0.0.1 → 0.0.2

package/dist/types-BfsmUzLC.d.mts

@@ -1,1908 +0,0 @@
-import { Log } from "@moku-labs/common/browser";
-import { AnyPluginInstance, PluginCtx } from "@moku-labs/core";
-
-//#region src/config.d.ts
-/**
- * Global configuration of a game.
- *
- * @example
- * ```ts
- * createApp({ config: { orientation: "portrait", referenceSide: 1080 } });
- * ```
- */
-type Config$5 = {
-  /** Screen orientation the game is designed for. */orientation: "portrait" | "landscape"; /** Short side of the reference resolution in pixels. */
-  referenceSide: number;
-};
-/**
- * Global events. Empty: every event belongs to a plugin.
- *
- * @example
- * ```ts
- * type AppEvents = Events;
- * ```
- */
-type Events$3 = Record<never, never>;
-/**
- * Public API type of a plugin instance, read from its phantom carrier.
- * Mirrors the kernel's non-exported `ExtractPluginApi`.
- *
- * @example
- * ```ts
- * type TimeApi = ApiOf<typeof timePlugin>;
- * ```
- */
-type ApiOf<Plugin> = Plugin extends {
-  readonly _phantom: {
-    readonly api: infer PluginApi;
-  };
-} ? PluginApi : never;
-/**
- * Structural type of `ctx.require`, for domain factories that resolve their own dependencies.
- * The bound repeats the kernel's plugin shape so the kernel's generic `require` is assignable to it.
- *
- * @example
- * ```ts
- * type LifecycleCtx = PluginCtx<Config, State, Events> & { readonly require: Require };
- * ```
- */
-type Require = <Plugin extends {
-  readonly name: string;
-  readonly spec: unknown;
-  readonly _phantom: {
-    readonly config: unknown;
-    readonly state: unknown;
-    readonly api: unknown;
-    readonly events: Record<string, unknown>;
-  };
-}>(plugin: Plugin) => ApiOf<Plugin>;
-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.
- *
- * @example
- * ```ts
- * const phase: Phase = "animate";
- * ```
- */
-type Phase = "input" | "animate" | "layout" | "sync" | "signals" | "render";
-/**
- * The Time resource, in scaled milliseconds.
- *
- * @example
- * ```ts
- * const time: Time = { delta: 16, elapsed: 1600, scale: 1, frame: 100 };
- * ```
- */
-type Time = {
-  delta: number;
-  elapsed: number;
-  scale: number;
-  frame: number;
-};
-/**
- * Callback run once per frame in its phase.
- *
- * @example
- * ```ts
- * const advanceTweens: FrameCallback = time => tweens.advance(time.delta);
- * ```
- */
-type FrameCallback = (time: Readonly<Time>) => void;
-/**
- * time plugin config.
- *
- * @example
- * ```ts
- * const config: Config = { maxFps: 60, maxDeltaMs: 50 };
- * ```
- */
-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).
-   */
-  maxFps: 30 | 60 | 120;
-  /**
-   * Upper bound of one frame's delta in milliseconds.
-   */
-  maxDeltaMs: number;
-};
-/**
- * time plugin state.
- *
- * @example
- * ```ts
- * const state: State = createTimeState({ global, config });
- * ```
- */
-type State$4 = {
-  callbacks: Record<Phase, FrameCallback[]>;
-  /**
-   * Scratch array of a frame: the six callback lists as they were when the frame started.
-   */
-  captured: (readonly FrameCallback[])[];
-  time: Time;
-  paused: boolean;
-  running: boolean;
-  /**
-   * True while a frame runs; guards `step` re-entry.
-   */
-  stepping: boolean;
-  rafId: number | undefined;
-  lastTimestamp: number | undefined;
-};
-/**
- * time plugin API.
- *
- * @example
- * ```ts
- * const time: Api = ctx.require(timePlugin);
- * const off = time.onFrame("animate", advanceTweens);
- * ```
- */
-type Api$4 = {
-  onFrame(phase: Phase, callback: FrameCallback): () => void;
-  snapshot(): Readonly<Time>;
-  setScale(scale: number): void;
-  pause(): void;
-  resume(): void;
-  isPaused(): boolean;
-  isRunning(): boolean;
-  step(deltaMs: number): void;
-};
-/**
- * Domain context of the time plugin.
- *
- * @example
- * ```ts
- * const api = createTimeApi(ctx satisfies TimeCtx);
- * ```
- */
-type TimeCtx = PluginCtx<Config$4, State$4> & {
-  readonly global: object;
-  readonly log: Log.LogApi;
-};
-declare namespace types_d_exports$3 {
-  export { Api$3 as Api, Config$3 as Config, Events$2 as Events, LifecycleCtx, PauseReason, State$3 as State };
-}
-/**
- * Why the game is paused. The named reasons are the engine's own; any other string is allowed.
- *
- * @example
- * ```ts
- * const reason: PauseReason = "background";
- * ```
- */
-type PauseReason = "background" | "devtools" | "system-dialog" | "device-lost" | (string & {});
-/**
- * lifecycle plugin events.
- *
- * @example
- * ```ts
- * const onChanged = (payload: Events["lifecycle:changed"]) => payload.resumed;
- * ```
- */
-type Events$2 = {
-  /**
-   * The pause stack changed. `reason` and `action` say what changed; `resumed` is true only on
-   * the change that emptied the stack.
-   */
-  "lifecycle:changed": {
-    reason: PauseReason;
-    action: "push" | "pop";
-    reasons: readonly PauseReason[];
-    paused: boolean;
-    resumed: boolean;
-  };
-};
-/**
- * lifecycle plugin config: none. The plugin has no tunable behaviour.
- *
- * @example
- * ```ts
- * const config: Config = {};
- * ```
- */
-type Config$3 = Record<string, never>;
-/**
- * lifecycle plugin state: the pause reasons in insertion order, no duplicates.
- *
- * @example
- * ```ts
- * const state: State = { reasons: ["background"] };
- * ```
- */
-type State$3 = {
-  reasons: PauseReason[];
-};
-/**
- * lifecycle plugin API.
- *
- * @example
- * ```ts
- * const lifecycle: Api = ctx.require(lifecyclePlugin);
- * lifecycle.push("background");
- * ```
- */
-type Api$3 = {
-  push(reason: PauseReason): void;
-  pop(reason: PauseReason): void;
-  reasons(): readonly PauseReason[];
-  isPaused(): boolean;
-};
-/**
- * Domain context: the kernel slice with `require`, used to reach `time`.
- * `emit` is a method signature on purpose: a property-typed `emit` breaks the kernel's event
- * inference when a factory is passed to `createPlugin` by direct reference (`api`).
- *
- * @example
- * ```ts
- * const api = createLifecycleApi(ctx satisfies LifecycleCtx);
- * ```
- */
-type LifecycleCtx = Omit<PluginCtx<Config$3, State$3, Events$2>, "emit"> & {
-  emit<Name extends keyof Events$2>(name: Name, payload: Events$2[Name]): void;
-  readonly require: Require;
-};
-//#endregion
-//#region src/plugins/model/rng/types.d.ts
-/**
- * @file model/rng — type definitions.
- */
-/**
- * Persisted randomness: one uint32 per stream id.
- *
- * @example
- * ```ts
- * const rng: RngState = { seed: 42, streams: { "chest:42": 123456789 } };
- * ```
- */
-type RngState = {
-  seed: number;
-  streams: Record<string, number>;
-};
-/**
- * One deterministic stream. Integers only.
- *
- * @example
- * ```ts
- * const reward = transaction.rng.stream("chest:42").pick(rewards);
- * ```
- */
-type RngStream = {
-  int(maxExclusive: number): number;
-  range(min: number, maxInclusive: number): number;
-  pick<Item>(items: readonly Item[]): Item;
-  weighted<Entry extends {
-    weight: number;
-  }>(table: readonly Entry[]): Entry;
-  chance(numerator: number, denominator: number): boolean;
-};
-/**
- * View over an rng branch, draft or frozen.
- *
- * @example
- * ```ts
- * const view: RngView = createRngView(doc.rng);
- * view.stream("chest:42").int(6);
- * ```
- */
-type RngView = {
-  stream(id: string): RngStream;
-};
-/**
- * rng module API.
- *
- * @example
- * ```ts
- * const state = ctx.require(modelPlugin).rng.peek("chest:42");
- * ```
- */
-type RngApi = {
-  peek(id: string): number | undefined;
-};
-//#endregion
-//#region src/plugins/model/store/types.d.ts
-/**
- * JSON patch produced by a commit.
- *
- * @example
- * ```ts
- * const patch: Patch = { op: "replace", path: ["player", "coins"], value: 12 };
- * ```
- */
-type Patch = {
-  op: "add" | "remove" | "replace";
-  path: (string | number)[];
-  value?: Json;
-};
-/**
- * The persisted document.
- *
- * @example
- * ```ts
- * const doc: SaveDoc = { player: { coins: 0 }, rng: { seed: 42, streams: {} } };
- * ```
- */
-type SaveDoc = {
-  player: Json;
-  rng: RngState;
-};
-/**
- * The save seam implemented by the application layer. `state` is the whole SaveDoc.
- *
- * @example
- * ```ts
- * createApp({ pluginConfigs: { model: { playerProvider: memory() } } });
- * ```
- */
-type PlayerStateProvider = {
-  /** `null` means a new player. */load(): Promise<{
-    state: Json;
-    version: number;
-  } | null>; /** Called at rest nodes. The provider accumulates and debounces writes. */
-  commit(patches: Patch[], version: number): void; /** Called after a barrier node. Resolves when the data is durable. */
-  commitDurable(patches: Patch[], txId: string, version: number): Promise<void>; /** Background, close. */
-  flush(): Promise<void>;
-};
-/**
- * One recorded call of the in-memory provider.
- *
- * @example
- * ```ts
- * expect(provider.calls).toEqual([{ method: "load" }, { method: "flush" }]);
- * ```
- */
-type ProviderCall = {
-  method: "load";
-} | {
-  method: "commit";
-  patches: Patch[];
-  version: number;
-} | {
-  method: "commitDurable";
-  patches: Patch[];
-  txId: string;
-  version: number;
-} | {
-  method: "flush";
-};
-/**
- * One step of the save migration chain.
- *
- * @example
- * ```ts
- * const addCoins: Migration = { from: 1, up: state => ({ player: state, coins: 0 }) };
- * ```
- */
-type Migration = {
-  from: number;
-  up(state: Json): Json;
-};
-/**
- * Frozen view of committed state.
- *
- * @example
- * ```ts
- * const { player, session }: Snapshot = model.store.snapshot();
- * ```
- */
-type Snapshot = {
-  readonly player: Json;
-  readonly session: Json;
-  readonly rng: Readonly<RngState>;
-};
-/**
- * Result of a commit.
- *
- * @example
- * ```ts
- * const { patches, roots }: CommitResult = transaction.commit();
- * ```
- */
-type CommitResult = {
-  patches: {
-    doc: Patch[];
-    session: Patch[];
-  };
-  roots: Root[];
-};
-/**
- * Open transaction handed to one node run.
- *
- * @example
- * ```ts
- * const transaction: Transaction = model.store.begin();
- * transaction.commit();
- * ```
- */
-type Transaction = {
-  /** Mutable draft of the player tree. */player: Json; /** Mutable draft of the session tree. */
-  session: Json; /** Rng view bound to the draft `doc.rng`. */
-  rng: RngView;
-  commit(): CommitResult;
-  discard(): void;
-};
-/**
- * store module state.
- *
- * @example
- * ```ts
- * const store: StoreState = createStoreState(config);
- * ```
- */
-type StoreState = {
-  /** Frozen save document. */doc: SaveDoc; /** Frozen session tree. */
-  session: Json; /** Frozen trees of the last rest point. */
-  restPoint: {
-    doc: SaveDoc;
-    session: Json;
-  } | undefined; /** Doc patches since the last provider commit. */
-  pending: Patch[];
-  transaction: Transaction | undefined;
-  loaded: boolean;
-  provider: PlayerStateProvider;
-};
-/**
- * store module API.
- *
- * @example
- * ```ts
- * const store: StoreApi = ctx.require(modelPlugin).store;
- * await store.load();
- * ```
- */
-type StoreApi = {
-  load(): Promise<void>;
-  snapshot(): Snapshot;
-  begin(): Transaction;
-  markRest(): void;
-  markBarrier(txId: string): Promise<void>;
-  rollback(): void;
-  restore(input: {
-    player: Json;
-    session?: Json;
-    rng?: RngState;
-  }): void;
-  flush(): Promise<void>;
-};
-/**
- * Thrown by `load()` when the save cannot be read by this build.
- *
- * @example
- * ```ts
- * if (error instanceof SaveUnreadableError) showSaveScreen(error);
- * ```
- */
-declare class SaveUnreadableError extends Error {
-  readonly savedVersion: number;
-  readonly schemaVersion: number;
-  /**
-   * Creates the error.
-   *
-   * @param savedVersion - Version found in the save.
-   * @param schemaVersion - Version this build writes.
-   * @param cause - The underlying failure.
-   * @example
-   * ```ts
-   * throw new SaveUnreadableError(3, 2, undefined);
-   * ```
-   */
-  constructor(savedVersion: number, schemaVersion: number, cause: unknown);
-}
-declare namespace types_d_exports$2 {
-  export { Api$2 as Api, CommitResult, Config$2 as Config, Events$1 as Events, Json, Migration, ModelCtx, Patch, PlayerStateProvider, ProviderCall, RngApi, RngState, RngStream, RngView, Root, SaveDoc, Snapshot, State$2 as State, StoreApi, Transaction };
-}
-/**
- * Plain JSON value. Everything in state is JSON.
- *
- * @example
- * ```ts
- * const player: Json = { coins: 10, inventory: ["key"] };
- * ```
- */
-type Json = null | boolean | number | string | Json[] | {
-  [key: string]: Json;
-};
-/**
- * State roots reported by `model:committed`.
- *
- * @example
- * ```ts
- * const roots: Root[] = ["player", "rng"];
- * ```
- */
-type Root = "player" | "session" | "rng";
-/**
- * model plugin events.
- *
- * @example
- * ```ts
- * hooks: { "model:committed": ({ roots, cause }) => reconcile(roots, cause) }
- * ```
- */
-type Events$1 = {
-  /** Committed state changed. Projections reconcile from the snapshot. */"model:committed": {
-    roots: readonly Root[];
-    cause: "edge" | "rollback" | "restore" | "load";
-  };
-};
-/**
- * model plugin config.
- *
- * @example
- * ```ts
- * createApp({ pluginConfigs: { model: { initialPlayer: { coins: 0 }, seed: 42 } } });
- * ```
- */
-type Config$2 = {
-  /** 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). */
-  seed: "from-save" | number; /** Version of the save schema written by this build. */
-  schemaVersion: number; /** Ordered chain; `up` of `from: n` produces version `n + 1`. */
-  migrations: readonly Migration[];
-};
-/**
- * model plugin state: one branch per module.
- *
- * @example
- * ```ts
- * const state: State = createModelState({ global, config });
- * ```
- */
-type State$2 = {
-  store: StoreState;
-  rng: Record<string, never>;
-};
-/**
- * model plugin API, grouped by module.
- *
- * @example
- * ```ts
- * const model: Api = ctx.require(modelPlugin);
- * model.store.snapshot();
- * ```
- */
-type Api$2 = {
-  store: StoreApi;
-  rng: RngApi;
-};
-/**
- * Domain context shared by the modules.
- * `emit` is a method signature on purpose: a property-typed `emit` breaks the kernel's event
- * inference when a factory is passed to `createPlugin` by direct reference (`onStart`).
- *
- * @example
- * ```ts
- * export function createStoreApi(ctx: ModelCtx, deps: { createRngView: CreateRngView }): StoreApi;
- * ```
- */
-type ModelCtx = Omit<PluginCtx<Config$2, State$2, Events$1>, "emit"> & {
-  emit<Name extends keyof Events$1>(name: Name, payload: Events$1[Name]): void;
-  readonly global: object;
-  readonly log: Log.LogApi;
-};
-declare namespace types_d_exports$1 {
-  export { Api$1 as Api, ClockCtx, ClockSource, Config$1 as Config, Elapsed, FakeClock, State$1 as State };
-}
-/**
- * Source of time and timers. The system source is the only code that reads the device clock.
- *
- * @example
- * ```ts
- * const source: ClockSource = fakeClock(1000);
- * ```
- */
-type ClockSource = {
-  now(): number;
-  setTimer(callback: () => void, delayMs: number): unknown;
-  clearTimer(handle: unknown): void;
-};
-/**
- * Fake source for tests.
- *
- * @example
- * ```ts
- * const clock: FakeClock = fakeClock();
- * clock.advance(5000);
- * ```
- */
-type FakeClock = ClockSource & {
-  advance(ms: number): void;
-  set(moment: number): void;
-};
-/**
- * Input delivered when a due moment arrives or the game resumes.
- *
- * @example
- * ```ts
- * const input: Elapsed = { now: clock.now() };
- * ```
- */
-type Elapsed = {
-  now: number;
-};
-/**
- * clock plugin config.
- *
- * @example
- * ```ts
- * const config: Config = { source: undefined };
- * ```
- */
-type Config$1 = {
-  /**
-   * Time source. `undefined` means the system source.
-   */
-  source: ClockSource | undefined;
-};
-/**
- * clock plugin state.
- *
- * @example
- * ```ts
- * const state: State = createClockState({ global, config });
- * ```
- */
-type State$1 = {
-  source: ClockSource;
-  last: number;
-  dueAt: number | undefined;
-  handle: unknown;
-  listeners: Array<(input: Elapsed) => void>;
-};
-/**
- * clock plugin API.
- *
- * @example
- * ```ts
- * const clock: Api = ctx.require(clockPlugin);
- * clock.scheduleAt(clock.now() + 60_000);
- * ```
- */
-type Api$1 = {
-  now(): number;
-  scheduleAt(moment: number | undefined): void;
-  onElapsed(listener: (input: Elapsed) => void): () => void;
-  poke(): void;
-  dueAt(): number | undefined;
-};
-/**
- * Domain context of the clock plugin.
- *
- * @example
- * ```ts
- * const api = createClockApi(ctx satisfies ClockCtx);
- * ```
- */
-type ClockCtx = PluginCtx<Config$1, State$1> & {
-  readonly global: object;
-};
-//#endregion
-//#region src/plugins/flow/gate/types.d.ts
-/**
- * One answer of the player, of an agent or of a test.
- *
- * @example
- * ```ts
- * const answer: Answer = { intent: "merge", payload: { from: "c2", to: "c3" } };
- * ```
- */
-type Answer = {
-  intent: string;
-  payload?: Json;
-};
-/**
- * The one answer a `guide` lets through. `payload` is compared by deep equality when present.
- *
- * @example
- * ```ts
- * const allow: Allow = { intent: "merge", payload: { from: "c2", to: "c3" } };
- * ```
- */
-type Allow = {
-  intent: string;
-  payload?: Json;
-};
-/**
- * What an open gate accepts.
- *
- * @example
- * ```ts
- * const spec: GateSpec = { allowed: ["play", "shop"] };
- * ```
- */
-type GateSpec = {
-  allowed: readonly string[];
-};
-/**
- * gate module state.
- *
- * @example
- * ```ts
- * const gate: GateState = createGateState();
- * ```
- */
-type GateState = {
-  /** The spec of the open gate. `undefined`: the gate is closed. */open: GateSpec | undefined; /** Resolver of the promise returned by `open`. */
-  resolve: ((answer: Answer) => void) | undefined; /** An answer given while the gate was closed, kept for one frame. */
-  held: {
-    answer: Answer;
-    frame: number;
-  } | undefined; /** The one answer a running `guide` lets through. */
-  narrow: Allow | undefined; /** True while a pointer is down. Entering an `over` node waits for false. */
-  pointerActive: boolean; /** Ends the pending pointer wait of the runner. Set while the wait runs, so a stop needs no frame. */
-  wake: (() => void) | undefined;
-};
-/**
- * gate module API: the single entry of player answers.
- *
- * @example
- * ```ts
- * const accepted = app.flow.gate.answer({ intent: "play" });
- * ```
- */
-type GateApi = {
-  answer(answer: Answer): boolean;
-  pointer(active: boolean): void;
-  state(): {
-    open: boolean;
-    allowed: readonly string[];
-    narrowed: boolean;
-  };
-};
-//#endregion
-//#region src/plugins/flow/fx/types.d.ts
-/**
- * An effect a node awaits. With `answers` the runner opens the gate for those intents.
- * `cosmetic: true` swallows a handler error and resolves `undefined`.
- *
- * @example
- * ```ts
- * const descriptor: Descriptor = { kind: "popup", payload: { name: "Retry" }, answers: ["again"] };
- * ```
- */
-type Descriptor = {
-  kind: string;
-  payload?: Json;
-  answers?: readonly string[];
-  cosmetic?: boolean;
-};
-/**
- * A fire-and-forget cosmetic effect. Released only after the commit of its transaction.
- *
- * @example
- * ```ts
- * const sparkle: Hint = { kind: "sparkle", payload: { cell: "c3" }, hint: true };
- * ```
- */
-type Hint = {
-  kind: string;
-  payload?: Json;
-  hint: true;
-};
-/**
- * Options of the `guide` descriptor: the one allowed answer and its visual part.
- *
- * @example
- * ```ts
- * const options: GuideOptions = { allow: { intent: "merge" }, hand: "drag", text: "Merge them" };
- * ```
- */
-type GuideOptions = {
-  allow: Allow;
-  highlight?: readonly string[];
-  hand?: "tap" | "drag";
-  text?: string;
-};
-/**
- * Handler of one effect kind, registered by a plugin above `flow`.
- *
- * @example
- * ```ts
- * const playSound: FxHandler = (descriptor, { signal }) => audio.play(descriptor.payload, signal);
- * ```
- */
-type FxHandler = (descriptor: Descriptor | Hint, ctx: {
-  signal: AbortSignal;
-  mode: "live" | "fast";
-}) => unknown | Promise<unknown>;
-/**
- * fx module state.
- *
- * @example
- * ```ts
- * const fx: FxState = createFxState();
- * ```
- */
-type FxState = {
-  /** One handler per effect kind. */handlers: Map<string, {
-    run: FxHandler;
-    runInFast: boolean;
-  }>; /** Hints of the open transaction. */
-  buffered: Hint[]; /** Completions waiting for the `signals` phase, in start order. */
-  settled: Array<() => void>;
-  mode: "live" | "fast";
-};
-/**
- * fx module API: the effects gateway.
- *
- * @example
- * ```ts
- * const off = app.flow.fx.handle("sfx", playSound);
- * ```
- */
-type FxApi = {
-  handle(kind: string, handler: FxHandler, options?: {
-    runInFast?: boolean;
-  }): () => void;
-  dispatch(descriptor: Descriptor | Hint): void;
-};
-/**
- * The `fx` of a node context: awaited effects by call, cosmetic hints by `emit`.
- *
- * @example
- * ```ts
- * const pick = await fx(popup("Retry", ["again", "home"]));
- * fx.emit(hint("sparkle", { cell: "c3" }));
- * ```
- */
-type NodeFx = ((descriptor: Descriptor) => Promise<unknown>) & {
-  emit(hint: Hint): void;
-};
-//#endregion
-//#region src/plugins/flow/inbox/types.d.ts
-/**
- * One event of the world: time that passed, a push message, a purchase that arrived.
- *
- * @example
- * ```ts
- * const event: WorldEvent = { type: "elapsed", payload: { now: 1000 } };
- * ```
- */
-type WorldEvent = {
-  type: string;
-  payload?: Json;
-};
-/**
- * inbox module state.
- *
- * @example
- * ```ts
- * const inbox: InboxState = createInboxState();
- * ```
- */
-type InboxState = {
-  /** Undelivered events, oldest first. One entry per `type`. */queue: WorldEvent[]; /** Callbacks woken by every `post`. Kept in state so every API instance over this state shares them. */
-  listeners: Array<() => void>;
-};
-/**
- * inbox module API.
- *
- * @example
- * ```ts
- * app.flow.inbox.post({ type: "elapsed", payload: { now: 1000 } });
- * ```
- */
-type InboxApi = {
-  post(event: WorldEvent): void;
-};
-//#endregion
-//#region src/plugins/flow/runner/types.d.ts
-/**
- * A value that carries only a type. Invariant in `Payload`, so `{ stars }` never passes for
- * `{ stars, moves }` in either direction.
- *
- * @example
- * ```ts
- * const stars: TypeTag<{ stars: number }> = type<{ stars: number }>();
- * ```
- */
-type TypeTag<Payload> = {
-  readonly kind: "type";
-  readonly $type?: (value: Payload) => Payload;
-};
-/**
- * Any type tag. The bound of tag records: it names no payload, so `type()` infers nothing from it.
- *
- * @example
- * ```ts
- * const tag: AnyTypeTag = type<{ level: number }>();
- * ```
- */
-type AnyTypeTag = {
-  readonly kind: "type";
-};
-/**
- * Outcome name to the type tag of its payload.
- *
- * @example
- * ```ts
- * const outcomes = { done: type(), failed: type<{ reason: string }>() } satisfies OutcomeTags;
- * ```
- */
-type OutcomeTags = Readonly<Record<string, AnyTypeTag>>;
-/**
- * The payload type carried by a type tag.
- *
- * @example
- * ```ts
- * type Reason = PayloadOf<TypeTag<{ reason: string }>>; // { reason: string }
- * ```
- */
-type PayloadOf<Tag> = Tag extends TypeTag<infer Payload> ? Payload : never;
-/**
- * The part of the game types a node sees. Inside the engine both trees are `Json`;
- * `defineGame<Types>()` narrows them for the game at the type level only.
- *
- * @example
- * ```ts
- * const game: GameState = { player: { lives: 3 }, session: { visits: 0 } };
- * ```
- */
-type GameState = {
-  player: Json;
-  session: Json;
-};
-/**
- * Whether a payload or input type is `void`: an outcome without data, a node without input.
- *
- * @example
- * ```ts
- * type Empty = IsVoid<PayloadOf<TypeTag<void>>>; // true
- * ```
- */
-type IsVoid<Payload> = [Payload] extends [void] ? true : false;
-/**
- * What `out.name(data)` returns. `run` must return one of these; a bare string is not accepted.
- * `Name` is the union of the node's outcome names; without a type argument it is the widened
- * result the runner reads.
- *
- * @example
- * ```ts
- * const result: Result<"done" | "rejected"> = out.done();
- * ```
- */
-type Result<Name extends string = string> = {
-  readonly outcome: Name;
-  readonly payload: Json;
-};
-/**
- * The `out` of a node context: one method per declared outcome, without an argument when the
- * payload is `void`.
- *
- * @example
- * ```ts
- * run: ({ out }) => (broken ? out.failed({ reason: "clock" }) : out.done())
- * ```
- */
-type Out<Tags extends OutcomeTags> = { readonly [Name in keyof Tags]: IsVoid<PayloadOf<Tags[Name]>> extends true ? () => Result<keyof Tags & string> : (data: PayloadOf<Tags[Name]>) => Result<keyof Tags & string> };
-/**
- * The one object a node body receives. `player` and `session` are drafts of the open
- * transaction, `rng` is its view, `now` is `clock.now()` read once at node entry.
- *
- * @example
- * ```ts
- * run: ({ input, player, out }: NodeContext<Game, { level: number }, Tags>) => out.done()
- * ```
- */
-type NodeContext<Game extends GameState = GameState, Input = void, Tags extends OutcomeTags = OutcomeTags> = {
-  input: Input;
-  player: Game["player"];
-  session: Game["session"];
-  rng: RngView;
-  fx: NodeFx;
-  out: Out<Tags>;
-  signal: AbortSignal;
-  now: number;
-};
-/**
- * The body of a node: plain `await` code that ends with `out.name(data)`.
- *
- * @example
- * ```ts
- * const run: NodeRun<Game, void, { done: TypeTag<void> }> = ({ out }) => out.done();
- * ```
- */
-type NodeRun<Game extends GameState, Input, Tags extends OutcomeTags> = (ctx: NodeContext<Game, Input, Tags>) => Result<keyof Tags & string> | Promise<Result<keyof Tags & string>>;
-/**
- * The part of a node, or of a flow used as a node, that an edge table looks at.
- *
- * @example
- * ```ts
- * const wired: Wired<{ level: number }, { win: TypeTag<void> }> = levelFlow;
- * ```
- */
-type Wired<Input, Tags extends OutcomeTags> = {
-  readonly input: TypeTag<Input>;
-  readonly outcomes: Tags;
-};
-/**
- * Anything that can sit in the `nodes` of a flow: a node, a sub-flow or a slot.
- *
- * @example
- * ```ts
- * const entry: AnyWired = catchUp;
- * ```
- */
-type AnyWired = {
-  readonly input: AnyTypeTag;
-  readonly outcomes: OutcomeTags;
-};
-/**
- * Node name to node: the `nodes` of one flow.
- *
- * @example
- * ```ts
- * const nodes = { catchUp, awaitIntent, merge } satisfies NodeTable;
- * ```
- */
-type NodeTable = Readonly<Record<string, AnyWired>>;
-/**
- * A node as `defineNode` returns it: plain data plus the optional body.
- *
- * @example
- * ```ts
- * const merge: NodeDefinition<{ from: string; to: string }, { done: TypeTag<void> }> = defineNode({
- *   input: type<{ from: string; to: string }>(),
- *   outcomes: { done: type() },
- *   run: ({ out }) => out.done()
- * });
- * ```
- */
-type NodeDefinition<Input, Tags extends OutcomeTags, Game extends GameState = GameState> = Wired<Input, Tags> & {
-  readonly kind: "node";
-  readonly rest: boolean;
-  readonly over: boolean;
-  readonly checkpoint: boolean;
-  readonly barrier: boolean;
-  readonly inbox: readonly (keyof Tags & string)[];
-  readonly run?: NodeRun<Game, Input, Tags>;
-};
-/**
- * What the author passes to `defineNode`. `run` is required unless `rest: true`: a rest node
- * without a body is a pure wait.
- *
- * @example
- * ```ts
- * const spec: NodeSpec<Game, void, { play: TypeTag<void> }> = {
- *   rest: true,
- *   checkpoint: true,
- *   outcomes: { play: type() }
- * };
- * ```
- */
-type NodeSpec<Game extends GameState, Input, Tags extends OutcomeTags> = {
-  input?: TypeTag<Input>;
-  outcomes: Tags;
-  over?: boolean;
-  checkpoint?: boolean;
-  barrier?: boolean;
-  inbox?: readonly (keyof Tags & string)[];
-} & ({
-  rest: true;
-  run?: NodeRun<Game, Input, Tags>;
-} | {
-  rest?: false;
-  run: NodeRun<Game, Input, Tags>;
-});
-/**
- * The signature of `defineNode` bound to one game. `defineGame<Types>()` returns it.
- *
- * @example
- * ```ts
- * const defineGameNode: DefineNode<{ player: Player; session: Session }> = defineNode;
- * ```
- */
-type DefineNode<Game extends GameState> = <Input = void, const Tags extends OutcomeTags = OutcomeTags>(spec: NodeSpec<Game, Input, Tags>) => NodeDefinition<Input, Tags, Game>;
-/**
- * An extension point inside a flow: a node whose body is "run the contributions in order".
- * Its single outcome is `done`.
- *
- * @example
- * ```ts
- * const afterWin: SlotNode = slot("afterWin");
- * ```
- */
-type SlotNode = Wired<void, {
-  readonly done: TypeTag<void>;
-}> & {
-  readonly kind: "slot";
-  readonly name: string;
-};
-/**
- * Edge target that leaves the sub-flow with this outcome. The payload passes through.
- *
- * @example
- * ```ts
- * const leave: Exit<"win"> = exit("win");
- * ```
- */
-type Exit<Name extends string = string> = {
-  readonly kind: "exit";
-  readonly outcome: Name;
-};
-/**
- * Edge target that adapts the payload on the edge. `map` is a property on purpose: the mapper's
- * parameter annotation is checked strictly against the outcome payload.
- *
- * @example
- * ```ts
- * const adapt: Mapped<"retry", { reason: string }, { why: string }> = to(
- *   "retry",
- *   (failure: { reason: string }) => ({ why: failure.reason })
- * );
- * ```
- */
-type Mapped<TargetName extends string = string, Payload = never, Output = unknown> = {
-  readonly kind: "map";
-  readonly target: TargetName;
-  readonly map: (payload: Payload) => Output;
-};
-/**
- * A mapped target as the runner calls it. `map` is a method on purpose: method parameters are
- * compared bivariantly, so every checked `Mapped` fits and the runner calls it without a cast.
- * The result is `unknown`: a mapper into a node without input returns nothing, and the runner
- * checks that a mapped payload is plain JSON before it becomes the next input.
- *
- * @example
- * ```ts
- * const input = mapped.map(result.payload);
- * ```
- */
-type AnyMapped = {
-  readonly kind: "map";
-  readonly target: string;
-  map(payload: unknown): unknown;
-};
-/**
- * Any edge target as the runner reads it: a node name, an exit or a mapped target.
- *
- * @example
- * ```ts
- * const target: Target | undefined = flow.edges[node]?.[result.outcome];
- * ```
- */
-type Target = string | Exit | AnyMapped;
-/**
- * Whether a receiver with input `Input` takes `Payload`. A receiver without input ignores the
- * payload, so it accepts anything; a void outcome into a node with input is an error.
- *
- * @example
- * ```ts
- * type Fits = Accepts<{ stars: number }, void>; // true
- * ```
- */
-type Accepts<Payload, Input> = IsVoid<Input> extends true ? true : [Payload] extends [Input] ? true : false;
-/**
- * The input type of a node or sub-flow.
- *
- * @example
- * ```ts
- * type MergeInput = InputOf<typeof merge>; // { from: string; to: string }
- * ```
- */
-type InputOf<Node extends AnyWired> = PayloadOf<Node["input"]>;
-/**
- * Names of the nodes whose input accepts `Payload`.
- *
- * @example
- * ```ts
- * type Starts = NodeNamesFor<{ boot: typeof boot; merge: typeof merge }, void>; // "boot"
- * ```
- */
-type NodeNamesFor<Nodes extends NodeTable, Payload> = { [Name in keyof Nodes & string]: Accepts<Payload, InputOf<Nodes[Name]>> extends true ? Name : never }[keyof Nodes & string];
-/**
- * Names of the flow outcomes whose payload accepts `Payload`.
- *
- * @example
- * ```ts
- * type Exits = ExitNamesFor<{ win: TypeTag<{ stars: number }> }, { stars: number }>; // "win"
- * ```
- */
-type ExitNamesFor<FlowTags extends OutcomeTags, Payload> = { [Name in keyof FlowTags & string]: Accepts<Payload, PayloadOf<FlowTags[Name]>> extends true ? Name : never }[keyof FlowTags & string];
-/**
- * Every correctly typed `to(node, map)` for `Payload`.
- *
- * @example
- * ```ts
- * type Adapters = MappedFor<{ retry: typeof retry }, { reason: string }>;
- * ```
- */
-type MappedFor<Nodes extends NodeTable, Payload> = { [Name in keyof Nodes & string]: Mapped<Name, Payload, InputOf<Nodes[Name]>> }[keyof Nodes & string];
-/**
- * Descriptive type: every legal target of an outcome that carries `Payload`.
- *
- * @example
- * ```ts
- * type AfterMerge = TargetFor<BoardNodes, BoardOutcomes, void>;
- * ```
- */
-type TargetFor<Nodes extends NodeTable, FlowTags extends OutcomeTags, Payload> = NodeNamesFor<Nodes, Payload> | Exit<ExitNamesFor<FlowTags, Payload>> | MappedFor<Nodes, Payload>;
-/**
- * Descriptive type of an edge table: one entry per outcome of every node. Stored on
- * `FlowDefinition` and read by tools; the check with readable errors is `CheckedEdges`.
- *
- * @example
- * ```ts
- * const edges: Edges<{ boot: typeof boot; home: typeof home }, Record<never, never>> = {
- *   boot: { done: "home" },
- *   home: { play: "boot" }
- * };
- * ```
- */
-type Edges<Nodes extends NodeTable, FlowTags extends OutcomeTags> = { readonly [Name in keyof Nodes]: { readonly [Outcome in keyof Nodes[Name]["outcomes"]]: TargetFor<Nodes, FlowTags, PayloadOf<Nodes[Name]["outcomes"][Outcome]>> } };
-/**
- * A branded sentence. The compiler prints it in the "is not assignable to" position, so a wrong
- * edge reads as a message with node and outcome names.
- *
- * @example
- * ```ts
- * type Problem = GraphError<'No node "awaitIntnet" in this flow (edge of outcome "done" of node "merge").'>;
- * ```
- */
-type GraphError<Message extends string> = {
-  readonly $graphError: Message;
-};
-/**
- * The loosest legal target of a flow: what a missing entry is expected to be.
- *
- * @example
- * ```ts
- * type Missing = AnyTargetOf<BoardNodes, BoardOutcomes>;
- * ```
- */
-type AnyTargetOf<Nodes extends NodeTable, FlowTags extends OutcomeTags> = (keyof Nodes & string) | Exit<keyof FlowTags & string> | Mapped<keyof Nodes & string, never, unknown>;
-/**
- * Checks one entry `Value` of the inferred edge table. A legal entry stays itself; a wrong one
- * becomes a `GraphError` sentence.
- *
- * @example
- * ```ts
- * type Checked = CheckTarget<BoardNodes, BoardOutcomes, "merge", "done", void, "awaitIntent">;
- * ```
- */
-type CheckTarget<Nodes extends NodeTable, FlowTags extends OutcomeTags, NodeName extends string, OutcomeName extends string, Payload, Value> = Value extends string ? Value extends keyof Nodes ? Accepts<Payload, InputOf<Nodes[Value]>> extends true ? Value : GraphError<`Payload of outcome "${OutcomeName}" of node "${NodeName}" does not fit the input of node "${Value}". Use to("${Value}", payload => ...).`> : GraphError<`No node "${Value}" in this flow (edge of outcome "${OutcomeName}" of node "${NodeName}").`> : Value extends Exit<infer ExitName> ? ExitName extends keyof FlowTags ? Accepts<Payload, PayloadOf<FlowTags[ExitName]>> extends true ? Value : GraphError<`Payload of outcome "${OutcomeName}" of node "${NodeName}" does not fit flow outcome "${ExitName}".`> : GraphError<`exit("${ExitName}"): the flow declares no outcome "${ExitName}".`> : Value extends Mapped<infer TargetName, never, unknown> ? TargetName extends keyof Nodes ? Mapped<TargetName, Payload, InputOf<Nodes[TargetName]>> : GraphError<`to("${TargetName}", ...): no node "${TargetName}" in this flow.`> : AnyTargetOf<Nodes, FlowTags>;
-/**
- * Checking type: validates the inferred edge table `Table` entry by entry. It reports a missing
- * edge, an unknown target, a payload that does not fit, an edge of an unknown outcome and an
- * edge table row of an unknown node.
- *
- * @example
- * ```ts
- * type Spec = { edges: Table & CheckedEdges<Nodes, FlowTags, Table> };
- * ```
- */
-type CheckedEdges<Nodes extends NodeTable, FlowTags extends OutcomeTags, Table> = { readonly [Name in keyof Nodes & string]: { readonly [Outcome in keyof Nodes[Name]["outcomes"] & string]: Name extends keyof Table ? Outcome extends keyof Table[Name] ? CheckTarget<Nodes, FlowTags, Name, Outcome, PayloadOf<Nodes[Name]["outcomes"][Outcome]>, Table[Name][Outcome]> : AnyTargetOf<Nodes, FlowTags> : AnyTargetOf<Nodes, FlowTags> } & (Name extends keyof Table ? { readonly [Extra in Exclude<keyof Table[Name], keyof Nodes[Name]["outcomes"]> & string]: GraphError<`Node "${Name}" has no outcome "${Extra}".`> } : unknown) } & { readonly [Extra in Exclude<keyof Table, keyof Nodes> & string]: GraphError<`"${Extra}" is not a node of this flow.`> };
-/**
- * A flow as `defineFlow` returns it: plain data. A flow that declares `input` and `outcomes`
- * is used as a node of another flow.
- *
- * @example
- * ```ts
- * const levelFlow: FlowDefinition<{ level: number }, { win: TypeTag<void> }, LevelNodes> =
- *   defineFlow("level", { input, outcomes, nodes, start: "prepare", edges });
- * ```
- */
-type FlowDefinition<Input, FlowTags extends OutcomeTags, Nodes extends NodeTable = NodeTable> = Wired<Input, FlowTags> & {
-  readonly kind: "flow";
-  readonly id: string;
-  readonly nodes: Nodes;
-  readonly start: keyof Nodes & string;
-  readonly edges: Edges<Nodes, FlowTags>;
-};
-/**
- * What the author passes to `defineFlow`. `start` must name a node whose input accepts the flow
- * input; `edges` is inferred as written and validated by `CheckedEdges`.
- *
- * @example
- * ```ts
- * defineFlow("main", { nodes: { boot, home }, start: "boot", edges: { boot: { done: "home" } } });
- * ```
- */
-type FlowSpec<Nodes extends NodeTable, Input, FlowTags extends OutcomeTags, Table> = {
-  nodes: Nodes;
-  start: NodeNamesFor<NoInfer<Nodes>, NoInfer<Input>>;
-  edges: Table & CheckedEdges<NoInfer<Nodes>, NoInfer<FlowTags>, NoInfer<Table>>;
-  input?: TypeTag<Input>;
-  outcomes?: FlowTags;
-};
-/**
- * The node context as the runner builds it. Every typed `NodeContext` is assignable to it.
- *
- * @example
- * ```ts
- * const ctx: AnyNodeContext = { input, player, session, rng, fx, out, signal, now };
- * ```
- */
-type AnyNodeContext = {
-  input: unknown;
-  player: unknown;
-  session: unknown;
-  rng: RngView;
-  fx: NodeFx;
-  out: Readonly<Record<string, (payload: never) => Result>>;
-  signal: AbortSignal;
-  now: number;
-};
-/**
- * Any node as the runner holds it. `run` is a method on purpose: method parameters are compared
- * bivariantly, so every typed `NodeDefinition` fits and the runner calls the body without a cast.
- *
- * @example
- * ```ts
- * const nodes: readonly AnyNode[] = [catchUp, merge];
- * ```
- */
-type AnyNode = AnyWired & {
-  readonly kind: "node";
-  readonly rest: boolean;
-  readonly over: boolean;
-  readonly checkpoint: boolean;
-  readonly barrier: boolean;
-  readonly inbox: readonly string[];
-  run?(ctx: AnyNodeContext): Result | Promise<Result>;
-};
-/**
- * One entry of a flow's `nodes`: a node, a sub-flow or a slot. The `kind` field tells them apart.
- *
- * @example
- * ```ts
- * const entry: FlowEntry | undefined = flow.nodes[name];
- * ```
- */
-type FlowEntry = AnyNode | AnyFlow | SlotNode;
-/**
- * Any flow as the runner holds it. Every typed `FlowDefinition` fits.
- *
- * @example
- * ```ts
- * const flows: Map<string, AnyFlow> = collectFlows(mainFlow, []);
- * ```
- */
-type AnyFlow = AnyWired & {
-  readonly kind: "flow";
-  readonly id: string;
-  readonly nodes: Readonly<Record<string, FlowEntry>>;
-  readonly start: string;
-  readonly edges: Readonly<Record<string, Readonly<Record<string, Target>>>>;
-};
-/**
- * One level of the position. The path is the frames joined: `"board/awaitIntent"`.
- *
- * @example
- * ```ts
- * const frame: Frame = { flow: "board", node: "awaitIntent", input: null };
- * ```
- */
-type Frame = {
-  flow: string;
-  node: string;
-  input: Json;
-};
-/**
- * One taken edge. `hash` covers `path + outcome + next`, so a replay against edited code fails
- * loudly in dev.
- *
- * @example
- * ```ts
- * const [last]: readonly JournalEntry[] = app.flow.history().slice(-1);
- * ```
- */
-type JournalEntry = {
-  index: number;
-  path: string;
-  outcome: string;
-  payload: Json;
-  next: string;
-  now: number;
-  hash: string;
-};
-/**
- * One step of a fast walk: a player answer at a rest node, or a substituted sub-flow result.
- *
- * @example
- * ```ts
- * const route: RouteStep[] = [
- *   { at: "home", intent: "play" },
- *   { at: "level", result: { outcome: "win", payload: { stars: 3 } } }
- * ];
- * ```
- */
-type RouteStep = {
-  at: string;
-  intent: string;
-  payload?: Json;
-} | {
-  at: string;
-  result: {
-    outcome: string;
-    payload?: Json;
-  };
-};
-/**
- * A rest node plus a state that really existed there. Serialisable. `graph` is the hash of
- * `describe()`.
- *
- * @example
- * ```ts
- * const bookmark: Bookmark = app.flow.bookmark();
- * await app.flow.restore(bookmark);
- * ```
- */
-type Bookmark = {
-  path: string;
-  input: Json;
-  player: Json;
-  session: Json;
-  rng: RngState;
-  graph: string;
-};
-/**
- * What `onEnter` callbacks learn about the node being entered.
- *
- * @example
- * ```ts
- * app.flow.onEnter("load", (node: NodeInfo) => preload(node.path));
- * ```
- */
-type NodeInfo = {
-  path: string;
-  flow: string;
-  node: string;
-  rest: boolean;
-  over: boolean;
-  checkpoint: boolean;
-  barrier: boolean;
-};
-/**
- * The whole graph as JSON. Edge targets are rendered as strings: `"node"`, `"exit:win"`,
- * `"map:node"`.
- *
- * @example
- * ```ts
- * const graph: FlowGraph = app.flow.describe();
- * graph.flows[graph.main]?.start;
- * ```
- */
-type FlowGraph = {
-  main: string;
-  flows: Record<string, {
-    nodes: Record<string, GraphNode>;
-    start: string;
-    edges: Record<string, Record<string, string>>;
-  }>;
-  slots: Record<string, {
-    feature: string;
-    flow: string;
-    order: number;
-  }[]>;
-};
-/**
- * One node of `describe()`: its flags, its outcome names and, when it is one, the slot it opens,
- * the sub-flow it enters and the feature that brought it.
- *
- * @example
- * ```ts
- * const node: GraphNode | undefined = app.flow.describe().flows.main?.nodes.board;
- * ```
- */
-type GraphNode = NodeInfo & {
-  outcomes: string[];
-  slot?: string;
-  subFlow?: string;
-  owner?: string;
-};
-/**
- * Inspection of the running graph.
- *
- * @example
- * ```ts
- * const { path, pending }: FlowState = app.flow.state();
- * ```
- */
-type FlowState = {
-  running: boolean;
-  path: string;
-  stack: readonly Frame[];
-  pending: {
-    fx?: string;
-    gate?: readonly string[];
-  };
-  mode: "live" | "fast";
-};
-/**
- * Stages of entering a node: `assets` preloads at `load`, `scenes` switches at `scene`.
- *
- * @example
- * ```ts
- * const stage: Stage = "load";
- * ```
- */
-type Stage = "load" | "scene";
-/**
- * Callback of `onEnter`. Called before `node.run`, awaited.
- *
- * @example
- * ```ts
- * const preloadNode: EnterCallback = (node, { signal }) => assets.preload(node.path, signal);
- * ```
- */
-type EnterCallback = (node: NodeInfo, ctx: {
-  mode: "live" | "fast";
-  signal: AbortSignal;
-}) => void | Promise<void>;
-/**
- * The seam the fast walk and `restore` steer the running loop with. It stays absent while the
- * game just runs: `walk.ts` and `restore` create it through `loopSeam` when they need it.
- *
- * @example
- * ```ts
- * loopSeam(ctx.state.runner).substitutions.set("level", { outcome: "win", payload: null });
- * ```
- */
-type LoopSeam = {
-  /** Sub-flow results a walk substitutes, by path. The loop takes each one once. */substitutions: Map<string, Result>; /** Called with the path every time the loop enters a rest node. */
-  rest: ((path: string) => void)[]; /** Called every time the loop opens the gate of a rest node. The walk waits on it. */
-  gateOpen: (() => void)[]; /** The bookmark the loop enters at the next turn. */
-  restoring: Bookmark | undefined;
-};
-/**
- * runner module state.
- *
- * @example
- * ```ts
- * const runner: RunnerState = createRunnerState();
- * ```
- */
-type RunnerState = {
-  /** Flush started by a background pause. `onStop` awaits it. */flushing: Promise<void> | undefined; /** Every reachable or registered flow by id. */
-  flows: Map<string, AnyFlow>;
-  enterCallbacks: Record<Stage, EnterCallback[]>; /** The position: one frame per nesting level. */
-  stack: Frame[]; /** The stack of the last rest node: the rollback target. */
-  restFrame: Frame[] | undefined; /** Edges since the last checkpoint. */
-  journal: JournalEntry[];
-  journalIndex: number; /** The promise of `run()`. `undefined`: not started. */
-  running: Promise<void> | undefined; /** Aborts the active node. */
-  abort: AbortController | undefined; /** Failed transitions in a row. */
-  failures: number; /** How `walk` and `restore` steer the loop. Absent until one of them needs it. */
-  seam?: LoopSeam;
-};
-/**
- * runner module API. Its methods are spread onto the plugin root: `app.flow.run()`.
- *
- * @example
- * ```ts
- * createApp({ onStart: ctx => { ctx.flow.run().catch(showFatal); } });
- * ```
- */
-type RunnerApi = {
-  run(): Promise<void>;
-  register(flow: AnyFlow): void;
-  onEnter(stage: Stage, callback: EnterCallback): () => void;
-  walk(route: readonly RouteStep[], options?: {
-    from?: Bookmark;
-  }): Promise<FlowState>;
-  bookmark(): Bookmark;
-  restore(bookmark: Bookmark): Promise<void>;
-  describe(): FlowGraph;
-  state(): FlowState;
-  history(): readonly JournalEntry[];
-  setMode(mode: "live" | "fast"): void;
-};
-//#endregion
-//#region src/plugins/flow/features/types.d.ts
-/**
- * What a feature brings to the game. V1 keys only; keys of later milestones pass through the
- * index signature until their plugin types them.
- *
- * @example
- * ```ts
- * const description: FeatureDescription = {
- *   flows: [rewardFlow],
- *   contribute: { afterWin: { flow: rewardFlow, order: 10 } }
- * };
- * ```
- */
-type FeatureDescription = {
-  /** Nodes the feature owns. Recorded for `describe()` and hot swap. */nodes?: readonly AnyNode[]; /** Flows the feature owns. */
-  flows?: readonly AnyFlow[]; /** Slot name to the sub-flow run in that slot. */
-  contribute?: Record<string, {
-    flow: AnyFlow;
-    order: number;
-    when?: (snapshot: Snapshot) => boolean;
-  }>;
-  [later: string]: unknown;
-};
-/**
- * One sub-flow contributed to a slot.
- *
- * @example
- * ```ts
- * const [first]: readonly Contribution[] = app.flow.features.contributions("afterWin");
- * ```
- */
-type Contribution = {
-  feature: string;
-  flow: AnyFlow;
-  order: number;
-  when?: (snapshot: Snapshot) => boolean;
-};
-/**
- * features module state.
- *
- * @example
- * ```ts
- * const features: FeaturesState = createFeaturesState();
- * ```
- */
-type FeaturesState = {
-  byName: Map<string, FeatureDescription>; /** True after `run()`: `register` throws. */
-  sealed: boolean;
-};
-/**
- * features module API.
- *
- * @example
- * ```ts
- * ctx.require(flowPlugin).features.register("board", description);
- * ```
- */
-type FeaturesApi = {
-  register(name: string, description: FeatureDescription): void;
-  all(): readonly {
-    name: string;
-    description: FeatureDescription;
-  }[];
-  contributions(slotName: string): readonly Contribution[];
-};
-//#endregion
-//#region src/plugins/flow/runner/define.d.ts
-/**
- * Creates a type tag: a value that carries only a payload type. Without a type argument the
- * payload is `void`. The tag never infers its type from the place it is written in.
- *
- * @returns A tag that carries the payload type and no value.
- * @example
- * ```ts
- * const outcomes = { done: type(), orderComplete: type<{ rewardId: string }>() };
- * ```
- */
-declare function type<Payload = void>(): TypeTag<NoInfer<Payload>>;
-/**
- * Defines a flow. The edge table is inferred as written and checked entry by entry: a missing
- * edge, an unknown target and a payload that does not fit are compile errors with a sentence.
- *
- * @param id - Flow id, unique in the game.
- * @param spec - Nodes, start node, edge table, and input and outcomes when used as a node.
- * @returns The flow as plain data.
- * @example
- * ```ts
- * const mainFlow = defineFlow("main", {
- *   nodes: { boot, home },
- *   start: "boot",
- *   edges: { boot: { done: "home" }, home: { play: "boot" } }
- * });
- * ```
- */
-declare function defineFlow<Nodes extends NodeTable, Input = void, const FlowTags extends OutcomeTags = Record<never, never>, const Table = Record<never, never>>(id: string, spec: FlowSpec<Nodes, Input, FlowTags, Table>): FlowDefinition<Input, FlowTags, Nodes>;
-/**
- * Edge target: leave the sub-flow with this outcome. The payload passes through to the parent.
- *
- * @param outcome - Outcome declared by the flow.
- * @returns The exit target as plain data.
- * @example
- * ```ts
- * edges: { play: { win: exit("win"), lose: exit("lose") } }
- * ```
- */
-declare function exit<const Name extends string>(outcome: Name): Exit<Name>;
-/**
- * Edge target: adapt the payload on the edge. The mapper's parameter is annotated by the author;
- * the annotation is checked against the outcome payload, the result against the target's input.
- *
- * @param target - Name of a node of the same flow.
- * @param map - Pure function from the outcome payload to the target's input.
- * @returns The mapped target as plain data.
- * @example
- * ```ts
- * edges: { loadCore: { failed: to("retry", (failure: { reason: string }) => ({ why: failure.reason })) } }
- * ```
- */
-declare function to<const TargetName extends string, Payload, Output>(target: TargetName, map: (payload: Payload) => Output): Mapped<TargetName, Payload, Output>;
-/**
- * Defines an extension point: a node whose body is "run the contributions of this slot in order".
- * Its single outcome is `done`.
- *
- * @param name - Slot name features contribute to.
- * @returns The slot node as plain data.
- * @example
- * ```ts
- * const afterWin = slot("afterWin");
- * ```
- */
-declare function slot(name: string): SlotNode;
-declare namespace types_d_exports {
-  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api, Bookmark, CheckedEdges, Config, Contribution, DefineNode, Deps, Descriptor, Edges, EnterCallback, Events, Exit, FeatureDescription, FeaturePlugin, FeaturesApi, FlowCtx, FlowDefinition, FlowGraph, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GuideOptions, Hint, InboxApi, JournalEntry, KernelSlice, Kit, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, OutcomeTags, Result, RouteStep, RunnerApi, SlotNode, Stage, State, Target, TypeTag, WorldEvent };
-}
-/**
- * flow plugin events.
- *
- * @example
- * ```ts
- * hooks: { "flow:rest": ({ path, checkpoint }) => track(path, checkpoint) }
- * ```
- */
-type Events = {
-  /** An edge was taken and its state committed. */"flow:edge": {
-    flow: string;
-    node: string;
-    outcome: string;
-    payload: Json;
-    next: string;
-    patches: {
-      doc: Patch[];
-      session: Patch[];
-    };
-    index: number;
-    now: number;
-  }; /** The graph reached a rest node. */
-  "flow:rest": {
-    path: string;
-    checkpoint: boolean;
-  }; /** A node failed and the graph rolled back. */
-  "flow:error": {
-    path: string;
-    error: unknown;
-    rolledBackTo: string;
-    retry: boolean;
-  };
-};
-/**
- * flow plugin config.
- *
- * @example
- * ```ts
- * createApp({ pluginConfigs: { flow: { mainFlow, safeNode: "home" } } });
- * ```
- */
-type Config = {
-  /** 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. */
-  settleTimeoutMs: number; /** Journal entries kept between checkpoints. */
-  journalLimit: number;
-};
-/**
- * flow plugin state: one branch per module.
- *
- * @example
- * ```ts
- * const state: State = createFlowState({ global, config });
- * ```
- */
-type State = {
-  features: FeaturesState;
-  fx: FxState;
-  gate: GateState;
-  inbox: InboxState;
-  runner: RunnerState;
-};
-/**
- * flow plugin API: the runner on the root, the other modules grouped.
- *
- * @example
- * ```ts
- * const flow: Api = ctx.require(flowPlugin);
- * flow.gate.answer({ intent: "play" });
- * ```
- */
-type Api = RunnerApi & {
-  gate: GateApi;
-  inbox: InboxApi;
-  fx: FxApi;
-  features: FeaturesApi;
-};
-/**
- * Resolved dependency APIs.
- *
- * @example
- * ```ts
- * const deps: Deps = resolveDeps(ctx);
- * deps.clock.now();
- * ```
- */
-type Deps = {
-  time: Api$4;
-  model: Api$2;
-  clock: Api$1;
-};
-/**
- * What the kernel context offers before the deps are attached.
- * `emit` is one plain method overload per event on purpose: `flow` has dependencies with events,
- * and both a property-typed and a generic `emit` break the kernel's event inference when a
- * factory is passed to `createPlugin` by direct reference (`api`, `hooks`, `onInit`, `onStart`).
- *
- * @example
- * ```ts
- * export function createFlowApi(ctx: KernelSlice): Api;
- * ```
- */
-type KernelSlice = Omit<PluginCtx<Config, State, Events>, "emit"> & {
-  emit(name: "flow:edge", payload: Events["flow:edge"]): void;
-  emit(name: "flow:rest", payload: Events["flow:rest"]): void;
-  emit(name: "flow:error", payload: Events["flow:error"]): void;
-  readonly global: object;
-  readonly log: Log.LogApi;
-  readonly require: Require;
-};
-/**
- * Domain context shared by the modules.
- *
- * @example
- * ```ts
- * const flowCtx: FlowCtx = { ...ctx, deps: resolveDeps(ctx) };
- * ```
- */
-type FlowCtx = KernelSlice & {
-  readonly deps: Deps;
-};
-/**
- * Payload of the one event flow listens to.
- *
- * @example
- * ```ts
- * const onChanged = (payload: LifecycleChanged) => payload.resumed;
- * ```
- */
-type LifecycleChanged = Events$2["lifecycle:changed"];
-/**
- * The types of one game. `player` and `session` type the node context; `assets` and `strings`
- * are accepted now and used from later milestones.
- *
- * @example
- * ```ts
- * type Types = { player: Player; session: Session; assets: AssetKey; strings: StringTable };
- * ```
- */
-type GameTypes = {
-  player: Json;
-  session: Json;
-  assets: string;
-  strings: Record<string, unknown>;
-};
-/**
- * A feature is an ordinary plugin with no API of its own; `AnyPluginInstance` is the kernel's
- * widened type for plugin lists. `logicOnly` is the same plugin reduced to the V1 keys.
- *
- * @example
- * ```ts
- * createApp({ plugins: [boardFeature.logicOnly] });
- * ```
- */
-type FeaturePlugin = AnyPluginInstance & {
-  readonly logicOnly: AnyPluginInstance;
-};
-/**
- * The flow helpers returned by `defineGame`. `defineNode` sees `player` and `session` with the
- * game's types; at run time they are the same functions the plugin exports.
- *
- * @example
- * ```ts
- * const kit: Kit<Types> = defineGame<Types>();
- * ```
- */
-type Kit<Types extends GameTypes> = {
-  defineNode: DefineNode<{
-    player: Types["player"];
-    session: Types["session"];
-  }>;
-  defineFlow: typeof defineFlow;
-  defineFeature: (name: string, description: FeatureDescription) => FeaturePlugin;
-};
-//#endregion
-export { Patch as A, PauseReason as B, State$1 as C, Root as D, Json as E, StoreApi as F, State$4 as G, types_d_exports$3 as H, RngApi as I, Events$3 as J, types_d_exports$4 as K, RngState as L, ProviderCall as M, SaveDoc as N, State$2 as O, SaveUnreadableError as P, Api$3 as R, FakeClock as S, Config$2 as T, Api$4 as U, State$3 as V, Config$4 as W, GuideOptions as _, Kit as a, Api$1 as b, exit as c, type as d, FeatureDescription as f, Descriptor as g, RouteStep as h, GameTypes as i, PlayerStateProvider as j, types_d_exports$2 as k, slot as l, JournalEntry as m, Config as n, State as o, FlowState as p, Config$5 as q, FeaturePlugin as r, types_d_exports as s, Api as t, to as u, Hint as v, types_d_exports$1 as w, Config$1 as x, Answer as y, Config$3 as z };