@moku-labs/game 0.0.1 → 0.0.2

package/dist/component-DGg5DqKK.mjs

@@ -0,0 +1,44 @@
+//#region src/plugins/ui/jsx/component.ts
+/** The local state a component that declares none starts every instance with. */
+const noLocal = {};
+/**
+* Tells a component definition from a plain function component, which JSX calls at build time.
+*
+* @param type - What stood in the tag position.
+* @returns True when `defineComponent` built it.
+* @example
+* ```ts
+* isComponentDefinition(() => ({ type: "row", props: {}, children: [] })); // false
+* ```
+*/
+function isComponentDefinition(type) {
+	return typeof type === "function" && type.isUiComponent === true;
+}
+/**
+* The one implementation behind the two overloads.
+*
+* @param name - Component name.
+* @param spec - What the game declared.
+* @returns The callable definition.
+*/
+function defineComponent(name, spec) {
+	const local = spec.local ?? noLocal;
+	const call = (props) => ({
+		type: name,
+		props,
+		children: []
+	});
+	const definition = Object.assign(call, {
+		outcomes: spec.outcomes,
+		local,
+		view: spec.view,
+		isUiComponent: true
+	});
+	Object.defineProperty(definition, "name", {
+		value: name,
+		configurable: true
+	});
+	return definition;
+}
+//#endregion
+export { isComponentDefinition as n, defineComponent as t };

package/dist/control.d.mts

@@ -0,0 +1,162 @@
+import { M as Time, X as Api, g as Bookmark, y as FlowState } from "./types-JNc_UQBo.mjs";
+import { s as DebugSwitches, t as Api$1 } from "./types-BxkNNYul.mjs";
+import { t as HeadlessApp } from "./headless-KaSWcd0s.mjs";
+import { a as ControlApp, c as InputSchema, i as Command, l as Ran, o as InputArguments, t as defineCommand } from "./define-sFoO3y6X.mjs";
+import { H as InputApi } from "./types-yg_ywtT-.mjs";
+import { r as UiApi } from "./types-DD-QrG_z.mjs";
+import { t as AnimApi } from "./types-CTPS9GBu.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.
+ *
+ * @example
+ * ```ts
+ * // An e2e script taps Play, and the editor registers every command.
+ * (await run(app, commands.tap, { key: "play" })).state.path; // "board/awaitIntent"
+ * for (const command of Object.values(commands)) registry.add(command);
+ * ```
+ */
+declare const commands: Readonly<{
+  answer: Command<{
+    intent: "string";
+    payload: "json?";
+  }, boolean, ControlApp>;
+  tap: Command<{
+    key: "string?";
+    target: "json?";
+  }, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly input: Pick<InputApi, "tap">;
+    readonly ui: Pick<UiApi, "find">;
+  }>;
+  drag: Command<{
+    from: "json";
+    to: "json";
+  }, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly input: InputApi;
+  }>;
+  key: Command<{
+    key: "string";
+    shift: "boolean?";
+  }, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly input: InputApi;
+  }>;
+  walk: Command<{
+    route: "json";
+  }, FlowState, ControlApp>;
+  bookmark: Command<{}, Bookmark, ControlApp>;
+  restore: Command<{
+    bookmark: "json?";
+    repro: "json?";
+  }, FlowState, ControlApp>;
+  step: Command<{
+    frames: "number";
+    deltaMs: "number?";
+  }, Readonly<Time>, ControlApp>;
+  pause: Command<{}, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly lifecycle: Api;
+  }>;
+  resume: Command<{}, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly lifecycle: Api;
+  }>;
+  capture: Command<{}, string | undefined, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly renderer: Api$1;
+  }>;
+  debug: Command<{
+    nineSlice: "boolean";
+  }, DebugSwitches, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly renderer: Api$1;
+  }>;
+  reducedMotion: Command<{
+    on: "boolean";
+  }, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly anim: AnimApi;
+  }>;
+}>;
+//#endregion
+//#region src/plugins/flow/doors/dev.d.ts
+/**
+ * @file flow/doors — the dev flag. `__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.
+ *
+ * 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:
+ * `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.
+ */
+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.
+   *
+   * @example
+   * ```ts
+   * // web/dev.ts, imported first by the dev page: /control commands run from here on.
+   * globalThis.__MOKU_GAME_DEV__ = true;
+   * ```
+   */
+  var __MOKU_GAME_DEV__: boolean | undefined;
+}
+/**
+ * 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 web/dev.ts before the engine started.
+ * globalThis.__MOKU_GAME_DEV__ = true;
+ * isDev(); // true
+ * ```
+ */
+/**
+ * Builds the error a control command throws outside a dev build.
+ *
+ * @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."
+ * ```
+ */
+declare function controlRefused(): Error;
+//#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.
+ *
+ * @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.
+ * @example
+ * ```ts
+ * // An e2e script: load the bug report, then tap Play.
+ * await run(app, commands.restore, { repro }); // state: { path: "home", frame: 12, tainted: true }
+ * const ran = await run(app, commands.answer, { intent: "play" });
+ * ran.value; // true
+ * ran.state; // { path: "board/awaitIntent", frame: 14, tainted: true }
+ * ```
+ */
+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 };