@moku-labs/game 0.14.12 → 0.14.13

package/dist/cli.mjs

@@ -1,14 +1,239 @@
-import { t as resolveConfig } from "./config-CdARrrhU.mjs";
-import { r as watchTree, t as createBatcher, x as isSkippedFolder$1 } from "./watch-CWI_on4T.mjs";
-import { a as runCli$1, i as compileStrings, n as importStrings, t as exportStrings } from "./assets-BrKSg1O6.mjs";
+import { t as resolveConfig } from "./config-B87aFTW-.mjs";
+import { t as findFeatureOwners } from "./features-DowEilZm.mjs";
+import { r as watchTree, t as createBatcher, x as isSkippedFolder$1 } from "./watch-BEdrp80i.mjs";
+import { a as runCli$1, i as compileStrings, n as importStrings, t as exportStrings } from "./assets-CEMfBogh.mjs";
 import { constants, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, realpathSync, 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";
+import { createHash } from "node:crypto";
+//#region src/app/engine.ts
+/**
+* @file app — the engine a page is served or built with: its version, a hash of its bundled dist and of any declared
+* patch. Imports `node:fs`, `node:path` and `node:crypto` only, nothing from a plugin. The dev page, the editor's
+* `preparePage` and a debug build write its id into the page as `globalThis.__MOKU_GAME_ENGINE__`.
+*/
+/** The package name of the engine. */
+const ENGINE_PACKAGE = "@moku-labs/game";
+/** The lock files that mark the install root, where the patch walk stops. */
+const LOCK_FILES$1 = ["bun.lock", "bun.lockb"];
+/**
+* Tells whether a path is a file.
+*
+* @param file - The path.
+* @returns True for an existing file.
+*/
+function isFile$1(file) {
+	return statSync(file, { throwIfNoEntry: false })?.isFile() === true;
+}
+/**
+* Reads the `package.json` of a folder.
+*
+* @param folder - The folder.
+* @returns Its fields, or `undefined` without a readable `package.json` object.
+*/
+function packageOf(folder) {
+	const file = path.join(folder, "package.json");
+	if (!isFile$1(file)) return void 0;
+	try {
+		const parsed = JSON.parse(readFileSync(file, "utf8"));
+		return typeof parsed === "object" && parsed !== null ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Tells whether a path lies inside a folder, the folder itself left out.
+*
+* @param file - The path.
+* @param folder - The folder.
+* @returns True when `file` is below `folder`.
+* @example
+* ```ts
+* isBelow("/g/dist/hot.mjs", "/g/dist"); // true
+* ```
+*/
+function isBelow(file, folder) {
+	const relative = path.relative(folder, file);
+	return relative !== "" && relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+/**
+* Walks up from a folder to the first one whose `package.json` names the engine.
+*
+* @param start - The folder to start in.
+* @returns The engine folder and its fields, or `undefined` at the top of the disk.
+*/
+function engineFolderOf(start) {
+	for (let folder = start;; folder = path.dirname(folder)) {
+		const fields = packageOf(folder);
+		if (fields?.name === ENGINE_PACKAGE) return {
+			folder,
+			fields
+		};
+		if (path.dirname(folder) === folder) return void 0;
+	}
+}
+/**
+* Lists the files under a folder, at any depth.
+*
+* @param folder - The folder.
+* @param relative - The folder under it to list, `/` separated.
+* @returns The files, relative to `folder`, `/` separated, in no set order.
+*/
+function filesUnder$1(folder, relative = "") {
+	return readdirSync(path.join(folder, relative), { withFileTypes: true }).flatMap((entry) => {
+		const inner = relative === "" ? entry.name : `${relative}/${entry.name}`;
+		if (entry.isDirectory()) return filesUnder$1(folder, inner);
+		return entry.isFile() ? [inner] : [];
+	});
+}
+/**
+* Hashes every file under a `dist` folder: each fed as `<relative path>\0<bytes>\0`, in sorted
+* order, so a renamed file changes the hash as a changed byte does.
+*
+* @param dist - The folder.
+* @returns The SHA-256, hex.
+*/
+function distHash(dist) {
+	const hash = createHash("sha256");
+	for (const file of filesUnder$1(dist).toSorted()) {
+		hash.update(`${file}\0`);
+		hash.update(readFileSync(path.join(dist, file)));
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+/**
+* The folders the patch walk reads, from the game up: it stops after the first folder that holds
+* `bun.lock` or `bun.lockb`, or at the top of the disk.
+*
+* @param root - The game folder.
+* @returns The folders, the game first.
+*/
+function foldersToInstallRoot(root) {
+	const folders = [];
+	for (let folder = root;; folder = path.dirname(folder)) {
+		folders.push(folder);
+		if (LOCK_FILES$1.some((lock) => isFile$1(path.join(folder, lock))) || path.dirname(folder) === folder) return folders;
+	}
+}
+/**
+* The patch file a `package.json` declares for one dependency key.
+*
+* @param fields - The fields of the `package.json`.
+* @param key - The key, `@moku-labs/game@<version>`.
+* @returns The declared file, relative to the folder of the `package.json`, or `undefined`.
+*/
+function declaredPatch(fields, key) {
+	const declared = fields?.patchedDependencies;
+	if (typeof declared !== "object" || declared === null) return void 0;
+	const file = Reflect.get(declared, key);
+	return typeof file === "string" ? file : void 0;
+}
+/**
+* Finds the patch the install root declares for the installed engine version: the first
+* `package.json` on the walk whose `patchedDependencies` has the key decides.
+*
+* @param root - The game folder.
+* @param version - The installed engine version.
+* @returns The patch file and its hash; `undefined` when none is declared or the file is missing.
+*/
+function patchOf(root, version) {
+	const key = `${ENGINE_PACKAGE}@${version}`;
+	for (const folder of foldersToInstallRoot(root)) {
+		const declared = declaredPatch(packageOf(folder), key);
+		if (declared === void 0) continue;
+		const file = path.resolve(folder, declared);
+		if (!isFile$1(file)) return void 0;
+		return {
+			file,
+			hash: createHash("sha256").update(readFileSync(file)).digest("hex")
+		};
+	}
+}
+/**
+* The install root of a game: the first folder from the game up that holds `bun.lock` or
+* `bun.lockb`, where the patch walk of `engineFingerprint` stops. The dev server watches it for an
+* engine change.
+*
+* @param root - The game folder.
+* @returns The folder, or `undefined` when no folder up to the top of the disk holds a lock file.
+* @example
+* ```ts
+* // A game in a workspace, installed at the workspace root.
+* installRootOf("/w/games/timber"); // "/w"
+* ```
+*/
+function installRootOf(root) {
+	const last = foldersToInstallRoot(root).at(-1);
+	return last !== void 0 && LOCK_FILES$1.some((lock) => isFile$1(path.join(last, lock))) ? last : void 0;
+}
+/**
+* Reads the fingerprint of the engine a game resolves: walks up from the hot plugin to the engine's package.json,
+* hashes its `dist/`, and finds the patch the install root declares for that version. A hot plugin with no engine
+* `package.json` above it (a stub path, a broken install) gives the id `"unknown"` and throws nothing.
+*
+* @param root - The game folder.
+* @param hotPlugin - The resolved path of `@moku-labs/game/hot`.
+* @returns The fingerprint.
+* @example
+* ```ts
+* engineFingerprint("/g", "/g/node_modules/@moku-labs/game/dist/hot.mjs").id; // "0.14.12+9c41e0"
+* ```
+*/
+function engineFingerprint(root, hotPlugin) {
+	const found = engineFolderOf(path.dirname(hotPlugin));
+	if (found === void 0) return {
+		id: "unknown",
+		version: "unknown",
+		dist: "unknown",
+		folder: path.dirname(hotPlugin)
+	};
+	const { folder, fields } = found;
+	const version = typeof fields.version === "string" ? fields.version : "unknown";
+	const distFolder = path.join(folder, "dist");
+	const dist = isBelow(hotPlugin, distFolder) ? distHash(distFolder) : "src";
+	const patch = patchOf(root, version);
+	const id = `${version}+${dist === "src" ? dist : dist.slice(0, 6)}${patch === void 0 ? "" : `.patch.${patch.hash.slice(0, 6)}`}`;
+	return patch === void 0 ? {
+		id,
+		version,
+		dist,
+		folder
+	} : {
+		id,
+		version,
+		dist,
+		patch,
+		folder
+	};
+}
+/**
+* The one line `dev` and `build` print about the engine: its id, and the patch file relative to the game when there is one.
+*
+* @param engine - The fingerprint.
+* @param root - The game folder.
+* @returns The line.
+* @example
+* ```ts
+* engineLine({ id: "0.14.12+9c41e0.patch.3f2a7b", version: "0.14.12", dist: "9c41e0", folder: "/g/node_modules/@moku-labs/game", patch: { file: "/g/patches/@moku-labs%2Fgame@0.14.12.patch", hash: "3f2a7b" } }, "/g"); // "engine 0.14.12+9c41e0.patch.3f2a7b (patches/@moku-labs%2Fgame@0.14.12.patch)"
+* ```
+*/
+function engineLine(engine, root) {
+	if (engine.patch === void 0) return `engine ${engine.id}`;
+	const { file } = engine.patch;
+	const shown = isBelow(file, root) ? path.relative(root, file) : file;
+	return `engine ${engine.id} (${shown})`;
+}
+//#endregion
 //#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.";
+/** The startup mark every generated main writes first after its imports: they all evaluated. */
+const MAIN_MARK = "performance.mark(\"moku:main\");";
+/** The one agent a debug page carries: the editor's page agent, resolved from the game. */
+const DEBUG_AGENT = "@moku-labs/editor/agent/page";
 /**
 * The stamp module of a game, a file of `<game>/.moku/`. One per game: the dev page and the page
 * of `moku-game visual` import the same one.
@@ -257,12 +482,13 @@ function toStampFolder(toRoot) {
 	return toRoot.slice(3) || "./";
 }
 /**
-* The `main.ts` of the dev page: the dev flag first, then the assets stamp, 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 with the loaders of the
-* named plugins when the game needs it, the agents and the `.dev` modules. The stamp import puts
-* the stamp module on the page: when the keys watch writes a new stamp, the hot plugin hands it to
-* the running game.
+* The `main.ts` of the dev page: the startup mark module first, the dev flag second, then the
+* assets stamp, the page entry, the game, its config, one import per scenario, and, with agents,
+* one per `.dev` module and one per agent. Its first statement marks `moku:main`, then it calls
+* `startPage` with the scenarios by file stem, the shell with the loaders of the named plugins
+* when the game needs it, the agents and the `.dev` modules. The stamp import puts the stamp
+* module on the page: when the keys watch writes a new stamp, the hot plugin hands it to the
+* running game.
 *
 * @param settings - The resolved `config.ts`.
 * @param sources - The scenario files, the `.dev` modules and the agents.
@@ -287,6 +513,7 @@ function devMain(settings, sources, toRoot = "../") {
 	];
 	return [
 		WRITTEN,
+		"import \"./script.ts\";",
 		"import \"./dev.ts\";",
 		`import "${toStampFolder(toRoot)}${ASSETS_STAMP}";`,
 		...pageImports(settings, toRoot),
@@ -294,6 +521,7 @@ function devMain(settings, sources, toRoot = "../") {
 		...devModules.map((file, index) => importLine(`* as devModule${index}`, `${toRoot}${file}`)),
 		...agents.map((agent, index) => importLine(`agent${index}`, agent)),
 		"",
+		MAIN_MARK,
 		"await startPage(game, config, {",
 		options.join(",\n"),
 		"});",
@@ -301,9 +529,10 @@ function devMain(settings, sources, toRoot = "../") {
 	].join("\n");
 }
 /**
-* The `main.ts` of the production page: the page entry, the game and its config, and the shell
-* with the loaders of the named plugins when the game needs it. No dev flag, no scenario, no
-* agent, no `.dev` module, no door: none of them ships.
+* The `main.ts` of the production page: the startup mark module, the page entry, the game and its
+* config, and the shell with the loaders of the named plugins when the game needs it; its first
+* statement marks `moku:main`. No dev flag, no scenario, no agent, no `.dev` module, no door: none
+* of them ships. The release page: `moku-game build --debug` uses `debugMain`.
 *
 * @param settings - The resolved `config.ts`.
 * @returns The text of the in-memory `.moku/build/main.ts`.
@@ -319,24 +548,111 @@ function buildMain(settings) {
 		"});"
 	] : ["await startPage(game, config);"];
 	return [
+		"import \"./script.ts\";",
 		...pageImports(settings, "../../"),
 		"",
+		MAIN_MARK,
 		...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.
+* The `main.ts` of a debug page, `moku-game build --debug`: the startup mark module first, the
+* agent flag module second, then the page entry, the game, its config, one import per `.dev`
+* module, sorted, and the editor's page agent. Its first statement marks `moku:main`, then it
+* calls `startPage` with the shell when the game needs it, the agent and the `.dev` modules. No
+* scenario (`?player=` stays a dev feature), no assets stamp, no dev flag.
+*
+* @param settings - The resolved `config.ts`.
+* @param devModules - The `.dev.ts` modules of the game, relative to the game folder, `/` separated.
+* @returns The text of the in-memory `.moku/build/main.ts`.
+* @example
+* ```ts
+* debugMain(resolveConfig({ page: { title: "T" } }), []).includes("agents: [agent0]"); // true
+* ```
+*/
+function debugMain(settings, devModules) {
+	const sorted = devModules.toSorted();
+	const options = [
+		...needsShell(settings) ? [shellOption(settings)] : [],
+		"  agents: [agent0]",
+		...sorted.length === 0 ? [] : [`  devModules: [${numbered("devModule", sorted.length)}]`]
+	];
+	return [
+		"import \"./script.ts\";",
+		"import \"./agent.ts\";",
+		...pageImports(settings, "../../"),
+		...sorted.map((file, index) => importLine(`* as devModule${index}`, `../../${file}`)),
+		importLine("agent0", DEBUG_AGENT),
+		"",
+		MAIN_MARK,
+		"await startPage(game, config, {",
+		options.join(",\n"),
+		"});",
+		""
+	].join("\n");
+}
+/**
+* The `script.ts` module every generated main imports first: it marks `moku:script` with the URL
+* of the chunk it lands in, the first statement the bundle runs. Two marks cost nothing, so no
+* flag guards them.
 *
+* @returns The text of `.moku/script.ts` and of the in-memory `script.ts` of a build.
+* @example
+* ```ts
+* scriptMark().startsWith('performance.mark("moku:script"'); // true
+* ```
+*/
+function scriptMark() {
+	return "performance.mark(\"moku:script\", { detail: import.meta.url });\n";
+}
+/**
+* The `dev.ts` module the dev `main.ts` imports after the startup mark: it sets on `globalThis`,
+* for code that reads the globals, the build id `"dev"`, the engine id, the control flag, the
+* agent flag and, last, the dev flag. The bunfig `define` already makes the three bare flags true
+* in the bundle.
+*
+* @param engine - The id of the engine fingerprint the page was written for.
 * @returns The text of `.moku/dev.ts`.
 * @example
 * ```ts
-* devFlag().endsWith("globalThis.__MOKU_GAME_DEV__ = true;\n"); // true
+* devFlag("0.0.0+src").endsWith("globalThis.__MOKU_GAME_DEV__ = true;\n"); // true
+* ```
+*/
+function devFlag(engine) {
+	return [
+		WRITTEN,
+		"globalThis.__MOKU_GAME_BUILD__ = \"dev\";",
+		`globalThis.__MOKU_GAME_ENGINE__ = ${JSON.stringify(engine)};`,
+		"globalThis.__MOKU_GAME_CONTROL__ = true;",
+		"globalThis.__MOKU_GAME_AGENT__ = true;",
+		"globalThis.__MOKU_GAME_DEV__ = true;",
+		""
+	].join("\n");
+}
+/**
+* The in-memory `agent.ts` module of a debug page, imported after the startup mark: six lines
+* that set the build id, the engine id and the editor address, each through `JSON.stringify`, the
+* control flag of the profile, the agent flag, and the dev flag `false`. No header: nobody opens
+* it.
+*
+* @param page - What the page is built with.
+* @returns The text.
+* @example
+* ```ts
+* agentFlag({ build: "debug-20261014T153012Z", control: false, engine: "0.14.12+9c41e0", editor: "127.0.0.1:47600" }).split("\n")[0]; // 'globalThis.__MOKU_GAME_BUILD__ = "debug-20261014T153012Z";'
 * ```
 */
-function devFlag() {
-	return `${WRITTEN}\nglobalThis.__MOKU_GAME_DEV__ = true;\n`;
+function agentFlag(page) {
+	return [
+		`globalThis.__MOKU_GAME_BUILD__ = ${JSON.stringify(page.build)};`,
+		`globalThis.__MOKU_GAME_ENGINE__ = ${JSON.stringify(page.engine)};`,
+		`globalThis.__MOKU_GAME_EDITOR__ = ${JSON.stringify(page.editor)};`,
+		`globalThis.__MOKU_GAME_CONTROL__ = ${String(page.control)};`,
+		"globalThis.__MOKU_GAME_AGENT__ = true;",
+		"globalThis.__MOKU_GAME_DEV__ = false;",
+		""
+	].join("\n");
 }
 /**
 * The `assets-stamp.ts` module the dev `main.ts` imports: the asset files of the game with their
@@ -384,7 +700,7 @@ function tomlList(paths) {
 }
 /**
 * 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.
+* plugins of the page, and the dev, agent and control flags defined true.
 *
 * @param paths - The absolute paths of the hot plugin, the extra plugins and the preloads.
 * @returns The text of `.moku/bunfig.toml`.
@@ -400,11 +716,171 @@ function bunfigText(paths) {
 		"",
 		"[serve.static]",
 		`plugins = ${tomlList([paths.hotPlugin, ...paths.servePlugins])}`,
-		"define = { \"__MOKU_GAME_DEV__\" = \"true\" }",
+		"define = { \"__MOKU_GAME_DEV__\" = \"true\", \"__MOKU_GAME_AGENT__\" = \"true\", \"__MOKU_GAME_CONTROL__\" = \"true\" }",
 		""
 	].join("\n");
 }
 //#endregion
+//#region src/app/engine-watch.ts
+/**
+* @file app — watches the installed engine and tells when the served engine or its patch changed:
+* the dev server restarts its child on a new engine, and the editor's dev server does the same
+* through `watchEngine` of `@moku-labs/game/cli`. Node and Bun only; the fingerprint is the one of
+* `./engine`.
+*/
+/** The quiet that closes one batch of engine events: an install writes many files. */
+const ENGINE_QUIET_MS = 300;
+/** The lock files of an install root, the first one found is watched. */
+const LOCK_FILES = ["bun.lock", "bun.lockb"];
+/** The length of a hash as an engine id shows it. */
+const SHORT_HASH = 6;
+/**
+* Tells whether a path exists.
+*
+* @param file - The path.
+* @returns True for an existing file or folder.
+*/
+function exists(file) {
+	return statSync(file, { throwIfNoEntry: false }) !== void 0;
+}
+/**
+* Lists a folder and every folder under it.
+*
+* @param folder - The folder.
+* @returns The folders, `folder` first; none when it is missing.
+*/
+function foldersUnder(folder) {
+	if (statSync(folder, { throwIfNoEntry: false })?.isDirectory() !== true) return [];
+	return [folder, ...readdirSync(folder, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => foldersUnder(path.join(folder, entry.name)))];
+}
+/**
+* The paths the watch opens for an engine: the scope folder (an install replaces the engine
+* folder), the engine folder, every folder of its `dist`, the folder of the patch, and the
+* `package.json` and lock file of the install root. An engine from its sources or an unidentified
+* one opens none.
+*
+* @param start - The fingerprint to watch.
+* @param root - The game folder.
+* @returns The existing paths, each once.
+*/
+function watchedPaths(start, root) {
+	if (start.dist === "src" || start.dist === "unknown") return [];
+	const installRoot = installRootOf(root);
+	const rootFiles = installRoot === void 0 ? [] : [path.join(installRoot, "package.json"), ...LOCK_FILES.map((file) => path.join(installRoot, file)).filter((file) => exists(file)).slice(0, 1)];
+	const paths = [
+		path.dirname(start.folder),
+		start.folder,
+		...foldersUnder(path.join(start.folder, "dist")),
+		...start.patch === void 0 ? [] : [path.dirname(start.patch.file)],
+		...rootFiles
+	];
+	return [...new Set(paths)].filter((file) => exists(file));
+}
+/**
+* The short hash of a patch, as an engine id shows it.
+*
+* @param patch - The patch, or `undefined` without one.
+* @returns The first six hex digits, or `none`.
+* @example
+* ```ts
+* patchName(undefined); // "none"
+* ```
+*/
+function patchName(patch) {
+	return patch === void 0 ? "none" : patch.hash.slice(0, SHORT_HASH);
+}
+/**
+* The warning lines `moku-game dev` prints for a change.
+*
+* @param change - The change.
+* @returns The lines, the first one a `[game]` message.
+* @example
+* ```ts
+* engineChangeLines({ before: { id: "0.14.12+1a2b3c", version: "0.14.12", dist: "1a2b3c", folder: "/e" }, after: { id: "0.14.12+9c41e0", version: "0.14.12", dist: "9c41e0", folder: "/e" }, restart: true }); // ["[game] dev: the engine changed (0.14.12+1a2b3c -> 0.14.12+9c41e0), restarting the dev server."]
+* ```
+*/
+function engineChangeLines(change) {
+	const { before, after } = change;
+	if (!change.restart) return [`[game] dev: the engine's patch changed (${patchName(before.patch)} -> ${patchName(after.patch)}), but the installed engine did not.`, "  Run bun install; the dev server restarts by itself when the engine changes."];
+	const changed = `[game] dev: the engine changed (${before.id} -> ${after.id}), restarting the dev server.`;
+	return before.version === after.version ? [changed] : [changed, `  This process keeps the tools of ${before.version} (the keys watch); restart moku-game dev to use ${after.version}'s.`];
+}
+/**
+* Closes every open watcher of the watch.
+*
+* @param watch - The running watch.
+*/
+function closeWatchers(watch) {
+	for (const watcher of watch.watchers.splice(0)) watcher.close();
+}
+/**
+* One batch: fingerprints the engine again, calls `onChange` when the served engine or its patch
+* changed, and opens the watchers again: a replaced folder killed its watcher, and a new `dist`
+* folder needs one. An engine that cannot be read goes to `onError`.
+*
+* @param root - The game folder.
+* @param watch - The running watch.
+* @param seams - The resolver.
+* @param onChange - Called with the change.
+* @param onError - Called when the engine cannot be read.
+*/
+function checkEngine(root, watch, seams, onChange, onError) {
+	const before = watch.current;
+	let after;
+	try {
+		after = engineFingerprint(root, seams.resolve("@moku-labs/game/hot", root));
+	} catch (error) {
+		const reason = error instanceof Error ? error.message : String(error);
+		onError?.(`[game] dev: the engine cannot be read (${reason}). Waiting for the next change.`);
+		watch.open?.();
+		return;
+	}
+	const restart = before.version !== after.version || before.dist !== after.dist;
+	const repatched = before.patch?.hash !== after.patch?.hash;
+	watch.current = after;
+	watch.open?.();
+	if (restart || repatched) onChange({
+		before,
+		after,
+		restart
+	});
+}
+/**
+* Watches the engine's folders, its patch and the install root's lock. Every event waits for 300 ms
+* of quiet, then the engine is fingerprinted again: a new version or dist calls `onChange` with
+* `restart: true`, a new patch alone with `restart: false`, no change calls nothing. An engine that
+* cannot be read goes to `onError`, and the next event checks again. After each batch the watchers
+* open again from the current fingerprint.
+*
+* @param root - The game folder.
+* @param start - The fingerprint the server started with.
+* @param seams - The watcher and the resolver.
+* @param onChange - Called with each change.
+* @param onError - Called when the engine cannot be read; nothing by default.
+* @returns The running watch; `close()` ends it.
+*/
+function watchEngineAt(root, start, seams, onChange, onError) {
+	const watch = {
+		current: start,
+		watchers: [],
+		closed: false
+	};
+	const batcher = createBatcher(ENGINE_QUIET_MS, async () => {
+		if (!watch.closed) checkEngine(root, watch, seams, onChange, onError);
+	});
+	watch.open = () => {
+		closeWatchers(watch);
+		for (const file of watchedPaths(watch.current, root)) watch.watchers.push(seams.watch(file, () => batcher.poke()));
+	};
+	watch.open();
+	return { close: () => {
+		if (watch.closed) return;
+		watch.closed = true;
+		batcher.cancel();
+		closeWatchers(watch);
+	} };
+}
+//#endregion
 //#region src/app/files.ts
 /**
 * @file The file write of the files `moku-game` generates for a game. The dev page and the stamp
@@ -535,7 +1011,8 @@ function checkFiles(flag, files) {
 }
 /**
 * 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.
+* `src/hot.ts` through the tsconfig `paths` of the engine repo. A debug build resolves it the
+* same way, for the engine fingerprint.
 *
 * @param root - The game folder.
 * @param resolve - Bun's resolver.
@@ -576,7 +1053,7 @@ function isSkippedFolder(name) {
 }
 /**
 * Lists the `.dev.ts` modules under a folder of the game, outside the dot folders and the folders
-* of tools and tests.
+* of tools and tests: what the editor's dev page and a debug page hand to their agents.
 *
 * @param root - The game folder.
 * @param relative - The folder under the game, `/` separated, `""` for the game itself.
@@ -611,19 +1088,21 @@ function mainOf(root, settings, agents, toRoot = "../") {
 	}, toRoot);
 }
 /**
-* Writes the dev page of a checked game into `<game>/.moku/`: `index.html`, `dev.ts`, `main.ts`
-* and `bunfig.toml`. `moku-game visual` writes its own page into `.moku/visual/`, so the page of
-* `dev` or of the editor stays as it is; the links of the page reach the game from its depth.
-* Every text is made before the first write, so a refused value writes nothing. A game without
-* `.moku/assets-stamp.ts` gets the empty one, so the import of `main.ts` resolves with or without
-* a keys watch; a stamp that is there is the watch's and stays.
+* Writes the dev page of a checked game into `<game>/.moku/`: `index.html`, `script.ts` (the
+* startup mark), `dev.ts` (the flags and the engine id), `main.ts` and `bunfig.toml`. `moku-game
+* visual` writes its own page into `.moku/visual/`, so the page of `dev` or of the editor stays as
+* it is; the links of the page reach the game from its depth. The hot plugin is resolved and the
+* engine fingerprinted before any text is made, and every text is made before the first write, so
+* a refused value writes nothing. A game without `.moku/assets-stamp.ts` gets the empty one, so
+* the import of `main.ts` resolves with or without a keys watch; a stamp that is there is the
+* watch's and stays.
 *
 * @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.
 * @param page - The folder of the page under the game, `/` separated: `.moku` by default.
-* @returns The paths of the HTML and the bunfig.
+* @returns The paths of the HTML and the bunfig, and the engine the page was written for.
 * @throws {Error} When the hot plugin does not resolve, a preload or plugin is not a file, or a
 *   page value is refused.
 */
@@ -637,15 +1116,18 @@ function writePage(root, settings, options, resolve, page = ".moku") {
 	const folder = path.join(root, ...segments);
 	const html = path.join(folder, "index.html");
 	const bunfig = path.join(folder, "bunfig.toml");
+	const hotPlugin = hotPluginOf(root, resolve);
+	const engine = engineFingerprint(root, hotPlugin);
 	const texts = [
 		[html, pageHtml(settings.page, {
 			toRoot,
 			script: "./main.ts"
 		})],
-		[path.join(folder, "dev.ts"), devFlag()],
+		[path.join(folder, "script.ts"), scriptMark()],
+		[path.join(folder, "dev.ts"), devFlag(engine.id)],
 		[path.join(folder, "main.ts"), mainOf(root, settings, options.agents, toRoot)],
 		[bunfig, bunfigText({
-			hotPlugin: hotPluginOf(root, resolve),
+			hotPlugin,
 			servePlugins,
 			preload
 		})]
@@ -655,7 +1137,8 @@ function writePage(root, settings, options, resolve, page = ".moku") {
 	if (!existsSync(stamp)) writeIfChanged(stamp, assetsStamp([], []));
 	return {
 		html,
-		bunfig
+		bunfig,
+		engine
 	};
 }
 /**
@@ -666,7 +1149,7 @@ function writePage(root, settings, options, resolve, page = ".moku") {
 * @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.
+* @returns The paths of the HTML and the bunfig, and the engine the page was written for.
 * @throws {Error} The errors of `moku-game dev` before its server starts.
 */
 async function preparePageAt(root, options, resolve) {
@@ -736,12 +1219,54 @@ function devChildCommand(run, page, deps) {
 	];
 }
 /**
+* Hands one engine change to the dev parent: prints its lines, and when the served engine changed
+* marks the run for a restart and stops the child with SIGTERM, the way Ctrl+C stops it.
+*
+* @param change - The change.
+* @param live - The running child and the restart mark.
+* @param deps - The console.
+*/
+function restartOnEngineChange(change, live, deps) {
+	for (const line of engineChangeLines(change)) deps.ui.warn(line);
+	if (!change.restart) return;
+	live.restart = true;
+	live.child?.kill("SIGTERM");
+}
+/**
+* Serves a written page in a child until it exits without a restart: prints the engine line, runs
+* the child with the scenario watcher, and when the engine changed writes the page again (the new
+* engine id, the hot plugin of the new install) and runs a new child.
+*
+* @param run - The flags of the run.
+* @param page - The written page.
+* @param settings - The resolved config.
+* @param deps - The process seams.
+* @param live - The running child and the restart mark.
+* @returns The exit code of the last child.
+*/
+async function serveUntilStopped(run, page, settings, deps, live) {
+	deps.ui.info(engineLine(page.engine, run.root));
+	const code = await runChild(devChildCommand(run, page, deps), deps, {
+		cwd: run.root,
+		whileRunning: (child) => {
+			live.child = child;
+			return watchScenarios(run.root, settings, deps);
+		}
+	});
+	live.child = void 0;
+	if (!live.restart) return code;
+	live.restart = false;
+	return serveUntilStopped(run, writePage(run.root, settings, run, deps.resolve), settings, deps, live);
+}
+/**
 * The dev parent: checks the game, starts the keys watch on the raw files, 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. The first scan of the keys watch writes
+* prints the engine line, re-runs the bin under the generated bunfig with the game as its working
+* directory, and watches the scenarios while the child runs. The first scan of the keys watch writes
 * `generated/manifest.json` before the page is served, and a save of an asset or a strings file
-* scans again; `--packed` serves the pack and watches no keys. It hands Ctrl+C and the other stop
-* signals to the child and answers the child's exit code.
+* scans again; `--packed` serves the pack and watches no keys. The installed engine is watched: a
+* new engine stops the child with SIGTERM, writes the page again and starts a new child; a patch
+* that changed while the engine did not is a warning. It hands Ctrl+C and the other stop signals to
+* the child and answers the exit code of a child that ends by itself.
 *
 * @param run - The flags of the run.
 * @param deps - The process seams.
@@ -753,14 +1278,18 @@ async function serveParent(run, deps) {
 	const hasPack = isFile(path.join(run.root, "dist", "assets", "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.`);
 	const keys = run.packed ? void 0 : await deps.watchKeys(run.root, settings);
+	const live = {
+		child: void 0,
+		restart: false
+	};
+	let engine;
 	try {
 		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.");
-		return await runChild(devChildCommand(run, page, deps), deps, {
-			cwd: run.root,
-			whileRunning: () => watchScenarios(run.root, settings, deps)
-		});
+		engine = watchEngineAt(run.root, page.engine, deps, (change) => restartOnEngineChange(change, live, deps), (message) => deps.ui.warn(message));
+		return await serveUntilStopped(run, page, settings, deps, live);
 	} finally {
+		engine?.close();
 		keys?.close();
 	}
 }
@@ -792,7 +1321,7 @@ async function runChild(command, deps, child) {
 	const removers = FORWARDED.map((signal) => deps.onSignal(signal, () => started.kill(signal)));
 	let watcher;
 	try {
-		watcher = child.whileRunning?.();
+		watcher = child.whileRunning?.(started);
 		return await started.exited;
 	} finally {
 		watcher?.close();
@@ -872,7 +1401,7 @@ function serveOn(run, page) {
 			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 });
+		if (error instanceof Error && "code" in error && 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;
 	}
 }
@@ -932,11 +1461,21 @@ async function serveChild(run, deps) {
 //#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.
+* bundled by `Bun.build` in the game folder, with its HTML, `main.ts` and `script.ts` in memory
+* under a virtual `<game>/.moku/build/` that is never written, then the packed assets copied
+* beside the page. A release page that carries the editor's agent is refused and removed. With
+* `--debug` the page is a debug page instead: the editor's page agent, the game's `.dev` modules,
+* the agent flag and a control profile, a marked title and a build id. 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 address the page agent of a debug page dials without `--editor`. */
+const DEFAULT_EDITOR = "127.0.0.1:47600";
+/**
+* The two strings the editor's agent bundle always carries: the bridge's default path and the
+* prefix of every editor error. A contract between the engine, the editor and `@moku-labs/native`.
 */
+const AGENT_MARKERS = ["/__editor/hello", "[moku-editor]"];
 /** 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. */
@@ -963,27 +1502,32 @@ function scanArguments(root, settings) {
 	];
 }
 /**
-* Lists the folders right inside a folder.
+* The folders of every feature owner of a game, at any depth (`src/project/features.ts`). A
+* feature name two folders share counts as no owner: the scan that follows finds the same clash
+* and reports it.
 *
-* @param folder - The folder.
-* @returns Their absolute paths; none when the folder is missing.
+* @param root - The game folder.
+* @returns Their absolute paths; none when the features 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));
+function featureFolders(root) {
+	try {
+		return findFeatureOwners(root).map((owner) => path.join(root, owner.dir));
+	} catch {
+		return [];
+	}
 }
 /**
 * 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.
+* `strings/en.json` in a feature folder at any depth (a feature owner of
+* `src/project/features.ts`) 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);
+	return [...featureFolders(root), ...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 in `generated/`, the
@@ -1085,32 +1629,106 @@ async function loadPlugins(files) {
 	}));
 }
 /**
-* 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.
+* The id of a debug build: the profile and the UTC time of the run, `YYYYMMDDTHHMMSSZ`.
+*
+* @param debug - The profile.
+* @param now - The wall-clock time of the run, ms.
+* @returns The id.
+* @example
+* ```ts
+* buildIdOf("read", Date.UTC(2026, 9, 14, 15, 30, 12)); // "debug-20261014T153012Z"
+* ```
+*/
+function buildIdOf(debug, now) {
+	const stamp = `${new Date(now).toISOString().slice(0, 19).replaceAll(/[-:]/g, "")}Z`;
+	return debug === "full" ? `debug-full-${stamp}` : `debug-${stamp}`;
+}
+/**
+* The `define` map of a page: a release page defines the three flags `false`; a debug page the
+* dev flag `false`, the agent flag `true`, the control flag of its profile, and the build id, the
+* engine id and the editor address as strings.
+*
+* @param page - What a debug page is built with; `undefined` for a release page.
+* @returns The defines for `Bun.build`.
+* @example
+* ```ts
+* definesOf(undefined).__MOKU_GAME_AGENT__; // "false"
+* ```
+*/
+function definesOf(page) {
+	if (page === void 0) return {
+		__MOKU_GAME_DEV__: "false",
+		__MOKU_GAME_AGENT__: "false",
+		__MOKU_GAME_CONTROL__: "false"
+	};
+	return {
+		__MOKU_GAME_DEV__: "false",
+		__MOKU_GAME_AGENT__: "true",
+		__MOKU_GAME_CONTROL__: page.level === "full" ? "true" : "false",
+		__MOKU_GAME_BUILD__: JSON.stringify(page.build),
+		__MOKU_GAME_ENGINE__: JSON.stringify(page.engine),
+		__MOKU_GAME_EDITOR__: JSON.stringify(page.editor)
+	};
+}
+/**
+* The in-memory files of the page under `<game>/.moku/build/`: a release page has `index.html`,
+* `main.ts` and `script.ts`; a debug page also `agent.ts`, its `main.ts` from `debugMain` with the
+* game's `.dev` modules, and its title marked `Debug`.
+*
+* @param run - The flags of the run.
+* @param settings - The resolved config.
+* @param page - What a debug page is built with; `undefined` for a release page.
+* @returns The texts by absolute path.
+*/
+function pageFiles(run, settings, page) {
+	const folder = path.join(run.root, ".moku", "build");
+	const links = {
+		toRoot: TO_ROOT,
+		script: "./main.ts"
+	};
+	const release = {
+		[path.join(folder, "index.html")]: pageHtml(settings.page, links),
+		[path.join(folder, "main.ts")]: buildMain(settings),
+		[path.join(folder, "script.ts")]: scriptMark()
+	};
+	if (page === void 0) return release;
+	const flags = {
+		build: page.build,
+		control: page.level === "full",
+		engine: page.engine
+	};
+	return {
+		...release,
+		[path.join(folder, "index.html")]: pageHtml({
+			...settings.page,
+			title: `${settings.page.title} Debug`
+		}, links),
+		[path.join(folder, "main.ts")]: debugMain(settings, devModulesOf(run.root)),
+		[path.join(folder, "agent.ts")]: agentFlag({
+			...flags,
+			editor: page.editor
+		})
+	};
+}
+/**
+* Bundles the page into the output folder: its files in memory, every link `./`, the flags
+* defined, no hot plugin.
 *
 * @param run - The flags of the run.
 * @param settings - The resolved config.
+* @param page - What a debug page is built with; `undefined` for a release page.
 * @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");
+async function bundlePage(run, settings, page) {
 	const result = await Bun.build({
-		entrypoints: [html],
-		files: {
-			[html]: pageHtml(settings.page, {
-				toRoot: TO_ROOT,
-				script: "./main.ts"
-			}),
-			[main]: buildMain(settings)
-		},
+		entrypoints: [path.join(run.root, ".moku", "build", "index.html")],
+		files: pageFiles(run, settings, page),
 		outdir: run.out,
 		publicPath: "./",
 		minify: true,
 		target: "browser",
-		define: { __MOKU_GAME_DEV__: "false" },
+		define: definesOf(page),
 		naming: {
 			entry: "[name].[ext]",
 			chunk: "page/[name]-[hash].[ext]",
@@ -1157,6 +1775,26 @@ function filesUnder(folder, relative = "") {
 	});
 }
 /**
+* Refuses a release page that carries the editor's agent: reads every `.js` file of the output
+* for the two marker strings of the agent bundle. On a hit the output folder is removed, so no
+* release page with an agent is left on disk.
+*
+* @param out - The output folder.
+* @throws {Error} Naming the marker and the file, when a page file carries one.
+*/
+function refuseAgent(out) {
+	for (const file of filesUnder(out).filter((name) => name.endsWith(".js")).toSorted()) {
+		const code = readFileSync(path.join(out, file), "utf8");
+		const marker = AGENT_MARKERS.find((text) => code.includes(text));
+		if (marker === void 0) continue;
+		rmSync(out, {
+			recursive: true,
+			force: true
+		});
+		throw new Error(`[game] build: the release page carries the editor agent ("${marker}" in ${file}).\n  Import @moku-labs/editor only behind __MOKU_GAME_DEV__, or build a debug page with --debug.`);
+	}
+}
+/**
 * 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.
@@ -1193,28 +1831,91 @@ async function inFolder(folder, step) {
 	}
 }
 /**
-* Builds the production page of a game: packs the assets, replaces the output folder with the
-* bundled page, and copies the pack beside it.
+* Refuses `--debug` when Tauri runs the web build of a store app: `MOKU_NATIVE_PROFILE=store`.
+*
+* @param run - The flags of the run.
+* @param env - The environment the bin started with.
+* @throws {Error} When the profile is `store` and the run is a debug run.
+*/
+function refuseStoreDebug(run, env) {
+	if (run.debug === void 0 || env.MOKU_NATIVE_PROFILE !== "store") return;
+	throw new Error("[game] build: MOKU_NATIVE_PROFILE is store: a store page must not carry the editor agent.\n  Build the store app without --debug.");
+}
+/**
+* What a debug run builds its page with: the editor's page agent must resolve from the game, and
+* the engine the page bundles is fingerprinted.
+*
+* @param run - The flags of a debug run.
+* @param level - Its profile.
+* @param deps - The resolver and the clock.
+* @returns The debug page and the engine fingerprint.
+* @throws {Error} With the install line when the game cannot resolve `@moku-labs/editor`, and
+*   when it cannot resolve `@moku-labs/game/hot`.
+*/
+function debugPageOf(run, level, deps) {
+	try {
+		deps.resolve(DEBUG_AGENT, run.root);
+	} catch (error) {
+		throw new Error("[game] build --debug needs @moku-labs/editor in the game.\n  Install it: bun add -d @moku-labs/editor.", { cause: error });
+	}
+	const engine = engineFingerprint(run.root, hotPluginOf(run.root, deps.resolve));
+	return {
+		page: {
+			level,
+			build: buildIdOf(level, deps.now()),
+			engine: engine.id,
+			editor: run.editor ?? "127.0.0.1:47600"
+		},
+		engine
+	};
+}
+/**
+* The warning a debug build prints before its size line: the profile, the build id, the engine and
+* the editor address.
+*
+* @param run - The flags of the run.
+* @param debug - The debug page and the engine fingerprint.
+* @param debug.page - What the page was built with.
+* @param debug.engine - The engine it bundles.
+* @returns The line.
+*/
+function debugWarning(run, debug) {
+	const { page, engine } = debug;
+	const control = page.level === "full" ? "every command, the state-changing ones too" : "read and cosmetic commands";
+	const engineText = engineLine(engine, run.root).slice(7);
+	return `build: a DEBUG page with the editor agent, control: ${control}. Build ${page.build}, engine ${engineText}, editor ${page.editor}. Never ship it to a store.`;
+}
+/**
+* Builds the page of a game: packs the assets, replaces the output folder with the bundled page,
+* refuses a release page that carries the editor's agent, and copies the pack beside it. A debug
+* run first checks that the game resolves the editor's agent and fingerprints the engine, and
+* prints one warning before the size line.
 *
 * @param run - The flags of the run.
-* @param deps - The process seams: the asset scanner and the console.
+* @param deps - The process seams: the asset scanner, the resolver, the clock, the environment 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.
+* @throws {Error} When the game, the output folder, the profile or the bundle is refused, a debug
+*   run cannot resolve the editor, or a release page carries the editor's agent.
 */
 async function runBuild(run, deps) {
+	refuseStoreDebug(run, deps.env);
 	const settings = await loadGame(run.root);
 	refuseOut(run.root, run.out);
+	const debug = run.debug === void 0 ? void 0 : debugPageOf(run, run.debug, deps);
 	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));
+	await inFolder(run.root, () => bundlePage(run, settings, debug?.page));
 	relinkIcons(run, settings);
+	if (debug === void 0) refuseAgent(run.out);
 	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);
+	if (debug !== void 0) deps.ui.warn(debugWarning(run, debug));
 	deps.ui.info(`built "${run.out}": ${files.length} files, ${Math.round(bytes / BYTES_PER_KB)} KB.`);
 	return 0;
 }
@@ -1438,17 +2139,28 @@ const ALL_OPTIONS = {
 		multiple: true
 	},
 	"no-pixels": { type: "boolean" },
+	"no-verify-frames": { type: "boolean" },
 	pixels: { type: "boolean" },
 	dir: { type: "string" },
-	webgl: { type: "boolean" }
+	webgl: { type: "boolean" },
+	debug: { type: "string" },
+	editor: { type: "string" }
 };
 /** The flags of `visual` that `parseVisualArgv` reads, in the runner's words. */
-const VISUAL_FLAGS = /^(?:update|only|no-pixels|pixels|dir|webgl)$/;
+const VISUAL_FLAGS = /^(?:update|only|no-pixels|pixels|dir|webgl|no-verify-frames)$/;
 /** The flags of one command besides the global ones. */
 const COMMAND_OPTIONS = {
 	dev: ["port", "packed"],
-	build: ["out"],
-	native: ["simulator"],
+	build: [
+		"out",
+		"debug",
+		"editor"
+	],
+	native: [
+		"simulator",
+		"debug",
+		"editor"
+	],
 	keys: ["check"],
 	pack: ["no-cache"],
 	visual: [
@@ -1459,7 +2171,8 @@ const COMMAND_OPTIONS = {
 		"no-pixels",
 		"pixels",
 		"dir",
-		"webgl"
+		"webgl",
+		"no-verify-frames"
 	]
 };
 /** The native verbs, in the order the messages name them. */
@@ -1477,19 +2190,21 @@ const VISUAL_TESTS = path.join("tests", "visual", "index.ts");
 const DEFAULT_PORT = "3000";
 /** The highest port number. */
 const MAX_PORT = 65535;
+/** A host of `--editor`: a name or an IPv4 address, or an IPv6 address in brackets. */
+const EDITOR_HOST = /^(?:[\w.-]+|\[[\da-f:.]+\])$/i;
 /** 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)",
+	"  build [--out dist/web] [--debug[=full] [--editor host:port]]  pack the assets and build the page; --debug adds the editor agent",
+	"  native build <target> [--simulator] [--debug[=full] [--editor host:port]]  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 generated/manifest.json",
 	"  pack [--no-cache]                     pack the assets into dist/assets",
 	"  visual [--update] [--only <name>]     run tests/visual/index.ts: headless, pixels on a Mac",
-	"    [--no-pixels | --pixels] [--webgl] [--dir tests/visual/baselines]",
+	"    [--no-pixels | --pixels] [--webgl] [--no-verify-frames] [--dir tests/visual/baselines]",
 	"    [--tests tests/visual/index.ts] [--url <url>]",
 	"  help                                  print this text",
 	"",
@@ -1564,14 +2279,16 @@ function checkTokens(command, tokens) {
 }
 /**
 * Reads the command line into one command with its flags, the paths resolved against the
-* working directory.
+* working directory. A bare `--debug` reads as `--debug=read`: a string flag without its value
+* would take the next word.
 *
-* @param argv - The arguments after the bin.
+* @param given - 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) {
+function parseCommand(given, cwd) {
+	const argv = given.map((word) => word === "--debug" ? "--debug=read" : word);
 	const loose = parseLoose(argv);
 	const word = loose.positionals[0];
 	if (loose.values.help === true || word === "help") return "help";
@@ -1598,7 +2315,47 @@ function parseCommand(argv, cwd) {
 */
 function refuseExtra(parsed, count) {
 	const extra = parsed.rest[count];
-	if (extra !== void 0) throw new Error(`[game] ${parsed.command}: unexpected argument "${extra}".`);
+	if (extra === void 0) return;
+	const advice = parsed.values.debug !== void 0 && (extra === "full" || extra === "read") ? ` Write --debug=${extra}.` : "";
+	throw new Error(`[game] ${parsed.command}: unexpected argument "${extra}".${advice}`);
+}
+/**
+* Reads `--debug`: no flag is a release page, a bare flag or `read` the read profile, `full`
+* every command.
+*
+* @param value - The value of the flag, `read` for a bare `--debug`.
+* @param command - The command word, for the message.
+* @returns The profile, or `undefined` without the flag.
+* @throws {Error} When the value is another word.
+* @example
+* ```ts
+* debugLevelOf("full"); // "full"
+* ```
+*/
+function debugLevelOf(value, command = "build") {
+	if (value === void 0 || value === "read" || value === "full") return value;
+	throw new Error(`[game] ${command}: --debug takes no value, "read" or "full", got "${value}".`);
+}
+/**
+* Reads `--editor`: the `host:port` the page agent of a debug page dials, 127.0.0.1:47600 when
+* left out.
+*
+* @param value - The value of the flag.
+* @param command - The command word, for the message.
+* @returns The address.
+* @throws {Error} When the value is not a host and a whole port from 1 to 65535.
+* @example
+* ```ts
+* editorOf("192.168.1.20:47600"); // "192.168.1.20:47600"
+* ```
+*/
+function editorOf(value, command = "build") {
+	if (value === void 0) return DEFAULT_EDITOR;
+	const colon = value.lastIndexOf(":");
+	const host = value.slice(0, Math.max(colon, 0));
+	const port = value.slice(colon + 1);
+	if (!(colon > 0 && EDITOR_HOST.test(host) && /^\d+$/.test(port) && Number(port) >= 1 && Number(port) <= MAX_PORT)) throw new Error(`[game] ${command}: --editor takes host:port, got "${value}".`);
+	return value;
 }
 /**
 * Reads `--port`: an integer 0-65535, 3000 when left out.
@@ -1667,6 +2424,7 @@ async function runNativeVerb(parsed, deps) {
 	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 debug = nativeDebugOf(parsed, verb, target);
 	const settings = await loadSettings(parsed.root);
 	const where = {
 		cwd: parsed.root,
@@ -1674,11 +2432,36 @@ async function runNativeVerb(parsed, deps) {
 	};
 	const options = {
 		...target === void 0 ? {} : { target },
-		...verb === "build" && parsed.values.simulator === true ? { simulator: true } : {}
+		...verb === "build" && parsed.values.simulator === true ? { simulator: true } : {},
+		...debug
 	};
+	if (debug.debug !== void 0 && target === "android") deps.ui.warn("native: a DEBUG app with the editor agent, installed beside the store app. Never ship it to a store.");
 	return await deps.native(verb, settings, where, options) ? 0 : 1;
 }
 /**
+* Reads `--debug` and `--editor` of `moku-game native`: they go with `native build android`
+* only in this release.
+*
+* @param parsed - The command line.
+* @param verb - The native verb.
+* @param target - The target the command line names, unchecked.
+* @returns The profile and the editor address as given, each only when given.
+* @throws {Error} When either goes with another verb, `--editor` comes without `--debug`, a value
+*   is refused, or the target is not `android`.
+*/
+function nativeDebugOf(parsed, verb, target) {
+	const debug = debugLevelOf(parsed.values.debug, "native");
+	const editor = parsed.values.editor;
+	if (debug === void 0 && editor === void 0) return {};
+	if (verb !== "build") throw new Error("[game] native: --debug goes with native build only.");
+	if (debug === void 0) throw new Error("[game] native: --editor goes with --debug.");
+	if (target !== void 0 && target !== "android") throw new Error(`[game] native: --debug builds Android only in this release (got ${target}).`);
+	return editor === void 0 ? { debug } : {
+		debug,
+		editor: editorOf(editor, "native")
+	};
+}
+/**
 * Runs `moku-game keys` or `pack` through the asset scanner, with the layers of `config.ts`.
 *
 * @param parsed - The command line.
@@ -1754,6 +2537,31 @@ function hop(argv, parsed, deps) {
 	}).exited;
 }
 /**
+* Runs `moku-game build`: a release page, or with `--debug[=full]` a debug page whose agent dials
+* `--editor`.
+*
+* @param parsed - The command line.
+* @param deps - The process seams.
+* @returns The exit code of the build.
+* @throws {Error} When an argument, `--debug` or `--editor` is refused.
+*/
+function runBuildCommand(parsed, deps) {
+	refuseExtra(parsed, 0);
+	const debug = debugLevelOf(parsed.values.debug);
+	const editor = parsed.values.editor;
+	if (debug === void 0 && editor !== void 0) throw new Error("[game] build: --editor goes with --debug.");
+	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,
+		...debug === void 0 ? {} : {
+			debug,
+			editor: editorOf(editor)
+		}
+	}, deps);
+}
+/**
 * Runs one checked command.
 *
 * @param argv - The arguments after the bin.
@@ -1768,15 +2576,7 @@ async function runParsed(argv, parsed, deps) {
 	if (parsed.command !== "dev" && parsed.command !== "visual" && 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 "build": return runBuildCommand(parsed, deps);
 		case "native": return runNativeVerb(parsed, deps);
 		case "keys":
 		case "pack": return runScan(parsed, deps);
@@ -1825,7 +2625,8 @@ async function runCommand(argv, deps) {
 * keeps `generated/` fresh while a dev page is open. A file event is only a trigger. When the
 * events stop for a quiet period, a batch walks the game and reads the size and the time stamp of
 * every asset file and every `strings/<locale>.json`; it runs the scan of `moku-game keys` only
-* when they differ from the batch before. After a scan it writes `.moku/assets-stamp.ts` from the
+* when they differ from the batch before. A folder that becomes or stops being a sub-feature scans
+* too: the keys and bundles of its files move between owners. After a scan it writes `.moku/assets-stamp.ts` from the
 * asset files: every file with its stamp, and the ones this batch found changed, so the dev page
 * reads only those again. One scan runs at a time, and a failed scan never stops the watch. A
 * batch that scanned is followed by one more walk: the platform reports only the first path of a
@@ -1884,6 +2685,22 @@ function readFolder(root, folder, walk) {
 	}
 }
 /**
+* Adds the feature owners below the top level to the inputs: a folder that becomes or stops being
+* a sub-feature moves keys and bundles between owners without any asset or strings file changing.
+* The trailing `/` keeps the entry apart from every file. A name two folders share adds one entry
+* with the message instead of throwing: the scan reports the clash, and a rename moves the entry.
+*
+* @param root - The real game folder.
+* @param walk - The inputs so far.
+*/
+function readOwners(root, walk) {
+	try {
+		for (const owner of findFeatureOwners(root)) if (owner.depth >= 1) walk.inputs.set(`${owner.dir}/`, `sub-feature of ${owner.parent}`);
+	} catch (error) {
+		walk.inputs.set("features/", `clash: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
 * Walks a game folder for the inputs of the scan.
 *
 * @param root - The real game folder.
@@ -1895,6 +2712,7 @@ function walkInputs(root) {
 		folders: []
 	};
 	readFolder(root, "", walk);
+	readOwners(root, walk);
 	return walk;
 }
 /**
@@ -2129,13 +2947,34 @@ function systemRowsOf(settings) {
 	return names.map((name) => ({ name }));
 }
 /**
+* The web build command native runs: `moku-game build`, with the debug profile and the editor
+* address of a debug app.
+*
+* @param where - The game folder and the command that runs `moku-game`.
+* @param debug - The debug profile, or `undefined` for a store app.
+* @returns The command.
+* @example
+* ```ts
+* webBuildOf({ cwd: "/g", command: '"bun" "/g/bin/moku-game.mjs"' }, { level: "full", editor: "192.168.1.20:47600" }); // '"bun" "/g/bin/moku-game.mjs" build --debug=full --editor 192.168.1.20:47600'
+* ```
+*/
+function webBuildOf(where, debug) {
+	if (debug === void 0) return `${where.command} build`;
+	const level = debug.level === "full" ? "--debug=full" : "--debug";
+	const editor = debug.editor === void 0 ? "" : ` --editor ${debug.editor}`;
+	return `${where.command} build ${level}${editor}`;
+}
+/**
 * 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.
+* project and output folders under the game. An Android app composes native's `shell` system
+* first, the one that sets `globalThis.__MOKU_NATIVE__`. A debug app builds its web page with the
+* same profile and `--editor`; its name and identifier stay the game's.
 *
 * @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.
+* @param debug - The debug profile of a debug app; left out for a store app.
 * @returns The config for `createApp({ config })` of `@moku-labs/native`.
 * @throws {Error} When `config.ts` has no native section.
 * @example
@@ -2144,8 +2983,9 @@ function systemRowsOf(settings) {
 * nativeConfigOf(resolveConfig({ page: { title: "T" }, native: { name: "T", identifier: "com.x.t" } }), where, "ios").web.dist; // "/g/dist/web"
 * ```
 */
-function nativeConfigOf(settings, where, target) {
+function nativeConfigOf(settings, where, target, debug) {
 	const native = nativeSectionOf(settings);
+	const rows = systemRowsOf(settings);
 	const config = {
 		app: {
 			name: native.name,
@@ -2155,12 +2995,12 @@ function nativeConfigOf(settings, where, target) {
 		},
 		web: {
 			cwd: where.cwd,
-			build: `${where.command} build`,
+			build: webBuildOf(where, debug),
 			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),
+		system: target === "android" ? [{ name: "shell" }, ...rows.filter((row) => row.name !== "shell")] : rows,
 		projectDir: path.join(where.cwd, ".moku/tauri"),
 		outDir: path.join(where.cwd, "dist-native")
 	};
@@ -2191,17 +3031,20 @@ function targetOf(known, verb, given) {
 * @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.
+* @param options - The simulator flag, and the debug profile of a debug app.
 * @returns The boolean of `doctor`, true for the other verbs once they finish.
 */
-async function runVerb(cli, verb, target, simulator) {
+async function runVerb(cli, verb, target, options) {
 	switch (verb) {
-		case "build":
-			await cli.build({
+		case "build": {
+			const build = {
 				target,
-				simulator
-			});
+				simulator: options.simulator,
+				...options.debug === void 0 ? {} : { debug: true }
+			};
+			await cli.build(build);
 			return true;
+		}
 		case "dev":
 			await cli.dev({ target });
 			return true;
@@ -2218,7 +3061,7 @@ async function runVerb(cli, verb, target, simulator) {
 * @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.
+* @param options - The target, the simulator flag, and the debug profile of a debug app.
 * @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.
@@ -2226,13 +3069,17 @@ async function runVerb(cli, verb, target, simulator) {
 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 });
+		throw new Error("[game] moku-game native needs @moku-labs/native.\n  Install it: bun add -d @moku-labs/native@^0.3.9.", { cause: error });
 	});
 	const target = targetOf(native.TARGETS, verb, options.target);
-	const app = native.createApp({ config: nativeConfigOf(settings, where, target) });
+	const debug = options.debug === void 0 ? void 0 : {
+		level: options.debug,
+		editor: options.editor
+	};
+	const app = native.createApp({ config: nativeConfigOf(settings, where, target, debug) });
 	await app.start();
 	try {
-		return await runVerb(app.cli, verb, target, options.simulator);
+		return await runVerb(app.cli, verb, target, options);
 	} catch {
 		return false;
 	} finally {
@@ -2245,11 +3092,35 @@ async function runNative(verb, settings, where, options) {
 * @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, visual,
 * 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, and `watchKeys` keeps the game's `generated/` fresh
-* while that page is open. It imports no Pixi, and the root entry never imports it. The code
+* caller starts itself, as the editor does, `watchKeys` keeps the game's `generated/` fresh
+* while that page is open, and `watchEngine` tells when the installed engine changed under it. It imports no Pixi, and the root entry never imports it. The code
 * lives in `app/`; this file wires the real process into it.
 */
 /**
+* Watches a folder with `fs.watch`: a watched folder that disappears ends that watch, and the
+* process runs on.
+*
+* @param folder - The folder or file.
+* @param listener - Gets the event name.
+* @returns The watcher.
+*/
+function watchFolder(folder, listener) {
+	const watcher = watch(folder, (event) => listener(event));
+	watcher.on("error", () => watcher.close());
+	return watcher;
+}
+/**
+* Bun's resolver: the file a specifier gives from a folder.
+*
+* @param specifier - The specifier.
+* @param from - The folder.
+* @returns The absolute path.
+* @throws {Error} When it does not resolve.
+*/
+function bunResolve(specifier, from) {
+	return Bun.resolveSync(specifier, from);
+}
+/**
 * Runs the asset scanner's command line with the string tools of i18n: the scan behind
 * `moku-game keys`, `pack`, and the keys watch.
 *
@@ -2303,17 +3174,14 @@ function processDeps() {
 				process.off(signal, handler);
 			};
 		},
-		watch: (folder, listener) => {
-			const watcher = watch(folder, (event) => listener(event));
-			watcher.on("error", () => watcher.close());
-			return watcher;
-		},
+		watch: watchFolder,
 		watchKeys: (root, settings) => watchKeysAt(root, settings, keysSeams(ui)),
 		assets: (argv) => runScanner(argv, ui),
 		native: runNative,
-		resolve: (specifier, from) => Bun.resolveSync(specifier, from),
+		resolve: bunResolve,
 		loadPage: (file) => import(file),
-		visual: () => import("./visual.mjs")
+		visual: () => import("./visual.mjs"),
+		now: () => Date.now()
 	};
 }
 /**
@@ -2328,6 +3196,7 @@ function processDeps() {
 * // bin/moku-game.mjs in a game folder:
 * await runCli(["dev", "--port", "0"]); // 0 after Ctrl+C; stdout had "http://localhost:<port>/"
 * await runCli(["visual", "--no-pixels"]); // 0 when every checkpoint of tests/visual/index.ts is the same
+* await runCli(["build", "--debug"]); // 0: dist/web carries the editor agent; one warning names build debug-20261014T153012Z
 * await runCli(["help"]); // 0
 * ```
 */
@@ -2336,8 +3205,9 @@ async function runCli(argv) {
 }
 /**
 * 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 also writes the
+* `script.ts`, `dev.ts` with the flags and the engine id, `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 also writes the
 * first `assets-stamp.ts`, the empty one, when the game has none: `main.ts` imports it, and
 * `watchKeys` rewrites it when an asset file changes. The page accepts the new stamp: new bytes
 * of a file swap in place, a new or removed file reloads the page. It starts no server and no
@@ -2345,15 +3215,16 @@ async function runCli(argv) {
 *
 * @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.
+* @returns The absolute paths of the HTML and the bunfig, and the engine the page was written for.
 * @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" }
+* const page = await preparePage("games/timber", { agents: ["@moku-labs/editor/agent/page"] });
+* // { html: "<cwd>/games/timber/.moku/index.html", bunfig: "<cwd>/games/timber/.moku/bunfig.toml", engine: { … } }
+* // page.engine.id: "0.14.12+9c41e0"
 * ```
 */
 async function preparePage(root, options = {}) {
@@ -2362,7 +3233,7 @@ async function preparePage(root, options = {}) {
 		...options.agents === void 0 ? {} : { agents: options.agents },
 		preload: absolute(options.preload),
 		servePlugins: absolute(options.servePlugins)
-	}, (specifier, from) => Bun.resolveSync(specifier, from));
+	}, bunResolve);
 }
 /**
 * Keeps `generated/` of a game fresh while its dev page is open, for a server the caller runs:
@@ -2395,5 +3266,42 @@ async function watchKeys(root, options = {}) {
 	const game = path.resolve(root);
 	return watchKeysAt(game, await loadGame(game), keysSeams(createBrandConsole()), options);
 }
+/**
+* Watches the engine a game resolves, for a page server the caller runs: the editor calls it next
+* to `preparePage`, and raw `moku-game dev` runs the same watch itself. It takes the fingerprint
+* of the installed engine now (the id `preparePage(...).engine` has), watches the engine's
+* folders, its patch and the install root's `package.json` and lock, and after 300 ms of quiet
+* fingerprints again: a new version or dist calls `onChange` with `restart: true` (the page server
+* must restart, Bun caches nothing across a restart), a changed patch alone with `restart: false`
+* (the install did not happen yet). An engine run from its sources is not watched. Sync: it
+* scans nothing.
+*
+* @param root - The game folder, relative to the cwd or absolute.
+* @param options - Where the changes and the errors go.
+* @returns The running watch; `close()` stops it.
+* @throws {Error} When the game does not resolve `@moku-labs/game/hot`.
+* @example
+* ```ts
+* // The editor bin, next to preparePage, started with --root games/timber:
+* const { preparePage, watchEngine } = await import(Bun.resolveSync("@moku-labs/game/cli", root));
+* const page = await preparePage("games/timber", { agents: ["@moku-labs/editor/agent/page"] });
+* page.engine.id; // "0.14.12+9c41e0"
+* const engine = watchEngine("games/timber", { onChange: change => change.restart && restartPageServer() });
+* // after `bun patch --commit` in the game: onChange({ before: { id: "0.14.12+9c41e0", … }, after: { id: "0.14.12+1a2b3c.patch.3f2a7b", … }, restart: true })
+* engine.close(); // when the editor closes the game
+* ```
+*/
+function watchEngine(root, options = {}) {
+	const game = path.resolve(root);
+	const start = engineFingerprint(game, hotPluginOf(game, bunResolve));
+	const ui = createBrandConsole();
+	const warn = (change) => {
+		for (const line of engineChangeLines(change)) ui.warn(line);
+	};
+	return watchEngineAt(game, start, {
+		watch: watchFolder,
+		resolve: bunResolve
+	}, options.onChange ?? warn, options.onError ?? ((message) => ui.warn(message)));
+}
 //#endregion
-export { preparePage, runCli, watchKeys };
+export { preparePage, runCli, watchEngine, watchKeys };