@moku-labs/game 0.0.1 → 0.0.3

package/dist/commands-BOxqlv7w.d.mts

@@ -0,0 +1,99 @@
+import { Tt as Time, Ut as Api, ft as FlowState, lt as Bookmark, t as Api$1, u as DebugSwitches } from "./types-Cjf3ywai.mjs";
+import { d as HeadlessApp, n as Command, r as ControlApp } from "./types-D0uYTTC3.mjs";
+import { H as InputApi } from "./types-C0SLQsx0.mjs";
+import { b as UiApi, t as AnimApi } from "./types-KlE_GL1z.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;
+  }>;
+  fill: Command<{
+    key: "string";
+    value: "string";
+  }, boolean, HeadlessApp & {
+    readonly log: import("@moku-labs/common/browser").LogApi;
+  } & {
+    readonly ui: Pick<UiApi, "fill">;
+  }>;
+}>;
+//#endregion
+export { commands as t };

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,73 @@
+import { d as HeadlessApp, i as InputArguments, n as Command, o as InputSchema, s as Ran } from "./types-D0uYTTC3.mjs";
+import { t as commands } from "./commands-BOxqlv7w.mjs";
+import { t as defineCommand } from "./define-BMo0pHe_.mjs";
+
+//#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 };

package/dist/control.mjs

@@ -0,0 +1,4 @@
+import { t as controlRefused } from "./dev-CcwFrwok.mjs";
+import { n as commands, t as run } from "./run-tlcn1w7y.mjs";
+import { a as defineCommand } from "./session-DmAxY6Ll.mjs";
+export { commands, controlRefused, defineCommand, run };

package/dist/define-BMo0pHe_.d.mts

@@ -0,0 +1,51 @@
+import { c as Source, d as HeadlessApp, n as Command, o as InputSchema } from "./types-D0uYTTC3.mjs";
+
+//#region src/plugins/flow/doors/define.d.ts
+/**
+ * Declares a source: a read-only view the editor lists, reads and watches. The types flow from
+ * the object: the input from `input`, the app from the `read` parameter, the output from its
+ * result.
+ *
+ * @param source - The descriptor.
+ * @returns The same descriptor, frozen.
+ * @throws {Error} When the id is not a dotted name such as `"game.position"`.
+ * @example
+ * ```ts
+ * // A game's .dev module: the orders on the board, re-read after every edge.
+ * export const orders = defineSource({
+ *   id: "timber.orders",
+ *   title: "Orders",
+ *   input: {},
+ *   changes: "edge",
+ *   read: app => app.flow.state().path
+ * });
+ * read(app, orders); // "board/awaitIntent"
+ * ```
+ */
+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.
+ *
+ * @param command - The descriptor.
+ * @returns The same descriptor, frozen.
+ * @throws {Error} When the id is not a dotted name such as `"game.answer"`.
+ * @example
+ * ```ts
+ * // A game's .dev module: open the shop from anywhere, through the graph.
+ * export const openShop = defineCommand({
+ *   id: "timber.openShop",
+ *   title: "Open the shop",
+ *   input: {},
+ *   effect: "route",
+ *   run: app => {
+ *     if (typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) throw controlRefused();
+ *     return app.flow.walk([{ at: "home", intent: "shop" }]);
+ *   }
+ * });
+ * (await run(app, openShop)).state.path; // "shop"
+ * ```
+ */
+declare function defineCommand<S extends InputSchema, O, App = HeadlessApp>(command: Command<S, O, App>): Command<S, O, App>;
+//#endregion
+export { defineSource as n, defineCommand as t };

package/dist/dev-CcwFrwok.mjs

@@ -0,0 +1,413 @@
+//#region src/plugins/flow/runner/journal.ts
+/** FNV-1a 32-bit offset basis. */
+const OFFSET_BASIS = 2166136261;
+/** FNV-1a 32-bit prime. */
+const PRIME = 16777619;
+/** Separates the parts of a hashed edge, so "a|b" and "a" + "b" never collide. */
+const SEPARATOR = "\0";
+/**
+* Hashes text with FNV-1a, 32 bit. Pure and deterministic: the same text always gives the same
+* eight hexadecimal characters, in every runtime.
+*
+* @param text - The text to hash.
+* @returns Eight lowercase hexadecimal characters.
+* @example
+* ```ts
+* hashText("board/merge"); // "53ceca70"
+* ```
+*/
+function hashText(text) {
+	let hash = OFFSET_BASIS;
+	for (const character of text) hash = Math.imul(hash ^ (character.codePointAt(0) ?? 0), PRIME);
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+/**
+* Hashes one edge, so a replay against edited code fails loudly in dev.
+*
+* @param path - Path of the node that produced the outcome.
+* @param outcome - Outcome name.
+* @param next - Rendered edge target.
+* @returns The digest of the three parts together.
+* @example
+* ```ts
+* entryHash("board/merge", "done", "board/awaitIntent"); // "e881176b"
+* ```
+*/
+function entryHash(path, outcome, next) {
+	return hashText([
+		path,
+		outcome,
+		next
+	].join(SEPARATOR));
+}
+/**
+* Appends an entry with the next index and its hash, and drops the oldest entries above the limit.
+* The index keeps counting while entries are dropped, so two entries never share a number.
+*
+* @param state - Runner state that holds the journal.
+* @param entry - The taken edge without `index` and `hash`.
+* @param limit - Journal entries kept between checkpoints.
+* @returns The stored entry.
+*/
+function pushEntry(state, entry, limit) {
+	const stored = {
+		...entry,
+		index: state.journalIndex,
+		hash: entryHash(entry.path, entry.outcome, entry.next)
+	};
+	state.journalIndex += 1;
+	state.journal.push(stored);
+	if (state.journal.length > limit) state.journal.splice(0, state.journal.length - limit);
+	return stored;
+}
+/**
+* Clears the journal at a checkpoint. The running index is kept, and so is the array itself: a
+* reader that holds `history()` sees the compaction.
+*
+* @param state - Runner state that holds the journal.
+*/
+function compact(state) {
+	state.journal.length = 0;
+}
+//#endregion
+//#region src/plugins/flow/runner/registry.ts
+/**
+* Creates the empty flow map. It lives in its own function because the plugin's lint rule L5
+* refuses a collection built inside an exported declaration.
+*
+* @returns An empty map of flow id to flow.
+* @example
+* ```ts
+* emptyFlows().size; // 0
+* ```
+*/
+function emptyFlows() {
+	return /* @__PURE__ */ new Map();
+}
+/**
+* Adds a flow and every flow it reaches by reference to the map. The first flow under an id wins,
+* so a collision is visible to `validateGraph` instead of silently replacing a flow.
+*
+* @param flow - The flow to add.
+* @param flows - The map being filled.
+*/
+function addFlow(flow, flows) {
+	if (flows.has(flow.id)) return;
+	flows.set(flow.id, flow);
+	for (const entry of Object.values(flow.nodes)) if (entry.kind === "flow") addFlow(entry, flows);
+}
+/**
+* Collects every flow reachable from the main flow by reference, plus the registered extras.
+* The main flow is the first entry: `describeGraph` reads it as the entry point of the graph.
+*
+* @param main - The top-level flow.
+* @param extra - Flows added with `register`, not reachable by reference.
+* @returns Flow id to flow, main first.
+* @example
+* ```ts
+* [...collectFlows(mainFlow, []).keys()]; // ["main", "board"]: the main flow first
+* ```
+*/
+function collectFlows(main, extra) {
+	const flows = emptyFlows();
+	addFlow(main, flows);
+	for (const flow of extra) addFlow(flow, flows);
+	return flows;
+}
+/**
+* Renders a position as a path: the node of every frame, outermost first.
+*
+* @param stack - One frame per nesting level.
+* @returns The path, for example `"board/awaitIntent"`; empty without a position.
+* @example
+* ```ts
+* const board = { flow: "main", node: "board", input: null };
+* framePath([board, { flow: "board", node: "merge", input: null }]); // "board/merge"
+* ```
+*/
+function framePath(stack) {
+	return stack.map((frame) => frame.node).join("/");
+}
+/**
+* Picks the flow a path continues in after one entry: the sub-flow itself, or, behind a slot, the
+* first contribution in order that has the next segment as a node. A path keeps node names only,
+* so two contributions of one slot with the same node name cannot be told apart; `validateGraph`
+* warns about that.
+*
+* @param entry - The entry the path just passed.
+* @param next - The next segment of the path.
+* @param contributionsOf - Reads the contributions of a slot, in order.
+* @returns The flow to go on in, or `undefined` when the path ends here.
+*/
+function flowBehind(entry, next, contributionsOf) {
+	if (entry.kind === "flow") return entry;
+	if (entry.kind !== "slot") return void 0;
+	return contributionsOf(entry.name).find((item) => Object.hasOwn(item.flow.nodes, next))?.flow;
+}
+/**
+* Reads no contributions: the default of `findNode` for a caller that has no features API.
+*
+* @returns An empty list.
+* @example
+* ```ts
+* noContributions(); // []
+* ```
+*/
+function noContributions() {
+	return [];
+}
+/**
+* Finds the node, sub-flow or slot a path names, starting at the main flow. A path descends one
+* sub-flow per segment, and through a slot into the contribution that has the next segment; a
+* segment after a plain node finds nothing.
+*
+* @param main - The top-level flow.
+* @param path - A path as `framePath` renders it.
+* @param contributionsOf - Reads the contributions of a slot, in order. Without it a path ends at
+*   a slot.
+* @returns Where the path leads, or `undefined` when no such node exists.
+* @example
+* ```ts
+* findNode(mainFlow, "board/awaitIntent")?.trail;
+* // [{ flow: "main", node: "board" }, { flow: "board", node: "awaitIntent" }]
+* findNode(mainFlow, "afterOrder/show", () => [{ flow: rewardFlow }])?.trail;
+* // [{ flow: "main", node: "afterOrder" }, { flow: "rewardPopup", node: "show" }]
+* ```
+*/
+function findNode(main, path, contributionsOf = noContributions) {
+	const names = path.split("/").filter(Boolean);
+	const trail = [];
+	let flow = main;
+	for (const [step, name] of names.entries()) {
+		const entry = flow.nodes[name];
+		if (!entry) return void 0;
+		trail.push({
+			flow: flow.id,
+			node: name
+		});
+		if (step === names.length - 1) return {
+			flow,
+			name,
+			entry,
+			trail
+		};
+		const behind = flowBehind(entry, names[step + 1] ?? "", contributionsOf);
+		if (behind === void 0) return void 0;
+		flow = behind;
+	}
+}
+/**
+* Renders an edge target as a string: a node name, `"exit:win"` or `"map:node"`.
+*
+* @param target - The target as the edge table holds it.
+* @returns The rendered target.
+* @example
+* ```ts
+* renderTarget("home"); // "home"
+* renderTarget({ kind: "exit", outcome: "win" }); // "exit:win"
+* ```
+*/
+function renderTarget(target) {
+	if (typeof target === "string") return target;
+	return target.kind === "exit" ? `exit:${target.outcome}` : `map:${target.target}`;
+}
+/**
+* Renders the edge table of one flow.
+*
+* @param flow - The flow to render.
+* @returns Node name to outcome name to rendered target.
+* @example
+* ```ts
+* renderEdges(boardFlow).awaitIntent?.leave; // "exit:left"
+* ```
+*/
+function renderEdges(flow) {
+	const edges = {};
+	for (const [name, row] of Object.entries(flow.edges)) {
+		const rendered = {};
+		for (const [outcome, target] of Object.entries(row)) rendered[outcome] = renderTarget(target);
+		edges[name] = rendered;
+	}
+	return edges;
+}
+/**
+* Maps every node and flow a feature brought to the name of that feature.
+*
+* @param features - Features API.
+* @returns Node or flow object to feature name.
+*/
+function collectOwners(features) {
+	const owners = /* @__PURE__ */ new Map();
+	for (const { name, description } of features.all()) {
+		for (const node of description.nodes ?? []) owners.set(node, name);
+		for (const flow of description.flows ?? []) owners.set(flow, name);
+	}
+	return owners;
+}
+/**
+* Describes one entry of a flow: its flags, its scene, its outcome names, and the slot, sub-flow
+* or owning feature when it has one.
+*
+* @param flow - The flow that holds the entry.
+* @param name - Name of the entry inside that flow.
+* @param entry - The node, sub-flow or slot.
+* @param owner - Name of the feature that brought it, when a feature did.
+* @returns The entry as JSON.
+* @example
+* ```ts
+* describeNode(mainFlow, "home", home, undefined).rest; // true
+* describeNode(mainFlow, "board", boardFlow, "board").subFlow; // "board"
+* ```
+*/
+function describeNode(flow, name, entry, owner) {
+	const node = entry.kind === "node" ? entry : void 0;
+	return {
+		flow: flow.id,
+		node: name,
+		rest: node?.rest ?? false,
+		over: node?.over ?? false,
+		checkpoint: node?.checkpoint ?? false,
+		barrier: node?.barrier ?? false,
+		outcomes: Object.keys(entry.outcomes),
+		...node?.scene === void 0 ? {} : { scene: node.scene },
+		...entry.kind === "slot" ? { slot: entry.name } : {},
+		...entry.kind === "flow" ? { subFlow: entry.id } : {},
+		...owner === void 0 ? {} : { owner }
+	};
+}
+/**
+* Describes every entry of one flow.
+*
+* @param flow - The flow to describe.
+* @param owners - Node or flow object to feature name.
+* @returns Node name to description.
+* @example
+* ```ts
+* describeNodes(boardFlow, new Map()).merge?.outcomes; // ["done", "rejected"]
+* ```
+*/
+function describeNodes(flow, owners) {
+	const nodes = {};
+	for (const [name, entry] of Object.entries(flow.nodes)) nodes[name] = describeNode(flow, name, entry, owners.get(entry) ?? owners.get(flow));
+	return nodes;
+}
+/**
+* Collects the slot names of every flow of the graph. `describe()` and `validate` both read the
+* contributions of exactly these slots.
+*
+* @param flows - Every collected flow by id.
+* @returns The slot names, in the order the graph declares them, each once.
+* @example
+* ```ts
+* slotNames(collectFlows(mainFlow, [])); // ["afterOrder"]
+* ```
+*/
+function slotNames(flows) {
+	const names = [];
+	for (const flow of flows.values()) for (const entry of Object.values(flow.nodes)) if (entry.kind === "slot" && !names.includes(entry.name)) names.push(entry.name);
+	return names;
+}
+/**
+* Renders the whole graph as JSON without running the game: nodes, flags, outcomes, edges,
+* slots and who contributed. Edge targets become `"node"`, `"exit:win"`, `"map:node"`.
+*
+* @param flows - Every collected flow by id, the main flow first, as `collectFlows` returns them.
+* @param features - Features API: owners and slot contributions.
+* @returns The graph as plain JSON.
+*/
+function describeGraph(flows, features) {
+	const owners = collectOwners(features);
+	const described = {};
+	const slots = {};
+	for (const flow of flows.values()) described[flow.id] = {
+		nodes: describeNodes(flow, owners),
+		start: flow.start,
+		edges: renderEdges(flow)
+	};
+	for (const name of slotNames(flows)) slots[name] = features.contributions(name).map(({ feature, flow, order }) => ({
+		feature,
+		flow: flow.id,
+		order
+	}));
+	return {
+		main: [...flows.keys()][0] ?? "",
+		flows: described,
+		slots
+	};
+}
+/**
+* Compares two object keys without a locale, so the rendering is the same everywhere.
+*
+* @param first - First key.
+* @param second - Second key.
+* @returns A negative number, zero or a positive number.
+* @example
+* ```ts
+* compareKeys("edges", "nodes"); // -1
+* ```
+*/
+function compareKeys(first, second) {
+	if (first === second) return 0;
+	return first < second ? -1 : 1;
+}
+/**
+* Renders a JSON value with its object keys sorted, so two equal graphs written in a different
+* order hash the same.
+*
+* @param value - Any JSON value.
+* @returns The value as text.
+* @example
+* ```ts
+* stableJson({ b: 1, a: 2 }); // '{"a":2,"b":1}'
+* ```
+*/
+function stableJson(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableJson(item)).join(",")}]`;
+	if (typeof value !== "object" || !value) return JSON.stringify(value) ?? "";
+	return `{${Object.entries(value).filter(([, item]) => item !== void 0).toSorted(([first], [second]) => compareKeys(first, second)).map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(",")}}`;
+}
+/**
+* Hashes a graph description. A bookmark of a plain rest node is accepted only while this hash
+* is unchanged.
+*
+* @param graph - Result of `describeGraph`.
+* @returns Eight lowercase hexadecimal characters.
+* @example
+* ```ts
+* graphHash({ main: "main", flows: {}, slots: {} }); // "cfb16c03"
+* ```
+*/
+function graphHash(graph) {
+	return hashText(stableJson(graph));
+}
+//#endregion
+//#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 web/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;
+}
+/**
+* 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."
+* ```
+*/
+function controlRefused() {
+	return /* @__PURE__ */ new Error("[game] Control commands run in dev builds only.\n  Define __MOKU_GAME_DEV__ as true in the dev build.");
+}
+//#endregion
+export { findNode as a, slotNames as c, describeGraph as i, compact as l, isDev as n, framePath as o, collectFlows as r, graphHash as s, controlRefused as t, pushEntry as u };