@moku-labs/game 0.7.1 → 0.9.0

package/dist/{run-Bcyg32M5.mjs → run-CofJEdYx.mjs}

@@ -1,190 +1,7 @@
-import { a as sheetAlone, u as graphHash } from "./capture-fpd83Mi5.mjs";
+import { a as sheetAlone } from "./capture-fpd83Mi5.mjs";
 import { n as isDev, r as notInstalled, t as controlRefused } from "./dev-wKLgOw7c.mjs";
-import { a as isProjectionTarget, i as recordCheat, o as readTarget, r as isTainted, s as defineCommand, t as inputOrEmpty } from "./input-CK4nxBO1.mjs";
-//#region src/plugins/flow/headless.ts
-const noPayload = null;
-/** Seed of a repro that pins no rng state, the seed `saveOf` writes. */
-const defaultSeed = 1;
-/**
-* Turns whatever `run()` rejected with into an error that can be thrown again.
-*
-* @param value - The rejection value.
-* @returns The value itself when it is an error, a wrapped one otherwise.
-* @example
-* ```ts
-* asError("offline").message; // "[game] The headless run failed.\n  offline."
-* ```
-*/
-function asError(value) {
-	if (value instanceof Error) return value;
-	return /* @__PURE__ */ new Error(`[game] The headless run failed.\n  ${String(value)}.`);
-}
-/**
-* Starts the one loop unless the app's own `onStart` already did, and keeps a fatal error until
-* someone asks for it. `run()` rejects only on a fatal error, and nobody awaits it here.
-*
-* @param app - The started app.
-* @returns The holder of the fatal error.
-*/
-function startLoop(app) {
-	const fatal = { error: void 0 };
-	if (app.flow.state().running) return fatal;
-	app.flow.run().catch((error) => {
-		fatal.error = error;
-	});
-	return fatal;
-}
-/**
-* Waits until the loop rests for the first time, or ends. An empty route walks nowhere: it only
-* waits for the gate the loop opens at the node it enters, so a start that is a chain of transit
-* nodes is played out before anything reads the game.
-*
-* @param app - The started app whose loop is running.
-* @param fatal - Holder of the fatal error of `run()`.
-* @returns Resolves once the loop rests at its first rest node.
-* @throws {Error} When the loop failed fatally instead of reaching a rest node.
-*/
-async function settleAtFirstRest(app, fatal) {
-	await app.flow.walk([]).catch((error) => {
-		throw asError(fatal.error ?? error);
-	});
-	if (fatal.error !== void 0) throw asError(fatal.error);
-}
-/**
-* Starts an app headless: sets flow mode `"fast"`, awaits `app.start()`, starts `flow.run()`
-* unless the app's own `onStart` already did, and waits until the loop rests for the first time.
-* `game.state().path` therefore names the first rest node of the graph as soon as the call
-* resolves. A fatal error of the loop rejects this call, and a later one is re-thrown by `walk`
-* and by `stop`, so a headless test never loses it.
-*
-* @param app - An app that is not started yet.
-* @returns The game: walk it, answer it, read it, stop it.
-* @throws {Error} When the loop failed fatally before it reached its first rest node.
-* @example
-* ```ts
-* // A test starts the merge game without a screen. The call resolves at the first rest node.
-* const game = await createHeadless(app);
-*
-* game.state().path; // "home": the transit node "boot" was played out
-* game.state().mode; // "fast"
-* await game.stop();
-* ```
-*/
-async function createHeadless(app) {
-	app.flow.setMode("fast");
-	await app.start();
-	const fatal = startLoop(app);
-	await settleAtFirstRest(app, fatal);
-	return {
-		walk: async (route) => {
-			const state = await app.flow.walk(route).catch((error) => {
-				throw asError(fatal.error ?? error);
-			});
-			if (fatal.error !== void 0) throw asError(fatal.error);
-			return state;
-		},
-		answer: (answer) => app.flow.gate.answer(answer),
-		state: () => app.flow.state(),
-		history: () => app.flow.history(),
-		stop: async () => {
-			await app.stop();
-			if (fatal.error !== void 0) throw asError(fatal.error);
-		}
-	};
-}
-/**
-* Reads the rest node a repro starts at: its checkpoint, or the start of the main flow.
-*
-* @param app - The started app.
-* @param repro - Starting state, optional checkpoint and the route.
-* @returns The path of the node the repro enters.
-* @throws {Error} When the graph has no main flow to start from.
-*/
-function reproPath(app, repro) {
-	if (repro.checkpoint !== void 0) return repro.checkpoint;
-	const graph = app.flow.describe();
-	const start = graph.flows[graph.main]?.start;
-	if (start === void 0) throw new Error(`[game] runRepro() found no flow "${graph.main}" to start from.\n  Name the checkpoint the repro was taken at.`);
-	return start;
-}
-/**
-* Builds the bookmark a repro is entered with: its state, its checkpoint and the hash of the
-* graph that runs now, so a checkpoint is accepted and any other rest node is checked. The route
-* is not part of it: the caller walks it after the restore.
-*
-* @param app - The started app.
-* @param repro - Starting state, optional checkpoint and the route.
-* @returns The bookmark to restore.
-* @throws {Error} When the repro names no checkpoint and the graph has no main flow.
-* @example
-* ```ts
-* // The game.restore command loads a bug report taken at the "home" checkpoint.
-* const bookmark = reproBookmark(app, { player: { coins: 7 }, checkpoint: "home", route: [] });
-* bookmark.path; // "home"
-* bookmark.rng; // { seed: 1, streams: {} }: the repro pinned no rng
-* await app.flow.restore(bookmark);
-* ```
-*/
-function reproBookmark(app, repro) {
-	return {
-		path: reproPath(app, repro),
-		input: noPayload,
-		player: repro.player,
-		session: repro.session ?? {},
-		rng: repro.rng ?? {
-			seed: defaultSeed,
-			streams: {}
-		},
-		graph: graphHash(app.flow.describe())
-	};
-}
-/**
-* Plays a repro: starts the app headless, restores the bookmark built from its state and
-* checkpoint, then walks its route. The app keeps running, so the caller can read more than the
-* result and stops it itself.
-*
-* @param app - An app that is not started yet.
-* @param repro - Starting state, optional checkpoint and the route.
-* @returns The path the run ended at, and the committed state.
-* @example
-* ```ts
-* // A bug report on the dice game: "reset keeps my coins". Replay it from the "home" checkpoint.
-* const reset = { at: "home", intent: "reset" };
-* const result = await runRepro(app, { player: { coins: 7 }, checkpoint: "home", route: [reset] });
-*
-* result.player; // { coins: 0 }; result.path is ["home"]
-* await app.stop(); // the app keeps running after the run
-* ```
-*/
-async function runRepro(app, repro) {
-	const game = await createHeadless(app);
-	await app.flow.restore(reproBookmark(app, repro));
-	const state = await game.walk(repro.route);
-	const ended = app.flow.bookmark();
-	return {
-		path: state.stack.map((frame) => frame.node),
-		player: ended.player,
-		session: ended.session
-	};
-}
-/**
-* Steps the frame loop by hand: `count` calls of `app.time.step(deltaMs)`. A headless game has no
-* frame source, so this is the only thing that moves the frame phases.
-*
-* @param app - A started app.
-* @param count - Number of frames.
-* @param deltaMs - Milliseconds per frame.
-* @example
-* ```ts
-* // A headless game has no frame source: the test moves the six frame phases by hand.
-* stepFrames(app, 2, 16);
-* app.time.snapshot(); // frame: 2, delta: 16, elapsed: 32
-* ```
-*/
-function stepFrames(app, count, deltaMs) {
-	for (let frame = 0; frame < count; frame += 1) app.time.step(deltaMs);
-}
-//#endregion
+import { n as reproBookmark } from "./headless-BsNdJs9W.mjs";
+import { a as isProjectionTarget, i as recordCheat, o as readTarget, r as isTainted, s as defineCommand, t as inputOrEmpty } from "./input-z_35Jwfn.mjs";
 //#region src/plugins/anim/control.ts
 /**
 * @file anim plugin — the anim command of the `/control` door: switch reduced motion. Dev builds
@@ -1282,4 +1099,4 @@ async function run(app, command, ...input) {
 	};
 }
 //#endregion
-export { stepFrames as a, runRepro as i, commands as n, createHeadless as r, run as t };
+export { commands as n, run as t };

package/dist/{runtime-HTlmRb81.d.mts → runtime-CdNJ0UBm.d.mts}

@@ -1,4 +1,4 @@
-import { a as JsxChild, m as UiIntrinsicElements, t as DescriptionNode } from "./types-BaUUcIaN.mjs";
+import { a as JsxChild, m as UiIntrinsicElements, t as DescriptionNode } from "./types-xXfyk56Q.mjs";
 
 //#region src/plugins/ui/jsx/runtime.d.ts
 /** What the compiler passes as props: the children plus whatever the tag declared. */

package/dist/{sources-DVWJ8nfr.mjs → sources-DNnzyCYf.mjs}

@@ -1,6 +1,6 @@
-import { i as scaleByFits, w as Layer } from "./visual-DUvvPPCt.mjs";
+import { i as scaleByFits, w as Layer } from "./visual-dMW8iqAE.mjs";
 import { r as notInstalled } from "./dev-wKLgOw7c.mjs";
-import { c as defineSource, n as cheatsOf, o as readTarget, r as isTainted, t as inputOrEmpty } from "./input-CK4nxBO1.mjs";
+import { c as defineSource, n as cheatsOf, o as readTarget, r as isTainted, t as inputOrEmpty } from "./input-z_35Jwfn.mjs";
 //#region src/plugins/flow/doors/read.ts
 /**
 * @file flow/doors — `read` and `watch`, the `/inspect` side. Neither changes the game.