@moku-labs/game 0.15.39 → 0.15.40

package/dist/testing.d.mts

@@ -1,7 +1,7 @@
-import { $n as FeaturePlugin, Dr as Json, dr as Descriptor, gr as NodeFx, hr as Hint, sr as NodeTable, tr as AnyFlow, xr as FakeClock, yr as ClockSource } from "./types-C_dk-lXz.mjs";
-import { t as createApp } from "./index-DFAjLwxi.mjs";
-import { b as saveOf, v as WithGameState, y as memory } from "./types-H1FiWmKa.mjs";
-import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-CRqMxzqv.mjs";
+import { $n as FeaturePlugin, Dr as Json, dr as Descriptor, gr as NodeFx, hr as Hint, sr as NodeTable, tr as AnyFlow, xr as FakeClock, yr as ClockSource } from "./types-DY_DRbGY.mjs";
+import { t as createApp } from "./index-BQGifHXV.mjs";
+import { b as saveOf, v as WithGameState, y as memory } from "./types-B4DmdMle.mjs";
+import { a as createHeadless, i as ReproResult, n as HeadlessGame, o as runRepro, r as Repro, s as stepFrames, t as HeadlessApp } from "./headless-CEwDAhgH.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/clock/fake.d.ts

package/dist/testing.mjs

@@ -1,4 +1,4 @@
-import { en as refuseStart, in as type, m as flattenFeatures, t as createApp, tn as exit } from "./src-B2vblgmb.mjs";
+import { en as refuseStart, in as type, m as flattenFeatures, t as createApp, tn as exit } from "./src-Cz-QeLTp.mjs";
 import { n as saveOf, t as memory } from "./memory-CWlqhS7l.mjs";
 import { n as fakeClock } from "./fake-hnJcJeYf.mjs";
 import { i as stepFrames, r as runRepro, t as createHeadless } from "./headless-Bxxl_mQX.mjs";

package/dist/{types-H1FiWmKa.d.mts → types-B4DmdMle.d.mts}

@@ -1,7 +1,7 @@
-import { $ as PixiModule, $n as FeaturePlugin, Dr as Json, Lr as SnapshotOf, Mr as PlayerStateProvider, Nr as ProviderCall, Pr as SaveDoc, Tr as Config, X as Config$2, a as Config$3, d as Manifest, lt as Orientation, n as AssetsIo, tr as AnyFlow, ur as TypeTag, xr as FakeClock, yr as ClockSource, zn as Config$1 } from "./types-C_dk-lXz.mjs";
-import { o as AudioContextLike, s as Config$4 } from "./types-54KzmAA6.mjs";
-import { R as I18nApi, U as StringTable, W as TextKey } from "./types-0Br0SjTB.mjs";
-import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-DFAjLwxi.mjs";
+import { $ as PixiModule, $n as FeaturePlugin, Dr as Json, Lr as SnapshotOf, Mr as PlayerStateProvider, Nr as ProviderCall, Pr as SaveDoc, Tr as Config, X as Config$2, a as Config$3, d as Manifest, lt as Orientation, n as AssetsIo, tr as AnyFlow, ur as TypeTag, xr as FakeClock, yr as ClockSource, zn as Config$1 } from "./types-DY_DRbGY.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-CP22WjU9.mjs";
+import { R as I18nApi, U as StringTable, W as TextKey } from "./types-Dnh8LZxo.mjs";
+import { St as effectsPlugin, Tt as audioPlugin, ht as PlatformProvider, i as screen, pt as platformPlugin, t as createApp } from "./index-BQGifHXV.mjs";
 import { AnyPluginInstance } from "@moku-labs/core";
 
 //#region src/plugins/model/store/providers/memory.d.ts

package/dist/{types-54KzmAA6.d.mts → types-CP22WjU9.d.mts}

@@ -1,5 +1,5 @@
-import { $ as PixiModule, A as SyncApi, An as NumericFields, Dr as Json, En as Ease, Er as Events$3, Fn as TrackSegment, Ln as Api$2, Nn as ReducedMotion, O as FilterSlot, Pn as TrackOptions, Q as PixiFilter, Ur as Events$5, Y as Api$4, b as Events$4, dr as Descriptor, et as PixiSprite, fn as ComponentType, ft as FilterCache, k as FilterSlotInputs, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, ni as Events$2, nn as Api$3, qr as Api$1, ri as Require, s as Events$1, sn as AnyComponent, t as Api$5, tt as PixiTexture, un as ComponentHandle, ur as TypeTag, ut as Point, wr as Api$6 } from "./types-C_dk-lXz.mjs";
-import { N as InputApi, R as I18nApi, X as StylesState, c as UiNode, i as Finding, l as LayoutState, n as ElementChange, o as JsxState, r as ElementMotion, w as TextApi } from "./types-0Br0SjTB.mjs";
+import { $ as PixiModule, A as SyncApi, An as NumericFields, Dr as Json, En as Ease, Er as Events$3, Fn as TrackSegment, Ln as Api$2, Nn as ReducedMotion, O as FilterSlot, Pn as TrackOptions, Q as PixiFilter, Ur as Events$5, Y as Api$4, b as Events$4, dr as Descriptor, et as PixiSprite, fn as ComponentType, ft as FilterCache, k as FilterSlotInputs, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, ni as Events$2, nn as Api$3, qr as Api$1, ri as Require, s as Events$1, sn as AnyComponent, t as Api$5, tt as PixiTexture, un as ComponentHandle, ur as TypeTag, ut as Point, wr as Api$6 } from "./types-DY_DRbGY.mjs";
+import { N as InputApi, R as I18nApi, X as StylesState, c as UiNode, i as Finding, l as LayoutState, n as ElementChange, o as JsxState, r as ElementMotion, w as TextApi } from "./types-Dnh8LZxo.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/dist/{types-CGPWYbZO.d.mts → types-CoTkzbEB.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 { Dr as Json, Ir as Snapshot } from "./types-DY_DRbGY.mjs";
+import { t as HeadlessApp } from "./headless-CEwDAhgH.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts

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

@@ -9320,7 +9320,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 +10874,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 +11160,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 +11278,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 +11731,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 +11767,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 +11867,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 +11957,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 +11993,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 +12023,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 +12033,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 +12045,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 +12109,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.

package/dist/{types-0Br0SjTB.d.mts → types-Dnh8LZxo.d.mts}

@@ -1,4 +1,4 @@
-import { An as NumericFields, Cn as TagType, Dn as Motion, Dr as Json, En as Ease, In as ViewHandle, K as TransformValue, Ln as Api$1, Nn as ReducedMotion, On as MotionCause, Y as Api$3, _r as Answer, cn as AnyComponentType, dr as Descriptor, dt as ViewportSize, fn as ComponentType, hr as Hint, jn as ProjectionMotion, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, nn as Api$2, qr as Api, ri as Require, s as Events$1, sn as AnyComponent, t as Api$4, vr as Api$5, wn as ChangeHook } from "./types-C_dk-lXz.mjs";
+import { An as NumericFields, Cn as TagType, Dn as Motion, Dr as Json, En as Ease, In as ViewHandle, K as TransformValue, Ln as Api$1, Nn as ReducedMotion, On as MotionCause, Y as Api$3, _r as Answer, cn as AnyComponentType, dr as Descriptor, dt as ViewportSize, fn as ComponentType, hr as Hint, jn as ProjectionMotion, kn as MotionHandle, ln as AnyComponentValue, mn as Entity, nn as Api$2, qr as Api, ri as Require, s as Events$1, sn as AnyComponent, t as Api$4, vr as Api$5, wn as ChangeHook } from "./types-DY_DRbGY.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 import { Node, Yoga } from "yoga-layout/load";

package/dist/{visual-DjTJ02c3.d.mts → visual-BcS4CTps.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 { Vr as Api$3, Y as Api, nn as Api$1, vr as Api$4, wr as Api$2 } from "./types-DY_DRbGY.mjs";
+import { P as AnimApi, r as UiApi } from "./types-CP22WjU9.mjs";
+import { N as InputApi } from "./types-Dnh8LZxo.mjs";
+import { r as Repro } from "./headless-CEwDAhgH.mjs";
+import { a as InputOf, r as ControlApp } from "./types-CoTkzbEB.mjs";
+import { t as commands } from "./commands-CvwzXCxM.mjs";
 
 //#region src/visual/types.d.ts
 /** The base commands of the `/control` door, keyed by their short names. */

package/dist/visual.d.mts

@@ -1,2 +1,2 @@
-import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-DjTJ02c3.mjs";
+import { a as VisualApp, c as VisualRenderer, d as VisualStart, f as VisualStep, h as VisualTolerance, i as CheckpointResult, l as VisualReport, m as VisualTestResult, n as runVisualTests, o as VisualOptions, p as VisualTest, r as defineVisualTest, s as VisualPage, t as parseVisualArgv, u as VisualSetup } from "./visual-BcS4CTps.mjs";
 export { type CheckpointResult, type VisualApp, type VisualOptions, type VisualPage, type VisualRenderer, type VisualReport, type VisualSetup, type VisualStart, type VisualStep, type VisualTest, type VisualTestResult, type VisualTolerance, defineVisualTest, parseVisualArgv, runVisualTests };

package/llms.txt

@@ -525,6 +525,7 @@ The graph. Modules `runner`, `gate`, `inbox`, `fx`, `features`. Runner methods s
 - Overlays: `Overlay({ dim, dimColor, cover, hud, fade, hold })` on the root of an overlay (in `components`) keeps everything drawn before it as one picture, retaken in the frame anything in it changes, and with `cover: "opaque"` draws none of it once landed at alpha 1; `hold: true` (default `false`) holds the endless loops under it while it stands, as under a cover or a blurred picture (their phase follows time), so a dimmed sheet over a sharp scene draws no frame at rest; the engine draws the dim (`dim × level`, right under the root); the level follows the root's own enter and exit motion, `fade` (250 ms) only when it has none; level and landing are read through `app.renderer.sync.debug.overlays()`. A `backdrop: true` filter inside the kept range runs no pass while the picture stands (its look is in the picture) and is drawn again in the frame the overlay is gone. Types: `OverlayValue` (the component's value) and `HudPartValue` (a part of the HUD an overlay keeps shown or lets fade).
 - HUD: a scene layer `{ above: "overlays" }` is the HUD layer, drawn above every overlay and never in a picture; a scene with a HUD layer and no `ui` gets `ui` right under it. Its roots never take the keyboard: Escape and the Back press reach the top sheet under it. `HudPart({ key })` tags a HUD view; an overlay's `hud` (`"all"`, `"none"` or keys) names the parts that stay shown, the others fade with its level and take no tap. Keys are typed by `defineGame<{ …, hud: "energy" | "gems" }>()`.
 - Endless loops of views under an opaque or blurred overlay write nothing (`renderer.sync.loopsHeld(entity)`, the seam anim asks before an endless loop writes); their phase follows time.
+- Scene switch look: from the start of a live switch (before its bundles and textures are awaited) the renderer draws a veil over the scene being left, above every layer, and, when the switch is not done `afterMs` after its start, a loader above it until the swap; then the veil fades out over the new scene. Config `scenes.leave` (default `{ cover: { color: 0x000000, alpha: 0.45, inMs: 150, outMs: 150 }, loader: { afterMs: 400 } }`) and a scene's `leave` (`defineScene("ward", { ..., leave: false })`) are merged field by field (the scene being left decides; `false` turns a part or the whole off); the loader is the engine's white ring, `loader: { texture: "ui.loader.ring" }` a game texture turning, or `loader: { projection: "loading" }` a projection mounted only once the loader is due, in a layer of its own the scene declares (no other projection of the scene may draw there); an abort or a throw drops both at once; fast walks, a world that is not live, headless apps and the first scene show nothing; types `SceneLeave`, `SceneCover`, `SceneLoader` (`Scenes`).
 - A scene names bundles on top of its `bundle` from the committed state: `defineScene("ward", { bundle: "episodes-kit", bundles: ({ session }) => [session.episode], layers: {}, projections: [wardRoom] })`. `bundles` is read each time a node enters the scene, and every way in (a live entry, a restore, the `safeNode` recovery) waits for all of them before the scene is mounted and the node's gate opens. The keys are `BundleKey`s of `generated/assets.ts`.
 - `app.assets`: `load(bundle)`, `warm(bundle)` (loads it if needed, then puts its textures and atlas pages on the GPU through `renderer.sync.textures.upload`, `renderer.uploads` a drawn frame; joins a running or finished warm; an unload forgets it; resolves also when the renderer could not upload; headless at once), `unload(bundle)`, `isLoaded(bundle)`, `has(bundle)` (the manifest carries it, loaded or not), `texture(key)`, `font(key)`, `audio(key)`, `usage()`. Per bundle in a feature's `assets.ts`: `defineBundles({ ep01: { tier: "feature", release: "leave", mipmaps: ["items/**"] } })`. `release: "leave"` also unloads the bundle, with reason `"leave"`, at the next rest once nothing holds it: not pinned by the node entered, not named by the mounted scene, no node of its feature on the stack; a bundle the outgoing scene named leaves one rest later. The default `"budget"` leaves only under the texture budget. `mipmaps` (`true` or globs relative to `assets/`) uploads the textures with their full chain; such a texture stays loose in a pack. A sub-feature with resources gets its own bundles, named like its folder, with `dir` and `parent` in the manifest; a code-only one has none. The effect `ready(bundle | bundles)` (root export, also from `defineGame`) lets a node rest on a load and stay answerable: its handler (fast mode too) answers `true` headless, throws for an unknown bundle, answers `true` when every bundle is loaded and warmed or its last warm failed (`ctx.log.warn("assets:ready-failed", { bundle, error })`, cleared by a later successful load), otherwise starts `warm` for what is missing, answers `false` and posts `{ type: "ready" }` into `flow.inbox` once all of it settled. Recipe: a rest node `inbox: ["elapsed", "ready"]` with outcomes `ready` and `back`, and a transit node `if ((await fx(ready(list))) === false) return out.wait();`. `companions.add({ load(bundle), unload(bundle) })` adds what loads and unloads with every bundle; `i18n` adds the strings of a sub-feature that way, only when `assets` is composed. Events `assets:bundle-loaded`, `assets:bundle-progress`, `assets:bundle-unloaded` (`reason: "budget" | "request" | "leave"`), `assets:replaced` (dev). Config: `manifest`, `textureBudgetMb: 192`, `preloadDepth: 2`, `baseUrl`, `io`.
 - `resource(name, defaults)` clones plain JSON defaults into every world. `resource(name, () => value)` calls the factory once per world on first read, so the value may hold a `Map` or a function: `const Looks = resource("boardLooks", () => ({ shown: new Map<World.Entity, { look: string }>() }))`. A system keeps its own state there; `snapshot()` leaves a value that is not JSON out.

package/package.json

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