@moku-labs/game 0.9.0 → 0.11.0

package/dist/types-Ca_z_4tQ.d.mts

@@ -0,0 +1,586 @@
+import { Dt as AnyFlow, Ht as ClockSource, Jt as Config, Wt as FakeClock, Xt as Json, a as Config$3, g as Config$2, ht as FeaturePlugin, n as AssetsIo, pt as Config$1, tn as PlayerStateProvider, u as Manifest, v as PixiModule } from "./types-ZQLYXo5X.mjs";
+import { o as AudioContextLike, s as Config$4 } from "./types-BM4shh8K.mjs";
+import { ht as audioPlugin, i as screen, it as platformPlugin, ot as PlatformProvider, pt as effectsPlugin, t as createApp } from "./index-8TiJQjQA.mjs";
+import { t as memory } from "./memory-DwDhfFWK.mjs";
+import { AnyPluginInstance } from "@moku-labs/core";
+
+//#region src/app/types.d.ts
+/**
+ * The name of a `@moku-labs/system` plugin the game shell wires, as the system package names it.
+ * Only the five a game shell uses.
+ *
+ * @example
+ * ```ts
+ * const wanted: SystemName[] = ["lifecycle", "back", "haptics", "keepAwake"];
+ * ```
+ */
+type SystemName = "lifecycle" | "back" | "haptics" | "keepAwake" | "store";
+/**
+ * Where the player's save lives: in memory for this page only, in `localStorage`, or in the
+ * system store (idb on the web, the Tauri store in the native shell).
+ *
+ * @example
+ * ```ts
+ * const save: SaveKind = "local"; // progress survives a reload of the page
+ * ```
+ */
+type SaveKind = "memory" | "local" | "store";
+/**
+ * What `config.ts` of a game holds: plain data, no call. The page, the native build and the shell
+ * read it; the game logic never does.
+ *
+ * @example
+ * ```ts
+ * // config.ts of a game
+ * import type { GameConfig } from "@moku-labs/game/app";
+ * export default {
+ *   page: { title: "Лесной городок", lang: "ru", background: "#10161d", orientation: "portrait", icons: { favicon: "assets/icon.png" } },
+ *   native: { name: "Лесной городок", identifier: "com.mokulabs.timber", icon: "assets/icon.png" },
+ *   system: ["lifecycle", "back", "haptics", "keepAwake"],
+ *   save: "memory",
+ *   assets: { layers: { shared: "ui" } }
+ * } satisfies GameConfig;
+ * ```
+ */
+type GameConfig = {
+  /** The HTML page the game runs in. */page: {
+    /** The page title. Required, never empty. */title: string; /** The `lang` of the page. Default `"en"`. */
+    lang?: string; /** CSS colour of the page behind the canvas, also the native window. Default `"#000000"`. */
+    background?: string; /** The orientation the native build locks. Default `"portrait"`. */
+    orientation?: "portrait" | "landscape" | "any"; /** Icon files, relative to the game folder. None by default. */
+    icons?: {
+      favicon?: string;
+      appleTouch?: string;
+    }; /** Raw tags written into `<head>`, verbatim, in order. None by default. */
+    head?: readonly string[];
+  }; /** The native app. Left out, the game has no native build. */
+  native?: {
+    /** The app name under the icon. */name: string; /** The bundle identifier, reverse DNS. */
+    identifier: string; /** A 1024 px PNG, relative to the game folder. A placeholder by default. */
+    icon?: string; /** The native targets a build makes. The target of the command by default. */
+    targets?: readonly ("ios" | "android" | "macos")[];
+  }; /** The system plugins the shell wires. Default `[]`, a web page with no shell. */
+  system?: readonly SystemName[]; /** Where the save lives. Default `"memory"`. */
+  save?: SaveKind; /** The asset build. Default: no layers. */
+  assets?: {
+    /** Asset layers by name: `{ shared: "ui" }` packs the shared layer from `features/ui`. */layers?: Readonly<Record<string, string>>;
+  };
+};
+/**
+ * `GameConfig` with every default filled, as `resolveConfig` returns it. The page, the CLI and the
+ * shell read this one, never the raw config.
+ *
+ * @example
+ * ```ts
+ * const settings: ResolvedGameConfig = {
+ *   page: { title: "mini-game", lang: "en", background: "#000000", orientation: "portrait", icons: {}, head: [] },
+ *   native: undefined, system: [], save: "memory", assets: { layers: {} }
+ * };
+ * ```
+ */
+type ResolvedGameConfig = {
+  /** The page, every field set. */page: Required<GameConfig["page"]>; /** The native app, or `undefined` for a game with no native build. */
+  native: GameConfig["native"]; /** The system plugins the shell wires. */
+  system: readonly SystemName[]; /** Where the save lives. */
+  save: SaveKind; /** The asset build. */
+  assets: {
+    layers: Readonly<Record<string, string>>;
+  };
+};
+/**
+ * The engine part of a screen app, in dependency order: the screen set, `audio`, `effects`,
+ * `platform`. The game's features and plugins come after it.
+ */
+type ScreenSet = readonly [...typeof screen, typeof audioPlugin, typeof effectsPlugin, typeof platformPlugin];
+/**
+ * The screen app of a game whose own plugins are `Plugins`, as `createApp` types it.
+ *
+ * @example
+ * ```ts
+ * type App = ScreenAppOf<readonly [typeof scorePlugin]>; // app.ui, app.platform, app.score
+ * ```
+ */
+type ScreenAppOf<Plugins extends readonly AnyPluginInstance[]> = ReturnType<typeof createApp<[...ScreenSet, ...Plugins]>>;
+/**
+ * The headless app of a game whose headless plugins are `Plugins`, as `createApp` types it.
+ *
+ * @example
+ * ```ts
+ * type App = HeadlessAppOf<readonly []>; // app.time, .lifecycle, .model, .clock, .flow, .log, .env
+ * ```
+ */
+type HeadlessAppOf<Plugins extends readonly AnyPluginInstance[]> = ReturnType<typeof createApp<[...Plugins]>>;
+/** Every `pluginConfigs` key of the screen app of a game, as `createApp` accepts them. */
+type AllConfigs<Plugins extends readonly AnyPluginInstance[]> = NonNullable<NonNullable<Parameters<typeof createApp<[...ScreenSet, ...Plugins]>>[0]>["pluginConfigs"]>;
+/** The plugin configs the shell writes as a whole, or in part: they leave the game's type. */
+type SeamOwned = "model" | "clock" | "platform" | "flow" | "renderer" | "assets" | "audio";
+/**
+ * The `pluginConfigs` a game writes in `defineGameApp`: every plugin of its screen app, without
+ * the keys the shell writes from the seams. `clock` and `platform` are gone; `model` keeps
+ * `schemaVersion` and `migrations`; `flow` loses `mainFlow` and `safeNode`; `renderer` loses
+ * `mount`; `assets` loses `manifest` and `io`; `audio` loses `context`. A seam-owned key is a
+ * compile error, never a value the shallow merge would drop.
+ *
+ * @example
+ * ```ts
+ * defineGameApp({ flow: mainFlow, player, session, pluginConfigs: { ui: { tapTargetPt: 48 } } }); // passes
+ * defineGameApp({ flow: mainFlow, player, session, pluginConfigs: { clock: {} } }); // compile error: the shell owns clock
+ * ```
+ */
+type GamePluginConfigs<Plugins extends readonly AnyPluginInstance[] = readonly []> = Omit<AllConfigs<Plugins>, SeamOwned> & {
+  /** The save schema of the game. The shell writes the provider, the seed and the starting state. */model?: Pick<Partial<Config>, "schemaVersion" | "migrations">; /** The runner limits. The shell writes `mainFlow` and `safeNode` from the definition. */
+  flow?: Omit<Partial<Config$1>, "mainFlow" | "safeNode">; /** The canvas. The shell writes `mount`; a seam's `loadPixi` and `preference` win. */
+  renderer?: Omit<Partial<Config$2>, "mount">; /** The texture budget and the CDN prefix. The shell writes `manifest` and `io`. */
+  assets?: Omit<Partial<Config$3>, "manifest" | "io">; /** Buses, volumes, music. The shell writes `context`; a seam's `journal` wins. */
+  audio?: Omit<Partial<Config$4>, "context">;
+};
+/**
+ * What `defineGameApp` takes: the whole game as one data object. Nothing here is a seam: the
+ * clock, the save provider, the manifest and the platform come from `headless()` and `screen()`.
+ *
+ * @example
+ * ```ts
+ * // tests/fixtures/mini-game/index.ts
+ * const definition: GameDefinition = {
+ *   flow: mainFlow, safeNode: "home", player: { count: 0 }, session: { opened: 0 },
+ *   features: [homeFeature, infoFeature], headless: { features: [infoFeature] }
+ * };
+ * ```
+ */
+type GameDefinition<Plugins extends readonly AnyPluginInstance[] = readonly [], HeadlessPlugins extends readonly AnyPluginInstance[] = readonly [], Player extends Json = Json, Session extends Json = Json> = {
+  /** The main flow. */flow: AnyFlow; /** The checkpoint entered after a failed retry. Default: the start of the main flow. */
+  safeNode?: string; /** The player a new save starts from. */
+  player: Player; /** The session at every start. */
+  session: Session; /** The long side the layout needs, in reference units. Default 1920. */
+  referenceLong?: number; /** The rng seed of a new save. Default 42. */
+  seed?: number; /** The shared layer: composed first among the features. */
+  shared?: FeaturePlugin; /** The features of the screen app, in order, after `shared`. */
+  features?: readonly FeaturePlugin[]; /** The game's own plugins, after the features. Their APIs land on `screen().app`. */
+  plugins?: Plugins; /** What the headless app composes: the logic of these features and these plugins, nothing else. */
+  headless?: {
+    features?: readonly FeaturePlugin[];
+    plugins?: HeadlessPlugins;
+  }; /** Plugin configs of the game. Seam-owned keys are not accepted. */
+  pluginConfigs?: NoInfer<GamePluginConfigs<Plugins>>;
+};
+/**
+ * The in-memory save provider a seam gets when it passes none: it records every call.
+ *
+ * @example
+ * ```ts
+ * const { app, provider } = game.headless();
+ * await createHeadless(app); // flow.run() loads the save and commits a new player at once
+ * provider.calls.map(call => call.method); // ["load", "commit"]
+ * ```
+ */
+type MemoryProvider = ReturnType<typeof memory>;
+/**
+ * What one call of `headless()` or `screen()` gives: the app, not started, and the clock and save
+ * provider it runs on, so a test can move the time and read the save.
+ *
+ * @example
+ * ```ts
+ * const { app, clock, provider } = game.headless({ seed: 7 });
+ * ```
+ */
+type GameHandle<App, Source, Provider> = {
+  /**
+   * The app, not started.
+   *
+   * @example
+   * ```ts
+   * const { app } = game.headless();
+   * await app.start(); // the caller starts it, and runs the graph
+   * ```
+   */
+  app: App;
+  /**
+   * The clock source the app runs on: the fake clock at `startMoment` unless a seam passed one.
+   *
+   * @example
+   * ```ts
+   * const { clock } = game.headless();
+   * clock.advance(60_000); // clock.now() is 1060000
+   * ```
+   */
+  clock: Source;
+  /**
+   * The save provider the app runs on: a fresh memory provider unless a seam passed one.
+   *
+   * @example
+   * ```ts
+   * const { provider } = game.headless();
+   * provider.calls; // []: flow.run() loads the save, start() does not
+   * ```
+   */
+  provider: Provider;
+};
+/**
+ * What a test or the page may pin on a headless app. Every field is optional; the definition and
+ * the engine defaults fill the rest.
+ *
+ * @example
+ * ```ts
+ * game.headless({ seed: 7, player: { count: 3 } });
+ * ```
+ */
+type HeadlessSeams<Player, Session, Source, Provider> = {
+  /**
+   * The rng seed of a new save. Default: the definition's seed, else 42.
+   *
+   * @example
+   * ```ts
+   * game.headless({ seed: 7 }); // a new save draws from seed 7
+   * ```
+   */
+  seed?: number;
+  /**
+   * The clock source. Default: `fakeClock(startMoment)`; the page passes the device clock.
+   *
+   * @example
+   * ```ts
+   * game.headless({ clock: fakeClock(5000) }).clock.now(); // 5000
+   * ```
+   */
+  clock?: Source;
+  /**
+   * The save provider. Default: a fresh `memory()`.
+   *
+   * @example
+   * ```ts
+   * game.headless({ provider: memory({ state: saveOf({ count: 3 }, 42), version: 1 }) }); // a returning player
+   * ```
+   */
+  provider?: Provider;
+  /**
+   * The player a new save starts from. Default: the definition's player.
+   *
+   * @example
+   * ```ts
+   * game.headless({ player: { count: 3 } }); // a new save counts 3
+   * ```
+   */
+  player?: Player;
+  /**
+   * The session at start. Default: the definition's session.
+   *
+   * @example
+   * ```ts
+   * game.headless({ session: { opened: 2 } });
+   * ```
+   */
+  session?: Session;
+};
+/**
+ * What a test or the page may pin on a screen app: the headless seams, and the manifest, the
+ * file seam, the platform and the screen-on switch, the audio and the renderer seams.
+ *
+ * @example
+ * ```ts
+ * game.screen({ manifest: "/manifest.json", renderer: { mount: "#game" } });
+ * ```
+ */
+type ScreenSeams<Player, Session, Source, Provider> = HeadlessSeams<Player, Session, Source, Provider> & {
+  /**
+   * The manifest the assets plugin reads: a URL on the page, the parsed file in a test.
+   *
+   * @example
+   * ```ts
+   * game.screen({ manifest: await readManifest() }); // tests/integration/mini-helpers.ts
+   * ```
+   */
+  manifest?: string | Manifest;
+  /**
+   * The file seam of the assets plugin. Left out, the browser fetch, or headless in a test.
+   *
+   * @example
+   * ```ts
+   * game.screen({ manifest, io: folderIo().io }); // the fixture's files, read from disk
+   * ```
+   */
+  io?: AssetsIo;
+  /**
+   * The platform provider. Left out, the platform plugin is inert and `back()` answers `"none"`.
+   *
+   * @example
+   * ```ts
+   * const { app } = game.screen({ platform: provider });
+   * await app.start();
+   * void app.flow.run();
+   * app.platform.back(); // "exit" once the graph rests on Home: Home does not list "back"
+   * ```
+   */
+  platform?: PlatformProvider;
+  /**
+   * Keeps the screen on while the game runs. Default `false`.
+   *
+   * @example
+   * ```ts
+   * await game.screen({ platform: provider, keepAwake: true }).app.start(); // provider.keepAwake(true)
+   * ```
+   */
+  keepAwake?: boolean;
+  /**
+   * The audio seams: the context factory, and how many started sounds the journal keeps.
+   *
+   * @example
+   * ```ts
+   * game.screen({ audio: { context: () => fakeContext, journal: 200 } }); // the dev page keeps 200
+   * ```
+   */
+  audio?: {
+    context?: () => AudioContextLike;
+    journal?: number;
+  };
+  /**
+   * The renderer seams: where the canvas goes, how Pixi loads, which backend it asks for.
+   *
+   * @example
+   * ```ts
+   * game.screen({ renderer: { mount: "#game", preference: "webgl" } }); // the page under ?renderer=webgl
+   * ```
+   */
+  renderer?: {
+    mount?: string | HTMLElement;
+    loadPixi?: () => Promise<PixiModule>;
+    preference?: "webgpu" | "webgl";
+  };
+};
+/**
+ * The game, as `defineGameApp` returns it: two ways to make its app. `headless()` composes the
+ * logic only, for tests; `screen()` composes the engine's screen set, the features and the game's
+ * plugins, for the page and the screen tests. Neither starts the app.
+ *
+ * @example
+ * ```ts
+ * import game from "../index";
+ * const { app, clock, provider } = game.headless({ seed: 7 });
+ * ```
+ */
+type GameApp<Plugins extends readonly AnyPluginInstance[] = readonly [], HeadlessPlugins extends readonly AnyPluginInstance[] = readonly [], Player extends Json = Json, Session extends Json = Json> = {
+  /**
+   * Makes the logic app: the core plugins, the logic of `headless.features` and the
+   * `headless.plugins`. No screen plugin, no game plugin unless listed. Each call gives a fresh
+   * app, clock and provider.
+   *
+   * @param seams - What the test pins: seed, clock, provider, player, session.
+   * @returns The app, not started, and its clock and provider.
+   * @example
+   * ```ts
+   * const { app, clock } = game.headless({ seed: 7 });
+   * clock.now(); // 1000000, the fake clock at startMoment
+   * const run = await createHeadless(app);
+   * run.state().path; // "home"
+   * ```
+   */
+  headless<Source extends ClockSource = FakeClock, Provider extends PlayerStateProvider = MemoryProvider>(seams?: HeadlessSeams<Player, Session, Source, Provider>): GameHandle<HeadlessAppOf<HeadlessPlugins>, Source, Provider>;
+  /**
+   * Makes the screen app: the screen set, `audio`, `effects`, `platform`, then `shared`, the
+   * features and the game's plugins, in that order. Without a mount the renderer is inert, so the
+   * same app runs in a test. Each call gives a fresh app, clock and provider.
+   *
+   * @param seams - What the test or the page pins, the headless seams and the screen seams.
+   * @returns The app, not started, and its clock and provider.
+   * @example
+   * ```ts
+   * const { app } = game.screen({ manifest: await readManifest(), io: folderIo().io });
+   * await app.start();
+   * void app.flow.run(); // the page runs the graph; the mini game starts on its Home checkpoint
+   * app.flow.state().path; // "home" once the runner rests
+   * ```
+   */
+  screen<Source extends ClockSource = FakeClock, Provider extends PlayerStateProvider = MemoryProvider>(seams?: ScreenSeams<Player, Session, Source, Provider>): GameHandle<ScreenAppOf<Plugins>, Source, Provider>;
+};
+/**
+ * Any game, whatever its plugins and state: what the page takes.
+ *
+ * @example
+ * ```ts
+ * const page: AnyGameApp = game; // the default export of a game's index.ts
+ * ```
+ */
+type AnyGameApp = GameApp<readonly AnyPluginInstance[], readonly AnyPluginInstance[], Json, Json>;
+/**
+ * The screen app of a game, as `game.screen().app` types it.
+ *
+ * @example
+ * ```ts
+ * type MiniApp = ScreenAppOfGame<typeof game>; // has app.flow, app.ui, app.platform
+ * ```
+ */
+type ScreenAppOfGame<Game extends AnyGameApp> = ReturnType<Game["screen"]>["app"];
+/**
+ * One prepared save of the dev page, picked with `?player=<name>`: the default export of
+ * `tests/scenarios/<name>.ts`. It gets the device time, so a timer can be due already.
+ *
+ * @example
+ * ```ts
+ * // tests/scenarios/full.ts of a game: `?player=full` opens on a full board, a refill due in 60 s.
+ * const full: Scenario<Player> = now => ({ player: { ...startingPlayer, board: fullBoard, refillAt: now + 60_000 } });
+ * export default full;
+ * ```
+ */
+type Scenario<Player = Json, Session = Json> = (now: number) => {
+  player: Player;
+  session?: Session;
+};
+/**
+ * A dev agent the page starts after the app: the default export of an agent module the CLI names,
+ * the editor's among them. It gets the running app, the page title and the game's `.dev` modules.
+ *
+ * @example
+ * ```ts
+ * // .moku/main.ts, written by moku-game dev: the editor's agent module's default export.
+ * await startPage(game, config, { agents: [agent0] }); // agent0({ app, name: "mini-game", modules: [] })
+ * ```
+ */
+type PageAgent<App = ScreenAppOfGame<AnyGameApp>> = (page: {
+  app: App;
+  name: string;
+  modules: readonly object[];
+}) => void | Promise<void>;
+/**
+ * Builds the system shell from the resolved config: what `systemShellOf` of
+ * `@moku-labs/game/app/system` returns over the loaders of the page. The page reaches the shell
+ * only through this.
+ *
+ * @example
+ * ```ts
+ * const factory: SystemShellFactory = systemShellOf({ system: () => import("@moku-labs/system"), back: () => import("@moku-labs/system/back") });
+ * await startPage(game, config, { system: factory }); // the page builds the shell of config.system: ["back"]
+ * ```
+ */
+type SystemShellFactory = (config: ResolvedGameConfig, report: (problem: string) => void) => Promise<SystemShell>;
+/**
+ * What the generated `.moku/main.ts` hands the page besides the game and its config.
+ *
+ * @example
+ * ```ts
+ * const system = systemShellOf({ system: () => import("@moku-labs/system"), haptics: () => import("@moku-labs/system/haptics") });
+ * const options: PageOptions = { scenarios: { ready }, system, agents: [agent0], devModules: [devModule0] };
+ * ```
+ */
+type PageOptions = {
+  /** Prepared saves by name, for `?player=`. Dev only; the build passes none. */scenarios?: Readonly<Record<string, Scenario>>; /** The system shell factory, when `config.ts` names a system plugin or the store save. */
+  system?: SystemShellFactory; /** Agents started after the app. Dev only. */
+  agents?: readonly PageAgent[]; /** The game's `.dev` modules, handed to the agents. Dev only. */
+  devModules?: readonly object[];
+};
+/**
+ * What `startPage` resolves to: the running screen app, and the system app for
+ * `globalThis.system` (`undefined` without a shell).
+ *
+ * @example
+ * ```ts
+ * const { app } = await startPage(game, config);
+ * app.flow.state().path; // "home" once the runner rests
+ * ```
+ */
+type StartedPage<Game extends AnyGameApp> = {
+  /** The screen app, started. */app: ScreenAppOfGame<Game>; /** The `@moku-labs/system` app, or `undefined` without a shell. Typed `unknown`: see `SystemShell.handle`. */
+  system: unknown;
+};
+/**
+ * The modules of `@moku-labs/system` the page loads, one loader per name of `config.ts`: the
+ * package itself always, and the entry of each plugin the game names, the store for a store save.
+ * The generated `main.ts` writes only the loaders of the names, so the page bundles only those
+ * plugins and never meets the native package of another. Typed `unknown`: a system type here would
+ * land in the `.d.mts` of every game and break the typecheck of a web-only one.
+ *
+ * @example
+ * ```ts
+ * // A page of its own for a game whose config.ts names haptics, with a memory save.
+ * const modules: SystemModules = {
+ *   system: () => import("@moku-labs/system"),
+ *   haptics: () => import("@moku-labs/system/haptics")
+ * };
+ * await startPage(game, config, { system: systemShellOf(modules) }); // the bundle holds no store plugin
+ * ```
+ */
+type SystemModules = {
+  /** `@moku-labs/system` itself, for its `createApp`. Always there. */system: () => Promise<{
+    createApp: unknown;
+  }>; /** `@moku-labs/system/lifecycle`, when the game names `lifecycle`. */
+  lifecycle?: () => Promise<{
+    lifecyclePlugin: unknown;
+  }>; /** `@moku-labs/system/back`, when the game names `back`. */
+  back?: () => Promise<{
+    backPlugin: unknown;
+  }>; /** `@moku-labs/system/haptics`, when the game names `haptics`. */
+  haptics?: () => Promise<{
+    hapticsPlugin: unknown;
+  }>; /** `@moku-labs/system/keep-awake`, when the game names `keepAwake`. */
+  keepAwake?: () => Promise<{
+    keepAwakePlugin: unknown;
+  }>; /** `@moku-labs/system/store`, when the game names `store` or its save is `"store"`. */
+  store?: () => Promise<{
+    storePlugin: unknown;
+  }>;
+};
+/**
+ * The system shell: the `@moku-labs/system` app the config names, and what the engine takes from
+ * it. The factory of `systemShellOf` builds it; the page starts it before the game and stops it
+ * after.
+ *
+ * @example
+ * ```ts
+ * const build = systemShellOf({ system: () => import("@moku-labs/system"), store: () => import("@moku-labs/system/store") });
+ * const shell = await build(resolveConfig({ page: { title: "T" }, save: "store" }), problem => problems.push(problem));
+ * game.screen({ platform: shell.platform, provider: shell.save });
+ * ```
+ */
+type SystemShell = {
+  /**
+   * The `@moku-labs/system` app, for `globalThis.system`. Typed `unknown`: a system type here
+   * would land in the `.d.mts` of every game and break the typecheck of a web-only one.
+   *
+   * @example
+   * ```ts
+   * Reflect.set(globalThis, "system", shell.handle); // e2e: system.haptics.selection()
+   * ```
+   */
+  handle: unknown;
+  /**
+   * The engine's platform provider over the system app. A capability the config does not name is
+   * inert.
+   *
+   * @example
+   * ```ts
+   * shell.platform.haptic("success"); // the shell plays system.haptics.notify("success")
+   * ```
+   */
+  platform: PlatformProvider;
+  /**
+   * The save provider over the system store, set when `config.save` is `"store"`.
+   *
+   * @example
+   * ```ts
+   * game.screen({ provider: shell.save }); // the save survives a restart of the native app
+   * ```
+   */
+  save: PlayerStateProvider | undefined;
+  /**
+   * Starts the system app. The page starts it before the game, so keep-awake finds it running.
+   *
+   * @returns Resolves when the system app runs.
+   * @example
+   * ```ts
+   * await shell.start();
+   * await app.start();
+   * ```
+   */
+  start(): Promise<void>;
+  /**
+   * Stops the system app.
+   *
+   * @returns Resolves when the system app stopped.
+   * @example
+   * ```ts
+   * await app.stop();
+   * await shell.stop();
+   * ```
+   */
+  stop(): Promise<void>;
+};
+//#endregion
+export { SystemShellFactory as _, GameHandle as a, MemoryProvider as c, SaveKind as d, Scenario as f, SystemName as g, SystemModules as h, GameDefinition as i, PageAgent as l, StartedPage as m, GameApp as n, GamePluginConfigs as o, ScreenSeams as p, GameConfig as r, HeadlessSeams as s, AnyGameApp as t, PageOptions as u };

package/dist/{types-CQueODzo.d.mts → types-CefgYzFt.d.mts}

@@ -1,5 +1,5 @@
-import { D as Point, E as FilterSlot, L as ComponentHandle, V as Entity, _ as PixiModule, bn as Events$1, g as PixiFilter, k as Api$1, m as Api$2, o as Events, t as Api$3, ut as Api, v as PixiSprite, xn as Require, y as PixiTexture, z as ComponentType } from "./types-B0v5VVa3.mjs";
-import { b as AnimApi } from "./types-VZVWwqCg.mjs";
+import { A as Api$1, B as ComponentType, D as FilterSlot, H as Entity, O as Point, R as ComponentHandle, Sn as Require, _ as PixiFilter, b as PixiTexture, dt as Api, h as Api$2, s as Events, t as Api$3, v as PixiModule, xn as Events$1, y as PixiSprite } from "./types-ZQLYXo5X.mjs";
+import { x as AnimApi } from "./types-BM4shh8K.mjs";
 import { Log } from "@moku-labs/common/browser";
 import { PluginCtx } from "@moku-labs/core";
 

package/dist/{types-DUMoYPYe.d.mts → types-DAdwEJMp.d.mts}

@@ -1,5 +1,5 @@
-import { Jt as Json, rn as Snapshot } from "./types-B0v5VVa3.mjs";
-import { t as HeadlessApp } from "./headless-SCQXJxQf.mjs";
+import { Xt as Json, an as Snapshot } from "./types-ZQLYXo5X.mjs";
+import { t as HeadlessApp } from "./headless-G4nuZ-xz.mjs";
 import { Log } from "@moku-labs/common/browser";
 
 //#region src/plugins/flow/doors/types.d.ts