@moku-labs/game 0.2.0 → 0.4.0

package/dist/{visual-NPrDkvUk.mjs → visual-DUvvPPCt.mjs}

@@ -282,6 +282,56 @@ const Text = /*#__PURE__*/ component("Text", {
 	alpha: 1,
 	resolved: ""
 }, { owned: ["resolved"] });
+/** What a `Countdown` starts as. Its own const, because a component takes a typed defaults object. */
+const countdownDefaults = {
+	until: 0,
+	left: 0
+};
+/**
+* Shows a numeric component field of the label's own entity: read every frame, written to
+* `Text.resolved` only when the shown string changes. The field must hold a number; the format
+* is `"int"` (rounded) unless named. Reads the component's own name, so a renamed component
+* cannot drift from its label.
+*
+* @param component - The component whose field the label shows.
+* @param field - A numeric field of that component.
+* @param options - How the number is shown.
+* @returns The bind a `Text` carries.
+* @example
+* ```ts
+* const Counter = component("Counter", { value: 0 });
+*
+* bind(Counter, "value"); // { component: "Counter", field: "value", format: "int" }
+*
+* // The chest timer: the time left, as minutes and seconds.
+* Text({ style: "digits", bind: bind(Countdown, "left", { format: "mm:ss" }) });
+* // bind is { component: "Countdown", field: "left", format: "mm:ss" }; 95 s left shows "01:35"
+* ```
+*/
+function bind(component, field, options = {}) {
+	return {
+		component: component.componentName,
+		field,
+		format: options.format ?? "int"
+	};
+}
+/**
+* A moment to count down to. A game writes `until`, a moment of `clock` in epoch milliseconds;
+* `text` keeps `left` at the time that is left, computed from one `clock.now()` per frame on the
+* render side, and writes it only when the label bound to it changes. At zero both stay at zero.
+* Nothing of it reaches the save.
+*
+* @example
+* ```ts
+* // The chest of the board opens at a moment of the save; clock.now() is 1_790_000_000_000.
+* view: chest => [
+*   Countdown({ until: chest.opensAt }), // opensAt: 1_790_000_095_000
+*   Text({ style: "digits", bind: bind(Countdown, "left", { format: "mm:ss" }) })
+* ]
+* // after the frame that spawns it: Text.resolved is "01:35", Countdown.left is 95000
+* ```
+*/
+const Countdown = /*#__PURE__*/ component("Countdown", countdownDefaults, { owned: ["left"] });
 /**
 * Bundles the two components a label needs, so a projection `view` reads as one line. The anchor
 * is the point of the block that sits on the transform.
@@ -737,4 +787,4 @@ function samePose(first, second) {
 	return first.x === second.x && first.y === second.y && first.rotation === second.rotation && first.scale === second.scale && first.pivot.x === second.pivot.x && first.pivot.y === second.pivot.y;
 }
 //#endregion
-export { Order as C, resource as D, mut as E, system as O, Layer as S, component as T, Sprite as _, visualOf as a, sprite as b, builtInStyles as c, readStyle as d, textFor as f, Shape as g, Parent as h, scaleByFits as i, tag as k, defineTextStyles as l, NineSlice as m, fitScaleOf as n, visualRectOf as o, Display as p, samePose as r, Text as s, CONTENT as t, label as u, Transform as v, Tree as w, Exiting as x, componentsFor as y };
+export { system as A, Exiting as C, component as D, Tree as E, mut as O, sprite as S, Order as T, Parent as _, visualOf as a, Transform as b, Text as c, defineTextStyles as d, label as f, NineSlice as g, Display as h, scaleByFits as i, tag as j, resource as k, bind as l, textFor as m, fitScaleOf as n, visualRectOf as o, readStyle as p, samePose as r, Countdown as s, CONTENT as t, builtInStyles as u, Shape as v, Layer as w, componentsFor as x, Sprite as y };

package/llms.txt

@@ -18,12 +18,12 @@ Root exports:
 - Functions: `createApp`, `createPlugin`, `defineGame`, `defineFeature`, `type`, `exit`, `to`, `slot`, `schedule`, `guide`, `hint`.
 - Class: `SaveUnreadableError`.
 - Plugin instances: `timePlugin`, `lifecyclePlugin`, `modelPlugin`, `clockPlugin`, `flowPlugin`, `worldPlugin`, `rendererPlugin`, `inputPlugin`, `assetsPlugin`, `scenesPlugin`, `animPlugin`, `i18nPlugin`, `textPlugin`, `uiPlugin`, `audioPlugin`, `effectsPlugin`, `platformPlugin`; the list `screen` = `world`, `renderer`, `input`, `assets`, `scenes`, `anim`, `i18n`, `text`, `ui`. `effects`, `audio` and `platform` are opt-in: `plugins: [...screen, effectsPlugin, audioPlugin, platformPlugin]`, `platform` last.
-- Screen helpers from the root: `component`, `tag`, `resource`, `mut`, `system`, `projection`, `Layer`, `Order`, `Exiting`, `Tree`, `Transform`, `Sprite`, `NineSlice`, `Shape`, `Parent`, `Display`, `sprite`, `Tappable`, `Pressable`, `Draggable`, `DropTarget`, `Swipeable`, `Touchable`, `Held`, `Hovered`, `PointerOver`, `Pressed`, `Pointer`, `defineBundles`, `load`, `defineScene`.
-- Interface helpers from the root (V3): `defineAnimation`, `sequence`, `parallel`, `stagger`, `tween`, `set`, `wait`, `mark`, `frames`, `sfx`, `haptic`, `use`, `spawn`, `spawned`, `play`, `external`, `defineMotion`, `Animation`, `Frames`; `tr`; `Text`, `label`, `defineTextStyles`; `defineComponent`, `popup`, `defineStyle`, `defineTokens`, `resolve`, `Box`, `LocalWrite`; `music`.
+- Screen helpers from the root: `component`, `tag`, `resource`, `mut`, `system`, `projection`, `Layer`, `Order`, `Exiting`, `Tree`, `Transform`, `Sprite`, `NineSlice`, `Shape`, `Parent`, `Display`, `sprite`, `Tappable`, `Pressable`, `Draggable`, `DropTarget`, `Swipeable`, `Traceable`, `Touchable`, `Held`, `Hovered`, `PointerOver`, `Pressed`, `Pointer`, `Traced`, `defineBundles`, `load`, `defineScene`.
+- Interface helpers from the root (V3): `defineAnimation`, `sequence`, `parallel`, `stagger`, `tween`, `set`, `wait`, `mark`, `frames`, `sfx`, `haptic`, `use`, `spawn`, `spawned`, `play`, `external`, `defineMotion`, `Animation`, `Frames`; `tr`; `Text`, `label`, `defineTextStyles`, `bind`, `Countdown` and the types `BindOptions`, `CountdownValue`, `TextFormat`; `defineComponent`, `popup`, `defineStyle`, `defineTokens`, `resolve`, `Box`, `LocalWrite`; `music`.
 - Effects helpers from the root (V5): `defineEmitter`, `Emitter`, `defineFilter`, `Glow`, `Outline`, `Blur`, `ColorMatrix`, `Noise`, `Displacement`, `Alpha`.
 - Platform from the root (V6): the types `PlatformProvider`, `BackResult`, `HapticKind` and the frozen list `HAPTIC_KINDS`.
 - `defineGame<Types>()` returns, typed by the game's `player`, `session`, `assets`, `bundles`, `scenes`, `strings` and `textStyles`: `defineNode`, `defineFlow`, `defineFeature`, `projection`, `sprite`, `Sprite`, `NineSlice`, `defineBundles`, `load`, `defineScene`, `defineAnimation`, `frames`, `sfx`, `play`, `tr`, `label`, `defineTextStyles`, `defineComponent`, `defineStyle`, `defineTokens`, `popup`, `music`, `Frames`, `defineEmitter`, `Emitter`, `Displacement`. `Types` is `{ player; session; assets: string; bundles?: string; scenes?: string; strings: Record<string, unknown>; textStyles?: string; emitters?: string }`.
-- `@moku-labs/game/assets`: `scanAssets(options)`, `emitKeys`, `emitManifest`, `compileStrings(root, out, options?)`, `checkStrings`, `packAssets(options)`, `runCli(argv, compileStrings)`. Asset key = feature + "." + path inside `assets/`. `runCli` (a game's `bun run assets:keys`) scans the assets and compiles `features/*/strings/<locale>.json` into `generated/strings.ts` (the `Strings` type for `defineGame`) and one `generated/strings.<locale>.ts` per locale; `--check` fails when any output is out of date; `--pack <dir>` writes the production build. The package bin `moku-game-assets` is this CLI: a game's script is `"assets:keys": "moku-game-assets --root src --manifest public/assets/manifest.json --keys src/generated/assets.ts"`.
+- `@moku-labs/game/assets`: `scanAssets(options)`, `emitKeys`, `emitManifest`, `compileStrings(root, out, options?)`, `checkStrings`, `packAssets(options)`, `exportStrings`, `importStrings`, `runCli(argv, strings)` with `strings: StringsTools` = `{ compile: compileStrings, exportStrings, importStrings }`. Audio files are `.mp3` or `.m4a`. Asset key = feature + "." + path inside `assets/`. `runCli` (a game's `bun run assets:keys`) scans the assets and compiles `features/*/strings/<locale>.json` into `generated/strings.ts` (the `Strings` type for `defineGame`) and one `generated/strings.<locale>.ts` per locale; `--check` fails when any output is out of date; `--pack <dir>` writes the production build. `--pseudo` also writes the pseudo-locale `en-XA`. `--export <dir>` and `--import <dir>` exchange strings with translators; `--source <locale>` names the locale they read from, `"en"` by default. The package bin `moku-game-assets` is this CLI: a game's script is `"assets:keys": "moku-game-assets --root src --manifest public/assets/manifest.json --keys src/generated/assets.ts"`.
 - Type namespaces: `Time`, `Lifecycle`, `Model`, `Clock`, `Flow`, `World`, `Renderer`, `Input`, `Assets`, `Scenes`, `Anim`, `I18n`, `TextTypes`, `Ui`, `Audio`, `Effects`, `Platform`. Use `import type { Flow } from "@moku-labs/game"` and then `Flow.RouteStep`, `Flow.NodeContext`, `Model.Json`, `Model.PlayerStateProvider`, `Clock.ClockSource`, `Time.Phase`, `Lifecycle.PauseReason`, `Anim.Target`, `I18n.Message`. `Text` is the component, so the text types are `TextTypes`.
 - `defineNode` and `defineFlow` are NOT root exports. They come from `defineGame<Types>()`.
 
@@ -367,13 +367,13 @@ The graph. Modules `runner`, `gate`, `inbox`, `fx`, `features`. Runner methods s
 
 A screen is a projection whose `view` returns JSX. The game's `tsconfig.json` sets `"jsx": "react-jsx"` and `"jsxImportSource": "@moku-labs/game"`; screens are `.tsx` files. There is no DOM and no React.
 
-- Tags: `screen`, `layer`, `row`, `column`, `stack`, `spacer`, `panel` (swallows taps), `image` (`texture`, `fit?: "contain" | "cover" | "fill"`), `icon` (`name`, `fit?`), `text` (`content: string | Message`, or `bind: { component, field }`; `style` is a text style key), `button` (`intent` + `payload`, or `local`, never both), `scroll` (`axis: "y"` only in V3), `input` (a text field; its text lives in the component's `local`, see the ui README). Common props: `key`, `style`, `state: { active?, disabled?, selected? }`, `motion`, `components` (extra component values for the element's entity, such as a filter: `components={[Glow({ strength: 2 })]}`); containers take `hosts?: string[]` (projections drawn inside the element). Style adds `nineSlice`, `tint`, `offsetX`, `offsetY`, `scale`, `origin`, `fit: "contain"`; state variants `is: { hover, pressed, disabled, active, selected, covered }`. `popup(Component, props, { over })` stacks a popup over a kept one.
+- Tags: `screen`, `layer`, `row`, `column`, `stack`, `spacer`, `panel` (swallows taps), `image` (`texture`, `fit?: "contain" | "cover" | "fill"`), `icon` (`name`, `fit?`), `text` (`content: string | Message`, or `bind={bind(Counter, "value")}` with `components={[Counter({ value })]}`; formats `int`, `mm:ss`, `h:mm:ss`, `duration`; `Countdown({ until })` with `bind(Countdown, "left", { format: "mm:ss" })` counts down to a `clock` moment; `style` is a text style key), `button` (`intent` + `payload`, or `local`, never both), `scroll` (`axis: "y"`; children for a short list, or the windowed form `rows`, `rowHeight`, `overscan?` (5), `row: index => node`; row state belongs in the model, a row that leaves the window loses its local state), `input` (a text field; its text lives in the component's `local`, see the ui README). Common props: `key`, `style`, `state: { active?, disabled?, selected? }`, `motion`, `components` (extra component values for the element's entity, such as a filter: `components={[Glow({ strength: 2 })]}`); containers take `hosts?: string[]` (projections drawn inside the element). Style adds `nineSlice`, `tint`, `offsetX`, `offsetY`, `scale`, `origin`, `fit: "contain"`; state variants `is: { hover, pressed, disabled, active, selected, covered }`. `popup(Component, props, { over })` stacks a popup over a kept one.
 - Style vocabulary (`defineStyle`, plain data): flow `direction`, `wrap`, `justify`, `align`, `alignSelf`, `gap`, `grow`, `shrink`; box `padding`, `margin`, `width`, `height`, `minWidth`, `minHeight`, `maxWidth`, `maxHeight`, `aspect`, `overflow`; position `position`, `left`, `top`, `right`, `bottom`, `reason`; visual `fill`, `stroke`, `strokeWidth`, `radius`, `alpha`; variants `is: { pressed?, disabled?, active?, selected? }` and `when: { portrait?, landscape?, tall?, wide? }`, each a partial style merged in when the flag holds. Lengths are reference units or `"safeArea.top" | "safeArea.right" | "safeArea.bottom" | "safeArea.left"`. No font size here: it comes from the text style.
 - `defineComponent(name, { local?, outcomes?, view(props, local) })`. A component with `outcomes` is a popup: `await fx(popup(Component, props))` opens the gate for its outcomes and resolves with `{ intent, payload }` of the pressed button. A button with `local` writes into the nearest component instance; it never reaches the graph.
 - `tr(key, params?)` returns a frozen `Message` `{ key, params }`; no locale is read at the call site. Strings live in `features/<feature>/strings/<locale>.json` as ICU MessageFormat 1 (`{n, plural, one {# order} other {# orders}}`, `select`, `selectordinal`, `number`, `date`, `time`; no skeletons, no `currency`). `bun run assets:keys` compiles them. `app.i18n`: `locale()`, `setLocale(locale)` (async, emits `i18n:locale-changed`), `format(message, locale?)` returns `Part[]`, `plain(message)` returns a string, `has(key)`, `locales()`. Config: `locale: "en"`, `fallback: "en"`, `locales: {}`.
 - Text: `Text` component, `label({ text, style, at, anchor? })` for board text in a projection view, `defineTextStyles({ "hud.digits": { font, size, fill, bold?, italic?, stroke?, strokeWidth?, letterSpacing?, align?, wrap?, digits? } })` under the feature's `textStyles` key. Tags inside a string: `<b>`, `<i>`, `<color=#rrggbb>`, `<icon=key>`, `\<`, `\n`. Built-in styles `body` and `digits` from config `fonts: { body: "ui.font-body", digits: "ui.font-digits" }`. `app.text.measure(content, style)` gives the same numbers in a browser and in Bun.
 - Animation is data: `defineAnimation(id, { slots: { name: type<Anim.Target>() }, build: (slots, { at }) => Step })`. Steps: `sequence(...)`, `parallel(...)`, `stagger(items, ms, item => Step)`, `tween(target, Component, to, { ms, ease?, delayMs?, additive? })`, `set(target, Component, patch)`, `wait(ms)`, `mark(name)`, `frames(target, { keys, fps, loop? })`, `sfx(key, { bus? })`, `haptic(kind)`, `use(animation, slots, tools?)`, `spawn` (a temporary entity, flying coins, that the timeline despawns when it ends; see the anim README). `Frames({ keys, fps, loop, playing })` is a component that walks a sprite through its textures for the entity's whole life. A target is `{ projection, key }` or an entity. A node plays it with `await fx(play(animation, slots))`; in fast mode it finishes at once. `defineMotion({ states, transition?, on: { enter?, exit?, change? } })` builds the enter, exit and change hooks for a projection or the `motion` prop of a tag. Events `anim:mark` `{ animation, mark }` and `anim:finished` `{ animation }`. Config `maxTracks: 2000`.
-- Audio is opt-in: `plugins: [...screen, audioPlugin]`. `fx(sfx("orders.complete"))` resolves when the sound started. `await fx(music("board.theme"))` cross-fades; `music(null)` fades out; a scene's `music` key switches the track on `scenes:changed`. Buses `master`, `music`, `sfx`. Volumes come from the committed player: config `volumes: player => (player as Player).settings.audio`, applied on every `model:committed`. `app.audio`: `setVolume(bus, value)`, `volume(bus)`, `mute(bus, on)`, `unlocked()`, `journal()` (the last started sounds, empty unless config `journal` is above 0). Config: `buses: { master: 1, music: 0.6, sfx: 1 }`, `musicFadeMs: 600`, `volumes`, `context`, `journal: 0`. Without `audio` every `sfx` and `music` effect resolves `undefined` at once, so the same node runs in a game with no sound.
+- Audio is opt-in: `plugins: [...screen, audioPlugin]`. `fx(sfx("orders.complete"))` resolves when the sound started. `await fx(music("board.theme"))` cross-fades; `music(null)` fades out; a scene's `music` key switches the track on `scenes:changed`. Buses `master`, `music`, `sfx`. Volumes come from the committed player: config `volumes: player => (player as Player).settings.audio`, applied on every `model:committed`. `app.audio`: `setVolume(bus, value)`, `volume(bus)`, `mute(bus, on)`, `unlocked()`, `journal()` (the last started sounds, empty unless config `journal` is above 0). Config: `buses: { master: 1, music: 0.6, sfx: 1 }`, `musicFadeMs: 600`, `volumes`, `context`, `journal: 0`, `music: "decode" | "stream"` default `"decode"` (gapless buffer; `"stream"` is an `<audio>` element, less memory, a gap at every loop), `session: "ambient" | "playback" | "auto"` default `"ambient"` (iOS only: ambient mixes with other apps and obeys the silent switch). Without `audio` every `sfx` and `music` effect resolves `undefined` at once, so the same node runs in a game with no sound.
 - `app.ui`: `tree()` the live screen as plain data, `find(key)` the entity of a keyed element, `fill(key, value)` types into the text field with that `key`, `lint()` tap targets under `tapTargetPt` (default `44`), text that overflows in some locale, absolute elements without `reason`. Config: `tapTargetPt: 44`, `breakpoints: { tall: 2, wide: 1.5 }`. `ui` emits nothing.
 
 ```tsx

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moku-labs/game",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "2D puzzle game engine on TypeScript and PixiJS, built on @moku-labs/core.",
   "type": "module",
   "sideEffects": false,
@@ -66,10 +66,10 @@
     "lint:fix": "biome check --write . && eslint --fix .",
     "format": "biome format --write .",
     "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:unit": "vitest run --project unit",
-    "test:integration": "vitest run --project integration",
-    "test:coverage": "vitest run --project unit --project integration --coverage",
+    "test": "bun --bun vitest run",
+    "test:unit": "bun --bun vitest run --project unit",
+    "test:integration": "bun --bun vitest run --project integration",
+    "test:coverage": "bun --bun vitest run --project unit --project integration --coverage",
     "build": "tsdown",
     "fixture:pack": "bun src/assets.ts --root tests/integration/merge-game --keys tests/integration/merge-game/generated/assets.ts --pack tests/integration/merge-game/dist/assets",
     "fixture:visual": "bun tests/visual/run.ts",

package/dist/component-DGg5DqKK.mjs

@@ -1,44 +0,0 @@
-//#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/dev-CcwFrwok.mjs

@@ -1,413 +0,0 @@
-//#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 };