@moku-labs/game 0.14.12 → 0.14.13

package/dist/{commands-BaCx2B9j.d.mts → commands-DAETmK86.d.mts}

@@ -1,13 +1,14 @@
-import { A as Api$2, E as DebugSwitches, Ot as Bookmark, h as Api$1, jt as FlowState, un as Api, w as Captured, yn as Time } from "./types-BjTtGSFb.mjs";
-import { a as AudioApi, r as UiApi, v as ScenesApi, x as AnimApi } from "./types-Y_rCuXtj.mjs";
-import { A as InputApi } from "./types-DOlpeuGx.mjs";
-import { t as HeadlessApp } from "./headless-CMHNsKjW.mjs";
-import { n as Command, r as ControlApp } from "./types-CAPv9l29.mjs";
+import { Hn as FlowState, I as Captured, Ir as Time, Mr as FrameRate, S as ScenesApi, T as Api$1, ht as DebugSwitches, wr as Api, xr as StoreApi, yr as Snapshot, zn as Bookmark, zt as Api$2 } from "./types-BGcda5Le.mjs";
+import { P as AnimApi, a as AudioApi, h as EffectsApi, r as UiApi } from "./types-GHE4J5Uf.mjs";
+import { j as InputApi } from "./types-7GXcXxxv.mjs";
+import { t as HeadlessApp } from "./headless-cFveciuY.mjs";
+import { n as Command, r as ControlApp } from "./types-DngFQJro.mjs";
 
 //#region src/plugins/flow/doors/commands.d.ts
 /**
  * Every command of the engine, keyed by its short name: what an editor lists as buttons and MCP
- * tools. Frozen. Each runs in dev builds only.
+ * tools. Frozen. Each runs on the dev page and on a debug page, by the profile `run` checks: a
+ * `--debug` page runs the read and cosmetic ones.
  *
  * @example
  * ```ts
@@ -62,6 +63,28 @@ declare const commands: Readonly<{
   } & {
     readonly scenes?: ScenesApi;
   }>;
+  saveExport: Command<{}, Snapshot, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly scenes?: ScenesApi;
+  } & {
+    readonly model: {
+      readonly store: Pick<StoreApi, "snapshot" | "flush">;
+    };
+  }>;
+  saveImport: Command<{
+    save: "json";
+  }, {
+    restored: boolean;
+  }, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly scenes?: ScenesApi;
+  } & {
+    readonly model: {
+      readonly store: Pick<StoreApi, "snapshot" | "flush">;
+    };
+  }>;
   step: Command<{
     frames: "number";
     deltaMs: "number?";
@@ -89,7 +112,9 @@ declare const commands: Readonly<{
     readonly world: Api$2;
   }>;
   debug: Command<{
-    nineSlice: "boolean";
+    nineSlice: "boolean?";
+    verifyFrames: "boolean?";
+    kept: "boolean?";
   }, DebugSwitches, HeadlessApp & {
     readonly log: import("@moku-labs/common/browser").LogApi;
   } & {
@@ -113,6 +138,9 @@ declare const commands: Readonly<{
   timeScale: Command<{
     scale: "number";
   }, Readonly<Time>, ControlApp>;
+  frameRate: Command<{
+    fps: "number?";
+  }, Readonly<FrameRate>, ControlApp>;
   mute: Command<{
     muted: "boolean";
   }, boolean, HeadlessApp & {
@@ -127,6 +155,14 @@ declare const commands: Readonly<{
   } & {
     readonly input: InputApi;
   }>;
+  filter: Command<{
+    kind: "string";
+    on: "boolean";
+  }, readonly string[], HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly effects?: EffectsApi;
+  }>;
 }>;
 //#endregion
 export { commands as t };

package/dist/{config-CdARrrhU.mjs → config-B87aFTW-.mjs}

@@ -35,10 +35,27 @@ function systemNames() {
 	]);
 }
 /**
+* The modes a debug page may start the overlay in.
+*
+* @returns The set of `debug.overlay` values.
+* @example
+* ```ts
+* overlayStarts().has("pill"); // true
+* ```
+*/
+function overlayStarts() {
+	return /* @__PURE__ */ new Set([
+		"closed",
+		"pill",
+		"open"
+	]);
+}
+/**
 * Throws for the first value of a config that TypeScript would have refused.
 *
 * @param config - The default export of `config.ts`.
-* @throws {Error} When `save` is not a save kind, a `system` name is not wired, or the title is empty.
+* @throws {Error} When `save` is not a save kind, a `system` name is not wired, the title is empty, or
+* `debug.overlay` is not a start mode.
 */
 function checkConfig(config) {
 	if (config.save !== void 0 && !saveKinds().has(config.save)) throw new Error(`[game] config.save is "${config.save}".\n  Use "memory", "local" or "store".`);
@@ -46,15 +63,18 @@ function checkConfig(config) {
 	const unwired = config.system?.find((name) => !wired.has(name));
 	if (unwired !== void 0) throw new Error(`[game] config.system names "${unwired}", which the game shell does not wire.\n  Use lifecycle, back, haptics, keepAwake or store.`);
 	if (config.page.title.trim() === "") throw new Error("[game] config.page.title is empty.\n  Give the page a title in config.ts.");
+	const overlay = config.debug?.overlay;
+	if (overlay !== void 0 && !overlayStarts().has(overlay)) throw new Error(`[game] config.ts: debug.overlay must be "closed", "pill" or "open", got "${String(overlay)}".`);
 }
 /**
 * Fills every default of a game's `config.ts`: `lang` `"en"`, `background` `"#000000"`,
 * `orientation` `"portrait"`, no icons, no head tags, no system plugin, the memory save, no asset
-* layers.
+* layers, the overlay of a debug page closed at its start.
 *
 * @param config - The default export of `config.ts`.
 * @returns The config with every field set.
-* @throws {Error} When `save` is not a save kind, a `system` name is not wired, or the title is empty.
+* @throws {Error} When `save` is not a save kind, a `system` name is not wired, the title is empty, or
+* `debug.overlay` is not a start mode.
 * @example
 * ```ts
 * resolveConfig({ page: { title: "T" } }).save; // "memory"
@@ -74,7 +94,8 @@ function resolveConfig(config) {
 		native: config.native,
 		system: config.system ?? [],
 		save: config.save ?? "memory",
-		assets: { layers: config.assets?.layers ?? {} }
+		assets: { layers: config.assets?.layers ?? {} },
+		debug: { overlay: config.debug?.overlay ?? "closed" }
 	};
 }
 //#endregion

package/dist/control.d.mts

@@ -1,12 +1,12 @@
-import { t as HeadlessApp } from "./headless-CMHNsKjW.mjs";
-import { i as InputArguments, n as Command, o as InputSchema, s as Ran } from "./types-CAPv9l29.mjs";
-import { t as commands } from "./commands-BaCx2B9j.mjs";
-import { t as defineCommand } from "./define-Ce8SVEN-.mjs";
+import { t as HeadlessApp } from "./headless-cFveciuY.mjs";
+import { i as InputArguments, n as Command, o as InputSchema, s as Ran } from "./types-DngFQJro.mjs";
+import { t as commands } from "./commands-DAETmK86.mjs";
+import { t as defineCommand } from "./define-BASd9ZUh.mjs";
 
 //#region src/plugins/flow/doors/dev.d.ts
 /**
- * @file flow/doors — the dev flag and the errors a door throws. `__MOKU_GAME_DEV__` is a global
- * the engine never replaces: `moku-game dev` defines it `true` (bunfig `define`) and sets
+ * @file flow/doors — the flags of a page and the errors a door throws. `__MOKU_GAME_DEV__` is a
+ * global the engine never replaces: `moku-game dev` defines it `true` (bunfig `define`) and sets
  * `globalThis.__MOKU_GAME_DEV__` in `.moku/dev.ts` before the engine runs; `moku-game build`
  * defines it `false`; undefined means a production build.
  *
@@ -14,6 +14,8 @@ import { t as defineCommand } from "./define-Ce8SVEN-.mjs";
  * vanish from a production bundle writes the guard inline:
  * `if (typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) throw controlRefused();`.
  * A `define` of `false` folds that condition, and the minifier drops the code behind it.
+ * `__MOKU_GAME_AGENT__` and `__MOKU_GAME_CONTROL__` follow the same rules: a define of `false`
+ * folds their guard.
  */
 declare global {
   /**
@@ -27,40 +29,150 @@ declare global {
    * ```
    */
   var __MOKU_GAME_DEV__: boolean | undefined;
+  /**
+   * The agent flag: the editor's page agent is on the page, and measurement code runs. `moku-game dev` and
+   * `moku-game build --debug` set it, `moku-game build` defines it `false`. A game never re-declares it.
+   *
+   * @example
+   * ```ts
+   * // The in-memory agent.ts of `moku-game build --debug`, the first import of its main.ts.
+   * globalThis.__MOKU_GAME_AGENT__ = true;
+   * ```
+   */
+  var __MOKU_GAME_AGENT__: boolean | undefined;
+  /**
+   * The control flag: every /control command runs, the state-changing ones too (`route`, `cheat`, `raw`).
+   * `moku-game dev` and `moku-game build --debug=full` set it; `--debug` and `moku-game build` define it `false`.
+   *
+   * @example
+   * ```ts
+   * // The in-memory agent.ts of `moku-game build --debug=full`.
+   * globalThis.__MOKU_GAME_CONTROL__ = true;
+   * ```
+   */
+  var __MOKU_GAME_CONTROL__: boolean | undefined;
+  /**
+   * The id of the build the page came from: `"dev"` on the dev page, `"debug-20261014T153012Z"` or
+   * `"debug-full-20261014T153012Z"` on a debug build, undefined on a release build.
+   *
+   * @example
+   * ```ts
+   * // The overlay shows which build runs on the phone.
+   * globalThis.__MOKU_GAME_BUILD__; // "debug-20261014T153012Z"
+   * ```
+   */
+  var __MOKU_GAME_BUILD__: string | undefined;
+  /**
+   * The engine the page runs: the id of `engineFingerprint` (E), its version plus a hash of its bundled `dist` and of
+   * any patch of that version. Set on the dev page and on a debug build; undefined on a release build. The editor's
+   * overlay and the header of the performance log (spec 11) read it; the engine's plugins never do.
+   *
+   * @example
+   * ```ts
+   * // The overlay names the engine the phone runs.
+   * globalThis.__MOKU_GAME_ENGINE__; // "0.14.12+9c41e0.patch.3f2a7b"
+   * ```
+   */
+  var __MOKU_GAME_ENGINE__: string | undefined;
+  /**
+   * Where the page agent of a debug build finds the editor: `host:port`, written by `--editor` (default
+   * `"127.0.0.1:47600"`). Undefined on the dev page, whose agent talks to the server that served it, and on a release
+   * build.
+   *
+   * @example
+   * ```ts
+   * // moku-game build --debug --editor 192.168.1.20:47600
+   * globalThis.__MOKU_GAME_EDITOR__; // "192.168.1.20:47600"
+   * ```
+   */
+  var __MOKU_GAME_EDITOR__: string | undefined;
+  /**
+   * The overlay channel of the page agent: the editor's page agent sets it when it starts and deletes it when it stops.
+   * `open()` shows the card; `open({ mode: "pill" })` the small pill; `toggle()` switches between hidden and the last
+   * visible mode; `isOpen()` is true for the pill or the card. A game never sets it: it calls `app.debug.overlay`.
+   *
+   * @example
+   * ```ts
+   * // The editor's page agent, at start:
+   * globalThis.__MOKU_GAME_OVERLAY__ = { open: options => overlay.show(options?.mode ?? "card"), close, toggle, isOpen };
+   * ```
+   */
+  var __MOKU_GAME_OVERLAY__: {
+    open(options?: {
+      mode?: "pill" | "card";
+    }): void;
+    close(): void;
+    toggle(): void;
+    isOpen(): boolean;
+  } | undefined;
 }
 /**
- * Reads the dev flag at call time. Undefined means off: production is the default.
+ * The error `run` throws on a `--debug` page for a command that changes the game: its `reason`
+ * tells it apart from any other failure.
+ *
+ * @example
+ * ```ts
+ * // The editor greys the command out instead of reporting a failure.
+ * const refused: ControlReadOnlyError = controlReadOnly("game.tap");
+ * refused.reason; // "read-only"
+ * ```
+ */
+type ControlReadOnlyError = Error & {
+  readonly reason: "read-only";
+};
+/**
+ * The error a control command throws when its body runs outside the builds its guard allows. It
+ * carries `reason: "dev-only"`, so an editor tells a refusal by the body's guard apart from a
+ * failure, as `reason: "read-only"` tells the refusal of `run` on a `--debug` page.
  *
- * @returns True only when `__MOKU_GAME_DEV__` is exactly `true`.
  * @example
  * ```ts
- * // The dev page set the flag in .moku/dev.ts before the engine started.
- * globalThis.__MOKU_GAME_DEV__ = true;
- * isDev(); // true
+ * const refused: ControlRefusedError = controlRefused();
+ * refused.reason; // "dev-only"
  * ```
  */
+type ControlRefusedError = Error & {
+  readonly reason: "dev-only";
+};
 /**
- * Builds the error a control command throws outside a dev build.
+ * Builds the error a control command throws outside a dev build. It carries `reason: "dev-only"`.
  *
  * @returns The error, ready to throw.
  * @example
  * ```ts
  * // A production build called a /control command.
  * controlRefused().message; // "[game] Control commands run in dev builds only.\n  Define __MOKU_GAME_DEV__ as true in the dev build."
+ * controlRefused().reason; // "dev-only"
+ * ```
+ */
+declare function controlRefused(): ControlRefusedError;
+/**
+ * Builds the error `run` throws on a `--debug` page for a command whose effect is `route`,
+ * `cheat` or `raw`. It carries `reason: "read-only"`, so an editor tells it apart from a failure.
+ *
+ * @param id - The id of the refused command.
+ * @returns The error, ready to throw.
+ * @example
+ * ```ts
+ * // The editor on a --debug page.
+ * try { await run(app, commands.tap, { key: "play" }); } catch (error) { Reflect.get(Object(error), "reason"); // "read-only" }
  * ```
  */
-declare function controlRefused(): Error;
+declare function controlReadOnly(id: string): ControlReadOnlyError;
 //#endregion
 //#region src/plugins/flow/doors/run.d.ts
 /**
- * Runs a command in a dev build. A `cheat` or `raw` command taints the session and is journaled
- * before it runs, so a failing one still counts.
+ * Runs a command in a dev build or a debug build. A debug build of `--debug` runs the read and
+ * cosmetic commands only; `--debug=full` and the dev page run every command. A `cheat` or `raw`
+ * command taints the session and is journaled before it runs, so a failing one still counts.
  *
  * @param app - The app the command acts on.
  * @param command - The command.
  * @param input - Its input; left out when every field of its schema is optional.
  * @returns The command's value and the envelope read after it.
- * @throws {Error} Outside a dev build, and whatever the command throws.
+ * @throws {Error} Outside dev builds and debug builds (read and cosmetic commands; every command
+ *   with `--debug=full`), the read-only refusal of `controlReadOnly` for a `route`, `cheat` or
+ *   `raw` command on a `--debug` page, and whatever the command throws.
  * @example
  * ```ts
  * // An e2e script: load the bug report, then tap Play.
@@ -68,8 +180,9 @@ declare function controlRefused(): Error;
  * const ran = await run(app, commands.answer, { intent: "play" });
  * ran.value; // true
  * ran.state; // { path: "board/awaitIntent", frame: 14, tainted: true }
+ * // On a --debug page: await run(app, commands.tap, { key: "play" }); // throws "[game] The command game.tap changes the game: …"
  * ```
  */
 declare function run<S extends InputSchema, O, App extends HeadlessApp>(app: App, command: Command<S, O, App>, ...input: InputArguments<S>): Promise<Ran<O>>;
 //#endregion
-export { type Command, type Ran, commands, controlRefused, defineCommand, run };
+export { type Command, type ControlReadOnlyError, type ControlRefusedError, type Ran, commands, controlReadOnly, controlRefused, defineCommand, run };

package/dist/control.mjs

@@ -1,4 +1,4 @@
-import { t as controlRefused } from "./dev-Cc50Dk7H.mjs";
-import { s as defineCommand } from "./session-DgukhR_7.mjs";
-import { n as commands, t as run } from "./run-Bf2hKyjZ.mjs";
-export { commands, controlRefused, defineCommand, run };
+import { n as controlRefused, t as controlReadOnly } from "./dev-DbHgx-R-.mjs";
+import { s as defineCommand } from "./session-CeKgO2hy.mjs";
+import { n as commands, t as run } from "./run-BbipFRc6.mjs";
+export { commands, controlReadOnly, controlRefused, defineCommand, run };

package/dist/{define-Ce8SVEN-.d.mts → define-BASd9ZUh.d.mts}

@@ -1,5 +1,5 @@
-import { t as HeadlessApp } from "./headless-CMHNsKjW.mjs";
-import { c as Source, n as Command, o as InputSchema } from "./types-CAPv9l29.mjs";
+import { t as HeadlessApp } from "./headless-cFveciuY.mjs";
+import { c as Source, n as Command, o as InputSchema } from "./types-DngFQJro.mjs";
 
 //#region src/plugins/flow/doors/define.d.ts
 /**
@@ -25,8 +25,13 @@ import { c as Source, n as Command, o as InputSchema } from "./types-CAPv9l29.mj
  */
 declare function defineSource<S extends InputSchema, O, App = HeadlessApp>(source: Source<S, O, App>): Source<S, O, App>;
 /**
- * Declares a command: a dev-only action the editor lists and runs. Its body starts with the
- * inline dev guard, so a production build drops it.
+ * Declares a command: an action the editor lists and runs on the dev page and on a debug page.
+ * Its body starts with the guard of its effect: the agent form for `read` and `cosmetic`, the
+ * control form for the others (see docs/doors.md), so a production build drops it. A game's
+ * `.dev` command with only the `__MOKU_GAME_DEV__` guard runs in dev and is refused on a debug
+ * page. `overlay` shows it in the editor's overlay: `"toggle"` with the input `{ on: "boolean" }`
+ * and a `value(app)` the switch is drawn from, `"button"` with no required input and no value;
+ * any other combination is a type error.
  *
  * @param command - The descriptor.
  * @returns The same descriptor, frozen.
@@ -46,6 +51,29 @@ declare function defineSource<S extends InputSchema, O, App = HeadlessApp>(sourc
  * });
  * (await run(app, openShop)).state.path; // "shop"
  * ```
+ * @example
+ * ```ts
+ * // features/ward/glow.dev.ts — the overlay's "Glow" switch of this game.
+ * export const glowSwitch = defineCommand({
+ *   id: "ward.glow",
+ *   title: "Glow",
+ *   input: { on: "boolean" },
+ *   effect: "cosmetic",
+ *   overlay: "toggle",
+ *   value: (app: { readonly effects: Effects.EffectsApi }) =>
+ *     !app.effects.diagnostics.disabled().includes("effects.glow"),
+ *   run: (app, { on }) => {
+ *     if (
+ *       (typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) &&
+ *       (typeof __MOKU_GAME_AGENT__ === "undefined" || !__MOKU_GAME_AGENT__)
+ *     ) {
+ *       throw controlRefused();
+ *     }
+ *     return on ? app.effects.diagnostics.enable("effects.glow") : app.effects.diagnostics.disable("effects.glow");
+ *   }
+ * });
+ * // The overlay draws a switch "Glow", on; a tap runs it with { on: false } and the next frame draws no glow.
+ * ```
  */
 declare function defineCommand<S extends InputSchema, O, App = HeadlessApp>(command: Command<S, O, App>): Command<S, O, App>;
 //#endregion

package/dist/dev-DbHgx-R-.mjs

@@ -0,0 +1,89 @@
+//#region src/plugins/flow/doors/dev.ts
+/**
+* Reads the dev flag at call time. Undefined means off: production is the default.
+*
+* @returns True only when `__MOKU_GAME_DEV__` is exactly `true`.
+* @example
+* ```ts
+* // The dev page set the flag in .moku/dev.ts before the engine started.
+* globalThis.__MOKU_GAME_DEV__ = true;
+* isDev(); // true
+* ```
+*/
+function isDev() {
+	return typeof __MOKU_GAME_DEV__ !== "undefined" && __MOKU_GAME_DEV__ === true;
+}
+/**
+* Reads the agent flag at call time, for a runtime check; a branch that must leave a bundle
+* writes the inline guard instead.
+*
+* @returns True only when `__MOKU_GAME_AGENT__` is exactly `true`.
+* @example
+* ```ts
+* isAgent(); // true on the page of moku-game build --debug, false on a release page
+* ```
+*/
+function isAgent() {
+	return typeof __MOKU_GAME_AGENT__ !== "undefined" && __MOKU_GAME_AGENT__ === true;
+}
+/**
+* Reads the control flag at call time, for a runtime check; a branch that must leave a bundle
+* writes the inline guard instead.
+*
+* @returns True only when `__MOKU_GAME_CONTROL__` is exactly `true`.
+* @example
+* ```ts
+* isControl(); // true on the page of moku-game build --debug=full, false on a --debug page
+* ```
+*/
+function isControl() {
+	return typeof __MOKU_GAME_CONTROL__ !== "undefined" && __MOKU_GAME_CONTROL__ === true;
+}
+/**
+* Builds the error a control command throws outside a dev build. It carries `reason: "dev-only"`.
+*
+* @returns The error, ready to throw.
+* @example
+* ```ts
+* // A production build called a /control command.
+* controlRefused().message; // "[game] Control commands run in dev builds only.\n  Define __MOKU_GAME_DEV__ as true in the dev build."
+* controlRefused().reason; // "dev-only"
+* ```
+*/
+function controlRefused() {
+	return Object.assign(/* @__PURE__ */ new Error("[game] Control commands run in dev builds only.\n  Define __MOKU_GAME_DEV__ as true in the dev build."), { reason: "dev-only" });
+}
+/**
+* Builds the error `run` throws on a `--debug` page for a command whose effect is `route`,
+* `cheat` or `raw`. It carries `reason: "read-only"`, so an editor tells it apart from a failure.
+*
+* @param id - The id of the refused command.
+* @returns The error, ready to throw.
+* @example
+* ```ts
+* // The editor on a --debug page.
+* try { await run(app, commands.tap, { key: "play" }); } catch (error) { Reflect.get(Object(error), "reason"); // "read-only" }
+* ```
+*/
+function controlReadOnly(id) {
+	return Object.assign(/* @__PURE__ */ new Error(`[game] The command ${id} changes the game: this debug build runs read and cosmetic commands only.\n  Build with moku-game build --debug=full to run it.`), { reason: "read-only" });
+}
+/**
+* Builds the error a door source or command throws when the opt-in plugin it uses is not
+* installed.
+*
+* @param id - The id of the source or the command.
+* @param plugin - The export name of the plugin it uses.
+* @param kind - What the door descriptor is. A source by default.
+* @returns The error, ready to throw.
+* @example
+* ```ts
+* notInstalled("game.sounds", "audioPlugin").message; // "[game] The source game.sounds needs audioPlugin.\n  Add audioPlugin to createApp({ plugins })."
+* notInstalled("game.mute", "audioPlugin", "command").message; // "[game] The command game.mute needs audioPlugin.\n  Add audioPlugin to createApp({ plugins })."
+* ```
+*/
+function notInstalled(id, plugin, kind = "source") {
+	return /* @__PURE__ */ new Error(`[game] The ${kind} ${id} needs ${plugin}.\n  Add ${plugin} to createApp({ plugins }).`);
+}
+//#endregion
+export { isDev as a, isControl as i, controlRefused as n, notInstalled as o, isAgent as r, controlReadOnly as t };

package/dist/{fake-MpzwZhIZ.mjs → fake-6mazmHK3.mjs}

@@ -1,4 +1,6 @@
 //#region src/plugins/clock/fake.ts
+/** Every source `fakeClock` made: the app shell keeps a fake clock's app from adapting its frame rate. */
+const fakeClocks = /*#__PURE__*/ new WeakSet();
 /**
 * Removes and returns the timer that is due first, up to and including `until`.
 * Timers due at the same moment come out in the order they were scheduled.
@@ -59,7 +61,7 @@ function fakeClock(start = 0) {
 		nextId: 1,
 		timers: []
 	};
-	return {
+	const clock = {
 		now: () => state.now,
 		setTimer: (callback, delayMs) => {
 			const id = state.nextId;
@@ -82,6 +84,22 @@ function fakeClock(start = 0) {
 			state.now = moment;
 		}
 	};
+	fakeClocks.add(clock);
+	return clock;
+}
+/**
+* Tells a source `fakeClock` made from any other: the app shell's test seams run on it, and their
+* apps never adapt their frame rate. Not in the root.
+*
+* @param source - A clock source.
+* @returns True for a fake source.
+* @example
+* ```ts
+* isFakeClock(fakeClock()); // true
+* ```
+*/
+function isFakeClock(source) {
+	return fakeClocks.has(source);
 }
 //#endregion
-export { fakeClock as t };
+export { isFakeClock as n, fakeClock as t };