@moku-labs/game 0.8.0 → 0.10.0

package/dist/cli.mjs

@@ -0,0 +1,1650 @@
+import { t as resolveConfig } from "./config-CdARrrhU.mjs";
+import { a as runCli$1, i as compileStrings, n as importStrings, t as exportStrings } from "./assets-BHwTLVta.mjs";
+import { constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import path from "node:path";
+import { createBrandConsole } from "@moku-labs/common/cli";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+//#region src/app/generate.ts
+/** The first line of a generated file a person may open. */
+const WRITTEN = "// Written by moku-game dev. Do not edit.";
+/** A colour or a language tag: it lands in a `<style>` and in attributes, so nothing else passes. */
+const SAFE_VALUE = /^[#\w(),.%\s-]+$/;
+/** The files of `tests/scenarios/` that are not scenarios. */
+const NOT_SCENARIO = /\.(?:test|spec|d)\.ts$|^index\.ts$/;
+/**
+* Escapes the five characters HTML reads as markup.
+*
+* @param text - The text.
+* @returns The text, safe in an element and in a quoted attribute.
+* @example
+* ```ts
+* escapeHtml(`Tom & "Jerry"`); // "Tom &amp; &quot;Jerry&quot;"
+* ```
+*/
+function escapeHtml(text) {
+	return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;").replaceAll("'", "&#39;");
+}
+/**
+* Checks a value of the page that lands in the style and in attributes.
+*
+* @param value - The background or the lang.
+* @param problem - The error when the value has another character.
+* @returns The value.
+* @throws {Error} The problem, when the value is not a plain colour or tag.
+* @example
+* ```ts
+* safeValue("#10161d", "not a colour"); // "#10161d"
+* ```
+*/
+function safeValue(value, problem) {
+	if (!SAFE_VALUE.test(value)) throw new Error(problem);
+	return value;
+}
+/**
+* The link of one icon: a path inside the game folder, never above it.
+*
+* @param name - The icon field.
+* @param file - The path the config gives, relative to the game folder.
+* @returns The path with `/` separators.
+* @throws {Error} When the path is absolute or climbs out of the game folder.
+* @example
+* ```ts
+* iconPath("favicon", "assets/icon.png"); // "assets/icon.png"
+* ```
+*/
+function iconPath(name, file) {
+	const slashed = file.replaceAll("\\", "/");
+	if (slashed.startsWith("/") || /^[a-z]:/i.test(slashed) || slashed.split("/").includes("..") || slashed === "") throw new Error(`[game] moku-game: page.icons.${name} "${file}" is not a file in the game.`);
+	return slashed;
+}
+/**
+* The `<link>` tags of the icons the page sets, in a fixed order.
+*
+* @param icons - The icons of the page.
+* @param toRoot - The path from the page to the game folder.
+* @returns One line per icon set.
+* @example
+* ```ts
+* iconLinks({ favicon: "icon.png" }, "../"); // ['    <link rel="icon" href="../icon.png" />']
+* ```
+*/
+function iconLinks(icons, toRoot) {
+	return [["favicon", "icon"], ["appleTouch", "apple-touch-icon"]].flatMap(([name, relation]) => {
+		const file = icons[name];
+		if (file === void 0) return [];
+		return [`    <link rel="${relation}" href="${escapeHtml(toRoot + iconPath(name, file))}" />`];
+	});
+}
+/**
+* The page a game runs in: the title, the language, the background (also the theme colour), the
+* icons as links (never `url()` in the style: `Bun.build` does not rewrite it), the `head` tags
+* verbatim after the style, `<div id="game">` and the module script.
+*
+* @param page - The page of the resolved `config.ts`.
+* @param links - The path to the game folder and the script.
+* @returns The HTML.
+* @throws {Error} When the background is not a CSS colour, the lang not a language tag, or an
+*   icon path leaves the game folder.
+* @example
+* ```ts
+* pageHtml(resolveConfig({ page: { title: "mini-game" } }).page, { toRoot: "../", script: "./main.ts" }).includes("<title>mini-game</title>"); // true
+* ```
+*/
+function pageHtml(page, links) {
+	const background = safeValue(page.background, `[game] moku-game: page.background "${page.background}" is not a CSS color.`);
+	const lang = safeValue(page.lang, `[game] moku-game: page.lang "${page.lang}" is not a language tag.`);
+	const style = `html, body { margin: 0; height: 100%; background: ${background}; } #game { width: 100%; height: 100%; touch-action: none; }`;
+	return [
+		"<!doctype html>",
+		`<html lang="${lang}">`,
+		"  <head>",
+		"    <meta charset=\"utf-8\" />",
+		"    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1, viewport-fit=cover\" />",
+		`    <meta name="theme-color" content="${background}" />`,
+		`    <title>${escapeHtml(page.title)}</title>`,
+		...iconLinks(page.icons, links.toRoot),
+		`    <style>${style}</style>`,
+		...page.head.map((tag) => `    ${tag}`),
+		"  </head>",
+		"  <body>",
+		"    <div id=\"game\"></div>",
+		`    <script type="module" src="${escapeHtml(links.script)}"><\/script>`,
+		"  </body>",
+		"</html>",
+		""
+	].join("\n");
+}
+/**
+* The scenario files of `tests/scenarios/`, sorted: every `.ts` file but tests, declarations and
+* `index.ts`.
+*
+* @param files - The file names of the folder.
+* @returns The scenario file names, sorted.
+* @example
+* ```ts
+* scenarioFiles(["ready.ts", "ready.test.ts", "index.ts", "empty.ts"]); // ["empty.ts", "ready.ts"]
+* ```
+*/
+function scenarioFiles(files) {
+	return files.filter((file) => file.endsWith(".ts") && !NOT_SCENARIO.test(file)).toSorted();
+}
+/**
+* Whether the page needs the system shell: a system plugin is named, or the save is the store.
+*
+* @param settings - The resolved `config.ts`.
+* @returns True when `main.ts` imports `systemShell`.
+* @example
+* ```ts
+* needsShell(resolveConfig({ page: { title: "T" }, save: "store" })); // true
+* ```
+*/
+function needsShell(settings) {
+	return settings.system.length > 0 || settings.save === "store";
+}
+/**
+* The imports of `main.ts` every page has: the page entry, the shell when needed, the game and its
+* config.
+*
+* @param settings - The resolved `config.ts`.
+* @param toRoot - The path from `main.ts` to the game folder.
+* @returns The import lines.
+* @example
+* ```ts
+* pageImports(resolveConfig({ page: { title: "T" } }), "../")[1]; // 'import game from "../index.ts";'
+* ```
+*/
+function pageImports(settings, toRoot) {
+	return [
+		"import { startPage } from \"@moku-labs/game/app/page\";",
+		...needsShell(settings) ? ["import { systemShell } from \"@moku-labs/game/app/system\";"] : [],
+		`import game from "${toRoot}index.ts";`,
+		`import config from "${toRoot}config.ts";`
+	];
+}
+/**
+* The names of numbered bindings, as a list.
+*
+* @param prefix - The name before the number.
+* @param count - How many.
+* @returns The names, comma separated.
+* @example
+* ```ts
+* numbered("agent", 2); // "agent0, agent1"
+* ```
+*/
+function numbered(prefix, count) {
+	return Array.from({ length: count }, (_, index) => prefix + String(index)).join(", ");
+}
+/**
+* One import line of a generated file. The specifier is written by `JSON.stringify`: a file name
+* may hold a quote or a backslash.
+*
+* @param binding - What the line imports, such as `scenario0` or `* as devModule0`.
+* @param specifier - The module.
+* @returns The line.
+* @example
+* ```ts
+* importLine("* as devModule0", "../features/board/board.dev.ts"); // 'import * as devModule0 from "../features/board/board.dev.ts";'
+* ```
+*/
+function importLine(binding, specifier) {
+	return `import ${binding} from ${JSON.stringify(specifier)};`;
+}
+/**
+* The `main.ts` of the dev page: the dev flag first, then the page entry, the game, its config,
+* one import per scenario, and, with agents, one per `.dev` module and one per agent. It calls
+* `startPage` with the scenarios by file stem, the shell when the game needs it, the agents and
+* the `.dev` modules.
+*
+* @param settings - The resolved `config.ts`.
+* @param sources - The scenario files, the `.dev` modules and the agents.
+* @returns The text of `.moku/main.ts`.
+* @example
+* ```ts
+* devMain(resolveConfig({ page: { title: "T" } }), { scenarios: ["ready.ts"], devModules: [] }).includes('scenarios: { "ready": scenario0 }'); // true
+* ```
+*/
+function devMain(settings, sources) {
+	const scenarios = scenarioFiles(sources.scenarios);
+	const agents = sources.agents ?? [];
+	const devModules = agents.length === 0 ? [] : sources.devModules.toSorted();
+	const keys = scenarios.map((file, index) => `${JSON.stringify(file.slice(0, -3))}: scenario${index}`);
+	const options = [
+		`  scenarios: ${keys.length === 0 ? "{}" : `{ ${keys.join(", ")} }`}`,
+		...needsShell(settings) ? ["  system: systemShell"] : [],
+		...agents.length === 0 ? [] : [`  agents: [${numbered("agent", agents.length)}]`],
+		...devModules.length === 0 ? [] : [`  devModules: [${numbered("devModule", devModules.length)}]`]
+	];
+	return [
+		WRITTEN,
+		"import \"./dev.ts\";",
+		...pageImports(settings, "../"),
+		...scenarios.map((file, index) => importLine(`scenario${index}`, `../tests/scenarios/${file}`)),
+		...devModules.map((file, index) => importLine(`* as devModule${index}`, `../${file}`)),
+		...agents.map((agent, index) => importLine(`agent${index}`, agent)),
+		"",
+		"await startPage(game, config, {",
+		options.join(",\n"),
+		"});",
+		""
+	].join("\n");
+}
+/**
+* The `main.ts` of the production page: the page entry, the game and its config, and the shell
+* when the game needs it. No dev flag, no scenario, no agent, no `.dev` module, no door: none of
+* them ships.
+*
+* @param settings - The resolved `config.ts`.
+* @returns The text of the in-memory `.moku/build/main.ts`.
+* @example
+* ```ts
+* buildMain(resolveConfig({ page: { title: "T" } })).endsWith("await startPage(game, config);\n"); // true
+* ```
+*/
+function buildMain(settings) {
+	const call = needsShell(settings) ? "await startPage(game, config, { system: systemShell });" : "await startPage(game, config);";
+	return [
+		...pageImports(settings, "../../"),
+		"",
+		call,
+		""
+	].join("\n");
+}
+/**
+* The `dev.ts` module the dev `main.ts` imports first: it sets the dev flag on `globalThis` for
+* code that reads the global. The bunfig `define` already makes the bare flag true in the bundle.
+*
+* @returns The text of `.moku/dev.ts`.
+* @example
+* ```ts
+* devFlag().endsWith("globalThis.__MOKU_GAME_DEV__ = true;\n"); // true
+* ```
+*/
+function devFlag() {
+	return `${WRITTEN}\nglobalThis.__MOKU_GAME_DEV__ = true;\n`;
+}
+/**
+* A TOML array of strings. `JSON.stringify` of a path is a valid TOML basic string, also for a
+* Windows path.
+*
+* @param paths - The paths.
+* @returns The array text.
+* @example
+* ```ts
+* tomlList(["/a.ts", "C:\\b.ts"]); // '["/a.ts", "C:\\\\b.ts"]'
+* ```
+*/
+function tomlList(paths) {
+	return `[${paths.map((file) => JSON.stringify(file)).join(", ")}]`;
+}
+/**
+* The bunfig of the dev server: the preloads when given, the hot plugin first among the bundler
+* plugins of the page, and the dev flag defined true.
+*
+* @param paths - The absolute paths of the hot plugin, the extra plugins and the preloads.
+* @returns The text of `.moku/bunfig.toml`.
+* @example
+* ```ts
+* bunfigText({ hotPlugin: "/g/node_modules/@moku-labs/game/dist/hot.mjs", servePlugins: [], preload: [] }).includes('plugins = ["/g/node_modules/@moku-labs/game/dist/hot.mjs"]'); // true
+* ```
+*/
+function bunfigText(paths) {
+	return [
+		`# ${WRITTEN.slice(3)}`,
+		...paths.preload.length === 0 ? [] : [`preload = ${tomlList(paths.preload)}`],
+		"",
+		"[serve.static]",
+		`plugins = ${tomlList([paths.hotPlugin, ...paths.servePlugins])}`,
+		"define = { \"__MOKU_GAME_DEV__\" = \"true\" }",
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/app/serve.ts
+/**
+* @file `moku-game dev`: the game folder read and checked, the dev page written into
+* `<game>/.moku/`, the parent that re-runs the bin under the generated bunfig, and the child that
+* serves the page with `Bun.serve`. The hot plugin comes from the engine the game resolves, so
+* the game writes no bunfig, no HTML and no dev file. Node and Bun only: the bin bundles it.
+*/
+/** The signals the dev parent hands to its child. */
+const FORWARDED = [
+	"SIGINT",
+	"SIGTERM",
+	"SIGHUP"
+];
+/** The signals that stop the dev child. */
+const STOPPING = ["SIGINT", "SIGTERM"];
+/** How often the dev child checks that its parent still runs. */
+const PARENT_CHECK_MS = 1e3;
+/** The folders a `.dev.ts` module is never looked for in. */
+const NO_DEV_MODULES = /^(?:node_modules|dist|generated|tests|__tests__)$/;
+/** A `.gitignore` line that keeps `.moku/` of its own folder out. */
+const OWN_MOKU_LINE = /^\/?\.moku\/?$/;
+/** A `.gitignore` line that keeps every `.moku/` below its folder out. */
+const ANY_MOKU_LINE = /^(?:\*\*\/)?\.moku\/?$/;
+/**
+* Tells whether a path is a file.
+*
+* @param file - The path.
+* @returns True for an existing file.
+*/
+function isFile(file) {
+	return statSync(file, { throwIfNoEntry: false })?.isFile() === true;
+}
+/**
+* Tells whether a path is a folder.
+*
+* @param folder - The path.
+* @returns True for an existing folder.
+*/
+function isFolder(folder) {
+	return statSync(folder, { throwIfNoEntry: false })?.isDirectory() === true;
+}
+/**
+* Checks that a game folder has its `config.ts`.
+*
+* @param root - The game folder, absolute.
+* @returns The path of `config.ts`.
+* @throws {Error} When the game has no `config.ts`.
+*/
+function configFileOf(root) {
+	const file = path.join(root, "config.ts");
+	if (!isFile(file)) throw new Error(`[game] moku-game: no config.ts in "${root}".\n  A game keeps its page, native, system, save and assets data there.`);
+	return file;
+}
+/**
+* Reads a game's `config.ts` and fills its defaults.
+*
+* @param root - The game folder, absolute.
+* @returns The resolved config.
+* @throws {Error} When the game has no `config.ts`, it has no default export, or a value is one
+*   TypeScript would refuse.
+*/
+async function loadSettings(root) {
+	const file = configFileOf(root);
+	const loaded = await import(pathToFileURL(file).href);
+	if (loaded.default === void 0) throw new Error(`[game] moku-game: config.ts in "${root}" has no default export.\n  End it with: export default { page: { title: "…" } } satisfies GameConfig.`);
+	return resolveConfig(loaded.default);
+}
+/**
+* Checks that every icon the page names is a file of the game.
+*
+* @param root - The game folder.
+* @param page - The resolved page.
+* @throws {Error} When an icon is not a file in the game.
+*/
+function checkIcons(root, page) {
+	for (const [name, file] of Object.entries(page.icons)) if (file !== void 0 && !isFile(path.join(root, file))) throw new Error(`[game] moku-game: page.icons.${name} "${file}" is not a file in the game.`);
+}
+/**
+* Reads and checks a game folder for a page: `config.ts` and `index.ts` exist, the config
+* resolves and its icons are files of the game.
+*
+* @param root - The game folder, absolute.
+* @returns The resolved config.
+* @throws {Error} When `config.ts` or `index.ts` is missing, a config value is refused, or an icon
+*   is not a file in the game.
+*/
+async function loadGame(root) {
+	configFileOf(root);
+	if (!isFile(path.join(root, "index.ts"))) throw new Error(`[game] moku-game: no index.ts in "${root}".\n  It default-exports defineGameApp({ ... }).`);
+	const settings = await loadSettings(root);
+	checkIcons(root, settings.page);
+	return settings;
+}
+/**
+* Checks that every file a flag names exists.
+*
+* @param flag - The flag, for the message.
+* @param files - The absolute paths.
+* @throws {Error} When a path is not a file.
+*/
+function checkFiles(flag, files) {
+	const missing = files.find((file) => !isFile(file));
+	if (missing !== void 0) throw new Error(`[game] moku-game: ${flag} "${missing}" is not a file.`);
+}
+/**
+* Finds the hot plugin of the engine the game resolves: the installed `dist/hot.mjs`, or
+* `src/hot.ts` through the tsconfig `paths` of the engine repo.
+*
+* @param root - The game folder.
+* @param resolve - Bun's resolver.
+* @returns The absolute path of the plugin.
+* @throws {Error} When the game cannot resolve `@moku-labs/game/hot`.
+*/
+function hotPluginOf(root, resolve) {
+	try {
+		return resolve("@moku-labs/game/hot", root);
+	} catch (error) {
+		throw new Error(`[game] dev: "@moku-labs/game/hot" does not resolve from "${root}".\n  Install @moku-labs/game in the game: bun add @moku-labs/game.`, { cause: error });
+	}
+}
+/**
+* Lists the files of the game's `tests/scenarios/` folder.
+*
+* @param root - The game folder.
+* @returns The file names, or none without the folder.
+*/
+function scenarioNamesOf(root) {
+	const folder = path.join(root, "tests", "scenarios");
+	if (!isFolder(folder)) return [];
+	return readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => entry.name);
+}
+/**
+* Tells whether the search for `.dev.ts` modules skips a folder: a dot folder, or a folder of
+* tools and tests.
+*
+* @param name - The folder name.
+* @returns True for a skipped folder.
+* @example
+* ```ts
+* isSkippedFolder("node_modules"); // true
+* ```
+*/
+function isSkippedFolder(name) {
+	return name.startsWith(".") || NO_DEV_MODULES.test(name);
+}
+/**
+* Lists the `.dev.ts` modules under a folder of the game, outside the dot folders and the folders
+* of tools and tests.
+*
+* @param root - The game folder.
+* @param relative - The folder under the game, `/` separated, `""` for the game itself.
+* @returns The modules, relative to the game, `/` separated.
+*/
+function devModulesOf(root, relative = "") {
+	return readdirSync(path.join(root, relative), { withFileTypes: true }).flatMap((entry) => {
+		const inGame = relative === "" ? entry.name : `${relative}/${entry.name}`;
+		if (entry.isDirectory() && isSkippedFolder(entry.name)) return [];
+		if (entry.isDirectory()) return devModulesOf(root, inGame);
+		return entry.isFile() && entry.name.endsWith(".dev.ts") ? [inGame] : [];
+	});
+}
+/**
+* Writes a file only when its text changed, so a second run wakes no watcher.
+*
+* @param file - The absolute path.
+* @param text - The text.
+*/
+function writeIfChanged(file, text) {
+	if (existsSync(file) && readFileSync(file, "utf8") === text) return;
+	mkdirSync(path.dirname(file), { recursive: true });
+	writeFileSync(file, text);
+}
+/**
+* The text of the dev `main.ts` for the game as it is on disk now.
+*
+* @param root - The game folder.
+* @param settings - The resolved config.
+* @param agents - The agent modules, when the page has any.
+* @returns The text.
+*/
+function mainOf(root, settings, agents) {
+	const scenarios = scenarioNamesOf(root);
+	return agents === void 0 || agents.length === 0 ? devMain(settings, {
+		scenarios,
+		devModules: []
+	}) : devMain(settings, {
+		scenarios,
+		devModules: devModulesOf(root),
+		agents
+	});
+}
+/**
+* Writes the dev page of a checked game into `<game>/.moku/`: `index.html`, `dev.ts`, `main.ts`
+* and `bunfig.toml`. Every text is made before the first write, so a refused value writes
+* nothing.
+*
+* @param root - The game folder, absolute.
+* @param settings - The resolved config.
+* @param options - The agents, the preloads and the extra plugins, absolute.
+* @param resolve - Bun's resolver, to find the hot plugin.
+* @returns The paths of the HTML and the bunfig.
+* @throws {Error} When the hot plugin does not resolve, a preload or plugin is not a file, or a
+*   page value is refused.
+*/
+function writePage(root, settings, options, resolve) {
+	const preload = options.preload ?? [];
+	const servePlugins = options.servePlugins ?? [];
+	checkFiles("--preload", preload);
+	checkFiles("--serve-plugin", servePlugins);
+	const folder = path.join(root, ".moku");
+	const html = path.join(folder, "index.html");
+	const bunfig = path.join(folder, "bunfig.toml");
+	const texts = [
+		[html, pageHtml(settings.page, {
+			toRoot: "../",
+			script: "./main.ts"
+		})],
+		[path.join(folder, "dev.ts"), devFlag()],
+		[path.join(folder, "main.ts"), mainOf(root, settings, options.agents)],
+		[bunfig, bunfigText({
+			hotPlugin: hotPluginOf(root, resolve),
+			servePlugins,
+			preload
+		})]
+	];
+	for (const [file, text] of texts) writeIfChanged(file, text);
+	return {
+		html,
+		bunfig
+	};
+}
+/**
+* Reads and checks a game, then writes its dev page into `<game>/.moku/`. The editor's step and
+* the dev parent's step 3; it starts no server and no watcher.
+*
+* @param root - The game folder, absolute.
+* @param options - The agents, the preloads and the extra plugins, absolute.
+* @param resolve - Bun's resolver, to find the hot plugin.
+* @returns The paths of the HTML and the bunfig.
+* @throws {Error} The errors of `moku-game dev` before its server starts.
+*/
+async function preparePageAt(root, options, resolve) {
+	return writePage(root, await loadGame(root), options, resolve);
+}
+/**
+* Tells whether a `.gitignore` of the folder or of a folder above it, up to the repository, keeps
+* the game's `.moku/` out of git.
+*
+* @param folder - The folder to read.
+* @param own - True for the game folder itself, where `/.moku` counts too.
+* @returns True when a line ignores `.moku/`.
+*/
+function ignoresMoku(folder, own = true) {
+	const file = path.join(folder, ".gitignore");
+	const lines = isFile(file) ? readFileSync(file, "utf8").split(/\r?\n/u) : [];
+	const pattern = own ? OWN_MOKU_LINE : ANY_MOKU_LINE;
+	if (lines.some((line) => pattern.test(line.trim()))) return true;
+	const parent = path.dirname(folder);
+	if (existsSync(path.join(folder, ".git")) || parent === folder) return false;
+	return ignoresMoku(parent, false);
+}
+/**
+* Watches `tests/scenarios/` while the dev server runs: a file added or removed rewrites `main.ts`,
+* and Bun reloads the page with the new registry. An edit of a scenario needs nothing: Bun
+* watches the import itself.
+*
+* @param root - The game folder.
+* @param settings - The resolved config.
+* @param deps - The watcher and the console.
+* @returns The watcher, or `undefined` when the game has no scenario folder.
+*/
+function watchScenarios(root, settings, deps) {
+	const folder = path.join(root, "tests", "scenarios");
+	const main = path.join(root, ".moku", "main.ts");
+	if (!isFolder(folder)) return void 0;
+	return deps.watch(folder, (event) => {
+		if (event !== "rename") return;
+		try {
+			writeIfChanged(main, mainOf(root, settings));
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			deps.ui.warn(`[game] dev: main.ts was not rewritten: ${reason}.`);
+		}
+	});
+}
+/**
+* The command that runs the bin again as the dev child: the Bun under the page's bunfig, then
+* `dev` with the game, the port and `--packed`.
+*
+* @param run - The flags of the run.
+* @param page - The written page, for its bunfig.
+* @param deps - The Bun and the bin.
+* @returns The words of the command.
+*/
+function devChildCommand(run, page, deps) {
+	return [
+		deps.execPath,
+		`--config=${page.bunfig}`,
+		...deps.self,
+		"dev",
+		"--root",
+		run.root,
+		"--port",
+		String(run.port),
+		...run.packed ? ["--packed"] : []
+	];
+}
+/**
+* The dev parent: checks the game, writes the page, re-runs the bin under the generated bunfig
+* with the game as its working directory, and watches the scenarios while the child runs. It
+* hands Ctrl+C and the other stop signals to the child and answers the child's exit code.
+*
+* @param run - The flags of the run.
+* @param deps - The process seams.
+* @returns The exit code of the child.
+* @throws {Error} When the game, a flag or the page is refused, or the child does not start.
+*/
+async function serveParent(run, deps) {
+	const settings = await loadGame(run.root);
+	const hasPack = isFile(path.join(run.root, "dist", "assets", "manifest.json"));
+	const hasManifest = isFile(path.join(run.root, "manifest.json"));
+	if (run.packed && !hasPack) throw new Error(`[game] dev: no packed build in "${path.join(run.root, "dist", "assets")}".\n  Run "moku-game pack" first.`);
+	if (!run.packed && !hasManifest) deps.ui.warn(`[game] dev: no manifest.json in "${run.root}".\n  Run "moku-game keys" first.`);
+	const page = writePage(run.root, settings, run, deps.resolve);
+	if (!ignoresMoku(run.root)) deps.ui.warn("[game] dev: add \".moku/\" to .gitignore. moku-game writes its dev page there.");
+	const child = deps.spawn(devChildCommand(run, page, deps), {
+		cwd: run.root,
+		env: {
+			...deps.env,
+			MOKU_GAME_CHILD: "1"
+		},
+		stdio: [
+			"inherit",
+			"inherit",
+			"inherit"
+		],
+		detached: true
+	});
+	const removers = FORWARDED.map((signal) => deps.onSignal(signal, () => child.kill(signal)));
+	let watcher;
+	try {
+		watcher = watchScenarios(run.root, settings, deps);
+		return await child.exited;
+	} finally {
+		watcher?.close();
+		for (const remove of removers) remove();
+	}
+}
+/**
+* The path of a request under the served folder: decoded, so the `%7B` braces of a nine-slice
+* name work, and refused when it could leave the folder or reach a hidden or installed file.
+*
+* @param base - The served folder.
+* @param pathname - The path of the request URL.
+* @returns The absolute file path, or `undefined` for a refused path.
+* @example
+* ```ts
+* staticPath("/g", "/features/ui/assets/%7Bbutton%7D.png"); // "/g/features/ui/assets/{button}.png"
+* ```
+*/
+function staticPath(base, pathname) {
+	const decoded = safeDecode(pathname);
+	if (decoded === void 0 || decoded.includes("\0") || decoded.includes("\\")) return void 0;
+	const segments = decoded.split("/").filter((segment) => segment !== "");
+	return segments.some((segment) => segment.startsWith(".") || segment === "node_modules") ? void 0 : path.join(base, ...segments);
+}
+/**
+* Decodes a percent-encoded path.
+*
+* @param pathname - The encoded path.
+* @returns The decoded path, or `undefined` when an escape is broken.
+* @example
+* ```ts
+* safeDecode("/a%E0"); // undefined
+* ```
+*/
+function safeDecode(pathname) {
+	try {
+		return decodeURIComponent(pathname);
+	} catch {
+		return;
+	}
+}
+/**
+* Answers a request with a file, or a 404 for a missing or empty one.
+*
+* @param file - The absolute path, or `undefined` for a refused path.
+* @returns The response.
+*/
+function fileResponse(file) {
+	const found = file === void 0 ? void 0 : statSync(file, { throwIfNoEntry: false });
+	return file !== void 0 && found?.isFile() === true && found.size > 0 ? new Response(Bun.file(file)) : new Response("Not found", { status: 404 });
+}
+/**
+* Starts the dev server on `127.0.0.1` only, never on every interface: the page on `/`, the
+* manifest of the served folder on `/manifest.json`, and its files as static files.
+*
+* @param run - The flags of the run.
+* @param page - The page bundle the child imported.
+* @returns The server.
+* @throws {Error} When the port is in use.
+*/
+function serveOn(run, page) {
+	const base = run.packed ? path.join(run.root, "dist", "assets") : run.root;
+	try {
+		return Bun.serve({
+			hostname: "127.0.0.1",
+			port: run.port,
+			development: true,
+			routes: {
+				"/": page,
+				"/manifest.json": () => fileResponse(path.join(base, "manifest.json"))
+			},
+			fetch: (request) => fileResponse(staticPath(base, new URL(request.url).pathname))
+		});
+	} catch (error) {
+		if (error.code === "EADDRINUSE") throw new Error(`[game] dev: port ${run.port} is in use.\n  Pass --port 0 for a free port.`, { cause: error });
+		throw error;
+	}
+}
+/**
+* Waits until the dev child should stop: Ctrl+C, a stop signal, or a parent that died (its
+* parent id changed). Then stops the server.
+*
+* @param server - The running server.
+* @param deps - The signal seam.
+* @returns Resolves to the exit code `0` once the server stopped.
+*/
+function untilStopped(server, deps) {
+	const parent = process.ppid;
+	return new Promise((resolve) => {
+		const removers = [];
+		const timer = setInterval(() => {
+			if (process.ppid !== parent) stop();
+		}, PARENT_CHECK_MS);
+		const stop = () => {
+			clearInterval(timer);
+			for (const remove of removers.splice(0)) remove();
+			resolve(server.stop(true).then(() => 0));
+		};
+		for (const signal of STOPPING) removers.push(deps.onSignal(signal, stop));
+	});
+}
+/**
+* The dev child, under the generated bunfig in the game folder: imports the written page, serves
+* it, prints the bound URL on its own plain line, and runs until it is stopped.
+*
+* @param run - The flags of the run.
+* @param deps - The process seams.
+* @returns The exit code `0` once stopped.
+* @throws {Error} When the port is in use.
+*/
+async function serveChild(run, deps) {
+	const server = serveOn(run, (await deps.loadPage(path.join(run.root, ".moku", "index.html"))).default);
+	const assets = run.packed ? "packed build" : "raw assets";
+	deps.ui.info(`${path.basename(run.root)}: dev server, ${assets}. Ctrl+C stops it.`);
+	deps.ui.line(server.url.href);
+	return untilStopped(server, deps);
+}
+//#endregion
+//#region src/app/build.ts
+/**
+* @file `moku-game build`: the assets packed with the config's layers, then the production page
+* bundled by `Bun.build` in the game folder, with its HTML and `main.ts` in memory under a virtual
+* `<game>/.moku/build/` that is never written, then the packed assets copied beside the page. The
+* output works from any http sub-path and from the Tauri protocol: every link starts with `./`,
+* and the page reads `manifest.json` next to itself. Node and Bun only: the bin bundles it.
+*/
+/** The link prefix of the in-memory page, two folders under the game. */
+const TO_ROOT = "../../";
+/** Bytes in a kilobyte, for the size line of a run. */
+const BYTES_PER_KB = 1024;
+/**
+* The scan flags of a game: its root, its key module and one `--layer` per config layer.
+*
+* @param root - The game folder.
+* @param settings - The resolved config.
+* @returns The flags.
+* @example
+* ```ts
+* scanArguments("/g", resolveConfig({ page: { title: "T" }, assets: { layers: { shared: "ui" } } })).slice(4); // ["--layer", "shared=ui"]
+* ```
+*/
+function scanArguments(root, settings) {
+	const layers = Object.entries(settings.assets.layers).flatMap(([folder, name]) => ["--layer", `${folder}=${name}`]);
+	return [
+		"--root",
+		root,
+		"--keys",
+		path.join(root, "generated", "assets.ts"),
+		...layers
+	];
+}
+/**
+* Lists the folders right inside a folder.
+*
+* @param folder - The folder.
+* @returns Their absolute paths; none when the folder is missing.
+*/
+function foldersIn(folder) {
+	if (statSync(folder, { throwIfNoEntry: false })?.isDirectory() !== true) return [];
+	return readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path.join(folder, entry.name));
+}
+/**
+* Tells whether a game has an English string file to derive the pseudo-locale from: a
+* `strings/en.json` in a feature folder or in a layer folder of the config.
+*
+* @param root - The game folder.
+* @param settings - The resolved config, for its layer folders.
+* @returns True when at least one such file exists.
+*/
+function hasEnglishStrings(root, settings) {
+	const featureFolders = foldersIn(path.join(root, "features"));
+	const layerFolders = Object.keys(settings.assets.layers).map((folder) => path.join(root, folder));
+	return [...featureFolders, ...layerFolders].some((folder) => statSync(path.join(folder, "strings", "en.json"), { throwIfNoEntry: false })?.isFile() === true);
+}
+/**
+* The flags of the asset scan for `moku-game keys`: the dev manifest beside the game, the
+* pseudo-locale when the game has an English string file, and `--check` for a check run.
+*
+* @param root - The game folder.
+* @param settings - The resolved config.
+* @param check - True to check instead of write.
+* @returns The flags for the scanner's command line.
+* @example
+* ```ts
+* keysArguments("/g", resolveConfig({ page: { title: "T" } }), true).slice(4); // ["--manifest", "/g/manifest.json", "--check"]: no strings
+* keysArguments("/g", resolveConfig({ page: { title: "T" } }), false).at(-1); // "--pseudo" once /g/features/home/strings/en.json exists
+* ```
+*/
+function keysArguments(root, settings, check) {
+	return [
+		...scanArguments(root, settings),
+		"--manifest",
+		path.join(root, "manifest.json"),
+		...hasEnglishStrings(root, settings) ? ["--pseudo"] : [],
+		...check ? ["--check"] : []
+	];
+}
+/**
+* The flags of the asset scan for `moku-game pack` and the first step of `build`: the pack into
+* `<game>/dist/assets`, and `--no-cache` for a cold run.
+*
+* @param root - The game folder.
+* @param settings - The resolved config.
+* @param noCache - True to pack without the cache.
+* @returns The flags for the scanner's command line.
+* @example
+* ```ts
+* packArguments("/g", resolveConfig({ page: { title: "T" } }), false).slice(4); // ["--pack", "/g/dist/assets"]
+* ```
+*/
+function packArguments(root, settings, noCache) {
+	return [
+		...scanArguments(root, settings),
+		"--pack",
+		path.join(root, "dist", "assets"),
+		...noCache ? ["--no-cache"] : []
+	];
+}
+/**
+* Tells whether a folder is another folder or lies inside it.
+*
+* @param folder - The folder that may sit inside.
+* @param outer - The outer folder.
+* @returns True when `folder` is `outer` or lies under it.
+* @example
+* ```ts
+* isInside("/g", "/g/dist/web"); // false
+* ```
+*/
+function isInside(folder, outer) {
+	const relative = path.relative(outer, folder);
+	const climbs = relative === ".." || relative.startsWith(`..${path.sep}`);
+	return relative === "" || !climbs && !path.isAbsolute(relative);
+}
+/**
+* Refuses an output folder whose removal would take the game or its packed assets with it. Inside
+* the game, only a folder under `dist` is the build's.
+*
+* @param root - The game folder.
+* @param out - The output folder.
+* @throws {Error} When the folder is the game, holds it, is, holds or lies in the pack, or lies in
+*   the game outside `dist`.
+*/
+function refuseOut(root, out) {
+	const pack = path.join(root, "dist", "assets");
+	const replacesGame = isInside(root, out);
+	const touchesPack = isInside(out, pack) || isInside(pack, out);
+	const outsideBuildFolder = isInside(out, root) && !isInside(out, path.join(root, "dist"));
+	if (replacesGame || touchesPack || outsideBuildFolder) throw new Error(`[game] build: --out "${out}" would replace the game or its packed assets. Name another folder.`);
+}
+/**
+* Tells whether a default export is a Bun plugin.
+*
+* @param value - The default export.
+* @returns True for an object with a name and a `setup` function.
+*/
+function isBunPlugin(value) {
+	return typeof value === "object" && value !== null && "name" in value && typeof value.name === "string" && "setup" in value && typeof value.setup === "function";
+}
+/**
+* Imports the `--serve-plugin` files and takes their default exports.
+*
+* @param files - The absolute paths.
+* @returns The plugins, in order.
+* @throws {Error} When a file default-exports no Bun plugin.
+*/
+async function loadPlugins(files) {
+	return Promise.all(files.map(async (file) => {
+		const loaded = await import(pathToFileURL(file).href);
+		if (!isBunPlugin(loaded.default)) throw new Error(`[game] build: --serve-plugin "${file}" default-exports no Bun plugin.\n  End it with: export default { name, setup(build) { … } }.`);
+		return loaded.default;
+	}));
+}
+/**
+* Bundles the production page into the output folder: the HTML and `main.ts` in memory, every
+* link `./`, the dev flag defined false, no hot plugin.
+*
+* @param run - The flags of the run.
+* @param settings - The resolved config.
+* @returns Resolves when the page is written.
+* @throws {Error} With one Bun log per line when the page did not bundle.
+*/
+async function bundlePage(run, settings) {
+	const folder = path.join(run.root, ".moku", "build");
+	const html = path.join(folder, "index.html");
+	const main = path.join(folder, "main.ts");
+	const result = await Bun.build({
+		entrypoints: [html],
+		files: {
+			[html]: pageHtml(settings.page, {
+				toRoot: TO_ROOT,
+				script: "./main.ts"
+			}),
+			[main]: buildMain(settings)
+		},
+		outdir: run.out,
+		publicPath: "./",
+		minify: true,
+		target: "browser",
+		define: { __MOKU_GAME_DEV__: "false" },
+		naming: {
+			entry: "[name].[ext]",
+			chunk: "page/[name]-[hash].[ext]",
+			asset: "page/[name]-[hash].[ext]"
+		},
+		plugins: await loadPlugins(run.servePlugins),
+		throw: false
+	});
+	if (!result.success) throw new Error(["[game] build: the page did not bundle.", ...result.logs.map(String)].join("\n"));
+}
+/**
+* The fallback for icons Bun left as links into the game: copies each icon beside the page and
+* links it as `./<name>`.
+*
+* @param run - The flags of the run.
+* @param settings - The resolved config.
+*/
+function relinkIcons(run, settings) {
+	const file = path.join(run.out, "index.html");
+	let html = readFileSync(file, "utf8");
+	if (!html.includes(`"${TO_ROOT}`)) return;
+	for (const icon of Object.values(settings.page.icons)) {
+		const linked = icon?.replaceAll("\\", "/");
+		if (!(linked !== void 0 && html.includes(`"${TO_ROOT}${linked}"`))) continue;
+		const name = path.basename(linked);
+		copyFileSync(path.join(run.root, linked), path.join(run.out, name));
+		html = html.replaceAll(`"${TO_ROOT}${linked}"`, `"./${name}"`);
+	}
+	writeFileSync(file, html);
+}
+/**
+* Lists the files under a folder.
+*
+* @param folder - The folder.
+* @param relative - The folder under it to list, `/` separated.
+* @returns The files, relative to `folder`, `/` separated; none when it is missing.
+*/
+function filesUnder(folder, relative = "") {
+	const here = path.join(folder, relative);
+	if (statSync(here, { throwIfNoEntry: false })?.isDirectory() !== true) return [];
+	return readdirSync(here, { withFileTypes: true }).flatMap((entry) => {
+		const inner = relative === "" ? entry.name : `${relative}/${entry.name}`;
+		return entry.isDirectory() ? filesUnder(folder, inner) : [inner];
+	});
+}
+/**
+* Copies the packed assets beside the page, `manifest.json` next to `index.html`. File by file:
+* the output folder and its page folders exist already, and a packed file never replaces a page
+* file.
+*
+* @param run - The flags of the run.
+* @throws {Error} When a packed file has the path of a page file.
+*/
+function copyPack(run) {
+	const pack = path.join(run.root, "dist", "assets");
+	const page = new Set(filesUnder(run.out));
+	const packed = filesUnder(pack);
+	const clash = packed.find((file) => page.has(file));
+	if (clash !== void 0) throw new Error(`[game] build: "${clash}" is both a page file and a packed asset.`);
+	for (const file of packed) {
+		const target = path.join(run.out, file);
+		mkdirSync(path.dirname(target), { recursive: true });
+		copyFileSync(path.join(pack, file), target, constants.COPYFILE_EXCL);
+	}
+}
+/**
+* Runs a step with a folder as the working directory, then returns to the one before.
+*
+* @param folder - The folder the step runs in.
+* @param step - The step.
+* @returns What the step resolves to.
+*/
+async function inFolder(folder, step) {
+	const before = process.cwd();
+	process.chdir(folder);
+	try {
+		return await step();
+	} finally {
+		process.chdir(before);
+	}
+}
+/**
+* Builds the production page of a game: packs the assets, replaces the output folder with the
+* bundled page, and copies the pack beside it.
+*
+* @param run - The flags of the run.
+* @param deps - The process seams: the asset scanner and the console.
+* @returns The exit code: the pack's when it failed, else `0`.
+* @throws {Error} When the game, the output folder or the bundle is refused.
+*/
+async function runBuild(run, deps) {
+	const settings = await loadGame(run.root);
+	refuseOut(run.root, run.out);
+	const packed = await deps.assets(packArguments(run.root, settings, false));
+	if (packed !== 0) return packed;
+	rmSync(run.out, {
+		recursive: true,
+		force: true
+	});
+	await inFolder(run.root, () => bundlePage(run, settings));
+	relinkIcons(run, settings);
+	copyPack(run);
+	const files = filesUnder(run.out);
+	const bytes = files.map((file) => statSync(path.join(run.out, file)).size).reduce((sum, size) => sum + size, 0);
+	deps.ui.info(`built "${run.out}": ${files.length} files, ${Math.round(bytes / BYTES_PER_KB)} KB.`);
+	return 0;
+}
+//#endregion
+//#region src/app/cli.ts
+/**
+* @file The command line of `moku-game`: the arguments read per command with `node:util`
+* `parseArgs`, then one of `dev`, `build`, `native <verb>`, `keys`, `pack` or `help`. Every seam
+* of the process (the console, the environment, spawning, signals, the watcher, the asset
+* scanner, native, Bun's resolver) comes in as `deps`, so a test runs a command with stubs. It
+* returns the exit code and never exits itself. A plain function, on no API.
+*/
+/** The flags every command takes. */
+const GLOBAL_OPTIONS = [
+	"root",
+	"preload",
+	"serve-plugin",
+	"help"
+];
+/** Every flag of the line, as `parseArgs` reads it. */
+const ALL_OPTIONS = {
+	root: { type: "string" },
+	preload: {
+		type: "string",
+		multiple: true
+	},
+	"serve-plugin": {
+		type: "string",
+		multiple: true
+	},
+	help: {
+		type: "boolean",
+		short: "h"
+	},
+	port: { type: "string" },
+	packed: { type: "boolean" },
+	out: { type: "string" },
+	simulator: { type: "boolean" },
+	check: { type: "boolean" },
+	"no-cache": { type: "boolean" }
+};
+/** The flags of one command besides the global ones. */
+const COMMAND_OPTIONS = {
+	dev: ["port", "packed"],
+	build: ["out"],
+	native: ["simulator"],
+	keys: ["check"],
+	pack: ["no-cache"]
+};
+/** The native verbs, in the order the messages name them. */
+const NATIVE_VERBS = [
+	"build",
+	"dev",
+	"doctor",
+	"clean"
+];
+/** The port of `moku-game dev` without `--port`. */
+const DEFAULT_PORT = "3000";
+/** The highest port number. */
+const MAX_PORT = 65535;
+/** The text of `moku-game help`. */
+const USAGE = [
+	"moku-game <command> [options]",
+	"",
+	"  dev [--port 3000] [--packed]          serve the game with hot reload",
+	"  build [--out dist/web]                pack the assets and build the page",
+	"  native build <target> [--simulator]   build the native app (ios, macos, android)",
+	"  native dev <target>                   run the native shell on the dev server",
+	"  native doctor | native clean          check or remove the native project",
+	"  keys [--check]                        write generated/assets.ts and manifest.json",
+	"  pack [--no-cache]                     pack the assets into dist/assets",
+	"  help                                  print this text",
+	"",
+	"Every command: --root <dir> (default .), --preload <path>, --serve-plugin <path>."
+];
+/**
+* Tells whether a word is a command of the line that runs something.
+*
+* @param word - The first positional argument.
+* @returns True for `dev`, `build`, `native`, `keys` and `pack`.
+*/
+function isCommand(word) {
+	return Object.hasOwn(COMMAND_OPTIONS, word);
+}
+/**
+* Reads the message of anything that was thrown.
+*
+* @param failure - What the `catch` caught.
+* @returns The message.
+*/
+function messageOf(failure) {
+	return failure instanceof Error ? failure.message : String(failure);
+}
+/**
+* Reads the arguments without refusing anything, to find the command and the raw flags.
+*
+* @param argv - The arguments after the bin.
+* @returns The positionals, the values and the tokens.
+*/
+function parseLoose(argv) {
+	return parseArgs({
+		args: [...argv],
+		options: ALL_OPTIONS,
+		strict: false,
+		allowPositionals: true,
+		tokens: true
+	});
+}
+/**
+* Reads the arguments of a command whose flags were checked.
+*
+* @param argv - The arguments after the bin.
+* @returns The values and the positionals.
+*/
+function parseStrict(argv) {
+	return parseArgs({
+		args: [...argv],
+		options: ALL_OPTIONS,
+		strict: true,
+		allowPositionals: true
+	});
+}
+/**
+* Refuses a flag the command does not take, a flag without its value, and a value given to a
+* switch.
+*
+* @param command - The command.
+* @param tokens - The tokens of the loose read.
+* @throws {Error} Naming the command and the flag.
+*/
+function checkTokens(command, tokens) {
+	const names = /* @__PURE__ */ new Set([...GLOBAL_OPTIONS, ...COMMAND_OPTIONS[command]]);
+	const allowed = new Map(Object.entries(ALL_OPTIONS).filter(([name]) => names.has(name)).map(([name, option]) => [name, option.type]));
+	for (const token of tokens) {
+		if (token.kind !== "option") continue;
+		const type = allowed.get(token.name);
+		if (type === void 0) throw new Error(`[game] ${command}: unknown option "${token.rawName}".`);
+		const missing = token.value === void 0 || token.inlineValue !== true && token.value.startsWith("-");
+		if (type === "string" && missing) throw new Error(`[game] ${command}: "${token.rawName}" needs a value.`);
+		if (type === "boolean" && token.inlineValue === true) throw new Error(`[game] ${command}: "${token.rawName}" takes no value.`);
+	}
+}
+/**
+* Reads the command line into one command with its flags, the paths resolved against the
+* working directory.
+*
+* @param argv - The arguments after the bin.
+* @param cwd - The working directory.
+* @returns The command, `"help"`, or `undefined` when no command is named.
+* @throws {Error} When the command is unknown or a flag is refused.
+*/
+function parseCommand(argv, cwd) {
+	const loose = parseLoose(argv);
+	const word = loose.positionals[0];
+	if (loose.values.help === true || word === "help") return "help";
+	if (word === void 0) return void 0;
+	if (!isCommand(word)) throw new Error(`[game] moku-game: no command "${word}". Name one of dev, build, native, keys, pack, help.`);
+	checkTokens(word, loose.tokens);
+	const { values, positionals } = parseStrict(argv);
+	const resolveAll = (files) => (files ?? []).map((file) => path.resolve(cwd, file));
+	return {
+		command: word,
+		rest: positionals.slice(1),
+		root: path.resolve(cwd, values.root ?? "."),
+		preload: resolveAll(values.preload),
+		servePlugins: resolveAll(values["serve-plugin"]),
+		values
+	};
+}
+/**
+* Refuses arguments after the command word beyond the ones it takes.
+*
+* @param parsed - The command line.
+* @param count - How many positional arguments the command takes.
+* @throws {Error} Naming the first extra argument.
+*/
+function refuseExtra(parsed, count) {
+	const extra = parsed.rest[count];
+	if (extra !== void 0) throw new Error(`[game] ${parsed.command}: unexpected argument "${extra}".`);
+}
+/**
+* Reads `--port`: an integer 0-65535, 3000 when left out.
+*
+* @param given - The value of the flag.
+* @returns The port.
+* @throws {Error} When the value is not a port.
+* @example
+* ```ts
+* portOf(undefined); // 3000
+* ```
+*/
+function portOf(given) {
+	const text = given ?? DEFAULT_PORT;
+	const port = Number(text);
+	if (!(/^\d+$/.test(text) && port <= MAX_PORT)) throw new Error(`[game] dev: --port must be an integer 0-65535, got "${text}".`);
+	return port;
+}
+/**
+* Runs `moku-game dev`: the parent, or the server child the parent started.
+*
+* @param parsed - The command line.
+* @param deps - The process seams.
+* @returns The exit code.
+*/
+function runServe(parsed, deps) {
+	refuseExtra(parsed, 0);
+	const run = {
+		root: parsed.root,
+		port: portOf(parsed.values.port),
+		packed: parsed.values.packed === true,
+		preload: parsed.preload,
+		servePlugins: parsed.servePlugins
+	};
+	return deps.env.MOKU_GAME_CHILD === "1" ? serveChild(run, deps) : serveParent(run, deps);
+}
+/**
+* The command that runs `moku-game` again for native's web build and dev server, with the runner
+* flags, every word quoted.
+*
+* @param parsed - The command line.
+* @param deps - The Bun and the bin.
+* @returns The command text.
+*/
+function selfCommand(parsed, deps) {
+	const runnerFlags = [...parsed.preload.flatMap((file) => ["--preload", file]), ...parsed.servePlugins.flatMap((file) => ["--serve-plugin", file])];
+	return [
+		deps.execPath,
+		...deps.self,
+		"--root",
+		parsed.root,
+		...runnerFlags
+	].map((word) => JSON.stringify(word)).join(" ");
+}
+/**
+* Runs `moku-game native <verb> [<target>]` through native.
+*
+* @param parsed - The command line.
+* @param deps - The process seams.
+* @returns `0` when the verb succeeded, `1` when native reported a failure.
+* @throws {Error} When the verb is missing or unknown, or native refuses the config or target.
+*/
+async function runNativeVerb(parsed, deps) {
+	const [word, target] = parsed.rest;
+	const verb = NATIVE_VERBS.find((name) => name === word);
+	if (word === void 0) throw new Error("[game] native: name a verb: build, dev, doctor, clean.");
+	if (verb === void 0) throw new Error(`[game] native: no verb "${word}". Name one of build, dev, doctor, clean.`);
+	refuseExtra(parsed, 2);
+	const settings = await loadSettings(parsed.root);
+	const where = {
+		cwd: parsed.root,
+		command: selfCommand(parsed, deps)
+	};
+	const options = {
+		...target === void 0 ? {} : { target },
+		...verb === "build" && parsed.values.simulator === true ? { simulator: true } : {}
+	};
+	return await deps.native(verb, settings, where, options) ? 0 : 1;
+}
+/**
+* Runs `moku-game keys` or `pack` through the asset scanner, with the layers of `config.ts`.
+*
+* @param parsed - The command line.
+* @param deps - The process seams.
+* @returns The scanner's exit code.
+*/
+async function runScan(parsed, deps) {
+	refuseExtra(parsed, 0);
+	const settings = await loadSettings(parsed.root);
+	const argv = parsed.command === "keys" ? keysArguments(parsed.root, settings, parsed.values.check === true) : packArguments(parsed.root, settings, parsed.values["no-cache"] === true);
+	return deps.assets(argv);
+}
+/**
+* Runs the bin once more with every `--preload` as a Bun preload, so the preload runs before the
+* engine loads. The re-run is marked, so it does not hop again.
+*
+* @param argv - The arguments after the bin.
+* @param parsed - The command line.
+* @param deps - The process seams.
+* @returns The exit code of the re-run.
+*/
+function hop(argv, parsed, deps) {
+	return deps.spawn([
+		deps.execPath,
+		...parsed.preload.map((file) => `--preload=${file}`),
+		...deps.self,
+		...argv
+	], {
+		env: {
+			...deps.env,
+			MOKU_GAME_CHILD: "1"
+		},
+		stdio: [
+			"inherit",
+			"inherit",
+			"inherit"
+		]
+	}).exited;
+}
+/**
+* Runs one checked command.
+*
+* @param argv - The arguments after the bin.
+* @param parsed - The command line.
+* @param deps - The process seams.
+* @returns The exit code.
+*/
+async function runParsed(argv, parsed, deps) {
+	const usesPlugins = parsed.command !== "keys" && parsed.command !== "pack";
+	checkFiles("--preload", parsed.preload);
+	if (usesPlugins) checkFiles("--serve-plugin", parsed.servePlugins);
+	if (parsed.command !== "dev" && parsed.preload.length > 0 && deps.env.MOKU_GAME_CHILD !== "1") return hop(argv, parsed, deps);
+	switch (parsed.command) {
+		case "dev": return runServe(parsed, deps);
+		case "build": {
+			refuseExtra(parsed, 0);
+			const out = parsed.values.out ?? path.join(parsed.root, "dist", "web");
+			return runBuild({
+				root: parsed.root,
+				out: path.resolve(deps.cwd, out),
+				servePlugins: parsed.servePlugins
+			}, deps);
+		}
+		case "native": return runNativeVerb(parsed, deps);
+		case "keys":
+		case "pack": return runScan(parsed, deps);
+	}
+}
+/**
+* Prints the usage text on stdout.
+*
+* @param ui - The console.
+*/
+function printUsage(ui) {
+	for (const line of USAGE) ui.line(line);
+}
+/**
+* Runs one `moku-game` command line: reads the command and its flags, then runs `dev`, `build`,
+* `native <verb>`, `keys`, `pack` or `help`. Every failure is printed through the console as a
+* `[game] …` message; nothing exits the process.
+*
+* @param argv - The arguments after the bin.
+* @param deps - The process seams.
+* @returns The exit code: `0` on success, the child's code for `dev`, else `1` or the scanner's.
+*/
+async function runCommand(argv, deps) {
+	try {
+		const parsed = parseCommand(argv, deps.cwd);
+		if (parsed === "help") {
+			printUsage(deps.ui);
+			return 0;
+		}
+		if (parsed === void 0) {
+			printUsage(deps.ui);
+			deps.ui.error("[game] moku-game: name a command: dev, build, native, keys, pack, help.");
+			return 1;
+		}
+		return await runParsed(argv, parsed, deps);
+	} catch (error) {
+		deps.ui.error(messageOf(error));
+		return 1;
+	}
+}
+//#endregion
+//#region src/app/native.ts
+/**
+* @file The native verbs of `moku-game`: a game's `config.ts` as the config of `@moku-labs/native`,
+* and one verb run over it. Node only, no package export: the bin bundles it. The only file of the
+* engine that imports `@moku-labs/native`, and only with `import()`, so a web-only game never
+* loads it.
+*/
+/** The port of the dev server Tauri's shell starts and loads. */
+const DEV_PORT = 5173;
+/**
+* The native section of a resolved config.
+*
+* @param settings - The resolved `config.ts` of the game.
+* @returns The native section.
+* @throws {Error} When `config.ts` has no native section.
+*/
+function nativeSectionOf(settings) {
+	if (settings.native === void 0) throw new Error("[game] config.ts has no native section.\n  Add native: { name, identifier } to config.ts.");
+	return settings.native;
+}
+/**
+* The system rows native packages: one per system plugin that needs a Tauri capability. The
+* webview's own events and wake lock serve `lifecycle` and `keepAwake`, so they need no row. A
+* `"store"` save needs the store row even when `system` leaves it out.
+*
+* @param settings - The resolved `config.ts` of the game.
+* @returns The rows, in the order of `config.system`.
+*/
+function systemRowsOf(settings) {
+	const names = settings.system.filter((name) => name !== "lifecycle" && name !== "keepAwake");
+	if (settings.save === "store" && !names.includes("store")) names.push("store");
+	return names.map((name) => ({ name }));
+}
+/**
+* Maps a game's resolved `config.ts` to the config of `@moku-labs/native`: the app from `native`
+* and `page`, the web build through `moku-game`, the system rows, the targets, and the Tauri
+* project and output folders under the game.
+*
+* @param settings - The resolved `config.ts` of the game.
+* @param where - The game folder and the command that runs `moku-game`.
+* @param target - The target of the verb, used when `config.ts` names no targets.
+* @returns The config for `createApp({ config })` of `@moku-labs/native`.
+* @throws {Error} When `config.ts` has no native section.
+* @example
+* ```ts
+* const where = { cwd: "/g", command: '"/usr/local/bin/bun" "/g/node_modules/@moku-labs/game/bin/moku-game.mjs" "--root" "/g"' };
+* nativeConfigOf(resolveConfig({ page: { title: "T" }, native: { name: "T", identifier: "com.x.t" } }), where, "ios").web.dist; // "/g/dist/web"
+* ```
+*/
+function nativeConfigOf(settings, where, target) {
+	const native = nativeSectionOf(settings);
+	const config = {
+		app: {
+			name: native.name,
+			identifier: native.identifier,
+			orientation: settings.page.orientation,
+			backgroundColor: settings.page.background
+		},
+		web: {
+			cwd: where.cwd,
+			build: `${where.command} build`,
+			devCommand: `${where.command} dev --port ${DEV_PORT}`,
+			devUrl: `http://127.0.0.1:${DEV_PORT}`,
+			dist: path.join(where.cwd, "dist/web")
+		},
+		system: systemRowsOf(settings),
+		projectDir: path.join(where.cwd, ".moku/tauri"),
+		outDir: path.join(where.cwd, "dist-native")
+	};
+	const targets = native.targets ?? (target === void 0 ? void 0 : [target]);
+	if (native.icon !== void 0) config.app.icon = native.icon;
+	if (targets !== void 0) config.targets = targets;
+	return config;
+}
+/**
+* Checks the target of a verb against the targets native knows. `build` and `dev` need one.
+*
+* @param known - The `TARGETS` of `@moku-labs/native`.
+* @param verb - The native verb.
+* @param given - The target the command line names, unchecked.
+* @returns The target, or `undefined` for a `doctor` or `clean` over every target.
+* @throws {Error} When the target is unknown, or `build` or `dev` names none.
+*/
+function targetOf(known, verb, given) {
+	const target = known.find((name) => name === given);
+	if (given !== void 0 && target === void 0) throw new Error(`[game] No native target "${given}".\n  Name one of ${known.join(", ")}.`);
+	if (target === void 0 && verb === "build") throw new Error("[game] moku-game native build needs a target.\n  Run: moku-game native build ios --simulator.");
+	if (target === void 0 && verb === "dev") throw new Error("[game] moku-game native dev needs a target.\n  Run: moku-game native dev ios.");
+	return target;
+}
+/**
+* Runs one verb on the cli of a started native app.
+*
+* @param cli - The cli of the native app.
+* @param verb - The native verb.
+* @param target - The checked target.
+* @param simulator - iOS: build the simulator slice.
+* @returns The boolean of `doctor`, true for the other verbs once they finish.
+*/
+async function runVerb(cli, verb, target, simulator) {
+	switch (verb) {
+		case "build":
+			await cli.build({
+				target,
+				simulator
+			});
+			return true;
+		case "dev":
+			await cli.dev({ target });
+			return true;
+		case "doctor": return cli.doctor({ target });
+		case "clean":
+			await cli.clean({ target });
+			return true;
+	}
+}
+/**
+* Runs one native verb through `@moku-labs/native` over the game's config. Native's cli prints
+* the progress and the failure itself.
+*
+* @param verb - The native verb: build, dev, doctor or clean.
+* @param settings - The resolved `config.ts` of the game.
+* @param where - The game folder and the command that runs `moku-game`.
+* @param options - The target and the simulator flag.
+* @returns True when the verb succeeded, false when it failed.
+* @throws {Error} When `config.ts` has no native section, `@moku-labs/native` is not installed, or
+* the target is unknown or missing.
+*/
+async function runNative(verb, settings, where, options) {
+	nativeSectionOf(settings);
+	const native = await import("@moku-labs/native").catch((error) => {
+		throw new Error("[game] moku-game native needs @moku-labs/native.\n  Install it: bun add -d @moku-labs/native@^0.3.2.", { cause: error });
+	});
+	const target = targetOf(native.TARGETS, verb, options.target);
+	const app = native.createApp({ config: nativeConfigOf(settings, where, target) });
+	await app.start();
+	try {
+		return await runVerb(app.cli, verb, target, options.simulator);
+	} catch {
+		return false;
+	} finally {
+		await app.stop();
+	}
+}
+//#endregion
+//#region src/cli.ts
+/**
+* @file The `@moku-labs/game/cli` door, node and bun only: the `moku-game` bin and the editor's
+* seam. `runCli` runs one command line of `moku-game` (dev, build, native, keys, pack, help) in
+* this process; `preparePage` writes a game's dev page into `<game>/.moku/` for a server the
+* caller starts itself, as the editor does. It imports no Pixi, and the root entry never imports
+* it. The code lives in `app/`; this file wires the real process into it.
+*/
+/**
+* The real process behind the command line: the branded console, the environment the bin
+* started with, Bun's spawn and resolver, the signals, `fs.watch`, the asset scanner with the
+* string tools, and native.
+*
+* @returns The seams of this process.
+*/
+function processDeps() {
+	const env = { ...process.env };
+	const ui = createBrandConsole();
+	Reflect.deleteProperty(process.env, "MOKU_GAME_CHILD");
+	return {
+		ui,
+		env,
+		cwd: process.cwd(),
+		execPath: process.execPath,
+		self: [Bun.main],
+		spawn: (command, options) => Bun.spawn(command, options),
+		onSignal: (signal, handler) => {
+			process.on(signal, handler);
+			return () => {
+				process.off(signal, handler);
+			};
+		},
+		watch: (folder, listener) => {
+			const watcher = watch(folder, (event) => listener(event));
+			watcher.on("error", () => watcher.close());
+			return watcher;
+		},
+		assets: (argv) => runCli$1(argv, {
+			compile: compileStrings,
+			exportStrings,
+			importStrings
+		}, ui),
+		native: runNative,
+		resolve: (specifier, from) => Bun.resolveSync(specifier, from),
+		loadPage: (file) => import(file)
+	};
+}
+/**
+* Runs one `moku-game` command line in this process: `dev`, `build`, `native <verb>`, `keys`,
+* `pack` or `help`, with `--root`, `--preload` and `--serve-plugin` before or after the command
+* word. Every line goes through the branded console; nothing exits the process.
+*
+* @param argv - The arguments after the bin.
+* @returns The exit code.
+* @example
+* ```ts
+* // bin/moku-game.mjs in a game folder:
+* await runCli(["dev", "--port", "0"]); // 0 after Ctrl+C; stdout had "http://localhost:<port>/"
+* await runCli(["help"]); // 0
+* ```
+*/
+async function runCli(argv) {
+	return runCommand(argv, processDeps());
+}
+/**
+* Writes a game's dev page into `<root>/.moku/` for a server the caller starts: `index.html`,
+* `dev.ts`, `main.ts` with the scenarios of `tests/scenarios/` (and, with agents, the agents and
+* the game's `.dev` modules), and `bunfig.toml` with the engine's hot plugin. It starts no server
+* and no watcher, and throws the `[game]` errors of `moku-game dev`.
+*
+* @param root - The game folder, relative to the cwd or absolute.
+* @param options - The agents, the preloads and the extra bundler plugins.
+* @returns The absolute paths of the HTML and the bunfig.
+* @throws {Error} When the game has no `config.ts` or `index.ts`, a config value is refused, the
+*   game does not resolve `@moku-labs/game/hot`, or a preload or plugin is not a file.
+* @example
+* ```ts
+* // The editor bin, started with --root games/timber:
+* const { preparePage } = await import(Bun.resolveSync("@moku-labs/game/cli", root));
+* await preparePage("games/timber", { agents: ["@moku-labs/editor/agent/page"] });
+* // { html: "<cwd>/games/timber/.moku/index.html", bunfig: "<cwd>/games/timber/.moku/bunfig.toml" }
+* ```
+*/
+async function preparePage(root, options = {}) {
+	const absolute = (files) => (files ?? []).map((file) => path.resolve(file));
+	return preparePageAt(path.resolve(root), {
+		...options.agents === void 0 ? {} : { agents: options.agents },
+		preload: absolute(options.preload),
+		servePlugins: absolute(options.servePlugins)
+	}, (specifier, from) => Bun.resolveSync(specifier, from));
+}
+//#endregion
+export { preparePage, runCli };