@moku-labs/game 0.15.39 → 0.15.41

package/dist/{types-C_dk-lXz.d.mts → types-DrkR03nL.d.mts}

@@ -2618,21 +2618,25 @@ type NodeSpec<Game extends GameState, Input, Tags extends OutcomeTags> = {
  */
 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`.
+ * An extension point inside a flow: a node whose body is "run the contributions in order". Its
+ * outcomes are `done` and the named outcomes `slot()` declares, so the flow that holds it routes
+ * each of them with an ordinary edge. Without type arguments it is a slot that declares none.
  *
  * @example
  * ```ts
- * const afterOrder: SlotNode = slot("afterOrder");
+ * // A feature may send the player from the slot to the shop, on the tab it names.
+ * const afterOrder: SlotNode<{ shop: TypeTag<{ tab: string }> }, "afterOrder"> = slot("afterOrder", {
+ *   shop: type<{ tab: string }>()
+ * });
  * // { kind: "slot", name: "afterOrder", input: { kind: "type" },
- * //   outcomes: { done: { kind: "type" } } }
+ * //   outcomes: { done: { kind: "type" }, shop: { kind: "type" } } }
  * ```
  */
-type SlotNode = Wired<void, {
+type SlotNode<Tags extends OutcomeTags = Record<never, never>, Name extends string = string> = Wired<void, {
   readonly done: TypeTag<void>;
-}> & {
+} & Tags> & {
   readonly kind: "slot";
-  readonly name: string;
+  readonly name: Name;
 };
 /**
  * Edge target that leaves the sub-flow with this outcome. The payload passes through.
@@ -2774,6 +2778,32 @@ type CheckTarget<Nodes extends NodeTable, FlowTags extends OutcomeTags, NodeName
  * ```
  */
 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.`> };
+/**
+ * Checks one outcome `Outcome` of the contributed flow `Contributed` against the slot `Host`:
+ * `never` when it is `done`, or an outcome the slot declares whose payload fits; a `GraphError`
+ * sentence otherwise.
+ */
+type OutcomeFit<Contributed extends AnyFlow, Host extends SlotNode<OutcomeTags, string>, Outcome extends keyof Contributed["outcomes"]> = Outcome extends "done" ? never : Outcome extends Exclude<keyof Host["outcomes"], "done"> ? Accepts<PayloadOf<Contributed["outcomes"][Outcome]>, PayloadOf<Host["outcomes"][Outcome]>> extends true ? never : GraphError<`Payload of outcome "${Outcome & string}" does not fit slot "${Host["name"]}".`> : GraphError<`Slot "${Host["name"]}" declares no outcome "${Outcome & string}".`>;
+/**
+ * The outcomes of `Contributed` that do not fit the slot `Host`, as `GraphError` sentences, or
+ * `never` when every outcome fits.
+ */
+type MisfitOutcomes<Contributed extends AnyFlow, Host extends SlotNode<OutcomeTags, string>> = { [Outcome in keyof Contributed["outcomes"]]: OutcomeFit<Contributed, Host, Outcome> }[keyof Contributed["outcomes"]];
+/**
+ * Checking type of `contribution()`: whether the flow `Contributed` fits the slot `Host`. Every
+ * outcome of the flow is `done`, or an outcome the slot declares whose payload fits; then it is
+ * `unknown`, otherwise the `GraphError` sentence of the misfit. A slot that declares no outcome
+ * accepts any flow, and a flow without outcomes fits any slot.
+ *
+ * @example
+ * ```ts
+ * // episodeStep = slot("episodeStep", { shop: type<{ tab: string }>() })
+ * type Fitting = Fits<typeof storyFlow, typeof episodeStep>; // unknown: outcomes done and shop
+ * type Misfit = Fits<typeof giftFlow, typeof episodeStep>; // giftFlow exits "gift":
+ * // GraphError<'Slot "episodeStep" declares no outcome "gift".'>
+ * ```
+ */
+type Fits<Contributed extends AnyFlow, Host extends SlotNode<OutcomeTags, string>> = [Exclude<keyof Host["outcomes"], "done">] extends [never] ? unknown : [MisfitOutcomes<Contributed, Host>] extends [never] ? unknown : MisfitOutcomes<Contributed, Host>;
 /**
  * A flow as `defineFlow` returns it: plain data. A flow that declares `input` and `outcomes`
  * is used as a node of another flow.
@@ -3118,7 +3148,13 @@ type RunnerState = {
    * transit nodes, so `bookmark()` writes its `rest` only when these frames name a rest node.
    */
   restFrame: Frame[] | undefined; /** Inside a slot: the contribution the loop just finished. The slot continues after it. */
-  slotAfter: string | undefined; /** Edges since the last checkpoint. */
+  slotAfter: string | undefined; /** Inside a slot: the declared outcome a contribution left on. The slot takes its edge next. */
+  slotLeave: {
+    outcome: string;
+    payload: Json;
+  } | undefined; /** Edges committed since the loop last arrived at a rest node. */
+  restless: number; /** Edges without a rest node after which the next one fails: `max(64, 4 × expanded nodes)`. */
+  restlessCap: number; /** Edges since the last checkpoint. */
   journal: JournalEntry[];
   journalIndex: number; /** The promise of `run()`. `undefined`: not started. */
   running: Promise<void> | undefined; /** Aborts the active node. */
@@ -3442,12 +3478,19 @@ type FeatureTextStyles = {
  */
 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;
-  }>;
+  flows?: readonly AnyFlow[];
+  /**
+   * Slot name to the sub-flow run in that slot. Written by hand, an entry is checked by name at
+   * `run()`; `...contribution(slot, spec)` also checks its outcomes against the slot at compile time.
+   *
+   * @example
+   * ```ts
+   * // The story runs in the slot "episodeStep" and may leave it on one of the slot's outcomes.
+   * contribute: { ...contribution(episodeStep, { flow: storyFlow, order: 10 }) }
+   * // { episodeStep: { flow: storyFlow, order: 10 } }
+   * ```
+   */
+  contribute?: Record<string, ContributionSpec>;
   /**
    * Sub-features this feature declares, each in a folder of its own inside this feature's folder,
    * in the order they are composed. `defineGameApp` composes them right after this feature; this
@@ -3483,19 +3526,37 @@ type FeaturePlugin = AnyPluginInstance & {
   readonly features: readonly FeaturePlugin[];
 };
 /**
- * One sub-flow contributed to a slot.
+ * One entry of a feature's `contribute`: the sub-flow a slot runs, its place among the slot's
+ * contributions (lowest `order` first) and the `when` that may skip it. `when` reads the committed
+ * state. `contribution(slot, spec)` builds the entry under the slot's name.
  *
  * @example
  * ```ts
- * const contribution: Contribution = { feature: "reward", flow: rewardFlow, order: 10 };
+ * // The story of episode 1 runs in the slot "episodeStep" while the player is in episode 1.
+ * // `episodeOf` is the game's reader of the committed player tree.
+ * const story: ContributionSpec = {
+ *   flow: storyFlow,
+ *   order: 10,
+ *   when: snapshot => episodeOf(snapshot.player) === "ep01"
+ * };
  * ```
  */
-type Contribution = {
-  feature: string;
+type ContributionSpec = {
   flow: AnyFlow;
   order: number;
   when?: (snapshot: Snapshot) => boolean;
 };
+/**
+ * One sub-flow contributed to a slot, with the feature that contributed it.
+ *
+ * @example
+ * ```ts
+ * const contribution: Contribution = { feature: "reward", flow: rewardFlow, order: 10 };
+ * ```
+ */
+type Contribution = ContributionSpec & {
+  feature: string;
+};
 /**
  * features module state.
  */
@@ -3652,20 +3713,55 @@ declare function exit<const Name extends string>(outcome: Name): Exit<Name>;
 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`.
+ * Its outcomes are `done` and the ones declared here; the flow that holds the slot gives each an
+ * edge. A contribution that exits `done` hands over to the next contribution whose `when` holds,
+ * and with none left the slot takes its `done` edge. A contribution that exits a declared outcome
+ * leaves the slot at once with its payload: the later contributions do not run, and the slot takes
+ * its own edge of that outcome, journalled like `done`. The next entry of the slot starts again at
+ * its first contribution. Without `outcomes` the slot declares only `done`.
  *
  * @param name - Slot name features contribute to.
+ * @param outcomes - The named outcomes besides `done`, with the type tag of each payload.
  * @returns The slot node as plain data.
+ * @throws {TypeError} When `outcomes` declares `done`, which is every slot's own outcome.
  * @example
  * ```ts
- * // The main flow leaves room after a finished order. Features contribute sub-flows to it.
- * nodes: { boot, home, board: boardFlow, afterOrder: slot("afterOrder") }
- * // slot("afterOrder"): { kind: "slot", name: "afterOrder", input: …, outcomes: { done: … } }
+ * // After an order a feature may send the player to the shop, on the tab it names.
+ * slot("afterOrder", { shop: type<{ tab: string }>() });
+ * // { kind: "slot", name: "afterOrder", input: { kind: "type" },
+ * //   outcomes: { done: { kind: "type" }, shop: { kind: "type" } } }
  * ```
  */
-declare function slot(name: string): SlotNode;
+declare function slot<const Name extends string, const Tags extends OutcomeTags = Record<never, never>>(name: Name, outcomes?: Tags & {
+  readonly done?: never;
+}): SlotNode<Tags, Name>;
+/**
+ * Builds one typed entry of a feature's `contribute`: the flow a slot runs, under the slot's
+ * name. The compiler checks every outcome of the flow: `done`, or an outcome the slot declares
+ * whose payload fits; a slot that declares none accepts any flow. A raw `contribute` entry stays
+ * valid and is checked by name at `run()` only.
+ *
+ * @param host - The slot node the flow runs in, as `slot()` returned it.
+ * @param spec - The flow, its `order` among the slot's contributions and an optional `when`.
+ * @param spec.flow - The contributed flow; an outcome the slot does not take is a compile error.
+ * @param spec.order - Place among the contributions of the slot, lowest first.
+ * @param spec.when - Skips the contribution while it returns false, read on the committed state.
+ * @returns `{ [host.name]: spec }`, spread into `contribute`; no `when` key when none was given.
+ * @example
+ * ```ts
+ * // The story feature fills the episode step of the main flow: spread the entry into contribute.
+ * contribution(episodeStep, { flow: storyFlow, order: 10 });
+ * // { episodeStep: { flow: storyFlow, order: 10 } }
+ * contribute: { ...contribution(episodeStep, { flow: storyFlow, order: 10 }) }
+ * ```
+ */
+declare function contribution<S extends SlotNode<OutcomeTags, string>, F extends AnyFlow>(host: S, spec: {
+  flow: F & Fits<F, S>;
+  order: number;
+  when?: (snapshot: Snapshot) => boolean;
+}): Readonly<Record<S["name"], ContributionSpec>>;
 declare namespace types_d_exports$4 {
-  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$4 as Config, Contribution, DefineNode, Deps$4 as Deps, Descriptor, Edges, Effect, EffectHandler, EffectOptions, EmitterIdOf, EnterCallback, Events$4 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeatureTree, FeaturesApi, FlowCtx, FlowDefinition, FlowEntry, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, HudKeysOf, InboxApi, JournalEntry, KernelSlice$4 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, NodeTable, OutcomeTags, Position, RecoverContext, RegisteredFeature, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$4 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
+  export { Allow, Answer, AnyFlow, AnyNode, AnyNodeContext, Api$3 as Api, Bookmark, BundlesOf, CheckedEdges, Config$4 as Config, Contribution, ContributionSpec, DefineNode, Deps$4 as Deps, Descriptor, Edges, Effect, EffectHandler, EffectOptions, EmitterIdOf, EnterCallback, Events$4 as Events, Exit, FeatureDescription, FeatureEmitter, FeatureFilter, FeaturePlugin, FeatureTree, FeaturesApi, FlowCtx, FlowDefinition, FlowEntry, FlowGraph, FlowKit, FlowSpec, FlowState, FxApi, FxHandler, GameState, GameTypes, GateApi, GraphError, GraphNode, GuideOptions, Hint, HudKeysOf, InboxApi, JournalEntry, KernelSlice$4 as KernelSlice, LifecycleChanged, Mapped, NodeContext, NodeDefinition, NodeFx, NodeInfo, NodeSpec, NodeTable, OutcomeTags, Position, RecoverContext, RegisteredFeature, Result, RouteStep, RunnerApi, SceneIdOf, SlotNode, Stage, State$4 as State, StringTableLike, Target, TextStylesOf, TypeTag, WorldEvent };
 }
 /**
  * flow plugin events.
@@ -9320,7 +9416,7 @@ type PictureRequest = {
   reject: (error: Error) => void;
 };
 declare namespace types_d_exports$2 {
-  export { AdaptiveScale, Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, MonitorSections, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfCounts, PerfDisplay, PerfEventLine, PerfEventName, PerfGapLine, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfTelemetryLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiMesh, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, PixiTextureSource, Point, PoolTrim, PoolTrimDetail, ProblemEventDetail, ProblemRule, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, ShaderEventDetail, ShaderWhat, SliceFrame, State$2 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState, WarmDetail };
+  export { AdaptiveScale, Api$1 as Api, AspectRange, BitmapFontData, CaptureOptions, Captured, Config$2 as Config, CountingClasses, CoverFrame, CreateTextureOptions$1 as CreateTextureOptions, DebugApi, DebugSwitches, DemandFrame, DemandModule, DemandReason, DemandState, Deps$2 as Deps, DisplayAdapter, DisplayEntry, DisplaysApi, DrawCounter, Events$2 as Events, FilterCache, FilterSlot, FilterSlotInputs, FiltersApi, FontsApi, FrameColumns, FrameReadResult, FrameReadout, FrameRecord, FrameRing, HitBox, HostApi, HostInternal, HostModule, HostState, HudPartValue, KeptInternal, KeptModule, KeptRange, KeptState, KeptStats, KernelSlice$2 as KernelSlice, LayerEntry, LeaveApi, LeaveCover, LeaveLoader, LeaveLook, LegendEntry, LongFrameEntry, Modules, MonitorApi, MonitorConfig, MonitorCounts, MonitorDeps, MonitorInternal, MonitorModule, MonitorSections, MonitorState, NineBorders$1 as NineBorders, Orientation, OverlayEventDetail, OverlayLevelValue, OverlayMode, OverlayPhase, OverlayReport, OverlayValue, OverlayWhat, PassKind, PassRecord, PerfCause, PerfChange, PerfChangeEntry, PerfCollectorLine, PerfCounts, PerfDisplay, PerfEventLine, PerfEventName, PerfGapLine, PerfHeaderLine, PerfLogLine, PerfLongFrameLine, PerfMarkLine, PerfMeasured, PerfMonitorApi, PerfSampleLine, PerfSpikeLine, PerfStartupLine, PerfTelemetryLine, PerfThermalLine, PictureRect, PixiApplication, PixiBitmapFont, PixiBounds, PixiContainer, PixiFilter, PixiFilterManager, PixiGraphics, PixiMatrix, PixiMesh, PixiModule, PixiNineSliceSprite, PixiRectangle, PixiRenderTexture, PixiSprite, PixiTexture, PixiTextureSource, Point, PoolTrim, PoolTrimDetail, ProblemEventDetail, ProblemRule, Rect, RenderStats, RendererCtx, RendererKind, SafeArea, ShaderEventDetail, ShaderWhat, SliceFrame, State$2 as State, SyncApi, SyncCounts, SyncInternal, SyncModule, SyncState, TeardownScope, TextureProvider, TextureUsage, TexturesApi, Under, View, ViewKind, ViewportApi, ViewportInternal, ViewportModule, ViewportSize, ViewportState, WarmDetail };
 }
 /**
  * The part of Pixi the engine uses: the classes `sync` builds views from (a `Rectangle` frames the
@@ -10874,6 +10970,158 @@ type DebugApi = {
    */
   state(): DebugSwitches;
 };
+/**
+ * The veil of a scene being left, every field resolved: a full-canvas rect in one colour that fades from 0 to `alpha`
+ * over `inMs` from the switch start, and back to 0 over `outMs` after the swap.
+ *
+ * @example
+ * ```ts
+ * // A game that writes nothing: black at 45 %, 150 ms in, 150 ms out.
+ * const cover: LeaveCover = { color: 0x000000, alpha: 0.45, inMs: 150, outMs: 150 };
+ * ```
+ */
+type LeaveCover = {
+  /** The colour of the veil, `0xRRGGBB`. */color: number; /** The alpha the veil fades in to, 0 to 1. */
+  alpha: number; /** Clock milliseconds from 0 to `alpha`; 0 shows it at once. */
+  inMs: number; /** Clock milliseconds from where it stands at the swap back to 0; 0 takes it away at once. */
+  outMs: number;
+};
+/**
+ * The loader of a scene being left, drawn above the veil when the switch is not done `afterMs` after its start, until
+ * the swap: a game texture turning at the centre (`texture`), a layer of the scene drawn above the veil (`due`, which
+ * makes what the loader draws only once it is due and answers its layer: `scenes` mounts a loader projection there),
+ * or, with neither, a white ring the engine draws.
+ *
+ * @example
+ * ```ts
+ * const ring: LeaveLoader = { afterMs: 400 };
+ * const spinner: LeaveLoader = { afterMs: 400, texture: "ui.loader.ring" };
+ * // The layer "loading" above the veil, its views made only if the switch takes 250 ms.
+ * const screen: LeaveLoader = { afterMs: 250, due: () => "loading" };
+ * ```
+ */
+type LeaveLoader = {
+  /** Clock milliseconds after the switch start the loader waits for. */afterMs: number; /** An asset key: the texture turns at the centre of the frame. A key no provider answers draws the ring. */
+  texture?: string;
+  /**
+   * Called once, in the first frame the loader is due and before it is drawn, never for a switch done sooner: it
+   * makes what the loader draws and answers the layer of the scene that holds it, whose container is drawn above the
+   * veil from then until the swap. `undefined`, or a throw, draws the ring; a layer the scene does not declare draws
+   * nothing.
+   *
+   * @returns The layer, or `undefined` for the ring.
+   */
+  due?: () => string | undefined;
+};
+/**
+ * What a scene switch shows over the scene being left: the veil, the loader, or both. A part left out is not drawn.
+ *
+ * @example
+ * ```ts
+ * // The default of `scenes`: the veil from the start, the engine's ring once the switch took 400 ms.
+ * const look: LeaveLook = { cover: { color: 0x000000, alpha: 0.45, inMs: 150, outMs: 150 }, loader: { afterMs: 400 } };
+ * ```
+ */
+type LeaveLook = {
+  /** The veil; absent for none. */cover?: LeaveCover; /** The loader; absent for none. */
+  loader?: LeaveLoader;
+};
+/**
+ * The picture of a scene being left, `app.renderer.sync.leave` (spec 33, slice A2): a veil over the whole canvas and a
+ * loader at its centre, drawn in a container of the engine above the root and every layer. `scenes` drives it: it
+ * shows it at the start of a live switch, lands it at the swap and drops it on an abort. It takes no hit: the hit test
+ * walks the layers of the scene only.
+ *
+ * @example
+ * ```ts
+ * // `scenes`, at the start of a switch from the ward, whose bundles are still loading.
+ * const renderer = ctx.require(rendererPlugin);
+ * renderer.sync.leave.show({ cover: { color: 0x000000, alpha: 0.45, inMs: 150, outMs: 150 }, loader: { afterMs: 400 } });
+ * renderer.sync.leave.land(); // the board stands: the veil fades out over 150 ms, the ring is gone
+ * ```
+ */
+type LeaveApi = {
+  /**
+   * Shows a look from now: the veil fades in from where it stands (0, or the level of a veil still fading out after
+   * the last swap), the loader waits for its `afterMs`. A look shown while another runs replaces it. Asks for a frame.
+   * Inert, nothing is drawn and nothing is kept.
+   *
+   * @param look - The veil and the loader, resolved.
+   * @example
+   * ```ts
+   * // `scenes` leaves a scene whose `leave` names a turning texture: the veil from the next frame, the texture at 400 ms.
+   * ctx.require(rendererPlugin).sync.leave.show({
+   *   cover: { color: 0x0b1020, alpha: 0.6, inMs: 150, outMs: 150 },
+   *   loader: { afterMs: 400, texture: "ui.loader.ring" }
+   * });
+   * ```
+   */
+  show(look: LeaveLook): void;
+  /**
+   * The switch swapped the next scene in: the loader goes at once, the veil fades out over its `outMs` from where it
+   * stands and is taken off the stage. Nothing runs: nothing happens.
+   *
+   * @example
+   * ```ts
+   * // `scenes`, right after the swap to the board: the board is drawn under the veil, which is gone 150 ms later.
+   * ctx.require(rendererPlugin).sync.leave.land();
+   * ```
+   */
+  land(): void;
+  /**
+   * The switch ended without a swap (an abort, a throw): the veil and the loader go at once, in the next frame.
+   * Nothing runs: nothing happens.
+   *
+   * @example
+   * ```ts
+   * // `scenes`, when a restore aborts the switch to the board: the ward stands as it was, undimmed.
+   * ctx.require(rendererPlugin).sync.leave.drop();
+   * ```
+   */
+  drop(): void;
+};
+/**
+ * The engine's objects of the picture of a scene being left, made once per application at the first step that needs
+ * them and kept: `top` hangs on the stage above the root while a look runs; `veil` (the white texture, tinted) covers
+ * the canvas; `frame` carries the root's transform, so `ring`, `spinner` and `held` (where a lifted layer hangs) are in
+ * reference units. Not public.
+ */
+type LeaveObjects = {
+  top: PixiContainer;
+  veil: PixiSprite;
+  frame: PixiContainer;
+  ring: PixiGraphics;
+  spinner: PixiSprite;
+  held: PixiContainer;
+};
+/** What the loader of a running look draws once it is due. Not public. */
+type LoaderKind = "none" | "ring" | "texture" | "layer";
+/**
+ * A running look: the moments it started and was last stepped at on the clock, the veil's level (0 to 1, the share of
+ * its `alpha`), whether the swap came, what its loader draws and whether it shows, and the layer container it lifted
+ * above the veil. Not public.
+ */
+type LeaveRun = {
+  look: LeaveLook;
+  startedAt: number;
+  steppedAt: number;
+  level: number;
+  landed: boolean;
+  loader: LoaderKind; /** The texture of a `"texture"` loader, resolved at `show`. */
+  texture?: PixiTexture; /** A `"layer"` loader's `due` was called: once, the first frame it was due. */
+  asked: boolean; /** The layer a `"layer"` loader's `due` answered; absent before. */
+  layer?: string; /** The layer container a `"layer"` loader drew above the veil; absent while none hangs there. */
+  lifted?: PixiContainer; /** The loader is shown: past its `afterMs`, before the swap. */
+  shown: boolean;
+};
+/**
+ * The picture of a scene being left (spec 33, slice A2): the running look, absent while none runs, and the engine's
+ * objects, absent until the first look needs them and after the application that held them was lost. Not public.
+ */
+type LeaveState = {
+  run?: LeaveRun;
+  objects?: LeaveObjects;
+};
 /**
  * sync module API, `app.renderer.sync`. The one owner of every display object: it builds them
  * from components, sorts them inside the named layers of the scene and answers hit tests.
@@ -11008,6 +11256,18 @@ type SyncApi = {
    * ```
    */
   filters: FiltersApi;
+  /**
+   * The picture of a scene being left: the veil and the loader `scenes` shows during a live switch.
+   *
+   * @example
+   * ```ts
+   * // `scenes`, at the start of a switch from the ward, and at the swap to the board.
+   * const renderer = ctx.require(rendererPlugin);
+   * renderer.sync.leave.show({ cover: { color: 0x000000, alpha: 0.45, inMs: 150, outMs: 150 }, loader: { afterMs: 400 } });
+   * renderer.sync.leave.land(); // the veil fades out over the board in 150 ms
+   * ```
+   */
+  leave: LeaveApi;
   /**
    * The render passes of the frame, the number `stats().renderPasses` reports: 1 for the frame,
    * plus, for every view in the tree with an enabled filter, 1 for its content and the passes of
@@ -11114,6 +11374,12 @@ type SyncInternal = {
    */
   layerOf(entity: Entity): string | undefined; /** The overlays of this frame: modes, ranges, reasons, dims, HUD parts, and the pictures to take (spec 22). */
   stepOverlays(): void;
+  /**
+   * The picture of a scene being left, for this frame (spec 33, slice A2): the veil's level from the clock, the loader
+   * once due, both placed over the canvas as it stands; a frame is asked for while either moves. Run by the draw
+   * callback before the decision. One field read and no allocation while no look runs.
+   */
+  stepLeave(): void;
   /**
    * Hands Pixi again the filters of every view whose filters were switched on or off since they were written: Pixi
    * holds only the enabled ones (E3). Run by the draw callback before anything reads the tree, so a switch is drawn in
@@ -11561,7 +11827,8 @@ type SyncState = {
   passes: PassCount; /** The name of the scene's HUD layer (`above: "overlays"`), kept with the layers; `undefined` without one. */
   hudLayer: string | undefined; /** The building entities waiting for their view (spec 31). */
   aside: AsideQueue; /** The held tops of the scene build, attached in the pass after its commit (spec 31). */
-  heldViews: HeldViews;
+  heldViews: HeldViews; /** The picture of a scene being left: the running look and the engine's objects (spec 33, slice A2). */
+  leave: LeaveState;
   cleanups: Array<() => void>;
 };
 /**
@@ -11596,7 +11863,7 @@ type PassCount = {
   enabled: boolean[];
 };
 declare namespace types_d_exports$1 {
-  export { AnySceneProjection, CheckedProjections, Config$1 as Config, DefineScene, Deps$1 as Deps, Events$1 as Events, KernelSlice$1 as KernelSlice, LayerMap, RunContext, SceneBuild, SceneDefinition, SceneLayer, SceneOwner, SceneProjection, SceneSpec, SceneState, ScenesApi, ScenesCtx, SortRule, State$1 as State, UiLayer };
+  export { AnySceneProjection, CheckedProjections, Config$1 as Config, DefineScene, Deps$1 as Deps, Events$1 as Events, FullCover, FullLeave, FullLoader, KernelSlice$1 as KernelSlice, LayerMap, Leaving, RunContext, SceneBuild, SceneCover, SceneDefinition, SceneLayer, SceneLeave, SceneLoader, SceneOwner, SceneProjection, SceneSpec, SceneState, ScenesApi, ScenesCtx, SortRule, State$1 as State, UiLayer };
 }
 /**
  * How a layer orders what is drawn in it. The scene's name for the rule `world` stores.
@@ -11696,6 +11963,65 @@ type CheckedProjection<Layer extends string, Spec> = Spec extends {
  * ```
  */
 type CheckedProjections<Layer extends string, List> = { readonly [Index in keyof List]: CheckedProjection<Layer, List[Index]> };
+/**
+ * The veil a live switch lays over the scene being left, from the switch start: a full-screen rect the engine draws
+ * above every layer, fading from 0 to `alpha` over `inMs`; after the swap the next scene is under it and it fades out
+ * over `outMs`. It takes no tap. A field left out keeps the one of the level below: the scene's over the config's over
+ * the engine's.
+ *
+ * @example
+ * ```ts
+ * // A navy veil at 60 %, the engine's 150 ms in and out.
+ * const cover: SceneCover = { color: 0x0b1020, alpha: 0.6 };
+ * ```
+ */
+type SceneCover = {
+  /** Colour of the veil, `0xRRGGBB`. Default `0x000000`. */color?: number; /** The alpha it fades in to, 0 to 1. Default 0.45. */
+  alpha?: number; /** Milliseconds from 0 to `alpha`, from the switch start. Default 150. */
+  inMs?: number; /** Milliseconds back to 0 after the swap. Default 150. */
+  outMs?: number;
+};
+/**
+ * What a live switch shows above the veil when it is not done `afterMs` after its start, until the swap: a game
+ * texture turning at the centre (`texture`), a projection of the game drawn above the veil (`projection`), or, with
+ * neither, a white ring the engine draws. `texture` and `projection` are one choice: a level that names either replaces
+ * both of the level below, and with both named `projection` is drawn. A projection loader draws in a layer of its own
+ * that the scene being left declares, mounted only once the loader is due: the whole layer is drawn above the veil
+ * while the loader shows.
+ *
+ * @example
+ * ```ts
+ * // The game's ring texture, shown once the switch took 400 ms.
+ * const loader: SceneLoader<"ui.loader.ring"> = { texture: "ui.loader.ring" };
+ * // The game's own loading screen, the projection "loading" in the layer "loading", after 250 ms.
+ * const screen: SceneLoader = { afterMs: 250, projection: "loading" };
+ * ```
+ */
+type SceneLoader<Asset extends string = string> = {
+  /** Milliseconds after the switch start the loader waits for. Default 400. */afterMs?: number; /** An asset key of the game: the texture turns at the centre of the frame. */
+  texture?: Asset; /** The name of a registered projection: mounted once the loader is due, its layer drawn above the veil. */
+  projection?: string;
+};
+/**
+ * What a live switch shows over the scene being left: the veil and the loader. The scene being left decides: its
+ * `leave` is merged field by field over `config.leave`, which is merged over the engine's default (`{ cover: { color:
+ * 0x000000, alpha: 0.45, inMs: 150, outMs: 150 }, loader: { afterMs: 400 } }`). `false` turns a part or the whole off;
+ * a part written over `false` starts from the engine's default. Fast mode, a headless app and the first scene of a run
+ * show nothing.
+ *
+ * @example
+ * ```ts
+ * // The board leaves under a navy veil with the game's ring texture; the ward leaves with nothing at all.
+ * const board: SceneLeave<"ui.loader.ring"> = { cover: { color: 0x0b1020, alpha: 0.6 }, loader: { texture: "ui.loader.ring" } };
+ * const ward: SceneLeave = false;
+ * // The veil without a loader.
+ * const quiet: SceneLeave = { loader: false };
+ * ```
+ */
+type SceneLeave<Asset extends string = string> = {
+  cover?: SceneCover | false;
+  loader?: SceneLoader<Asset> | false;
+} | false;
 /**
  * What the author passes to `defineScene`. The layer names come from the keys of `layers` plus
  * the appended `ui`; `NoInfer` keeps `projections` out of that inference, so a wrong name is
@@ -11727,7 +12053,8 @@ type SceneSpec<Layers extends LayerMap, Projections extends readonly AnyScenePro
   bundles?(state: SceneState<Player, Session>): readonly Bundle[];
   layers: Layers;
   projections: Projections & NoInfer<CheckedProjections<SceneLayer<Layers>, Projections>>;
-  music?: Asset;
+  music?: Asset; /** What a live switch shows over this scene when it is left: merged field by field over `config.leave`. */
+  leave?: SceneLeave<Asset>;
 };
 /**
  * The signature of `defineScene` bound to the asset and bundle keys and to the `Player` and
@@ -11762,7 +12089,8 @@ type SceneDefinition = {
    * @param state - The committed `player` and `session`, frozen.
    * @returns The bundle names the scene needs on top of `bundle`.
    */
-  bundles?(state: SceneState): readonly string[];
+  bundles?(state: SceneState): readonly string[]; /** What `defineScene` was given as `leave`; absent when the scene takes the config's. */
+  readonly leave?: SceneLeave;
 };
 /**
  * The committed state a scene's `bundles` reads: the frozen `player` and `session` of `model.store.snapshot()`, never a
@@ -11791,7 +12119,8 @@ type SceneOwner = Owner & {
   name: "scenes";
 };
 /**
- * scenes plugin config. A scene is data in a feature; the one key is the budget of a live switch.
+ * scenes plugin config. A scene is data in a feature; the keys are the budget of a live switch and what it shows over
+ * the scene being left.
  *
  * @example
  * ```ts
@@ -11800,6 +12129,9 @@ type SceneOwner = Owner & {
  *
  * // A game on a slow phone gives the next scene a fixed 3 ms of each frame: the switch takes more frames.
  * const fixed: Config = { buildMs: 3 };
+ *
+ * // Every switch shows the veil and no loader.
+ * const quiet: Config = { buildMs: "auto", leave: { loader: false } };
  * ```
  */
 type Config$1 = {
@@ -11809,6 +12141,23 @@ type Config$1 = {
    * frame interval the loop runs at, `(1000 / time.rate().fps) * 2 / 3`, read once at the build start.
    */
   buildMs: number | "auto";
+  /**
+   * What a live switch shows over the scene being left, for every scene; a scene's own `leave` is merged over it field
+   * by field. A field left out keeps the engine's default, `{ cover: { color: 0x000000, alpha: 0.45, inMs: 150,
+   * outMs: 150 }, loader: { afterMs: 400 } }`; `false` turns a part or the whole off.
+   *
+   * @example
+   * ```ts
+   * // The veil a little darker for every scene, and the game's ring texture after 300 ms instead of the white ring.
+   * createApp({
+   *   plugins: [...screen, boardFeature],
+   *   pluginConfigs: { scenes: { leave: { cover: { alpha: 0.6 }, loader: { afterMs: 300, texture: "ui.loader.ring" } } } }
+   * });
+   * // No veil and no loader on any switch.
+   * createApp({ plugins: [...screen, boardFeature], pluginConfigs: { scenes: { leave: false } } });
+   * ```
+   */
+  leave?: SceneLeave;
 };
 /**
  * The running build of the next scene (spec 31): what the commit needs, and how to stop
@@ -11856,6 +12205,39 @@ type State$1 = {
    * Absent otherwise: deleted, never written as `undefined`.
    */
   build?: SceneBuild;
+  /**
+   * The veil and the loader of the running switch, from its start to its swap or its end without one. Absent
+   * otherwise: deleted, never written as `undefined`.
+   */
+  leaving?: Leaving;
+};
+/**
+ * The veil and the loader a switch showed over the scene being left (spec 33, slice A2): whether they were taken down
+ * already, the loader projection it mounted once its loader was due, and how to stop listening to the abort of its node.
+ */
+type Leaving = {
+  /** Landed or dropped: a second end does nothing. */done: boolean; /** The loader projection the switch mounted, unmounted at the end; absent while it mounted none. */
+  projection?: string; /** Removes the abort listener of the switch's node. */
+  off: () => void;
+};
+/**
+ * A veil with every field: what a level of `leave` resolves to.
+ */
+type FullCover = Required<SceneCover>;
+/**
+ * A loader with its delay and at most one look: what a level of `leave` resolves to.
+ */
+type FullLoader = {
+  afterMs: number;
+  texture?: string;
+  projection?: string;
+};
+/**
+ * What a switch shows over the scene being left, every level merged: each part resolved or off.
+ */
+type FullLeave = {
+  cover: FullCover | false;
+  loader: FullLoader | false;
 };
 /**
  * scenes plugin events.
@@ -12967,4 +13349,4 @@ type BundleCompanion = {
   unload(bundle: string): void;
 };
 //#endregion
-export { PixiModule as $, FeaturePlugin as $n, Time as $r, ShaderWhat as $t, SyncApi as A, NumericFields as An, types_d_exports$6 as Ar, PerfChange as At, ShapeValue as B, EmitterIdOf as Bn, RngState as Br, PerfLongFrameLine as Bt, SceneSpec as C, TagType as Cn, types_d_exports$5 as Cr, PERF_CAUSES as Ct, DebugSwitches as D, Motion as Dn, Json as Dr, PassKind as Dt, types_d_exports$1 as E, Ease as En, Events$5 as Er, PROBLEM_RULES as Et, NineSliceValue as F, TrackSegment as Fn, SaveUnreadableError as Fr, PerfEventLine as Ft, Transform as G, TextStylesOf as Gn, State$7 as Gr, PerfStartupLine as Gt, SpriteBlend as H, HudKeysOf as Hn, Config$7 as Hr, PerfMeasured as Ht, Overlay as I, ViewHandle as In, Snapshot as Ir, PerfEventName as It, AdaptiveScale as J, exit as Jn, Config$8 as Jr, PoolTrimDetail as Jt, TransformValue as K, types_d_exports$4 as Kn, types_d_exports$7 as Kr, PerfTelemetryLine as Kt, OverlayValue as L, Api$3 as Ln, SnapshotOf as Lr, PerfGapLine as Lt, HudPart as M, ProjectionSpec as Mn, PlayerStateProvider as Mr, PerfCollectorLine as Mt, HudPartValue as N, ReducedMotion as Nn, ProviderCall as Nr, PerfCounts as Nt, FilterSlot as O, MotionCause as On, Root as Or, PassRecord as Ot, NineSlice$1 as P, TrackOptions as Pn, SaveDoc as Pr, PerfDisplay as Pt, PixiFilter as Q, FeatureDescription as Qn, ThermalReading as Qr, ShaderEventDetail as Qt, Parent as R, BundlesOf as Rn, StoreApi as Rr, PerfHeaderLine as Rt, SceneDefinition as S, SystemFor as Sn, State$5 as Sr, OverlayWhat as St, State$1 as T, DescriptionNode as Tn, Config$6 as Tr, PERF_LOG_VERSION as Tt, SpriteOptions as U, Position as Un, Events$6 as Ur, PerfSampleLine as Ut, Sprite as V, GameTypes as Vn, Api$6 as Vr, PerfMarkLine as Vt, SpriteValue as W, State$4 as Wn, PauseReason as Wr, PerfSpikeLine as Wt, Config$2 as X, to as Xn, RateChange as Xr, ProblemRule as Xt, Api$1 as Y, slot as Yn, FrameRate as Yr, ProblemEventDetail as Yt, MonitorConfig as Z, type as Zn, State$8 as Zr, SHADER_WHATS as Zt, AnySceneProjection as _, Mut as _n, Answer as _r, FrameRing as _t, Config as a, State$3 as an, FlowState as ar, types_d_exports$2 as at, Events$1 as b, ResourceType as bn, Config$5 as br, MonitorSections as bt, LoadBundles as c, AnyComponentType as cn, RouteStep as cr, RenderStats as ct, Manifest as d, ComponentSchema as dn, Descriptor as dr, ViewportSize as dt, types_d_exports$8 as ei, WarmDetail as en, FeatureTree as er, PixiSprite as et, ReadyBundles as f, ComponentType as fn, Effect as fr, FilterCache as ft, types_d_exports as g, FrameDiff as gn, NodeFx as gr, FrameRecord as gt, Usage as h, EntitySnapshot as hn, Hint as hr, FrameReadout as ht, BundleSpec as i, Explained as in, FlowGraph as ir, Under as it, Display as j, ProjectionMotion as jn, Patch as jr, PerfChangeEntry as jt, FilterSlotInputs as k, MotionHandle as kn, State$6 as kr, PerfCause as kt, LoadReason as l, AnyComponentValue as ln, SceneIdOf as lr, Orientation as lt, Tier as m, Entity as mn, GuideOptions as mr, FrameReadResult as mt, AssetsIo as n, Events$8 as ni, Api$2 as nn, Bookmark as nr, PoolTrim as nt, DefineBundles as o, types_d_exports$3 as on, JournalEntry as or, Captured as ot, State as p, ComponentValue as pn, EffectOptions as pr, FrameColumns as pt, sprite as q, defineFlow as qn, Api$7 as qr, PerfThermalLine as qt, BundleMap as r, Require as ri, Config$3 as rn, DefineNode as rr, State$2 as rt, Events as s, AnyComponent as sn, NodeTable as sr, MonitorCounts as st, Api as t, Config$9 as ti, DEMAND_REASONS as tn, AnyFlow as tr, PixiTexture as tt, LoadResult as u, ComponentHandle as un, TypeTag as ur, Point as ut, Config$1 as v, Narrowed as vn, Api$4 as vr, LongFrameEntry as vt, ScenesApi as w, ChangeHook as wn, Api$5 as wr, PERF_GAP_BUCKETS as wt, LayerMap as x, SystemDefinition as xn, FakeClock as xr, OverlayEventDetail as xt, DefineScene as y, QueryTerm as yn, ClockSource as yr, MONITOR_SECTIONS as yt, Shape as z, Config$4 as zn, RngApi as zr, PerfLogLine as zt };
+export { PixiModule as $, FeatureDescription as $n, ThermalReading as $r, ShaderWhat as $t, SyncApi as A, NumericFields as An, State$6 as Ar, PerfChange as At, ShapeValue as B, EmitterIdOf as Bn, RngApi as Br, PerfLongFrameLine as Bt, SceneSpec as C, TagType as Cn, State$5 as Cr, PERF_CAUSES as Ct, DebugSwitches as D, Motion as Dn, Events$5 as Dr, PassKind as Dt, types_d_exports$1 as E, Ease as En, Config$6 as Er, PROBLEM_RULES as Et, NineSliceValue as F, TrackSegment as Fn, SaveDoc as Fr, PerfEventLine as Ft, Transform as G, TextStylesOf as Gn, PauseReason as Gr, PerfStartupLine as Gt, SpriteBlend as H, HudKeysOf as Hn, Api$6 as Hr, PerfMeasured as Ht, Overlay as I, ViewHandle as In, SaveUnreadableError as Ir, PerfEventName as It, AdaptiveScale as J, defineFlow as Jn, Api$7 as Jr, PoolTrimDetail as Jt, TransformValue as K, types_d_exports$4 as Kn, State$7 as Kr, PerfTelemetryLine as Kt, OverlayValue as L, Api$3 as Ln, Snapshot as Lr, PerfGapLine as Lt, HudPart as M, ProjectionSpec as Mn, Patch as Mr, PerfCollectorLine as Mt, HudPartValue as N, ReducedMotion as Nn, PlayerStateProvider as Nr, PerfCounts as Nt, FilterSlot as O, MotionCause as On, Json as Or, PassRecord as Ot, NineSlice$1 as P, TrackOptions as Pn, ProviderCall as Pr, PerfDisplay as Pt, PixiFilter as Q, type as Qn, State$8 as Qr, ShaderEventDetail as Qt, Parent as R, BundlesOf as Rn, SnapshotOf as Rr, PerfHeaderLine as Rt, SceneDefinition as S, SystemFor as Sn, FakeClock as Sr, OverlayWhat as St, State$1 as T, DescriptionNode as Tn, Api$5 as Tr, PERF_LOG_VERSION as Tt, SpriteOptions as U, Position as Un, Config$7 as Ur, PerfSampleLine as Ut, Sprite as V, GameTypes as Vn, RngState as Vr, PerfMarkLine as Vt, SpriteValue as W, State$4 as Wn, Events$6 as Wr, PerfSpikeLine as Wt, Config$2 as X, slot as Xn, FrameRate as Xr, ProblemRule as Xt, Api$1 as Y, exit as Yn, Config$8 as Yr, ProblemEventDetail as Yt, MonitorConfig as Z, to as Zn, RateChange as Zr, SHADER_WHATS as Zt, AnySceneProjection as _, Mut as _n, NodeFx as _r, FrameRing as _t, Config as a, State$3 as an, FlowGraph as ar, types_d_exports$2 as at, Events$1 as b, ResourceType as bn, ClockSource as br, MonitorSections as bt, LoadBundles as c, AnyComponentType as cn, NodeTable as cr, RenderStats as ct, Manifest as d, ComponentSchema as dn, TypeTag as dr, ViewportSize as dt, Time as ei, WarmDetail as en, FeaturePlugin as er, PixiSprite as et, ReadyBundles as f, ComponentType as fn, Descriptor as fr, FilterCache as ft, types_d_exports as g, FrameDiff as gn, Hint as gr, FrameRecord as gt, Usage as h, EntitySnapshot as hn, GuideOptions as hr, FrameReadout as ht, BundleSpec as i, Require as ii, Explained as in, DefineNode as ir, Under as it, Display as j, ProjectionMotion as jn, types_d_exports$6 as jr, PerfChangeEntry as jt, FilterSlotInputs as k, MotionHandle as kn, Root as kr, PerfCause as kt, LoadReason as l, AnyComponentValue as ln, RouteStep as lr, Orientation as lt, Tier as m, Entity as mn, EffectOptions as mr, FrameReadResult as mt, AssetsIo as n, Config$9 as ni, Api$2 as nn, AnyFlow as nr, PoolTrim as nt, DefineBundles as o, types_d_exports$3 as on, FlowState as or, Captured as ot, State as p, ComponentValue as pn, Effect as pr, FrameColumns as pt, sprite as q, contribution as qn, types_d_exports$7 as qr, PerfThermalLine as qt, BundleMap as r, Events$8 as ri, Config$3 as rn, Bookmark as rr, State$2 as rt, Events as s, AnyComponent as sn, JournalEntry as sr, MonitorCounts as st, Api as t, types_d_exports$8 as ti, DEMAND_REASONS as tn, FeatureTree as tr, PixiTexture as tt, LoadResult as u, ComponentHandle as un, SceneIdOf as ur, Point as ut, Config$1 as v, Narrowed as vn, Answer as vr, LongFrameEntry as vt, ScenesApi as w, ChangeHook as wn, types_d_exports$5 as wr, PERF_GAP_BUCKETS as wt, LayerMap as x, SystemDefinition as xn, Config$5 as xr, OverlayEventDetail as xt, DefineScene as y, QueryTerm as yn, Api$4 as yr, MONITOR_SECTIONS as yt, Shape as z, Config$4 as zn, StoreApi as zr, PerfLogLine as zt };

package/dist/{types-CGPWYbZO.d.mts → types-gQATSj41.d.mts}

@@ -1,5 +1,5 @@
-import { Dr as Json, Ir as Snapshot } from "./types-C_dk-lXz.mjs";
-import { t as HeadlessApp } from "./headless-CRqMxzqv.mjs";
+import { Lr as Snapshot, Or as Json } from "./types-DrkR03nL.mjs";
+import { t as HeadlessApp } from "./headless-1e3gEF1Y.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

package/dist/{visual-DjTJ02c3.d.mts → visual-pHKIFBSQ.d.mts}

@@ -1,9 +1,9 @@
-import { Vr as Api$3, Y as Api, nn as Api$1, vr as Api$4, wr as Api$2 } from "./types-C_dk-lXz.mjs";
-import { P as AnimApi, r as UiApi } from "./types-54KzmAA6.mjs";
-import { N as InputApi } from "./types-0Br0SjTB.mjs";
-import { r as Repro } from "./headless-CRqMxzqv.mjs";
-import { a as InputOf, r as ControlApp } from "./types-CGPWYbZO.mjs";
-import { t as commands } from "./commands-CMFdiDcg.mjs";
+import { Hr as Api$3, Tr as Api$2, Y as Api, nn as Api$1, yr as Api$4 } from "./types-DrkR03nL.mjs";
+import { P as AnimApi, r as UiApi } from "./types-B-o8Ul1v.mjs";
+import { N as InputApi } from "./types-CFEtGENK.mjs";
+import { r as Repro } from "./headless-1e3gEF1Y.mjs";
+import { a as InputOf, r as ControlApp } from "./types-gQATSj41.mjs";
+import { t as commands } from "./commands-DLk06fiL.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */