@moku-labs/game 0.4.5 → 0.5.0

package/dist/inspect.d.mts

@@ -1,9 +1,9 @@
-import { At as JournalEntry, H as EntitySnapshot, Ot as FlowGraph, R as ComponentSchema, U as FrameDiff, Ut as Api, f as Usage, gt as Position, j as Explained, k as Api$1, m as Api$2, t as Api$3, tn as Snapshot, w as RenderStats, x as Under } from "./types-Dy1xB68L.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-DtmFVCHf.mjs";
-import { c as UiNode } from "./types-VErbiEXy.mjs";
-import { G as UiApi, a as SoundEntry, t as AudioApi } from "./types-C-4f2jD_.mjs";
-import { n as defineSource } from "./define-BKWjWgyQ.mjs";
-import { n as EffectsApi, r as EffectsStats } from "./types-w646dMeA.mjs";
+import { At as JournalEntry, H as EntitySnapshot, Ot as FlowGraph, R as ComponentSchema, U as FrameDiff, Ut as Api, f as Usage, gt as Position, j as Explained, k as Api$1, m as Api$2, t as Api$3, tn as Snapshot, w as RenderStats, x as Under } from "./types-BMEn0tSC.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-CYYKjvLn.mjs";
+import { c as UiNode } from "./types-BaUUcIaN.mjs";
+import { a as SoundEntry, t as AudioApi, v as UiApi } from "./types-CXyipKhE.mjs";
+import { n as defineSource } from "./define-BbgXv4cy.mjs";
+import { n as EffectsApi, r as EffectsStats } from "./types-ClF8say0.mjs";
 
 //#region src/plugins/flow/doors/read.d.ts
 /**

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

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

package/dist/jsx-runtime.d.mts

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

package/dist/lint.d.mts

@@ -0,0 +1,79 @@
+//#region src/lint.d.ts
+/** The options every rule takes: which files it checks. A key given replaces the rule's default. */
+type GameLintOptions = {
+  /** Globs of the files the rule checks, relative to the directory oxlint runs in. */files?: string[]; /** Globs of the files the rule skips, even when `files` matches them. */
+  ignores?: string[];
+};
+/** The part of an ESTree node the rules read. oxlint and ESLint hand over full nodes. */
+type GameLintNode = {
+  readonly type: string;
+  readonly name?: string;
+  readonly value?: unknown;
+  readonly kind?: string;
+  readonly computed?: boolean;
+  readonly importKind?: string;
+  readonly exportKind?: string;
+  readonly source?: GameLintNode | null;
+  readonly body?: readonly GameLintNode[];
+  readonly declarations?: readonly GameLintNode[];
+  readonly declaration?: GameLintNode | null;
+  readonly init?: GameLintNode | null;
+  readonly callee?: GameLintNode;
+  readonly arguments?: readonly GameLintNode[];
+  readonly object?: GameLintNode;
+  readonly property?: GameLintNode;
+};
+/** The part of the rule context the rules read: where the file is, the options, the report. */
+type GameLintContext = {
+  readonly cwd: string;
+  readonly filename: string;
+  readonly options: readonly unknown[];
+  report(descriptor: {
+    node: GameLintNode;
+    message: string;
+  }): void;
+};
+/** A node visitor per ESTree node type. */
+type GameLintListeners = Record<string, (node: GameLintNode) => void>;
+/** One rule in the ESLint rule shape oxlint `jsPlugins` load. */
+type GameLintRule = {
+  readonly meta: {
+    readonly type: "problem";
+    readonly docs: {
+      readonly description: string;
+    };
+    readonly schema: readonly unknown[];
+  };
+  create(context: GameLintContext): GameLintListeners;
+};
+/** The plugin object: `moku-game` and its six rules. */
+type GameLintPlugin = {
+  readonly meta: {
+    readonly name: "moku-game";
+  };
+  readonly rules: Readonly<Record<GameLintRuleName, GameLintRule>>;
+};
+/** The rule names, without the `moku-game/` prefix. */
+type GameLintRuleName = "lazy-imports" | "native-imports" | "dev-imports" | "no-module-state" | "determinism" | "rules-siblings";
+/**
+ * Turn a glob into an anchored regular expression: `**`, `*`, `?` and one level of `{a,b}`.
+ *
+ * @param glob - A POSIX glob relative to the lint root.
+ * @returns The expression a relative POSIX path is tested against.
+ * @example
+ * ```ts
+ * globToRegExp("{nodes,rules}/*.ts").test("rules/merge.ts"); // true
+ * ```
+ */
+declare function globToRegExp(glob: string): RegExp;
+/**
+ * The `moku-game` oxlint plugin. A game loads it by package name and turns its rules on.
+ *
+ * @example
+ * ```json
+ * { "jsPlugins": ["@moku-labs/game/lint"], "rules": { "moku-game/lazy-imports": "error" } }
+ * ```
+ */
+declare const plugin: GameLintPlugin;
+//#endregion
+export { GameLintContext, GameLintListeners, GameLintNode, GameLintOptions, GameLintPlugin, GameLintRule, GameLintRuleName, plugin as default, globToRegExp };

package/dist/lint.mjs

@@ -0,0 +1,360 @@
+import path from "node:path";
+//#region src/lint.ts
+/**
+* @file The lint door of the engine (subpath `./lint`): an oxlint JS plugin named `moku-game` with
+* the rules a game carries. A game loads it by package name in `.oxlintrc.json`
+* (`"jsPlugins": ["@moku-labs/game/lint"]`) and turns the rules on as `moku-game/<rule>`. The rules
+* use the ESLint rule API, so ESLint 9 loads the same object. Every rule takes
+* `[{ files, ignores }]`: globs relative to the directory oxlint runs in; a key given replaces the
+* default. Only `node:path` is imported; the file is erasable TypeScript, so Node loads it unbuilt.
+*/
+/** Tests and test helpers: no rule checks them by default. */
+const TESTS = [
+	"tests/**",
+	"**/__tests__/**",
+	"**/*.{test,spec}.{ts,tsx}"
+];
+/** Dev modules: a `.dev` module is wired into the editor only. */
+const DEV_MODULES = ["**/*.dev.{ts,tsx}"];
+/** The logic of a game: state, tables, nodes, flows, rules, features. `**` so `src/` matches too. */
+const LOGIC = [
+	"**/state.ts",
+	"**/tables.ts",
+	"**/{nodes,flows,rules,features}/**"
+];
+/** The options schema every rule shares; oxlint refuses options a rule has no schema for. */
+const SCHEMA = [{
+	type: "object",
+	properties: {
+		files: {
+			type: "array",
+			items: { type: "string" }
+		},
+		ignores: {
+			type: "array",
+			items: { type: "string" }
+		}
+	},
+	additionalProperties: false
+}];
+/** Bases of a timer call that still reach the global timer. */
+const GLOBAL_OBJECT = /^(?:globalThis|window|self)$/;
+/** The global timers of L3. */
+const TIMER = /^set(?:Timeout|Interval)$/;
+/** The forbidden member reads of L3: object, property and the fix. */
+const CLOCK_READS = [
+	{
+		object: "Math",
+		property: "random",
+		message: "L3: use an rng stream: rng.stream(id)."
+	},
+	{
+		object: "Date",
+		property: "now",
+		message: "L3: use `now` from the node context."
+	},
+	{
+		object: "performance",
+		property: "now",
+		message: "L3: use `now` from the node context."
+	}
+];
+/** The collections a module may not hold at module scope (L5). */
+const COLLECTION = /^(?:Map|Set|WeakMap|WeakSet)$/;
+/**
+* Turn a glob into an anchored regular expression: `**`, `*`, `?` and one level of `{a,b}`.
+*
+* @param glob - A POSIX glob relative to the lint root.
+* @returns The expression a relative POSIX path is tested against.
+* @example
+* ```ts
+* globToRegExp("{nodes,rules}/*.ts").test("rules/merge.ts"); // true
+* ```
+*/
+function globToRegExp(glob) {
+	let source = "";
+	let index = 0;
+	while (index < glob.length) {
+		const char = glob.charAt(index);
+		if (glob.startsWith("**/", index)) {
+			source += "(?:.*/)?";
+			index += 3;
+		} else if (glob.startsWith("**", index)) {
+			source += ".*";
+			index += 2;
+		} else {
+			source += globChar(char);
+			index += 1;
+		}
+	}
+	return new RegExp(`^${source}$`);
+}
+/**
+* The expression for one glob character other than `**`.
+*
+* @param char - The character.
+* @returns Its regular-expression source.
+*/
+function globChar(char) {
+	switch (char) {
+		case "*": return "[^/]*";
+		case "?": return "[^/]";
+		case "{": return "(?:";
+		case "}": return ")";
+		case ",": return "|";
+		default: return char.replaceAll(/[$()+.[\\\]^|]/g, String.raw`\$&`);
+	}
+}
+/**
+* Whether the rule checks the file the context lints: `files` match and no `ignores` match.
+*
+* @param context - The rule context.
+* @param defaults - The rule's default globs.
+* @returns True when the rule applies.
+*/
+function inScope(context, defaults) {
+	const [given] = context.options;
+	const files = given?.files ?? defaults.files;
+	const ignores = given?.ignores ?? defaults.ignores;
+	const file = path.relative(context.cwd, context.filename).split(path.sep).join("/");
+	const matches = (globs) => globs.some((glob) => globToRegExp(glob).test(file));
+	return matches(files) && !matches(ignores);
+}
+/**
+* The specifier of an import node, when it is a string literal.
+*
+* @param node - An import, export-from or `import()` node.
+* @returns The specifier, or undefined for a computed `import()` or a local export.
+*/
+function specifierOf(node) {
+	const value = node.source?.type === "Literal" ? node.source.value : void 0;
+	return typeof value === "string" ? value : void 0;
+}
+/**
+* Whether a static import or export carries types only: `import type` or `export type`.
+* `import { type A }` keeps a side-effect import under `verbatimModuleSyntax`, so it counts as a value.
+*
+* @param node - A static import or export node.
+* @returns True for a type-only statement.
+*/
+function isTypeOnly(node) {
+	return node.importKind === "type" || node.exportKind === "type";
+}
+/**
+* Build a rule that reports imports of forbidden specifiers.
+*
+* @param description - What the rule enforces.
+* @param defaults - The rule's default globs.
+* @param checks - The forbidden patterns and their messages.
+* @param lazy - True for L2: `import()` and type-only statements pass.
+* @returns The rule.
+*/
+function importRule(description, defaults, checks, lazy = false) {
+	return {
+		meta: {
+			type: "problem",
+			docs: { description },
+			schema: SCHEMA
+		},
+		/**
+		* Visit the file when the rule's globs match it.
+		*
+		* @param context - The rule context.
+		* @returns The node visitors, none for a file out of scope.
+		*/
+		create(context) {
+			if (!inScope(context, defaults)) return {};
+			const check = (node) => {
+				const name = specifierOf(node);
+				const hit = name === void 0 ? void 0 : checks.find((item) => item.pattern.test(name));
+				if (hit === void 0) return;
+				if (lazy && isTypeOnly(node)) return;
+				context.report({
+					node,
+					message: hit.message
+				});
+			};
+			const listeners = {
+				ImportDeclaration: check,
+				ExportAllDeclaration: check,
+				ExportNamedDeclaration: check
+			};
+			if (!lazy) listeners.ImportExpression = check;
+			return listeners;
+		}
+	};
+}
+/**
+* The name of a member's property: `a.b` and `a["b"]`.
+*
+* @param node - A MemberExpression.
+* @returns The property name, or undefined for a computed non-literal key.
+*/
+function propertyName(node) {
+	const key = node.property;
+	if (key === void 0) return void 0;
+	if (!node.computed) return key.name;
+	return typeof key.value === "string" ? key.value : void 0;
+}
+/**
+* Report the module-scope state of one top-level statement (L5).
+*
+* @param context - The rule context.
+* @param statement - A statement of the Program body.
+*/
+function reportModuleState(context, statement) {
+	const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+	if (declaration?.type !== "VariableDeclaration") return;
+	if (declaration.kind === "let" || declaration.kind === "var") {
+		context.report({
+			node: declaration,
+			message: "L5: no module-scope state. State lives in player and session."
+		});
+		return;
+	}
+	for (const declarator of declaration.declarations ?? []) {
+		const init = declarator.init;
+		if (init?.type === "NewExpression" && COLLECTION.test(init.callee?.name ?? "")) context.report({
+			node: init,
+			message: "L5: no module-scope collections. Create them inside a function."
+		});
+	}
+}
+/**
+* Whether a call's callee reaches a global timer: `setTimeout(...)`, `globalThis.setInterval(...)`.
+*
+* @param callee - The callee of a CallExpression.
+* @returns True for a timer.
+*/
+function isTimer(callee) {
+	if (callee?.type === "Identifier") return TIMER.test(callee.name ?? "");
+	if (callee?.type !== "MemberExpression") return false;
+	return GLOBAL_OBJECT.test(callee.object?.name ?? "") && TIMER.test(propertyName(callee) ?? "");
+}
+/** L2: static value imports of the packages the engine loads lazily. */
+const lazyImports = importRule("No static import of pixi.js or yoga-layout; import() and import type pass.", {
+	files: ["**"],
+	ignores: TESTS
+}, [{
+	pattern: /^pixi\.js(?:\/|$)/,
+	message: "L2: the renderer loads Pixi lazily. Draw with the engine's tags, use import() or import type."
+}, {
+	pattern: /^yoga-layout(?:\/|$)/,
+	message: "L2: the ui plugin loads Yoga lazily. Use import() or import type."
+}], true);
+/** L13: native packages stay out of the engine-facing layers. */
+const nativeImports = importRule("No @moku-labs/system, @moku-labs/native or @tauri-apps/* in the engine-facing layers.", {
+	files: [
+		...LOGIC,
+		"**/kit.ts",
+		"**/game.ts"
+	],
+	ignores: [...DEV_MODULES, ...TESTS]
+}, [{
+	pattern: /^(?:@moku-labs\/(?:system|native)(?:\/|$)|@tauri-apps\/)/,
+	message: "L13: only platform-bridge.ts, native.ts and web/ import a native package. Pass a PlatformProvider."
+}]);
+/** Dev only: the editor and the control door stay in dev files. */
+const developmentImports = importRule("@moku-labs/editor and @moku-labs/game/control only in dev files and tests.", {
+	files: ["**"],
+	ignores: [
+		"web/main.ts",
+		"web/dev*.ts",
+		"web/editor*.ts",
+		...DEV_MODULES,
+		...TESTS
+	]
+}, [{
+	pattern: /^@moku-labs\/(?:editor(?:\/|$)|game\/control$)/,
+	message: "Dev only: web/main.ts, web/dev*.ts, web/editor*.ts, .dev modules and tests import the editor and /control."
+}]);
+/** L4: a rule imports only its siblings. */
+const rulesSiblings = importRule("A file under rules/ imports only its siblings.", {
+	files: ["**/rules/**"],
+	ignores: TESTS
+}, [{
+	pattern: /^(?!\.\/)/,
+	message: "L4: a rule imports only its siblings in rules/: (state, input, tables) => result."
+}]);
+/**
+* The `moku-game` oxlint plugin. A game loads it by package name and turns its rules on.
+*
+* @example
+* ```json
+* { "jsPlugins": ["@moku-labs/game/lint"], "rules": { "moku-game/lazy-imports": "error" } }
+* ```
+*/
+const plugin = {
+	meta: { name: "moku-game" },
+	rules: {
+		"lazy-imports": lazyImports,
+		"native-imports": nativeImports,
+		"dev-imports": developmentImports,
+		"no-module-state": {
+			meta: {
+				type: "problem",
+				docs: { description: "No module-scope let or var and no module-scope Map, Set, WeakMap, WeakSet." },
+				schema: SCHEMA
+			},
+			/**
+			* Visit the file when the rule's globs match it.
+			*
+			* @param context - The rule context.
+			* @returns The node visitors, none for a file out of scope.
+			*/
+			create(context) {
+				if (!inScope(context, {
+					files: ["**"],
+					ignores: TESTS
+				})) return {};
+				return { Program: (program) => {
+					for (const statement of program.body ?? []) reportModuleState(context, statement);
+				} };
+			}
+		},
+		determinism: {
+			meta: {
+				type: "problem",
+				docs: { description: "No Math.random, Date.now, performance.now, new Date(), setTimeout or setInterval in the logic." },
+				schema: SCHEMA
+			},
+			/**
+			* Visit the file when the rule's globs match it.
+			*
+			* @param context - The rule context.
+			* @returns The node visitors, none for a file out of scope.
+			*/
+			create(context) {
+				if (!inScope(context, {
+					files: LOGIC,
+					ignores: [...DEV_MODULES, ...TESTS]
+				})) return {};
+				return {
+					MemberExpression: (node) => {
+						const property = propertyName(node);
+						const read = CLOCK_READS.find((item) => item.object === node.object?.name && item.property === property);
+						if (read !== void 0) context.report({
+							node,
+							message: read.message
+						});
+					},
+					NewExpression: (node) => {
+						if (node.callee?.name === "Date" && (node.arguments ?? []).length === 0) context.report({
+							node,
+							message: "L3: use `now` from the node context."
+						});
+					},
+					CallExpression: (node) => {
+						if (isTimer(node.callee)) context.report({
+							node,
+							message: "L3: store the moment in player, await fx(schedule(moment))."
+						});
+					}
+				};
+			}
+		},
+		"rules-siblings": rulesSiblings
+	}
+};
+//#endregion
+export { plugin as default, globToRegExp };

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

@@ -525,7 +525,8 @@ function invalidBookmark() {
 	return /* @__PURE__ */ new Error("[game] The bookmark is not a flow.bookmark() value.\n  Pass the JSON that game.bookmark returned.");
 }
 /**
-* Reads a bookmark out of JSON, the value `flow.bookmark()` made and the editor kept.
+* Reads a bookmark out of JSON, the value `flow.bookmark()` made and the editor kept. The
+* `scene` the `game.bookmark` door added is kept when present.
 *
 * @param value - The JSON the editor sent.
 * @returns The bookmark.
@@ -539,8 +540,9 @@ function readBookmark(value) {
 	if (!isRecord(value)) throw invalidBookmark();
 	const { path, input, player, session, graph } = value;
 	const rng = readRng(value.rng);
-	if (typeof path !== "string" || typeof graph !== "string" || !(input !== void 0 && player !== void 0 && session !== void 0) || rng === void 0) throw invalidBookmark();
-	return {
+	if (!(typeof path === "string" && typeof graph === "string") || !(input !== void 0 && player !== void 0 && session !== void 0) || rng === void 0) throw invalidBookmark();
+	const { scene } = value;
+	if (scene === void 0) return {
 		path,
 		input,
 		player,
@@ -548,6 +550,16 @@ function readBookmark(value) {
 		rng,
 		graph
 	};
+	if (typeof scene !== "string") throw invalidBookmark();
+	return {
+		path,
+		input,
+		player,
+		session,
+		rng,
+		graph,
+		scene
+	};
 }
 /**
 * Builds the error of a value that is not a repro.
@@ -1051,9 +1063,10 @@ const fillCommand = defineCommand({
 //#endregion
 //#region src/plugins/flow/control.ts
 /**
-* Enters a bookmark, or a repro's bookmark followed by its route.
+* Enters a bookmark, or a repro's bookmark followed by its route. A bookmark's `scene` is handed
+* to `scenes.expect` first, so a rest node without a scene of its own mounts it.
 *
-* @param app - The app.
+* @param app - The app; with `scenes`, the bookmark's scene is expected before the restore.
 * @param input - Exactly one of a bookmark and a repro, as JSON.
 * @param input.bookmark - A `flow.bookmark()` value.
 * @param input.repro - A `/testing` repro.
@@ -1063,7 +1076,9 @@ const fillCommand = defineCommand({
 async function restoreFrom(app, input) {
 	const { bookmark, repro } = input;
 	if (bookmark !== void 0 && repro === void 0) {
-		await app.flow.restore(readBookmark(bookmark));
+		const read = readBookmark(bookmark);
+		if (read.scene !== void 0) app.scenes?.expect(read.scene);
+		await app.flow.restore(read);
 		return app.flow.state();
 	}
 	if (repro !== void 0 && bookmark === void 0) {
@@ -1127,13 +1142,15 @@ const walkCommand = defineCommand({
 	}
 });
 /**
-* Takes a bookmark of the rest point: the node plus the committed state, plain JSON.
+* Takes a bookmark of the rest point: the node plus the committed state, plain JSON. An app with
+* the screen plugins adds the mounted `scene`, so a restore in a fresh page builds it again.
 *
 * @example
 * ```ts
-* // The editor keeps the position before a risky test.
+* // The editor keeps the position while the Settings popup stands over Home.
 * const { value } = await run(app, commands.bookmark);
-* value.path; // "board/awaitIntent"
+* value.path; // "settings/open"
+* value.scene; // "home"
 * ```
 */
 const bookmarkCommand = defineCommand({
@@ -1144,12 +1161,18 @@ const bookmarkCommand = defineCommand({
 	run: (app) => {
 		if (typeof __MOKU_GAME_DEV__ === "undefined" || !__MOKU_GAME_DEV__) throw controlRefused();
 		app.log.debug("moku:dev", { command: "game.bookmark" });
-		return app.flow.bookmark();
+		const bookmark = app.flow.bookmark();
+		const scene = app.scenes?.current();
+		return scene === void 0 ? bookmark : {
+			...bookmark,
+			scene
+		};
 	}
 });
 /**
 * Restores a bookmark, or a repro: its state at its checkpoint, then its route. Replaces the
-* state outside the graph, so the session is tainted and the command journaled.
+* state outside the graph, so the session is tainted and the command journaled. A bookmark's
+* `scene` goes to `scenes.expect` first: a bookmark at a popup comes back with the scene under it.
 *
 * @example
 * ```ts
@@ -1157,6 +1180,12 @@ const bookmarkCommand = defineCommand({
 * const repro = { player: { coins: 40 }, checkpoint: "home", route: [{ at: "home", intent: "play" }] };
 * const ran = await run(app, commands.restore, { repro });
 * ran.state; // { path: "board/awaitIntent", frame: 12, tainted: true }
+*
+* // A fresh page restores the bookmark game.bookmark took at the Settings popup over Home.
+* bookmark.scene; // "home"
+* await run(app, commands.restore, { bookmark });
+* await app.flow.walk([]); // the scene stage runs after the restore resolved
+* app.scenes.current(); // "home"
 * ```
 */
 const restoreCommand = defineCommand({

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

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

package/dist/testing.d.mts

@@ -1,8 +1,8 @@
-import { $t as SaveDoc, Kt as Json, Qt as ProviderCall, Ut as Api$2, Zt as PlayerStateProvider, an as Api$3, k as Api$1, m as Api, pn as FakeClock } from "./types-Dy1xB68L.mjs";
-import { _ as stepFrames, a as InputOf, d as HeadlessApp, f as HeadlessGame, g as runRepro, h as createHeadless, m as ReproResult, p as Repro, r as ControlApp } from "./types-DtmFVCHf.mjs";
-import { H as InputApi } from "./types-VErbiEXy.mjs";
-import { G as UiApi, g as AnimApi } from "./types-C-4f2jD_.mjs";
-import { t as commands } from "./commands-C83eQ5B9.mjs";
+import { $t as SaveDoc, Kt as Json, Qt as ProviderCall, Ut as Api$2, Zt as PlayerStateProvider, an as Api$3, k as Api$1, m as Api, pn as FakeClock } from "./types-BMEn0tSC.mjs";
+import { _ as stepFrames, a as InputOf, d as HeadlessApp, f as HeadlessGame, g as runRepro, h as createHeadless, m as ReproResult, p as Repro, r as ControlApp } from "./types-CYYKjvLn.mjs";
+import { H as InputApi } from "./types-BaUUcIaN.mjs";
+import { b as AnimApi, v as UiApi } from "./types-CXyipKhE.mjs";
+import { t as commands } from "./commands-mzE9PX0H.mjs";
 
 //#region src/plugins/clock/fake.d.ts
 /**

package/dist/testing.mjs

@@ -1,5 +1,5 @@
 import { n as saveOf, t as memory } from "./memory-CvgdnsQO.mjs";
-import { a as stepFrames, i as runRepro, n as commands, r as createHeadless, t as run } from "./run-D_R0oJ6g.mjs";
+import { a as stepFrames, i as runRepro, n as commands, r as createHeadless, t as run } from "./run-Bcyg32M5.mjs";
 import { n as read, t as sources } from "./sources-DVWJ8nfr.mjs";
 import { createBrandConsole } from "@moku-labs/common/cli";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
@@ -629,7 +629,7 @@ function addressesOf(keys) {
 * ```
 */
 function parentOf(parent) {
-	if (typeof parent !== "object" || parent === null || Array.isArray(parent)) return void 0;
+	if (!(typeof parent === "object" && parent !== null && !Array.isArray(parent))) return void 0;
 	return typeof parent.entity === "number" ? parent.entity : void 0;
 }
 /**
@@ -663,6 +663,20 @@ function stateOf(app) {
 	};
 }
 /**
+* The ui tree without the words of its texts, at every depth.
+*
+* @param node - A node of the ui source.
+* @returns The node and its children, none with `content`.
+*/
+function withoutContent(node) {
+	const copy = {
+		...node,
+		children: node.children.map((child) => withoutContent(child))
+	};
+	delete copy.content;
+	return copy;
+}
+/**
 * Reads the screen a checkpoint saves: the ui tree, and every entity a projection names as
 * `{ projection, key, components }`, sorted by projection then key. Ui parts, rings and unkeyed
 * views appear through the tree only, or not at all.
@@ -675,13 +689,14 @@ function describeOf(app) {
 	const views = [];
 	for (const entity of read(app, sources.entities)) {
 		const address = addresses.get(entity.id);
-		if (address !== void 0) views.push({
+		if (address === void 0) continue;
+		views.push({
 			...address,
 			components: withParentAddress(entity.components, addresses)
 		});
 	}
 	return {
-		ui: read(app, sources.ui),
+		ui: withoutContent(read(app, sources.ui)),
 		views: views.toSorted(byAddress)
 	};
 }