@moku-labs/game 0.0.1 → 0.0.3

package/dist/inspect.d.mts

@@ -0,0 +1,111 @@
+import { $ as Position, Dt as Api, dt as FlowGraph, h as Api$1, l as RenderStats, pt as JournalEntry, t as Api$2, z as EntitySnapshot, zt as Snapshot } from "./types-Cjf3ywai.mjs";
+import { f as Usage, t as Api$3 } from "./types-DgwbzDLP.mjs";
+import { a as InputOf, c as Source, d as HeadlessApp, i as InputArguments, l as WatchApp, o as InputSchema, t as CheatEntry, u as WatchInput } from "./types-D0uYTTC3.mjs";
+import { c as UiNode } from "./types-C0SLQsx0.mjs";
+import { b as UiApi } from "./types-KlE_GL1z.mjs";
+import { n as defineSource } from "./define-BMo0pHe_.mjs";
+import { _ as EffectsApi, a as SoundEntry, t as AudioApi, v as EffectsStats } from "./types-BTycq8_Z.mjs";
+
+//#region src/plugins/flow/doors/read.d.ts
+/**
+ * Reads a source once.
+ *
+ * @param app - The app the source reads.
+ * @param source - The source.
+ * @param input - Its input; left out when every field of its schema is optional.
+ * @returns What the source reads.
+ * @example
+ * ```ts
+ * // An e2e script checks where the game rests after a tap on Play.
+ * read(app, sources.position); // { path: "board/awaitIntent", flow: "board", node: "awaitIntent", waiting: ["tap", "leave"] }
+ * read(app, sources.history, { last: 1 }); // [{ path: "home", outcome: "play", next: "board/awaitIntent", ... }]
+ * ```
+ */
+declare function read<S extends InputSchema, O, App>(app: App, source: Source<S, O, App>, ...input: InputArguments<S>): O;
+/**
+ * Watches a source: reads it on the first frame, then again whenever its change key moved,
+ * in the `signals` phase of the frame loop.
+ *
+ * @param app - The app the source reads.
+ * @param source - The source.
+ * @param input - Its input, or `undefined` when every field of its schema is optional.
+ * @param fn - Called with each value read.
+ * @returns Stops watching.
+ * @example
+ * ```ts
+ * // An editor panel follows the position; it redraws only after the graph moved.
+ * const stop = watch(app, sources.position, undefined, position => panel.show(position.path));
+ * // next frame: panel shows "home"; a tap on Play: panel shows "board/awaitIntent"
+ * stop();
+ * ```
+ */
+declare function watch<S extends InputSchema, O, App extends WatchApp>(app: App, source: Source<S, O, App>, input: WatchInput<S>, fn: (value: O) => void): () => void;
+//#endregion
+//#region src/plugins/flow/doors/sources.d.ts
+/**
+ * Every source of the engine, keyed by its short name: what an editor lists as panel data and
+ * MCP tools. Frozen.
+ *
+ * @example
+ * ```ts
+ * // An e2e script checks where the game rests, and the editor registers every source.
+ * read(app, sources.position).path; // "board/awaitIntent"
+ * for (const source of Object.values(sources)) registry.add(source);
+ * ```
+ */
+declare const sources: Readonly<{
+  graph: Source<{}, FlowGraph, HeadlessApp>;
+  position: Source<{}, Position, HeadlessApp>;
+  history: Source<{
+    last: "number?";
+  }, readonly JournalEntry[], HeadlessApp>;
+  tainted: Source<{}, boolean, HeadlessApp>;
+  cheats: Source<{}, readonly CheatEntry[], HeadlessApp>;
+  model: Source<{}, Snapshot, HeadlessApp & {
+    readonly model: Api;
+  }>;
+  entities: Source<{
+    owner: "string?";
+    component: "string?";
+  }, EntitySnapshot[], HeadlessApp & {
+    readonly world: Api$1;
+  }>;
+  projections: Source<{}, Record<string, Record<string, number>>, HeadlessApp & {
+    readonly world: Api$1;
+  }>;
+  ui: Source<{}, UiNode, HeadlessApp & {
+    readonly ui: UiApi;
+  }>;
+  rect: Source<{
+    key: "string";
+  }, {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+  } | undefined, HeadlessApp & {
+    readonly ui: UiApi;
+    readonly renderer: Api$2;
+  }>;
+  render: Source<{}, RenderStats, HeadlessApp & {
+    readonly renderer: Api$2;
+  }>;
+  sounds: Source<{
+    last: "number?";
+  }, readonly SoundEntry[], HeadlessApp & {
+    readonly audio: AudioApi;
+  }>;
+  effects: Source<{}, EffectsStats, HeadlessApp & {
+    readonly effects: EffectsApi;
+  }>;
+  assets: Source<{}, Usage, HeadlessApp & {
+    readonly assets: Api$3;
+  }>;
+  log: Source<{
+    level: "string?";
+  }, readonly import("@moku-labs/common/browser").LogEntry[], HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  }>;
+}>;
+//#endregion
+export { type InputOf, type InputSchema, type Source, defineSource, read, sources, watch };

package/dist/inspect.mjs

@@ -0,0 +1,3 @@
+import { o as defineSource } from "./session-DmAxY6Ll.mjs";
+import { n as read, r as watch, t as sources } from "./sources-BooL2MsX.mjs";
+export { defineSource, read, sources, watch };

package/dist/jsx-dev-runtime.d.mts

@@ -0,0 +1,2 @@
+import { a as jsxs, i as jsxDEV, n as JSX, r as jsx, t as Fragment } from "./runtime-BstIkrhH.mjs";
+export { Fragment, type JSX, jsx, jsxDEV, jsxs };

package/dist/jsx-dev-runtime.mjs

@@ -0,0 +1,2 @@
+import { i as jsxs, n as jsx, r as jsxDEV, t as Fragment } from "./runtime-DRlwxkIv.mjs";
+export { Fragment, jsx, jsxDEV, jsxs };

package/dist/jsx-runtime.d.mts

@@ -0,0 +1,2 @@
+import { a as jsxs, n as JSX, r as jsx, t as Fragment } from "./runtime-BstIkrhH.mjs";
+export { Fragment, type JSX, jsx, jsxs };

package/dist/jsx-runtime.mjs

@@ -0,0 +1,2 @@
+import { i as jsxs, n as jsx, t as Fragment } from "./runtime-DRlwxkIv.mjs";
+export { Fragment, jsx, jsxs };

package/dist/memory-CvgdnsQO.mjs

@@ -0,0 +1,259 @@
+import { applyPatches, createDraft, enablePatches, finishDraft } from "immer";
+//#region src/plugins/model/store/drafts.ts
+/** Root order of a commit result, so two commits never report the same roots in another order. */
+const rootOrder = Object.freeze([
+	"player",
+	"session",
+	"rng"
+]);
+/**
+* Turns on Immer's patch recording. Idempotent, and called from the state factory rather than at
+* module scope: a module-scope call would run on import, even when no app is created.
+*
+*/
+function enableDraftPatches() {
+	enablePatches();
+}
+/**
+* Freezes a tree and every branch of it. Immer freezes what it produces; this covers the trees
+* that never went through a draft — the initial trees and the ones handed to `restore()`.
+*
+* @param tree - The tree to freeze, in place.
+* @returns The same reference, now frozen.
+* @example
+* ```ts
+* const tree = deepFreeze({ player: { bag: ["key"] } });
+* Object.isFrozen(tree.player.bag); // true
+* ```
+*/
+function deepFreeze(tree) {
+	if (!tree || typeof tree !== "object") return tree;
+	for (const branch of Object.values(tree)) deepFreeze(branch);
+	return Object.freeze(tree);
+}
+/**
+* Maps one Immer patch to our own structural patch, so no Immer type reaches a public type.
+* A removal carries no value, and `exactOptionalPropertyTypes` forbids an explicit `undefined`.
+*
+* @param patch - The Immer patch.
+* @param path - Path of the patch inside its own tree, without the container segment.
+* @returns The structural patch.
+* @example
+* ```ts
+* toPatch({ op: "remove", path: ["doc", "player", "key"] }, ["player", "key"]);
+* // { op: "remove", path: ["player", "key"] }
+* ```
+*/
+function toPatch(patch, path) {
+	if (patch.op === "remove") return {
+		op: patch.op,
+		path
+	};
+	return {
+		op: patch.op,
+		path,
+		value: patch.value
+	};
+}
+/**
+* Derives the touched roots from the patches of one commit, in a fixed order.
+*
+* @param docPatches - Patches of the save document.
+* @param sessionPatches - Patches of the session tree.
+* @returns The roots a listener has to reconcile.
+* @example
+* ```ts
+* rootsOf([{ op: "add", path: ["rng", "streams", "dice"], value: 7 }], []); // ["rng"]
+* rootsOf([], [{ op: "replace", path: ["rolls"], value: 1 }]); // ["session"]
+* ```
+*/
+function rootsOf(docPatches, sessionPatches) {
+	const touched = /* @__PURE__ */ new Set();
+	for (const patch of docPatches) {
+		const [head] = patch.path;
+		if (head === "player" || head === "rng") touched.add(head);
+	}
+	if (sessionPatches.length > 0) touched.add("session");
+	return rootOrder.filter((root) => touched.has(root));
+}
+/**
+* Opens mutable drafts of the frozen save document and session tree.
+* Both live in one draft container, so one `finishDraft` closes the transaction and the patches
+* arrive in one list, tagged by their container key.
+*
+* @param doc - Frozen save document.
+* @param session - Frozen session tree.
+* @returns The open drafts of one transaction.
+* @example
+* ```ts
+* const pair = openDrafts({ player: { coins: 1 }, rng: { seed: 7, streams: {} } }, { rolls: 0 });
+* pair.session; // a mutable draft of { rolls: 0 }: a write never reaches the frozen input
+* ```
+*/
+function openDrafts(doc, session) {
+	return createDraft({
+		doc,
+		session
+	});
+}
+/**
+* Finishes the drafts: the new frozen trees, the patches per tree and the touched roots.
+* The drafts are revoked, so a draft that leaked into a view throws on the next touch instead of
+* corrupting the committed tree in silence.
+*
+* @param pair - Open drafts of one transaction.
+* @returns The frozen trees, the patches split by tree, and the touched roots.
+*/
+function finishDrafts(pair) {
+	const collected = [];
+	const finished = finishDraft(pair, (patches) => {
+		collected.push(...patches);
+	});
+	const docPatches = [];
+	const sessionPatches = [];
+	for (const patch of collected) {
+		const [container, ...path] = patch.path;
+		(container === "doc" ? docPatches : sessionPatches).push(toPatch(patch, path));
+	}
+	return {
+		doc: finished.doc,
+		session: finished.session,
+		patches: {
+			doc: docPatches,
+			session: sessionPatches
+		},
+		roots: rootsOf(docPatches, sessionPatches)
+	};
+}
+/**
+* Applies the patches of one commit to a document, the way a save seam stores what it was handed.
+* A whole-document patch carries the path `[]` and replaces the document. The input is left as it
+* is: the result is a new frozen document.
+*
+* @param document - The document the patches apply to.
+* @param patches - The patches of one commit, in order.
+* @returns The document after the patches.
+* @throws {Error} When a patch names a path the document does not have.
+* @example
+* ```ts
+* applyTo({ player: { coins: 0 } }, [{ op: "replace", path: ["player", "coins"], value: 4 }]);
+* // { player: { coins: 4 } }
+* ```
+*/
+function applyTo(document, patches) {
+	enablePatches();
+	return applyPatches(document, patches);
+}
+/**
+* Drops the drafts without a result: the base trees stay as they are and the drafts are revoked.
+*
+* @param pair - Open drafts of one transaction.
+*/
+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 };

package/dist/{rolldown-runtime-D7D4PA-g.mjs → rolldown-runtime-8H4AJuhK.mjs}

@@ -1,3 +1,4 @@
+import "node:module";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {