@moku-labs/game 0.8.0 → 0.10.0

package/dist/{commands-C1kIfOG5.d.mts → commands-C4QlqijJ.d.mts}

@@ -1,9 +1,8 @@
-import { N as Time, Z as Api, _ as Bookmark, b as FlowState } from "./types-ERb2Y9U5.mjs";
-import { C as Captured, T as DebugSwitches, k as Api$2, m as Api$1 } from "./types-BWzCSRM2.mjs";
-import { t as HeadlessApp } from "./headless-q98SwADR.mjs";
-import { n as Command, r as ControlApp } from "./types-CDSKa0vl.mjs";
-import { H as InputApi } from "./types-DgdMLZnV.mjs";
-import { b as AnimApi, p as ScenesApi, t as AudioApi, v as UiApi } from "./types-DlgsfOmW.mjs";
+import { A as Api$2, E as DebugSwitches, Ot as Bookmark, h as Api$1, jt as FlowState, ln as Api, vn as Time, w as Captured } from "./types-ZQLYXo5X.mjs";
+import { a as AudioApi, r as UiApi, v as ScenesApi, x as AnimApi } from "./types-BM4shh8K.mjs";
+import { A as InputApi } from "./types-BUwDHKXm.mjs";
+import { t as HeadlessApp } from "./headless-G4nuZ-xz.mjs";
+import { n as Command, r as ControlApp } from "./types-DAdwEJMp.mjs";
 
 //#region src/plugins/flow/doors/commands.d.ts
 /**

package/dist/config-CdARrrhU.mjs

@@ -0,0 +1,81 @@
+//#region src/app/config.ts
+/**
+* The save kinds a config may name.
+*
+* @returns The set of save kinds.
+* @example
+* ```ts
+* saveKinds().has("disk"); // false
+* ```
+*/
+function saveKinds() {
+	return /* @__PURE__ */ new Set([
+		"memory",
+		"local",
+		"store"
+	]);
+}
+/**
+* The system plugins the game shell wires, by their `@moku-labs/system` names.
+*
+* @returns The set of system names.
+* @example
+* ```ts
+* systemNames().has("keepAwake"); // true
+* systemNames().has("tray"); // false
+* ```
+*/
+function systemNames() {
+	return /* @__PURE__ */ new Set([
+		"lifecycle",
+		"back",
+		"haptics",
+		"keepAwake",
+		"store"
+	]);
+}
+/**
+* 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.
+*/
+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".`);
+	const wired = systemNames();
+	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.");
+}
+/**
+* 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.
+*
+* @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.
+* @example
+* ```ts
+* resolveConfig({ page: { title: "T" } }).save; // "memory"
+* ```
+*/
+function resolveConfig(config) {
+	checkConfig(config);
+	return {
+		page: {
+			title: config.page.title,
+			lang: config.page.lang ?? "en",
+			background: config.page.background ?? "#000000",
+			orientation: config.page.orientation ?? "portrait",
+			icons: config.page.icons ?? {},
+			head: config.page.head ?? []
+		},
+		native: config.native,
+		system: config.system ?? [],
+		save: config.save ?? "memory",
+		assets: { layers: config.assets?.layers ?? {} }
+	};
+}
+//#endregion
+export { resolveConfig as t };

package/dist/control.d.mts

@@ -1,13 +1,14 @@
-import { t as HeadlessApp } from "./headless-q98SwADR.mjs";
-import { i as InputArguments, n as Command, o as InputSchema, s as Ran } from "./types-CDSKa0vl.mjs";
-import { t as commands } from "./commands-C1kIfOG5.mjs";
-import { t as defineCommand } from "./define-BPpZcpxW.mjs";
+import { t as HeadlessApp } from "./headless-G4nuZ-xz.mjs";
+import { i as InputArguments, n as Command, o as InputSchema, s as Ran } from "./types-DAdwEJMp.mjs";
+import { t as commands } from "./commands-C4QlqijJ.mjs";
+import { t as defineCommand } from "./define-CCc0ozKe.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: a game's dev build defines it `true` (bundler `define`) or sets
- * `globalThis.__MOKU_GAME_DEV__` before the engine runs; undefined means a production build.
+ * 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.
  *
  * Bun does not inline `isDev()` across modules (checked on Bun 1.3.14), so a branch that must
  * vanish from a production bundle writes the guard inline:
@@ -16,12 +17,12 @@ import { t as defineCommand } from "./define-BPpZcpxW.mjs";
  */
 declare global {
   /**
-   * The dev flag of a game. A game never re-declares it: it defines it in the bundler, or sets
-   * `globalThis.__MOKU_GAME_DEV__ = true` in its dev entry.
+   * The dev flag of a game. A game never re-declares it: `moku-game dev` sets it, `moku-game
+   * build` defines it `false`, and a test stubs it.
    *
    * @example
    * ```ts
-   * // web/dev.ts, imported first by the dev page: /control commands run from here on.
+   * // .moku/dev.ts, written by moku-game dev, the first import of the dev page: /control commands run from here on.
    * globalThis.__MOKU_GAME_DEV__ = true;
    * ```
    */
@@ -33,7 +34,7 @@ declare global {
  * @returns True only when `__MOKU_GAME_DEV__` is exactly `true`.
  * @example
  * ```ts
- * // The dev page set the flag in web/dev.ts before the engine started.
+ * // The dev page set the flag in .moku/dev.ts before the engine started.
  * globalThis.__MOKU_GAME_DEV__ = true;
  * isDev(); // true
  * ```

package/dist/control.mjs

@@ -1,4 +1,4 @@
-import { t as controlRefused } from "./dev-wKLgOw7c.mjs";
-import { s as defineCommand } from "./input-z_35Jwfn.mjs";
-import { n as commands, t as run } from "./run-CUPSFM85.mjs";
+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-wYty_Lwo.mjs";
 export { commands, controlRefused, defineCommand, run };

package/dist/{define-BPpZcpxW.d.mts → define-CCc0ozKe.d.mts}

@@ -1,5 +1,5 @@
-import { t as HeadlessApp } from "./headless-q98SwADR.mjs";
-import { c as Source, n as Command, o as InputSchema } from "./types-CDSKa0vl.mjs";
+import { t as HeadlessApp } from "./headless-G4nuZ-xz.mjs";
+import { c as Source, n as Command, o as InputSchema } from "./types-DAdwEJMp.mjs";
 
 //#region src/plugins/flow/doors/define.d.ts
 /**

package/dist/{dev-wKLgOw7c.mjs → dev-Cc50Dk7H.mjs}

@@ -5,7 +5,7 @@
 * @returns True only when `__MOKU_GAME_DEV__` is exactly `true`.
 * @example
 * ```ts
-* // The dev page set the flag in web/dev.ts before the engine started.
+* // The dev page set the flag in .moku/dev.ts before the engine started.
 * globalThis.__MOKU_GAME_DEV__ = true;
 * isDev(); // true
 * ```

package/dist/{memory-CvgdnsQO.mjs → drafts-BawpSaVp.mjs}

@@ -153,107 +153,4 @@ function dropDrafts(pair) {
 	finishDraft(pair);
 }
 //#endregion
-//#region src/plugins/model/store/providers/memory.ts
-/** Seed of a save built by `saveOf` when the caller does not pin one. */
-const defaultSeed = 1;
-/** The base a patch applies to when the provider was never handed a document. */
-const noDocument = {};
-/**
-* Creates an in-memory provider that keeps what it was committed and records every call.
-* It is the default when a game configures no `playerProvider`, and the double every test uses:
-* `provider.calls` is the whole persistence protocol of one run, in order. The document lives as
-* long as the provider does, so a second app over the same instance reads what the first one
-* wrote, and nothing survives the process.
-*
-* `load()` reads the fixture, or everything committed since; without either, the player is new.
-* `commitDurable()` resolves at once: there is no disk behind it.
-*
-* @param fixture - The save `load()` starts from. Omitted: a new player.
-* @param fixture.state - The saved document.
-* @param fixture.version - Schema version of the saved document.
-* @returns A provider that keeps its document and records its calls.
-* @example
-* ```ts
-* // A new player is saved at once. One roll reaches the provider at the next rest node.
-* const provider = memory();
-* const game = await createHeadless(createGame(provider));
-*
-* await game.walk([{ at: "home", intent: "roll" }]);
-* provider.calls.map(call => call.method); // ["load", "commit", "commit"]
-* ```
-*/
-function memory(fixture) {
-	const calls = [];
-	const held = {
-		document: fixture?.state,
-		version: fixture?.version ?? 0
-	};
-	/**
-	* Applies the patches of one commit to the held document.
-	*
-	* @param patches - Doc patches since the last commit.
-	* @param version - Schema version this build writes.
-	* @throws {Error} When a patch names a path the held document does not have.
-	*/
-	const hold = (patches, version) => {
-		held.document = applyTo(held.document ?? noDocument, patches);
-		held.version = version;
-	};
-	return {
-		calls,
-		load: async () => {
-			calls.push({ method: "load" });
-			const document = held.document;
-			if (document === void 0) return null;
-			return {
-				state: document,
-				version: held.version
-			};
-		},
-		commit: (patches, version) => {
-			calls.push({
-				method: "commit",
-				patches,
-				version
-			});
-			hold(patches, version);
-		},
-		commitDurable: async (patches, txId, version) => {
-			calls.push({
-				method: "commitDurable",
-				patches,
-				txId,
-				version
-			});
-			hold(patches, version);
-		},
-		flush: async () => {
-			calls.push({ method: "flush" });
-		}
-	};
-}
-/**
-* Builds a save document from a player tree, with no rng streams drawn yet.
-* Short fixtures in tests read as `saveOf({ coins: 5 })` instead of spelling out the rng branch.
-*
-* @param player - Player tree of the save.
-* @param seed - Rng seed of the save.
-* @returns The save document.
-* @example
-* ```ts
-* // A returning player with 5 coins. The test starts from this save, not from `initialPlayer`.
-* saveOf({ coins: 5 }, 42); // { player: { coins: 5 }, rng: { seed: 42, streams: {} } }
-* const provider = memory({ state: saveOf({ coins: 5 }, 42), version: 1 });
-* ```
-*/
-function saveOf(player, seed = defaultSeed) {
-	return {
-		player,
-		rng: {
-			seed,
-			streams: {}
-		}
-	};
-}
-//#endregion
-export { enableDraftPatches as a, dropDrafts as i, saveOf as n, finishDrafts as o, deepFreeze as r, openDrafts as s, memory as t };
+export { finishDrafts as a, enableDraftPatches as i, deepFreeze as n, openDrafts as o, dropDrafts as r, applyTo as t };

package/dist/fake-MpzwZhIZ.mjs

@@ -0,0 +1,87 @@
+//#region src/plugins/clock/fake.ts
+/**
+* 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.
+*
+* @param state - Innards of the fake clock.
+* @param until - Latest moment that counts as due.
+* @returns The timer to fire, or `undefined` when nothing is due.
+*/
+function takeDue(state, until) {
+	let earliest;
+	for (const timer of state.timers) {
+		if (timer.at > until) continue;
+		if (earliest === void 0 || timer.at < earliest.at) earliest = timer;
+	}
+	if (earliest === void 0) return void 0;
+	const due = earliest;
+	state.timers = state.timers.filter((timer) => timer !== due);
+	return due;
+}
+/**
+* Moves the clock to `until`, firing every timer that falls due on the way, in due order.
+* A timer scheduled inside a callback fires in the same run when it is due before `until`.
+*
+* @param state - Innards of the fake clock.
+* @param until - Moment to stop at.
+*/
+function runDue(state, until) {
+	let due = takeDue(state, until);
+	while (due !== void 0) {
+		state.now = Math.max(state.now, due.at);
+		due.callback();
+		due = takeDue(state, until);
+	}
+	state.now = Math.max(state.now, until);
+}
+/**
+* Creates a fake source for tests. Timers fire synchronously inside `advance`, in due order. A
+* negative delay counts as zero and an unknown handle is ignored.
+*
+* @param start - Starting moment in epoch milliseconds. Defaults to 0.
+* @returns A clock source with the test-only controls `advance` and `set`.
+* @example
+* ```ts
+* // An energy point refills 60 s after it was spent. The test moves the clock, not the minute.
+* const clock = fakeClock(1000);
+* const app = createApp({ pluginConfigs: { clock: { source: clock } } });
+* const seen: number[] = [];
+*
+* app.clock.onElapsed(({ now }) => seen.push(now));
+* app.clock.scheduleAt(61_000);
+* clock.advance(60_000); // the timer fires inside advance, nothing waits
+* seen; // [61000]
+* ```
+*/
+function fakeClock(start = 0) {
+	const state = {
+		now: start,
+		nextId: 1,
+		timers: []
+	};
+	return {
+		now: () => state.now,
+		setTimer: (callback, delayMs) => {
+			const id = state.nextId;
+			state.nextId += 1;
+			state.timers.push({
+				id,
+				at: state.now + Math.max(0, delayMs),
+				callback
+			});
+			return id;
+		},
+		clearTimer: (handle) => {
+			if (typeof handle !== "number") return;
+			state.timers = state.timers.filter((timer) => timer.id !== handle);
+		},
+		advance: (ms) => {
+			runDue(state, state.now + Math.max(0, ms));
+		},
+		set: (moment) => {
+			state.now = moment;
+		}
+	};
+}
+//#endregion
+export { fakeClock as t };

package/dist/{headless-CvamCUcR.mjs → headless-BsNdJs9W.mjs}

@@ -1,4 +1,4 @@
-import { a as graphHash } from "./registry-DlpRCibU.mjs";
+import { u as graphHash } from "./capture-fpd83Mi5.mjs";
 //#region src/plugins/flow/headless.ts
 const noPayload = null;
 /** Seed of a repro that pins no rng state, the seed `saveOf` writes. */

package/dist/{headless-q98SwADR.d.mts → headless-G4nuZ-xz.d.mts}

@@ -1,4 +1,4 @@
-import { A as Api, C as RouteStep, R as Json, X as RngState, b as FlowState, k as Answer, t as Api$1, x as JournalEntry } from "./types-ERb2Y9U5.mjs";
+import { Bt as Answer, Mt as JournalEntry, Pt as RouteStep, Xt as Json, cn as RngState, dt as Api$1, hn as Api, jt as FlowState } from "./types-ZQLYXo5X.mjs";
 
 //#region src/plugins/flow/headless.d.ts
 /**

package/dist/hot.d.mts

@@ -14,8 +14,10 @@
 type HotOptions = {
   /**
    * The files that get the footer. Default: `.tsx` files, `styles.ts`, `view.ts`,
-   * `animations.ts`, `effects.ts` and `generated/strings.<locale>.ts`. Bun runs it as the load
-   * filter on the absolute path, so it should not anchor at the start.
+   * `animations.ts`, `effects.ts`, any `.ts` directly in a `styles/`, `motion/`, `effects/` or
+   * `views/` folder, and in `world/projections/` or `world/layout/`, and
+   * `generated/strings.<locale>.ts`. Bun runs it as the load filter on the absolute path, so it
+   * should not anchor at the start.
    */
   include?: RegExp;
   /**
@@ -70,16 +72,14 @@ type HotPlugin = {
  * @returns The Bun plugin object.
  * @example
  * ```ts
- * // bunfig.toml of a game with the default layout:
- * //   [serve.static]
- * //   plugins = ["@moku-labs/game/hot"]
- * // A game that keeps its views in `look/` folders exports its own plugin from `hot.ts`
- * // and lists `plugins = ["./hot.ts"]` instead:
+ * // `moku-game dev` lists the default plugin in `.moku/bunfig.toml`: a game sets nothing.
+ * // A game with a server of its own and its views in `look/` folders exports its own plugin
+ * // from `hot.ts` and lists `plugins = ["./hot.ts"]` in its own bunfig.toml:
  * export default hot({ include: /\/look\/.*\.ts$/ });
  * ```
  */
 declare function hot(options?: HotOptions): HotPlugin;
-/** The Bun plugin with the default filters, for `plugins = ["@moku-labs/game/hot"]` in `bunfig.toml`. */
+/** The Bun plugin with the default filters: the one `moku-game dev` lists, or `plugins = ["@moku-labs/game/hot"]` in a game's own `bunfig.toml`. */
 declare const _default: HotPlugin;
 //#endregion
 export { HotBuild, HotOptions, HotPlugin, _default as default, hot };

package/dist/hot.mjs

@@ -1,5 +1,5 @@
-import { readFile } from "node:fs/promises";
 import path from "node:path";
+import { readFile } from "node:fs/promises";
 //#region src/hot.ts
 /**
 * @file Hot entry (subpath `./hot`): the Bun plugin of the dev server that hot swaps the views of
@@ -7,16 +7,19 @@ import path from "node:path";
 * update and hands the new exports to the running game through `globalThis.__moku_hot`. The `ui`
 * plugin installs that handler in dev builds only. What swaps: styles, components, projections,
 * animations, text styles, emitters and generated strings. A view module is a `.tsx` file, a
-* `styles.ts`, a `view.ts`, an `animations.ts`, an `effects.ts` or a generated
-* `generated/strings.<locale>.ts`; a logic module never gets the footer, so its save reaches the
-* root and the page reloads and restores its state. The plugin lives in `[serve.static]` of
-* `bunfig.toml`, the dev server only: `Bun.build` of a production build never loads it.
+* `styles.ts`, a `view.ts`, an `animations.ts`, an `effects.ts`, any `.ts` directly in a
+* `styles/`, `motion/`, `effects/` or `views/` folder, any `.ts` directly in `world/projections/`
+* or `world/layout/`, or a generated `generated/strings.<locale>.ts`; a logic module never gets
+* the footer (`world/components/` and `world/systems/` included: they are registered at start), so
+* its save reaches the root and the page reloads and restores its state. `moku-game dev` lists the
+* plugin first in `[serve.static]` of the bunfig it writes, `.moku/bunfig.toml`; a game without the
+* shell lists it in its own `bunfig.toml`. The dev server only: `moku-game build` never loads it.
 */
 /**
-* The default view modules: `.tsx` files, `styles.ts`, `view.ts`, `animations.ts`, `effects.ts`
-* and the generated strings of a locale.
+* The default view modules: the view files by name or by kind folder. Two literals joined, so
+* each stays readable.
 */
-const DEFAULT_INCLUDE = /(\.tsx|\/styles\.ts|\/view\.ts|\/animations\.ts|\/effects\.ts|\/generated\/strings\.[\w-]+\.ts)$/;
+const DEFAULT_INCLUDE = new RegExp(`(${/\.tsx|\/styles\.ts|\/view\.ts|\/animations\.ts|\/effects\.ts|\/generated\/strings\.[\w-]+\.ts/.source}|${/\/(?:styles|motion|effects|views)\/[^/]+\.ts|\/world\/(?:projections|layout)\/[^/]+\.ts/.source})$`);
 /** The generated strings of one locale, the one file under `generated/` that swaps. */
 const STRINGS = /\/generated\/strings\.[\w-]+\.ts$/;
 /** The default folders and test files that never hot swap. The outer group only scopes the `$`. */
@@ -71,11 +74,9 @@ function footerOf(file) {
 * @returns The Bun plugin object.
 * @example
 * ```ts
-* // bunfig.toml of a game with the default layout:
-* //   [serve.static]
-* //   plugins = ["@moku-labs/game/hot"]
-* // A game that keeps its views in `look/` folders exports its own plugin from `hot.ts`
-* // and lists `plugins = ["./hot.ts"]` instead:
+* // `moku-game dev` lists the default plugin in `.moku/bunfig.toml`: a game sets nothing.
+* // A game with a server of its own and its views in `look/` folders exports its own plugin
+* // from `hot.ts` and lists `plugins = ["./hot.ts"]` in its own bunfig.toml:
 * export default hot({ include: /\/look\/.*\.ts$/ });
 * ```
 */
@@ -102,7 +103,7 @@ function hot(options = {}) {
 		}
 	};
 }
-/** The Bun plugin with the default filters, for `plugins = ["@moku-labs/game/hot"]` in `bunfig.toml`. */
+/** The Bun plugin with the default filters: the one `moku-game dev` lists, or `plugins = ["@moku-labs/game/hot"]` in a game's own `bunfig.toml`. */
 var hot_default = hot();
 //#endregion
 export { hot_default as default, hot };