@khorsheed/dsh-game 0.0.0-stage → 0.1.0

package/lib/index.js

@@ -0,0 +1,4154 @@
+import { createRequire } from "node:module";
+import { createUserMessage } from "@deepseek-ai/dsh-llm";
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { createHash, randomBytes } from "node:crypto";
+import { appendFile, mkdir, mkdtemp, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+//#region lib/types/types.js
+/**
+* Wire and storage shapes shared by the host half, the Remote face and the
+* browser half. Pure types and constants — no node imports, so the client
+* type program includes this file as-is.
+* @module @khorsheed/dsh-game/types
+*/
+const MANIFEST_FILE = "game.json";
+/** The plugin's own directory inside a project (snapshots, check results, logs). */
+const STATE_DIR = ".game";
+/**
+* The example styles the user picks from (decision D10). Without image
+* generation the game draws everything in code, so each style is one a
+* canvas/HTML game can render faithfully; `custom:<text>` covers the rest.
+*/
+const ART_STYLES = [
+	{
+		id: "pixel",
+		label: "像素",
+		look: "16×16 / 32×32 像素块，有限调色板，整数倍放大不糊",
+		palette: [
+			"#1a1c2c",
+			"#5d275d",
+			"#b13e53",
+			"#ef7d57",
+			"#ffcd75",
+			"#a7f070",
+			"#38b764",
+			"#257179",
+			"#29366f",
+			"#3b5dc9",
+			"#41a6f6",
+			"#73eff7",
+			"#f4f4f4",
+			"#94b0c2",
+			"#566c86",
+			"#333c57"
+		]
+	},
+	{
+		id: "flat",
+		label: "扁平矢量",
+		look: "纯色几何形，圆角，少量阴影，配色明快",
+		palette: [
+			"#264653",
+			"#2a9d8f",
+			"#8ab17d",
+			"#e9c46a",
+			"#f4a261",
+			"#e76f51",
+			"#fefae0",
+			"#3d405b"
+		]
+	},
+	{
+		id: "line",
+		label: "手绘线稿",
+		look: "黑色描线 + 淡彩填充，线条略抖",
+		palette: [
+			"#222222",
+			"#f7f3e8",
+			"#f2c6c2",
+			"#c9e4de",
+			"#c6def1",
+			"#faedcb",
+			"#dbcdf0",
+			"#8a8a8a"
+		]
+	},
+	{
+		id: "neon",
+		label: "霓虹几何",
+		look: "深色底，发光的线框与粒子",
+		palette: [
+			"#0d0221",
+			"#261447",
+			"#ff3864",
+			"#2de2e6",
+			"#f6019d",
+			"#fdf500",
+			"#7b2cbf",
+			"#ffffff"
+		]
+	},
+	{
+		id: "paper",
+		label: "剪纸拼贴",
+		look: "纸张纹理色块，轻微投影，层叠感",
+		palette: [
+			"#f2e8cf",
+			"#e0c9a6",
+			"#bc4749",
+			"#6a994e",
+			"#386641",
+			"#a7c957",
+			"#3d348b",
+			"#5c4033"
+		]
+	},
+	{
+		id: "mono",
+		label: "极简单色",
+		look: "一种主色加黑白，靠形状和留白区分",
+		palette: [
+			"#111111",
+			"#f5f5f5",
+			"#e63946",
+			"#9a9a9a",
+			"#5a5a5a",
+			"#d0d0d0"
+		]
+	}
+];
+/**
+* The 3D example styles (the 3d-three kit, proposal 2026-10-21-game-3d G8):
+* toon shading with an ink outline over a paper ground. The ids are what
+* `dsh3d.createWorld({ style })` takes.
+*/
+const ART_STYLES_3D = [{
+	id: "ink",
+	label: "水墨",
+	look: "低多边形 + 墨线描边 + 宣纸底与远雾，留白多",
+	palette: [
+		"#2a2622",
+		"#efe7d6",
+		"#e9dfcc",
+		"#b8442f",
+		"#8f897b",
+		"#4c5747",
+		"#a7bab4",
+		"#46698a"
+	]
+}, {
+	id: "qinglv",
+	label: "青绿山水",
+	look: "石青石绿的山、赭色描边、暖纸底，色块鲜明",
+	palette: [
+		"#4f3b28",
+		"#f1e8cf",
+		"#3c8a78",
+		"#3a6f93",
+		"#d9d9b0",
+		"#2c6a57",
+		"#77a9bb",
+		"#b8442f"
+	]
+}];
+/** Body archetypes a `parts3d` look builds on. */
+const BODY_BASES = [
+	"quadruped",
+	"bird",
+	"fish",
+	"serpent",
+	"humanoid"
+];
+/** Built-in parts a `parts3d` look can attach; a project can register more with `dsh3d.definePart`. */
+const PART_TYPES = [
+	"ear",
+	"horn",
+	"tail",
+	"wing",
+	"fin",
+	"eye",
+	"face"
+];
+/** Whether a look is the 2D pixel-row kind. */
+function isPixelLook(look) {
+	return !("kind" in look);
+}
+/** The characters a look row may use, in palette-index order. */
+const LOOK_CHARS = "0123456789abcdefghijklmnopqrstuvwxyz";
+/** The chaptered design doc (decision D12): fixed chapters, pillars pinned first. */
+const CHAPTERS = [
+	{
+		id: "pillars",
+		title: "支柱说明",
+		file: "design/pillars.md"
+	},
+	{
+		id: "core-loop",
+		title: "核心循环",
+		file: "design/core-loop.md"
+	},
+	{
+		id: "mechanics",
+		title: "机制与规则",
+		file: "design/mechanics.md"
+	},
+	{
+		id: "lore",
+		title: "元素设定",
+		file: "design/lore.md",
+		generated: true
+	},
+	{
+		id: "elements",
+		title: "元素与数值",
+		file: "design/elements.md",
+		generated: true
+	},
+	{
+		id: "levels",
+		title: "关卡与节奏",
+		file: "design/levels.md"
+	},
+	{
+		id: "art-audio",
+		title: "美术与音效",
+		file: "design/art-audio.md"
+	},
+	{
+		id: "playtest",
+		title: "试玩记录",
+		file: "design/playtest.md",
+		generated: true
+	}
+];
+/** Longest 设定 the panel saves. */
+const LORE_MAX = 2e3;
+/**
+* The opening of the message the panel writes into the composer for its
+* changes (「写进对话」). The pre-step hook recognizes a sent message by it and
+* clears exactly the changes the message lists.
+*/
+const PANEL_CHANGES_MARK = "【面板改动】";
+//#endregion
+//#region lib/types/hooks.js
+/** Build a dsh-game user message. */
+function gameMessage(text, section, op) {
+	return createUserMessage({
+		content: [{
+			type: "text",
+			text
+		}],
+		source: {
+			kind: "dsh-game",
+			plugin: "@khorsheed/dsh-game",
+			form: "snapshot",
+			sections: [{
+				name: section,
+				text
+			}],
+			...op
+		}
+	});
+}
+/** The steer text for one failed check (model-facing). */
+function failureText(record, attempt) {
+	const lines = [`[游戏检查未通过 ${attempt}/2] 这一轮改完的版本没过检查，试玩区还停在上一个版本。`, ...record.failures.slice(0, 8).map((f) => `- ${f.where}：${f.message}`)];
+	if (record.failures.length > 8) lines.push(`- ……另有 ${record.failures.length - 8} 项`);
+	if (record.skipped !== void 0) lines.push(`（${record.skipped}）`);
+	lines.push(attempt < 2 ? "请修好再结束这一轮：先读报错对应的代码，改完不用告诉我，结束时会自动重新检查。若是测试本身写错了，改测试并说明理由。" : "这是最后一次自动修复机会；修不好就如实告诉用户卡在哪里。");
+	return lines.join("\n");
+}
+/**
+* Register the hooks on the plugin's scope.
+* @param ctx - the core plugin's context.
+* @param store - the service core.
+*/
+function registerTurnHooks(ctx, store) {
+	/** Steers already sent, per `<session>:<turn>`. */
+	const steered = /* @__PURE__ */ new Map();
+	ctx.on("agent/turn-stopping", async ({ agent, turn, signal }) => {
+		if (signal.aborted) return;
+		const key = `${agent.session.id}:${turn}`;
+		const attempt = steered.get(key) ?? 0;
+		let outcome;
+		try {
+			outcome = await store.checkTurn(agent.session, attempt, 2);
+		} catch (error) {
+			ctx.logger.warn("game: end-of-turn check failed to run", error);
+			return;
+		}
+		if (outcome.kind !== "fail" || signal.aborted) return;
+		if (attempt >= 2) return;
+		steered.set(key, attempt + 1);
+		const text = failureText(outcome.record, attempt + 1);
+		agent.steer(gameMessage(text, "checks", {
+			op: "check-failed",
+			attempt: attempt + 1,
+			cap: 2,
+			failures: outcome.record.failures.slice(0, 8).map((f) => ({
+				where: f.where,
+				message: f.message.slice(0, 300)
+			}))
+		}));
+	});
+	ctx.on("agent/pre-step", async ({ agent, signal }, next) => {
+		const decision = await next();
+		if (decision.kind === "reject" || signal.aborted || decision.messages.length === 0) return decision;
+		const text = decision.messages.map((m) => m.content.map((block) => block.type === "text" ? block.text : "").join("\n")).join("\n");
+		if (text.includes("【面板改动】")) await store.clearSent(agent.session.id, text).catch((error) => {
+			ctx.logger.warn("game: could not clear sent panel changes", error);
+		});
+		return decision;
+	}, { prepend: true });
+	const baselines = /* @__PURE__ */ new Map();
+	ctx.on("session/event", (session, raw) => {
+		const event = raw;
+		const turn = event?.data?.turn ?? event?.turn;
+		if (event?.type === "turn/start") store.setTurnActive(session.id, true);
+		if (event?.type === "turn/end") store.setTurnActive(session.id, false);
+		if (event?.type === "turn/start" && turn !== void 0) {
+			baselines.set(`${session.id}:${turn}`, store.turnBaseline(session.id).catch(() => void 0));
+			return;
+		}
+		if (event?.type !== "turn/end") return;
+		if (turn !== void 0) {
+			steered.delete(`${session.id}:${turn}`);
+			const key = `${session.id}:${turn}`;
+			const base = baselines.get(key);
+			baselines.delete(key);
+			if (base !== void 0) base.then((b) => b === void 0 ? void 0 : store.recordTurn(session.id, turn, b)).catch((error) => {
+				ctx.logger.warn("game: could not record the turn report", error);
+			});
+		} else for (const key of steered.keys()) if (key.startsWith(`${session.id}:`)) steered.delete(key);
+	});
+}
+//#endregion
+//#region lib/types/panel-session.js
+/**
+* Resolve the session a panel call names.
+* @param ctx - host context carrying the session store and the typert lookups.
+* @param sessionId - the session the panel shows.
+* @returns the session.
+* @throws the host lookup's refusal, or when no session has that id.
+*/
+async function panelSession(ctx, sessionId) {
+	const attached = ctx.get("sessions")?.get(sessionId);
+	if (attached !== void 0) return attached;
+	const resolved = await ctx.get("typert")?.lookups.get("session")?.resolve(sessionId);
+	if (resolved === void 0) throw new Error(`session "${sessionId}" not found`);
+	return resolved;
+}
+//#endregion
+//#region lib/types/remote.js
+var __runInitializers = function(thisArg, initializers, value) {
+	var useValue = arguments.length > 2;
+	for (var i = 0; i < initializers.length; i++) value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+	return useValue ? value : void 0;
+};
+var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+	function accept(f) {
+		if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected");
+		return f;
+	}
+	var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+	var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+	var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+	var _, done = false;
+	for (var i = decorators.length - 1; i >= 0; i--) {
+		var context = {};
+		for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+		for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+		context.addInitializer = function(f) {
+			if (done) throw new TypeError("Cannot add initializers after decoration has completed");
+			extraInitializers.push(accept(f || null));
+		};
+		var result = (0, decorators[i])(kind === "accessor" ? {
+			get: descriptor.get,
+			set: descriptor.set
+		} : descriptor[key], context);
+		if (kind === "accessor") {
+			if (result === void 0) continue;
+			if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+			if (_ = accept(result.get)) descriptor.get = _;
+			if (_ = accept(result.set)) descriptor.set = _;
+			if (_ = accept(result.init)) initializers.unshift(_);
+		} else if (_ = accept(result)) {
+			if (kind === "field") initializers.unshift(_);
+			else descriptor[key] = _;
+		}
+	}
+	if (target) Object.defineProperty(target, contextIn.name, descriptor);
+	done = true;
+};
+/** The `game` wire namespace. */
+let GameRemoteService = (() => {
+	let _classSuper = TypertRemoteService;
+	let _instanceExtraInitializers = [];
+	let _state_decorators;
+	let _turnReport_decorators;
+	let _projectCards_decorators;
+	let _deleteProject_decorators;
+	let _bind_decorators;
+	let _workingFile_decorators;
+	let _bundle_decorators;
+	let _confirm_decorators;
+	let _changes_decorators;
+	let _commit_decorators;
+	let _setAutoConfirm_decorators;
+	let _logPlay_decorators;
+	let _dropPending_decorators;
+	let _setParam_decorators;
+	let _finalizeParams_decorators;
+	let _resetParams_decorators;
+	let _editElement_decorators;
+	let _pickProposal_decorators;
+	let _writeChapter_decorators;
+	let _setOnePager_decorators;
+	let _requestRestyle_decorators;
+	let _reject_decorators;
+	let _rollback_decorators;
+	let _diff_decorators;
+	let _checkShot_decorators;
+	let _versionBundle_decorators;
+	return class GameRemoteService extends _classSuper {
+		static {
+			const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+			_state_decorators = [Remote("state")];
+			_turnReport_decorators = [Remote("turnReport")];
+			_projectCards_decorators = [Remote("projectCards")];
+			_deleteProject_decorators = [Remote("deleteProject")];
+			_bind_decorators = [Remote("bind")];
+			_workingFile_decorators = [Remote("workingFile")];
+			_bundle_decorators = [Remote("bundle")];
+			_confirm_decorators = [Remote("confirm")];
+			_changes_decorators = [Remote("changes")];
+			_commit_decorators = [Remote("commit")];
+			_setAutoConfirm_decorators = [Remote("setAutoConfirm")];
+			_logPlay_decorators = [Remote("logPlay")];
+			_dropPending_decorators = [Remote("dropPending")];
+			_setParam_decorators = [Remote("setParam")];
+			_finalizeParams_decorators = [Remote("finalizeParams")];
+			_resetParams_decorators = [Remote("resetParams")];
+			_editElement_decorators = [Remote("editElement")];
+			_pickProposal_decorators = [Remote("pickProposal")];
+			_writeChapter_decorators = [Remote("writeChapter")];
+			_setOnePager_decorators = [Remote("setOnePager")];
+			_requestRestyle_decorators = [Remote("requestRestyle")];
+			_reject_decorators = [Remote("reject")];
+			_rollback_decorators = [Remote("rollback")];
+			_diff_decorators = [Remote("diff")];
+			_checkShot_decorators = [Remote("checkShot")];
+			_versionBundle_decorators = [Remote("versionBundle")];
+			__esDecorate(this, null, _state_decorators, {
+				kind: "method",
+				name: "state",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "state" in obj,
+					get: (obj) => obj.state
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _turnReport_decorators, {
+				kind: "method",
+				name: "turnReport",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "turnReport" in obj,
+					get: (obj) => obj.turnReport
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _projectCards_decorators, {
+				kind: "method",
+				name: "projectCards",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "projectCards" in obj,
+					get: (obj) => obj.projectCards
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _deleteProject_decorators, {
+				kind: "method",
+				name: "deleteProject",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "deleteProject" in obj,
+					get: (obj) => obj.deleteProject
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _bind_decorators, {
+				kind: "method",
+				name: "bind",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "bind" in obj,
+					get: (obj) => obj.bind
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _workingFile_decorators, {
+				kind: "method",
+				name: "workingFile",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "workingFile" in obj,
+					get: (obj) => obj.workingFile
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _bundle_decorators, {
+				kind: "method",
+				name: "bundle",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "bundle" in obj,
+					get: (obj) => obj.bundle
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _confirm_decorators, {
+				kind: "method",
+				name: "confirm",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "confirm" in obj,
+					get: (obj) => obj.confirm
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _changes_decorators, {
+				kind: "method",
+				name: "changes",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "changes" in obj,
+					get: (obj) => obj.changes
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _commit_decorators, {
+				kind: "method",
+				name: "commit",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "commit" in obj,
+					get: (obj) => obj.commit
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setAutoConfirm_decorators, {
+				kind: "method",
+				name: "setAutoConfirm",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setAutoConfirm" in obj,
+					get: (obj) => obj.setAutoConfirm
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _logPlay_decorators, {
+				kind: "method",
+				name: "logPlay",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "logPlay" in obj,
+					get: (obj) => obj.logPlay
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _dropPending_decorators, {
+				kind: "method",
+				name: "dropPending",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "dropPending" in obj,
+					get: (obj) => obj.dropPending
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setParam_decorators, {
+				kind: "method",
+				name: "setParam",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setParam" in obj,
+					get: (obj) => obj.setParam
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _finalizeParams_decorators, {
+				kind: "method",
+				name: "finalizeParams",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "finalizeParams" in obj,
+					get: (obj) => obj.finalizeParams
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _resetParams_decorators, {
+				kind: "method",
+				name: "resetParams",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "resetParams" in obj,
+					get: (obj) => obj.resetParams
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _editElement_decorators, {
+				kind: "method",
+				name: "editElement",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "editElement" in obj,
+					get: (obj) => obj.editElement
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _pickProposal_decorators, {
+				kind: "method",
+				name: "pickProposal",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "pickProposal" in obj,
+					get: (obj) => obj.pickProposal
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _writeChapter_decorators, {
+				kind: "method",
+				name: "writeChapter",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "writeChapter" in obj,
+					get: (obj) => obj.writeChapter
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _setOnePager_decorators, {
+				kind: "method",
+				name: "setOnePager",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "setOnePager" in obj,
+					get: (obj) => obj.setOnePager
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _requestRestyle_decorators, {
+				kind: "method",
+				name: "requestRestyle",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "requestRestyle" in obj,
+					get: (obj) => obj.requestRestyle
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _reject_decorators, {
+				kind: "method",
+				name: "reject",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "reject" in obj,
+					get: (obj) => obj.reject
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _rollback_decorators, {
+				kind: "method",
+				name: "rollback",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "rollback" in obj,
+					get: (obj) => obj.rollback
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _diff_decorators, {
+				kind: "method",
+				name: "diff",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "diff" in obj,
+					get: (obj) => obj.diff
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _checkShot_decorators, {
+				kind: "method",
+				name: "checkShot",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "checkShot" in obj,
+					get: (obj) => obj.checkShot
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			__esDecorate(this, null, _versionBundle_decorators, {
+				kind: "method",
+				name: "versionBundle",
+				static: false,
+				private: false,
+				access: {
+					has: (obj) => "versionBundle" in obj,
+					get: (obj) => obj.versionBundle
+				},
+				metadata: _metadata
+			}, null, _instanceExtraInitializers);
+			if (_metadata) Object.defineProperty(this, Symbol.metadata, {
+				enumerable: true,
+				configurable: true,
+				writable: true,
+				value: _metadata
+			});
+		}
+		static inject = ["gameStore"];
+		/**
+		* @param ctx - host context carrying the service core.
+		* @param _config - reserved.
+		*/
+		constructor(ctx, _config = {}) {
+			super(ctx, "gameRemote", { namespace: "game" });
+			__runInitializers(this, _instanceExtraInitializers);
+		}
+		get store() {
+			return this.ctx.gameStore;
+		}
+		/** The session's bound project (full view) and the project list. */
+		state(sessionId) {
+			return this.store.sessionState(sessionId);
+		}
+		/** What one of the session's turns changed (null when nothing, or not recorded). */
+		turnReport(sessionId, request) {
+			return this.store.turnReport(sessionId, request.turn);
+		}
+		/** Every project as a switcher card. */
+		projectCards() {
+			return this.store.projectCards();
+		}
+		/** Delete a project: `trash` moves its folder to the system trash, `forget` only removes it from the plugin. */
+		async deleteProject(sessionId, request) {
+			return this.store.deleteProject(request.projectId, request.mode === "forget" ? "forget" : "trash", await panelSession(this.ctx, sessionId));
+		}
+		/** Bind the session to a project, or unbind with `projectId: null`. */
+		bind(sessionId, request) {
+			return this.store.bind(sessionId, request.projectId);
+		}
+		/** One working build file, for a panel preview ahead of any version. */
+		workingFile(request) {
+			return this.store.workingFile(request.projectId, request.path);
+		}
+		/** A version's files for the play area. */
+		bundle(request) {
+			return this.store.bundle(request.projectId, request.which ?? "current");
+		}
+		/** Promote the candidate into the play area. */
+		async confirm(sessionId, request) {
+			return this.store.confirm(request.projectId, await panelSession(this.ctx, sessionId));
+		}
+		/** What the working files hold that the play area does not (the commit bar polls it). */
+		changes(request) {
+			return this.store.changes(request.projectId);
+		}
+		/** 检查并发版: check the working files and cut a version (by the user) carrying every change. */
+		async commit(sessionId, request) {
+			return this.store.commit(request.projectId, await panelSession(this.ctx, sessionId));
+		}
+		/** Switch the project's auto-confirm. */
+		async setAutoConfirm(sessionId, request) {
+			return this.store.setAutoConfirm(request.projectId, request.on, await panelSession(this.ctx, sessionId));
+		}
+		/** Record one play session into the playtest log. */
+		async logPlay(sessionId, request) {
+			return this.store.logPlay(request.projectId, request, await panelSession(this.ctx, sessionId));
+		}
+		/** Drop one pending change (the dock's ×). */
+		async dropPending(sessionId, request) {
+			return this.store.dropPending(request.projectId, request.key, await panelSession(this.ctx, sessionId));
+		}
+		/** Set one slider value (user layer). */
+		async setParam(sessionId, request) {
+			return this.store.setParam(request.projectId, request.key, request.value, await panelSession(this.ctx, sessionId));
+		}
+		/** 定稿: write slider values into game.json. */
+		async finalizeParams(sessionId, request) {
+			return this.store.finalizeParams(request.projectId, await panelSession(this.ctx, sessionId));
+		}
+		/** 还原: drop the slider overrides. */
+		async resetParams(sessionId, request) {
+			return this.store.resetParams(request.projectId, await panelSession(this.ctx, sessionId));
+		}
+		/** Edit one element's look (JSON text) and/or scalar fields (JSON text of an object). */
+		async editElement(sessionId, request) {
+			let look;
+			let fields;
+			try {
+				if (request.look !== void 0) look = JSON.parse(request.look);
+				if (request.fields !== void 0) fields = JSON.parse(request.fields);
+			} catch {
+				return {
+					ok: false,
+					error: "invalid"
+				};
+			}
+			const result = await this.store.editElement(request.projectId, request.elementId, {
+				...look === void 0 ? {} : { look },
+				...fields === void 0 ? {} : { fields }
+			}, await panelSession(this.ctx, sessionId));
+			return result.ok ? {
+				ok: true,
+				elementJson: JSON.stringify(result.element)
+			} : result;
+		}
+		/** Pick one appearance variant. */
+		async pickProposal(sessionId, request) {
+			return this.store.pickProposal(request.projectId, request.elementId, request.at, request.index, await panelSession(this.ctx, sessionId));
+		}
+		/** Write a design chapter. */
+		async writeChapter(sessionId, request) {
+			return this.store.writeChapter(request.projectId, request.chapterId, request.text, await panelSession(this.ctx, sessionId));
+		}
+		/** Edit the one-pager (game.json pitch / element types / pillars). */
+		async setOnePager(sessionId, request) {
+			return this.store.setOnePager(request.projectId, request, await panelSession(this.ctx, sessionId));
+		}
+		/** Mark a pending restyle (the next passing version becomes a candidate). */
+		async requestRestyle(sessionId, request) {
+			return this.store.requestRestyle(request.projectId, request.styleId, await panelSession(this.ctx, sessionId));
+		}
+		/** Throw the candidate away. */
+		async reject(sessionId, request) {
+			return this.store.reject(request.projectId, request.reason, await panelSession(this.ctx, sessionId));
+		}
+		/** Put an older version into the play area. */
+		async rollback(sessionId, request) {
+			return this.store.rollback(request.projectId, request.version, await panelSession(this.ctx, sessionId));
+		}
+		/** Files that differ between two versions. */
+		diff(request) {
+			return this.store.diff(request.projectId, request.from, request.to);
+		}
+		/** The last check's screenshot. */
+		checkShot(request) {
+			return this.store.checkShot(request.projectId, request.version);
+		}
+		/** A specific version's files (rollback preview, export). */
+		versionBundle(request) {
+			return this.store.versionBundle(request.projectId, request.version);
+		}
+	};
+})();
+//#endregion
+//#region lib/types/vfs.js
+/**
+* The in-sandbox loader (probe P0-1, proposal §5): a tiny HTML shell that
+* receives a project's files, mints blob URLs inside its OWN opaque origin,
+* rewrites relative module specifiers and CSS `url()`, shims `fetch` and
+* element `src`, then writes the project's `index.html` over itself.
+*
+* Shared by both halves: the panel puts the shell in a
+* `sandbox="allow-scripts"` iframe and posts the files in; the host's checks
+* load the same shell in headless Chrome with the files pre-set on
+* `window.__VFS_FILES__`. Everything that runs in the frame is kept as
+* STRINGS here — never `fn.toString()` — so a bundler's renaming can never
+* break it.
+*
+* The bridge script is installed twice, in the shell and again in the written
+* document, because `document.open()` drops every window listener. It reports
+* errors to the parent, and stands in for `localStorage` (an opaque origin
+* has none): saves start from what the parent sends with the files and each
+* write is posted back for the parent to keep.
+* @module @khorsheed/dsh-game/vfs
+*/
+/** The frame's CSP: nothing leaves the frame; scripts and assets come from blobs only. */
+const SANDBOX_CSP = "default-src 'none'; script-src 'unsafe-inline' blob:; style-src 'unsafe-inline' blob:; img-src blob: data:; media-src blob: data:; font-src blob: data:; connect-src blob: data:";
+/** The bridge (runs in the frame). */
+const BRIDGE = `(function(){
+  var errors = window.__gamedevErrors || (window.__gamedevErrors = []);
+  function post(m){ try { if (parent !== window) parent.postMessage(m, '*') } catch (e) {} }
+  function report(kind, msg){ var t = String(msg); if (errors.length < 50) errors.push({ kind: kind, msg: t }); post({ gamedev: 'error', kind: kind, msg: t }) }
+  addEventListener('error', function(e){
+    if (e.target && e.target !== window && e.target.tagName) { report('resource', (e.target.tagName || '') + ' ' + (e.target.src || e.target.href || '').slice(0, 60)); return }
+    report('error', (e.message || '') + (e.lineno ? ' (line ' + e.lineno + ')' : ''))
+  }, true);
+  addEventListener('unhandledrejection', function(e){ report('rejection', e.reason && e.reason.message || e.reason) });
+  if (!console.__gd) { var ce = console.error; console.error = function(){ report('console', [].join.call(arguments, ' ')); return ce.apply(console, arguments) }; console.__gd = 1 }
+  var saves = window.__gdSaves || (window.__gdSaves = {});
+  var nativeOk = false;
+  try { nativeOk = !!window.localStorage && (window.localStorage.getItem('__gd'), true) } catch (e) {}
+  if (!nativeOk) {
+    var store = {
+      getItem: function(k){ k = String(k); return Object.prototype.hasOwnProperty.call(saves, k) ? saves[k] : null },
+      setItem: function(k, v){ saves[String(k)] = String(v); post({ gamedev: 'save', saves: saves }) },
+      removeItem: function(k){ delete saves[String(k)]; post({ gamedev: 'save', saves: saves }) },
+      clear: function(){ for (var k in saves) delete saves[k]; post({ gamedev: 'save', saves: saves }) },
+      key: function(i){ return Object.keys(saves)[i] || null },
+      get length(){ return Object.keys(saves).length }
+    };
+    try { Object.defineProperty(window, 'localStorage', { configurable: true, get: function(){ return store } }) } catch (e) {}
+  }
+  window.dshParams = window.dshParams || {};
+  window.dshElements = window.dshElements || {};
+  addEventListener('message', function(e){
+    var d = e.data || {}, g = window.dshGame;
+    if (d.gamedev === 'inspect') post({ gamedev: 'inspect', ready: !!(g && g.ready), state: g && g.state ? g.state() : null, errors: errors });
+    if (d.gamedev === 'params' && d.values) {
+      for (var k in d.values) window.dshParams[k] = Number(d.values[k]);
+      dispatchEvent(new CustomEvent('dshparams', { detail: window.dshParams }));
+    }
+    if (d.gamedev === 'element' && d.element && d.element.id) {
+      window.dshElements[d.element.id] = d.element;
+      dispatchEvent(new CustomEvent('dshelements', { detail: d.element }));
+    }
+    if (d.gamedev === 'pick') {
+      var cv = document.querySelector('canvas'), id = null, ref = null, cx = 0, cy = 0;
+      if (cv) {
+        var rect = cv.getBoundingClientRect(), px = d.x * innerWidth, py = d.y * innerHeight;
+        cx = (px - rect.left) * cv.width / rect.width; cy = (py - rect.top) * cv.height / rect.height;
+        if (g && typeof g.pick === 'function' && cx >= 0 && cy >= 0 && cx <= cv.width && cy <= cv.height) {
+          try { var got = g.pick(cx, cy); if (got && typeof got === 'object') { ref = got; id = got.id || null } else id = got || null } catch (err) { report('error', 'pick: ' + err.message) }
+        }
+      }
+      // A string id (2D games) or a structured reference (dsh3d: id, inst, name, state, point, region).
+      post({ gamedev: 'picked', id: id, ref: ref, hover: !!d.hover, supported: !!(g && typeof g.pick === 'function'), x: d.x, y: d.y });
+    }
+    // The panel's pick mode freezes the game; a candidate's changes get ringed. Both optional on the game side.
+    // The panel sends them as soon as the files are posted, often before the game's modules ran: the latest
+    // of each is kept and applied once window.dshGame appears (polled briefly; installs share one record).
+    if (d.gamedev === 'pause' || d.gamedev === 'highlight') {
+      var pend = window.__gdPend || (window.__gdPend = {});
+      pend[d.gamedev] = d;
+      var apply = function () {
+        var game = window.dshGame;
+        if (!game) return false;
+        var p = window.__gdPend || {};
+        if (p.pause && typeof game.pause === 'function') { try { game.pause(!!p.pause.on) } catch (err) { report('error', 'pause: ' + err.message) } }
+        if (p.highlight && typeof game.highlight === 'function') { try { game.highlight(Array.isArray(p.highlight.list) ? p.highlight.list : []) } catch (err) { report('error', 'highlight: ' + err.message) } }
+        window.__gdPend = {};
+        return true;
+      };
+      if (!apply() && !window.__gdPendTimer) {
+        var tries = 0;
+        window.__gdPendTimer = setInterval(function () { if (apply() || ++tries > 150) { clearInterval(window.__gdPendTimer); window.__gdPendTimer = 0 } }, 100);
+      }
+    }
+  });
+})();`;
+/** The loader (runs in the frame): defines `window.__boot(files)`. */
+const LOADER = `window.__boot = function (files) {
+  var urls = {};
+  function norm(base, rel) {
+    if (/^[a-z][a-z0-9+.-]*:/i.test(rel) || rel.indexOf('//') === 0) return null;
+    var clean = rel.split(/[?#]/)[0], out = [];
+    var parts = ((clean.charAt(0) === '/' ? '' : base) + clean).split('/');
+    for (var i = 0; i < parts.length; i++) { var s = parts[i]; if (!s || s === '.') continue; if (s === '..') out.pop(); else out.push(s) }
+    return out.join('/');
+  }
+  function dir(p) { return p.indexOf('/') >= 0 ? p.slice(0, p.lastIndexOf('/') + 1) : '' }
+  function bytes(p) {
+    var f = files[p];
+    if (f.text != null) return new TextEncoder().encode(f.text);
+    var bin = atob(f.b64), u = new Uint8Array(bin.length);
+    for (var i = 0; i < bin.length; i++) u[i] = bin.charCodeAt(i);
+    return u;
+  }
+  function text(p) { return files[p].text != null ? files[p].text : new TextDecoder().decode(bytes(p)) }
+  function mint(body, type) { return URL.createObjectURL(new Blob([body], { type: type })) }
+  function rewriteCss(css, base) {
+    return css.replace(/url\\(\\s*(['"]?)([^'")]+)\\1\\s*\\)/g, function (m, q, u) { var r = norm(base, u); return r && files[r] ? 'url("' + urlFor(r) + '")' : m });
+  }
+  var busy = {};
+  // An exact bare name, else the longest prefix key ending in '/' (import-map style).
+  function bareOf(spec) {
+    if (bare[spec]) return bare[spec];
+    var best = '';
+    for (var k in bare) if (k.charAt(k.length - 1) === '/' && spec.indexOf(k) === 0 && k.length > best.length) best = k;
+    return best ? bare[best] + spec.slice(best.length) : undefined;
+  }
+  function modUrl(p) {
+    if (urls[p]) return urls[p];
+    if (busy[p]) throw new Error('module cycle at ' + p);
+    busy[p] = 1;
+    var src = text(p).replace(/(\\bimport\\s*\\(\\s*|\\bfrom\\s*|\\bimport\\s+)(['"])([^'"]+)\\2/g, function (m, pre, q, spec) {
+      var r = /^\\.{0,2}\\//.test(spec) ? norm(dir(p), spec) : bareOf(spec);
+      return r && files[r] ? pre + q + modUrl(r) + q : m;
+    });
+    delete busy[p];
+    return (urls[p] = mint(src, 'text/javascript'));
+  }
+  function urlFor(p) {
+    if (urls[p]) return urls[p];
+    if (/\\.m?js$/.test(p)) return modUrl(p);
+    if (/\\.css$/.test(p)) return (urls[p] = mint(rewriteCss(text(p), dir(p)), 'text/css'));
+    return (urls[p] = mint(bytes(p), files[p].type));
+  }
+  function rel(v) { var r = typeof v === 'string' && norm('', v); return r && files[r] ? urlFor(r) : null }
+  // A project path's blob URL (null when the project has no such file): three's loading
+  // manager maps model and texture paths through it, since a relative Request has no usable base here.
+  window.__dshFileUrl = rel;
+  var nativeFetch = window.fetch.bind(window);
+  window.fetch = function (input, init) {
+    var u = typeof input === 'string' ? input : input && input.url;
+    var r = typeof u === 'string' && norm('', u);
+    if (r && files[r]) return Promise.resolve(new Response(bytes(r), { status: 200, headers: { 'content-type': files[r].type } }));
+    return nativeFetch(input, init);
+  };
+  [[HTMLImageElement.prototype, 'src'], [HTMLMediaElement.prototype, 'src'], [HTMLSourceElement.prototype, 'src']].forEach(function (pair) {
+    var d = Object.getOwnPropertyDescriptor(pair[0], pair[1]);
+    Object.defineProperty(pair[0], pair[1], { configurable: true, enumerable: d.enumerable, get: function () { return d.get.call(this) }, set: function (v) { d.set.call(this, rel(v) || v) } });
+  });
+  // The kit's bare module map (e.g. 'three' → '_dsh/three.module.js').
+  var bare = {};
+  try { if (files['_dsh/imports.json']) bare = JSON.parse(text('_dsh/imports.json')) || {} } catch (e) {}
+  if (!files['index.html']) { document.body.textContent = '这个版本没有 index.html'; return }
+  try {
+    var manifest = files['game.json'] ? JSON.parse(text('game.json')) : {};
+    window.dshManifest = manifest;
+    (manifest.params || []).forEach(function (p) { if (p && p.key && !(p.key in window.dshParams)) window.dshParams[p.key] = Number(p.value) });
+  } catch (e) {}
+  Object.keys(files).forEach(function (p) {
+    if (p.indexOf('elements/') !== 0 || !/\.json$/.test(p)) return;
+    try { var raw = JSON.parse(text(p)); (Array.isArray(raw) ? raw : [raw]).forEach(function (el) { if (el && el.id) window.dshElements[el.id] = el }) } catch (e) {}
+  });
+  var doc = new DOMParser().parseFromString(text('index.html'), 'text/html');
+  doc.querySelectorAll('[src]').forEach(function (el) { var u = rel(el.getAttribute('src')); if (u) el.setAttribute('src', u) });
+  doc.querySelectorAll('link[href]').forEach(function (el) { var u = rel(el.getAttribute('href')); if (u) el.setAttribute('href', u) });
+  doc.querySelectorAll('style').forEach(function (st) { st.textContent = rewriteCss(st.textContent, '') });
+  var meta = doc.createElement('meta'); meta.httpEquiv = 'Content-Security-Policy'; meta.content = window.__GD_CSP;
+  var bridge = doc.createElement('script'); bridge.textContent = window.__GD_BRIDGE;
+  doc.head.prepend(meta, bridge);
+  // The kit runtime runs right after the bridge, before any of the game's own scripts.
+  if (files['_dsh/runtime.js']) { var kit = doc.createElement('script'); kit.src = urlFor('_dsh/runtime.js'); bridge.after(kit) }
+  document.open(); document.write('<!doctype html>' + doc.documentElement.outerHTML); document.close();
+};`;
+/** Starts the boot: pre-set files (headless) or the first `files` message (panel). */
+const START = `if (window.__VFS_FILES__) window.__boot(window.__VFS_FILES__);
+else { var once = false; addEventListener('message', function (e) {
+  var d = e.data;
+  if (once || !d || d.gamedev !== 'files') return;
+  once = true;
+  if (d.saves && typeof d.saves === 'object') { var s = window.__gdSaves || (window.__gdSaves = {}); for (var k in d.saves) s[k] = String(d.saves[k]) }
+  if (d.params && typeof d.params === 'object') { window.dshParams = window.dshParams || {}; for (var pk in d.params) window.dshParams[pk] = Number(d.params[pk]) }
+  window.__boot(d.files);
+}); }`;
+/** Escape a string for embedding inside an inline `<script>` (a literal `<\/script>` would end it). */
+function scriptSafe(json) {
+	return json.replace(/</g, "\\u003c");
+}
+/**
+* The shell document. `extraHead` lets the headless runner add a marker;
+* the panel passes nothing.
+* @param extraHead - raw HTML placed before the bridge.
+* @returns the complete HTML string.
+*/
+function shellHtml(extraHead = "") {
+	const globals = `window.__GD_CSP=${scriptSafe(JSON.stringify(SANDBOX_CSP))};window.__GD_BRIDGE=${scriptSafe(JSON.stringify(BRIDGE))};`;
+	return `<!doctype html><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${SANDBOX_CSP}"><style>html,body{margin:0;height:100%;background:#111;color:#ccc;font:13px system-ui}</style>${extraHead}<script>${BRIDGE}<\/script><script>${globals}${LOADER}<\/script><script>${START}<\/script>`;
+}
+//#endregion
+//#region lib/types/checks.js
+/**
+* The end-of-turn checks (proposal §6): data validation in plain node, then
+* a smoke run and the project's own test scripts in headless Chrome, all on
+* the same sandbox loader the panel uses.
+*
+* The browser is the machine's installed Chrome (or `chromePath`), driven by
+* `puppeteer-core` loaded on first use — a host without Chrome still runs
+* the data checks and reports the browser part as skipped instead of
+* failing. One browser stays up between turns and shuts down after a minute
+* idle.
+*
+* Test scripts are `tests/*.test.js` the agent writes beside the code. Each
+* file runs on a fresh load of the build, as the body of an async function
+* receiving `test`, `assert`, `game` (= `window.dshGame`), `step`, `press`
+* and `drag` (calls the game's optional `look(dx, dy)`); `test(name, fn)`
+* registers a case and every case runs in order.
+* @module @khorsheed/dsh-game
+*/
+var __rewriteRelativeImportExtension = function(path, preserveJsx) {
+	if (typeof path === "string" && /^\.\.?\//.test(path)) return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function(m, tsx, d, ext, cm) {
+		return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : d + ext + "." + cm.toLowerCase() + "js";
+	});
+	return path;
+};
+/** Common Chrome install locations, tried when no path is configured. */
+const CHROME_CANDIDATES = [
+	"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+	"/Applications/Chromium.app/Contents/MacOS/Chromium",
+	"/usr/bin/google-chrome",
+	"/usr/bin/google-chrome-stable",
+	"/usr/bin/chromium",
+	"/usr/bin/chromium-browser",
+	"C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe"
+];
+/**
+* The Chrome executable to drive: the configured path, `CHROME_PATH`, or the
+* first common install location that exists.
+* @param configured - the plugin config's `chromePath`.
+* @returns the path, or undefined when none is found.
+*/
+function findChrome(configured) {
+	for (const candidate of [
+		configured,
+		process.env.CHROME_PATH,
+		...CHROME_CANDIDATES
+	]) if (candidate !== void 0 && candidate !== "" && existsSync(candidate)) return candidate;
+}
+/** How long the game gets to set `dshGame.ready`. */
+const READY_TIMEOUT_MS = 4e3;
+/** …and how long while it says it is still loading assets (`dshGame.loading`). */
+const LOADING_TIMEOUT_MS = 2e4;
+/** How long one test file may run. */
+const TEST_TIMEOUT_MS = 8e3;
+/** The viewport checks render at. */
+const VIEWPORT = {
+	width: 640,
+	height: 400
+};
+/** The in-page wait for `window.dshGame.ready`; resolves true/false. */
+const WAIT_READY = `(async () => {
+  const start = Date.now();
+  for (;;) {
+    const g = window.dshGame;
+    if (g && g.ready) {
+      // Models still loading (dsh3d's glTF looks): smoke, tests and the screenshot wait for them.
+      if (window.__dshPending) await Promise.race([window.__dshPending(), new Promise(r => setTimeout(r, ${LOADING_TIMEOUT_MS}))]);
+      return true;
+    }
+    const limit = g && g.loading ? ${LOADING_TIMEOUT_MS} : ${READY_TIMEOUT_MS};
+    if (Date.now() - start >= limit) return false;
+    await new Promise(r => setTimeout(r, 40));
+  }
+})()`;
+/**
+* The in-page smoke run: 2 s of game time, then the kit's blank-screen probe.
+* @param blankProbe - the kit's expression (true blank, false drawn, null no canvas).
+*/
+function smokeExpression(blankProbe) {
+	return `(async () => {
+  const g = window.dshGame;
+  const out = { stepped: false, blank: null };
+  if (g && typeof g.step === 'function') { for (let i = 0; i < 120; i++) g.step(1 / 60); out.stepped = true; }
+  await new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r)));
+  out.blank = ${blankProbe};
+  return out;
+})()`;
+}
+/**
+* The in-page test harness for one file. The body is spliced in as the
+* function body — CSP is bypassed for the check page, never for the panel.
+* @param body - the test file's text.
+* @returns the expression to evaluate.
+*/
+function testExpression(body) {
+	return `(async () => {
+  const cases = [];
+  const test = (name, fn) => { cases.push({ name: String(name), fn }); };
+  const fail = (msg) => { throw new Error(msg); };
+  const assert = (cond, msg) => { if (!cond) fail(msg || 'assert 失败'); };
+  assert.equal = (a, b, msg) => { if (a !== b) fail((msg ? msg + '：' : '') + '期望 ' + JSON.stringify(b) + '，实际 ' + JSON.stringify(a)); };
+  assert.near = (a, b, eps, msg) => { if (!(Math.abs(a - b) <= (eps ?? 1e-6))) fail((msg ? msg + '：' : '') + '期望约 ' + b + '，实际 ' + a); };
+  const game = window.dshGame;
+  const step = (n = 1, dt = 1 / 60) => { for (let i = 0; i < n; i++) game.step(dt); };
+  const press = (key, frames = 1) => { game.input(key, true); step(frames); game.input(key, false); };
+  const drag = (dx, dy, frames = 1) => { if (typeof game.look !== 'function') fail('window.dshGame.look 不是函数，没法模拟鼠标拖动'); game.look(dx, dy); step(frames); };
+  try {
+    await (async (test, assert, game, step, press, drag) => {\n${body}\n})(test, assert, game, step, press, drag);
+  } catch (e) { return { load: String(e && e.message || e), results: [] }; }
+  const results = [];
+  for (const c of cases) {
+    try { await c.fn(); results.push({ name: c.name, ok: true }); }
+    catch (e) { results.push({ name: c.name, ok: false, msg: String(e && e.message || e).slice(0, 300) }); }
+  }
+  return { results };
+})()`;
+}
+/** The errors the bridge collected, worded for the model. */
+const READ_ERRORS = "(window.__gamedevErrors || []).slice(0, 5)";
+/** Race a promise against a timeout. */
+async function within(ms, work, what) {
+	let timer;
+	try {
+		return await Promise.race([work, new Promise((_, reject) => {
+			timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`${what}超时（${ms / 1e3} 秒）`)), ms);
+		})]);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+	}
+}
+/** The headless-Chrome checker. */
+var ChromeChecker = class {
+	chromePath;
+	browser;
+	idle;
+	profile;
+	/** @param chromePath - configured executable (optional). */
+	constructor(chromePath) {
+		this.chromePath = chromePath;
+	}
+	async launch(executablePath) {
+		const { launch } = await import(__rewriteRelativeImportExtension("puppeteer-core"));
+		this.profile = await mkdtemp(join(tmpdir(), "dsh-game-chrome-"));
+		const browser = await launch({
+			executablePath,
+			headless: true,
+			pipe: true,
+			userDataDir: this.profile,
+			args: [
+				"--no-first-run",
+				"--no-default-browser-check",
+				"--disable-background-networking",
+				"--mute-audio"
+			],
+			timeout: 3e4
+		});
+		browser.on("disconnected", () => {
+			this.browser = void 0;
+		});
+		return browser;
+	}
+	async page(executablePath) {
+		if (this.idle !== void 0) clearTimeout(this.idle);
+		this.browser ??= this.launch(executablePath).catch((error) => {
+			this.browser = void 0;
+			throw error;
+		});
+		return (await this.browser).newPage();
+	}
+	armIdle() {
+		if (this.idle !== void 0) clearTimeout(this.idle);
+		this.idle = setTimeout(() => {
+			this.dispose();
+		}, 6e4);
+		this.idle.unref?.();
+	}
+	/** Load the build into a fresh page with CSP bypassed and wait for ready. */
+	async load(executablePath, files) {
+		const page = await this.page(executablePath);
+		await page.setBypassCSP(true);
+		await page.setViewport(VIEWPORT);
+		await page.evaluateOnNewDocument(`window.__VFS_FILES__ = ${JSON.stringify(files)};`);
+		const shell = shellHtml("<script>window.__GAMEDEV_TEST__=true<\/script>");
+		await page.goto(`data:text/html;base64,${Buffer.from(shell).toString("base64")}`, {
+			waitUntil: "load",
+			timeout: 1e4
+		});
+		return {
+			page,
+			ready: await page.evaluate(WAIT_READY)
+		};
+	}
+	async run(files, tests, options) {
+		const executablePath = findChrome(this.chromePath);
+		if (executablePath === void 0) return {
+			failures: [],
+			passed: 0,
+			skipped: "没找到 Chrome，只跑了数据校验"
+		};
+		const failures = [];
+		let passed = 0;
+		let screenshot;
+		try {
+			const { page, ready } = await this.load(executablePath, files);
+			try {
+				if (!ready) failures.push({
+					where: "smoke",
+					message: `游戏没在 ${READY_TIMEOUT_MS / 1e3} 秒内就绪（加载资源时设 dshGame.loading = true 可放宽到 ${LOADING_TIMEOUT_MS / 1e3} 秒）：window.dshGame.ready 一直不是 true`
+				});
+				else {
+					const smoke = await within(5e3, page.evaluate(smokeExpression(options.blankProbe)), "冒烟运行");
+					if (!smoke.stepped) failures.push({
+						where: "smoke",
+						message: "window.dshGame.step 不是函数，测试没法推进游戏时间"
+					});
+					if (smoke.blank === true) failures.push({
+						where: "smoke",
+						message: "跑了 2 秒后画布仍是同一种颜色（什么都没画出来）"
+					});
+				}
+				const errors = await page.evaluate(READ_ERRORS);
+				for (const e of errors) failures.push({
+					where: "smoke",
+					message: `运行报错（${e.kind}）：${e.msg.slice(0, 300)}`
+				});
+				screenshot = await page.screenshot({
+					type: "webp",
+					quality: 70,
+					encoding: "base64",
+					captureBeyondViewport: false
+				});
+			} finally {
+				await page.close().catch(() => {});
+			}
+			if (failures.length === 0) for (const [file, body] of Object.entries(tests).sort(([a], [b]) => a.localeCompare(b))) {
+				const { page, ready } = await this.load(executablePath, files);
+				try {
+					if (!ready) {
+						failures.push({
+							where: file,
+							message: "这次加载游戏没有就绪，测试没跑"
+						});
+						continue;
+					}
+					const outcome = await within(TEST_TIMEOUT_MS, page.evaluate(testExpression(body)), "测试");
+					if (outcome.load !== void 0) failures.push({
+						where: file,
+						message: `测试文件本身出错：${outcome.load}`
+					});
+					if (outcome.load === void 0 && outcome.results.length === 0) failures.push({
+						where: file,
+						message: "没有用 test(名称, 函数) 登记任何用例"
+					});
+					for (const r of outcome.results) if (r.ok) passed++;
+					else failures.push({
+						where: `${file} › ${r.name}`,
+						message: r.msg ?? "失败"
+					});
+				} catch (error) {
+					failures.push({
+						where: file,
+						message: error.message.split("\n")[0] ?? "出错"
+					});
+				} finally {
+					await page.close().catch(() => {});
+				}
+			}
+		} catch (error) {
+			return {
+				failures,
+				passed,
+				skipped: `浏览器检查没跑起来：${error.message.split("\n")[0]?.slice(0, 200)}`
+			};
+		} finally {
+			this.armIdle();
+		}
+		return {
+			failures,
+			passed,
+			...screenshot === void 0 ? {} : { screenshot }
+		};
+	}
+	async dispose() {
+		if (this.idle !== void 0) clearTimeout(this.idle);
+		const pending = this.browser;
+		this.browser = void 0;
+		if (pending !== void 0) await pending.then((b) => b.close()).catch(() => {});
+		if (this.profile !== void 0) await rm(this.profile, {
+			recursive: true,
+			force: true
+		}).catch(() => {});
+		this.profile = void 0;
+	}
+};
+//#endregion
+//#region lib/types/kits/ids.js
+/** Every kit id this build ships. */
+const KIT_IDS = ["2d-canvas", "3d-three"];
+/** Whether a value names a shipped kit. */
+function isKitId(value) {
+	return typeof value === "string" && KIT_IDS.includes(value);
+}
+//#endregion
+//#region lib/types/project.js
+/**
+* Pure project logic: the creation gate, manifest parsing, chapter status,
+* element validation and which files make up a playable build. No I/O —
+* the store feeds it file contents, the specs feed it strings.
+* @module @khorsheed/dsh-game
+*/
+/** Split a list given either as an array or as one 、/,/newline-separated string. */
+function listOf(value) {
+	const raw = typeof value === "string" ? value.split(/[、,，;；\n]/) : Array.isArray(value) ? value : [];
+	const out = [];
+	for (const item of raw) {
+		const clean = typeof item === "string" ? item.trim() : "";
+		if (clean !== "" && !out.includes(clean)) out.push(clean);
+	}
+	return out;
+}
+/**
+* Resolve the art style the user picked: an example id, its Chinese label,
+* or `custom:<description>`. Anything else is not a choice the user made.
+* @param value - what the model passed.
+* @returns the stored spelling, or undefined when it names no style.
+*/
+function resolveArtStyle(value, styles = ART_STYLES) {
+	const wanted = (value ?? "").trim();
+	if (wanted === "") return void 0;
+	const known = styles.find((style) => style.id === wanted || style.label === wanted);
+	if (known !== void 0) return known.id;
+	if (/^custom[:：]\s*\S/.test(wanted)) return `custom:${wanted.replace(/^custom[:：]\s*/, "")}`;
+}
+/** The style's human label (`custom:` keeps the user's own words). */
+function artStyleLabel(id) {
+	if (id.startsWith("custom:")) return id.slice(7);
+	return [...ART_STYLES, ...ART_STYLES_3D].find((style) => style.id === id)?.label ?? id;
+}
+/** The kit a create request asks for: `3d` / `3d-three` → 3D, anything else 2D. */
+function requestedKit(runtime) {
+	return /^3d/i.test((runtime ?? "").trim()) ? "3d-three" : "2d-canvas";
+}
+/** The example styles a kit offers. */
+function stylesFor(kit) {
+	return kit === "3d-three" ? ART_STYLES_3D : ART_STYLES;
+}
+/**
+* The light gate: a project needs a title, a one-sentence pitch, at least one
+* element type and a chosen art style. The model gets back exactly what is
+* missing, so it asks the user instead of inventing it.
+* @param request - the create arguments.
+* @returns the manifest body, or the missing items.
+*/
+function gate(request) {
+	const missing = [];
+	const title = (request.title ?? "").trim().slice(0, 60);
+	const pitch = (request.pitch ?? "").trim().slice(0, 400);
+	const elementTypes = listOf(request.elementTypes).slice(0, 12);
+	const kit = requestedKit(request.runtime);
+	const styles = stylesFor(kit);
+	const artStyle = resolveArtStyle(request.artStyle, styles);
+	if (title === "") missing.push("title（游戏名）");
+	if (pitch === "") missing.push("pitch（一句话：玩家做什么、为什么好玩）");
+	if (elementTypes.length === 0) missing.push("elementTypes（游戏里有哪几类元素，如 角色、敌人、道具）");
+	if (artStyle === void 0) missing.push(`artStyle（用户从示例里选的美术风格：${styles.map((s) => `${s.id}=${s.label}`).join("、")}，或 custom:描述）`);
+	if (missing.length > 0) return {
+		ok: false,
+		missing
+	};
+	return {
+		ok: true,
+		manifest: {
+			schema: 1,
+			title,
+			pitch,
+			elementTypes,
+			artStyle,
+			pillars: listOf(request.pillars).slice(0, 5),
+			autoConfirm: true,
+			params: [],
+			palette: stylePalette(artStyle),
+			...kit === "2d-canvas" ? {} : { runtime: {
+				kit,
+				version: 1
+			} }
+		}
+	};
+}
+/** A style's palette; custom styles start from the pixel palette (the agent may set its own in game.json). */
+function stylePalette(styleId) {
+	return [...([...ART_STYLES, ...ART_STYLES_3D].find((style) => style.id === styleId) ?? ART_STYLES[0]).palette];
+}
+const HEX$1 = /^#[0-9a-f]{6}$/i;
+/** Parse `game.json` `params[]`, dropping malformed rows and clamping each value into its range. */
+function parseParams(raw) {
+	if (!Array.isArray(raw)) return [];
+	const out = [];
+	for (const row of raw) {
+		if (row === null || typeof row !== "object") continue;
+		const r = row;
+		const key = typeof r.key === "string" ? r.key.trim() : "";
+		const min = Number(r.min), max = Number(r.max);
+		if (key === "" || !Number.isFinite(min) || !Number.isFinite(max) || max <= min || out.some((p) => p.key === key)) continue;
+		const step = Number(r.step) > 0 ? Number(r.step) : (max - min) / 100;
+		const value = Number.isFinite(Number(r.value)) ? Math.min(max, Math.max(min, Number(r.value))) : min;
+		out.push({
+			key,
+			label: typeof r.label === "string" && r.label.trim() !== "" ? r.label.trim() : key,
+			min,
+			max,
+			step,
+			value,
+			...typeof r.unit === "string" && r.unit !== "" ? { unit: r.unit } : {}
+		});
+	}
+	return out.slice(0, 24);
+}
+/** What a usable pixel look needs, worded for the model. */
+const PIXEL_LOOK_HINT = "look 不可用：需要 palette（#rrggbb 数组）和 states（状态名 → 像素行数组）";
+/**
+* Normalize an element's `look`: a palette of `#rrggbb` colors and pixel
+* rows per state, every row padded/cut to the widest row, characters outside
+* the palette turned transparent. Anything unusable is null.
+*/
+function normalizeLook(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+	const r = raw;
+	const palette = Array.isArray(r.palette) ? r.palette.filter((c) => typeof c === "string" && HEX$1.test(c)).slice(0, 36) : [];
+	if (palette.length === 0 || r.states === null || typeof r.states !== "object") return null;
+	const states = {};
+	for (const [name, rowsRaw] of Object.entries(r.states).slice(0, 8)) {
+		if (!Array.isArray(rowsRaw)) continue;
+		const rows = rowsRaw.filter((row) => typeof row === "string").slice(0, 64);
+		if (rows.length === 0) continue;
+		const width = Math.min(64, Math.max(...rows.map((row) => row.length)));
+		states[name] = rows.map((row) => [...row.padEnd(width, ".").slice(0, width)].map((ch) => {
+			const index = LOOK_CHARS.indexOf(ch.toLowerCase());
+			return index >= 0 && index < palette.length ? ch.toLowerCase() : ".";
+		}).join(""));
+	}
+	return Object.keys(states).length === 0 ? null : {
+		palette,
+		states
+	};
+}
+/**
+* Parse `game.json`. Unknown keys are dropped; a missing optional key takes
+* its default, so a hand-edited manifest still loads.
+* @param text - the file's contents.
+* @returns the manifest, or a Chinese reason.
+*/
+function parseManifest(text) {
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch (error) {
+		return {
+			ok: false,
+			error: `${MANIFEST_FILE} 不是合法 JSON：${error.message}`
+		};
+	}
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return {
+		ok: false,
+		error: `${MANIFEST_FILE} 应是一个对象`
+	};
+	const r = raw;
+	const str = (v) => typeof v === "string" ? v : "";
+	const id = str(r.id);
+	if (id === "") return {
+		ok: false,
+		error: `${MANIFEST_FILE} 缺少 id`
+	};
+	return {
+		ok: true,
+		manifest: {
+			schema: 1,
+			id,
+			title: str(r.title) || id,
+			pitch: str(r.pitch),
+			elementTypes: listOf(Array.isArray(r.elementTypes) ? r.elementTypes.filter((x) => typeof x === "string") : str(r.elementTypes)),
+			artStyle: str(r.artStyle),
+			pillars: listOf(Array.isArray(r.pillars) ? r.pillars.filter((x) => typeof x === "string") : str(r.pillars)),
+			autoConfirm: r.autoConfirm !== false,
+			params: parseParams(r.params),
+			palette: Array.isArray(r.palette) && r.palette.some((c) => typeof c === "string" && HEX$1.test(c)) ? r.palette.filter((c) => typeof c === "string" && HEX$1.test(c)) : stylePalette(str(r.artStyle)),
+			createdAt: str(r.createdAt),
+			...runtimeOf(r.runtime) ?? {},
+			...style3dOf(r.style3d) ?? {}
+		}
+	};
+}
+/** The manifest's `style3d`, keeping valid colors and clamped numbers; undefined when nothing usable. */
+function style3dOf(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+	const r = raw;
+	const out = {};
+	if (typeof r.preset === "string" && /^[a-z][\w-]{0,31}$/.test(r.preset)) out.preset = r.preset;
+	Object.assign(out, sceneStyleOf(r));
+	if (typeof r.outline === "string" && HEX$1.test(r.outline)) out.outline = r.outline.toLowerCase();
+	const width = clampNum(r.outlineWidth, 0, .2), shades = clampNum(r.shades, 2, 5);
+	if (width !== void 0) out.outlineWidth = width;
+	if (shades !== void 0) out.shades = Math.round(shades);
+	if (typeof r.shadows === "boolean") out.shadows = r.shadows;
+	const rim = clampNum(r.rim, 0, 2);
+	if (rim !== void 0) out.rim = rim;
+	if (typeof r.rimColor === "string" && HEX$1.test(r.rimColor)) out.rimColor = r.rimColor.toLowerCase();
+	if (r.scenes !== null && typeof r.scenes === "object" && !Array.isArray(r.scenes)) {
+		const scenes = {};
+		for (const [name, raw] of Object.entries(r.scenes).slice(0, 32)) {
+			if (name.trim() === "" || name.length > 40 || raw === null || typeof raw !== "object" || Array.isArray(raw)) continue;
+			scenes[name] = sceneStyleOf(raw);
+		}
+		if (Object.keys(scenes).length > 0) out.scenes = scenes;
+	}
+	return Object.keys(out).length === 0 ? void 0 : { style3d: out };
+}
+const clampNum = (v, min, max) => typeof v === "number" && Number.isFinite(v) ? Math.min(max, Math.max(min, v)) : void 0;
+/** The keys a scene may override (and the game-wide style shares): colors, fog, light. */
+function sceneStyleOf(r) {
+	const out = {};
+	for (const key of [
+		"bg",
+		"ground",
+		"ground2",
+		"water"
+	]) {
+		const v = r[key];
+		if (typeof v === "string" && HEX$1.test(v)) out[key] = v.toLowerCase();
+	}
+	const light = clampNum(r.light, 0, 4);
+	if (light !== void 0) out.light = light;
+	if (Array.isArray(r.fog) && r.fog.length === 2) {
+		const a = clampNum(r.fog[0], 0, 500), b = clampNum(r.fog[1], 0, 1e3);
+		if (a !== void 0 && b !== void 0 && b > a) out.fog = [a, b];
+	}
+	return out;
+}
+/** The manifest's `runtime` when it names a shipped kit with a positive integer version. */
+function runtimeOf(raw) {
+	if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+	const r = raw;
+	if (!isKitId(r.kit)) return void 0;
+	const version = typeof r.version === "number" && Number.isInteger(r.version) && r.version > 0 ? r.version : 1;
+	return { runtime: {
+		kit: r.kit,
+		version
+	} };
+}
+/** Serialize a manifest the way the plugin writes it. */
+function serializeManifest(manifest) {
+	return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+/**
+* A chapter's status from its text: empty is `todo`, a `状态：定稿` (or
+* `status: done`) line is `done`, anything else is a `draft`.
+*/
+function chapterStatus(text) {
+	if (text === void 0 || text.trim() === "") return "todo";
+	if (/^\s*(状态[:：]\s*定稿|status:\s*done)\s*$/im.test(text)) return "done";
+	return "draft";
+}
+/**
+* The one-pager (pitch, element types, style, pillars) lives in `game.json`
+* and the panel pins it; `design/pillars.md` holds only the notes about the
+* pillars (why each matters, how to test it). Projects created before
+* 2026-10-10 got a pillars.md that restated the one-pager: this strips those
+* restated lines so the notes view never shows the card twice.
+* @param text - the chapter's text.
+* @param manifest - the one-pager it may restate.
+* @returns the notes that are not a restatement (trimmed; '' when none).
+*/
+function pillarNotes(text, manifest) {
+	if (manifest === null) return text.trim();
+	const pillars = new Set(manifest.pillars.map((p) => p.trim()));
+	return text.split("\n").filter((line) => {
+		const l = line.trim();
+		if (/^#\s/.test(l) && /设计支柱|支柱说明/.test(l)) return false;
+		if (l.startsWith(">") && l.replace(/^>\s*/, "") === manifest.pitch.trim()) return false;
+		if (/^(\d+\.|[-*])\s/.test(l) && pillars.has(l.replace(/^(\d+\.|[-*])\s+/, ""))) return false;
+		if (l === `美术风格：${artStyleLabel(manifest.artStyle)}` || l === `元素类型：${manifest.elementTypes.join("、")}`) return false;
+		if (l.startsWith("（还没定支柱")) return false;
+		return true;
+	}).join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+/** Element-file scalar values worth tabulating. */
+function scalarStats(r) {
+	const out = {};
+	for (const [key, value] of Object.entries(r)) {
+		if (key === "id" || key === "type" || key === "name" || key === "look" || key === "lore") continue;
+		if (typeof value === "number" || typeof value === "boolean" || typeof value === "string" && value.length <= 40) out[key] = value;
+	}
+	return out;
+}
+/**
+* Validate the element files. A file holds one element object or an array of
+* them; each needs `id`, `name` and a `type` the manifest declares, and ids
+* are unique across files.
+* @param files - project-relative path → contents, only `elements/*.json`.
+* @param elementTypes - the manifest's declared types (empty = accept any).
+* @param looks - how the project's kit normalizes a `look` (default: 2D pixel rows).
+* @returns the elements that parsed, and one failure per problem.
+*/
+function validateElements(files, elementTypes, looks = {
+	normalizeLook,
+	lookHint: PIXEL_LOOK_HINT
+}) {
+	const elements = [];
+	const failures = [];
+	const seen = /* @__PURE__ */ new Map();
+	for (const [file, text] of Object.entries(files).sort(([a], [b]) => a.localeCompare(b))) {
+		let raw;
+		try {
+			raw = JSON.parse(text);
+		} catch (error) {
+			failures.push({
+				where: file,
+				message: `不是合法 JSON：${error.message}`
+			});
+			continue;
+		}
+		(Array.isArray(raw) ? raw : [raw]).forEach((item, index) => {
+			const at = Array.isArray(raw) ? `${file}[${index}]` : file;
+			if (item === null || typeof item !== "object" || Array.isArray(item)) {
+				failures.push({
+					where: at,
+					message: "元素应是对象"
+				});
+				return;
+			}
+			const r = item;
+			const id = typeof r.id === "string" ? r.id.trim() : "";
+			const name = typeof r.name === "string" ? r.name.trim() : "";
+			const type = typeof r.type === "string" ? r.type.trim() : "";
+			if (id === "") failures.push({
+				where: at,
+				message: "缺少 id"
+			});
+			if (name === "") failures.push({
+				where: at,
+				message: "缺少 name"
+			});
+			if (type === "") failures.push({
+				where: at,
+				message: "缺少 type"
+			});
+			else if (elementTypes.length > 0 && !elementTypes.includes(type)) failures.push({
+				where: at,
+				message: `type「${type}」不在 game.json 的 elementTypes（${elementTypes.join("、")}）里`
+			});
+			if (id !== "") {
+				const earlier = seen.get(id);
+				if (earlier !== void 0) failures.push({
+					where: at,
+					message: `id「${id}」和 ${earlier} 重复`
+				});
+				else seen.set(id, at);
+			}
+			if (r.look !== void 0 && looks.normalizeLook(r.look) === null) failures.push({
+				where: at,
+				message: looks.lookHint
+			});
+			if (id !== "" && name !== "" && type !== "") {
+				const look = looks.normalizeLook(r.look);
+				elements.push({
+					file,
+					index: Array.isArray(raw) ? index : -1,
+					id,
+					type,
+					name,
+					stats: scalarStats(r),
+					look: look !== null && isPixelLook(look) ? look : null,
+					look3d: look !== null && !isPixelLook(look) ? look : null,
+					lore: typeof r.lore === "string" ? r.lore.trim() : ""
+				});
+			}
+		});
+	}
+	return {
+		elements,
+		failures
+	};
+}
+/** The generated 元素与数值 chapter: one table per element type. */
+function elementsChapter(elements, elementTypes) {
+	if (elements.length === 0) return "";
+	const types = [...elementTypes, ...elements.map((e) => e.type).filter((t) => !elementTypes.includes(t))];
+	const lines = [
+		"# 元素与数值",
+		"",
+		"（由 elements/ 里的文件自动生成，改数值请改元素文件。）",
+		""
+	];
+	for (const type of types) {
+		const rows = elements.filter((e) => e.type === type);
+		if (rows.length === 0) continue;
+		const keys = [...new Set(rows.flatMap((e) => Object.keys(e.stats)))].slice(0, 8);
+		lines.push(`## ${type}`, "", `| 名称 | id | ${keys.join(" | ")} |`.replace(/ \|  \|$/, " |"), `|${" --- |".repeat(2 + keys.length)}`);
+		for (const e of rows) lines.push(`| ${e.name} | ${e.id} | ${keys.map((k) => String(e.stats[k] ?? "")).join(" | ")} |`.replace(/ \|  \|$/, " |"));
+		lines.push("");
+	}
+	return lines.join("\n");
+}
+/** The generated 元素设定 chapter: every element's 设定 by type (elements without one are left out). */
+function loreChapter(elements, elementTypes) {
+	const written = elements.filter((e) => e.lore !== "");
+	if (written.length === 0) return "";
+	const types = [...elementTypes, ...written.map((e) => e.type).filter((t) => !elementTypes.includes(t))];
+	const lines = [
+		"# 元素设定",
+		"",
+		"（由元素文件里的设定自动汇总，在「元素」里打开一个元素就能改。）",
+		""
+	];
+	for (const type of types) {
+		const rows = written.filter((e) => e.type === type);
+		if (rows.length === 0) continue;
+		lines.push(`## ${type}`, "");
+		for (const e of rows) lines.push(`### ${e.name}`, "", e.lore, "");
+	}
+	return lines.join("\n");
+}
+/** Directories never part of a playable build. */
+const NON_BUILD_DIRS = /* @__PURE__ */ new Set([
+	STATE_DIR,
+	"design",
+	"tests",
+	"node_modules",
+	".git"
+]);
+/**
+* Whether a project-relative path belongs in a playable build: everything
+* except the plugin's state, the design doc, the tests and dot-files.
+*/
+function isBuildFile(path) {
+	const segments = path.split("/");
+	if (segments.some((s) => s.startsWith(".") && s !== ".")) return false;
+	return !NON_BUILD_DIRS.has(segments[0] ?? "");
+}
+/** File-extension → MIME type for the sandbox loader. */
+const TYPES = {
+	html: "text/html",
+	htm: "text/html",
+	js: "text/javascript",
+	mjs: "text/javascript",
+	css: "text/css",
+	json: "application/json",
+	txt: "text/plain",
+	md: "text/markdown",
+	svg: "image/svg+xml",
+	png: "image/png",
+	jpg: "image/jpeg",
+	jpeg: "image/jpeg",
+	gif: "image/gif",
+	webp: "image/webp",
+	wav: "audio/wav",
+	ogg: "audio/ogg",
+	mp3: "audio/mpeg",
+	m4a: "audio/mp4",
+	woff: "font/woff",
+	woff2: "font/woff2",
+	ttf: "font/ttf",
+	otf: "font/otf",
+	glb: "model/gltf-binary",
+	gltf: "model/gltf+json"
+};
+/** Extensions shipped as text (everything else is base64). */
+const TEXT_EXT = /* @__PURE__ */ new Set([
+	"html",
+	"htm",
+	"js",
+	"mjs",
+	"css",
+	"json",
+	"txt",
+	"md",
+	"svg"
+]);
+/** The extension of a path, lower-cased, without the dot. */
+function extOf(path) {
+	const name = path.slice(path.lastIndexOf("/") + 1);
+	return name.includes(".") ? name.slice(name.lastIndexOf(".") + 1).toLowerCase() : "";
+}
+/** A file's MIME type by extension. */
+function mimeOf(path) {
+	return TYPES[extOf(path)] ?? "application/octet-stream";
+}
+/** Whether a file ships to the sandbox as text. */
+function isTextFile(path) {
+	return TEXT_EXT.has(extOf(path));
+}
+/**
+* A directory-safe project folder name from a title: ASCII letters and
+* digits kept, other runs collapsed to `-`; a title with none falls back to
+* `game`. The store appends `-2`, `-3` … on collision.
+*/
+function slugOf(title) {
+	const slug = title.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40);
+	return slug === "" ? "game" : slug;
+}
+/**
+* Apply a patch to one element inside its file's text (an object, or one
+* entry of an array), keeping every other key. `undefined` values delete.
+* @returns the new file text, or undefined when the element is not there.
+*/
+function patchElementText(text, elementId, patch) {
+	let raw;
+	try {
+		raw = JSON.parse(text);
+	} catch {
+		return;
+	}
+	const target = (Array.isArray(raw) ? raw : [raw]).find((item) => item !== null && typeof item === "object" && item.id === elementId);
+	if (target === void 0) return void 0;
+	for (const [key, value] of Object.entries(patch)) {
+		if (key === "id") continue;
+		if (value === void 0) delete target[key];
+		else target[key] = value;
+	}
+	return `${JSON.stringify(raw, null, 2)}\n`;
+}
+//#endregion
+//#region lib/types/kits/types.js
+/** Bundle path prefix the kit's runtime files ride under (never written into a project). */
+const KIT_DIR = "_dsh";
+/** The runtime script the loader injects before the game's own scripts. */
+const KIT_RUNTIME_FILE = `${KIT_DIR}/runtime.js`;
+/** Bare module specifier → bundle path, read by the loader (e.g. `three` → `_dsh/three.module.js`). */
+const KIT_IMPORTS_FILE = `${KIT_DIR}/imports.json`;
+//#endregion
+//#region lib/types/kits/canvas2d.js
+/**
+* The `2d-canvas` kit: native canvas plus an HTML/CSS layer, pixel-row looks
+* drawn with `dshDraw`, the eight built-in 2D art styles. This is the
+* workbench's original runtime, moved behind the kit seam unchanged.
+* @module @khorsheed/dsh-game
+*/
+/** The frame runtime: pixel-look drawing helpers over `window.dshElements`. Kept as a string (never `fn.toString()`). */
+const RUNTIME = `(function(){
+  var CH = '0123456789abcdefghijklmnopqrstuvwxyz';
+  window.dshDraw = function(g, look, state, x, y, scale){
+    if (typeof look === 'string') { var el = window.dshElements[look]; look = el && el.look }
+    if (!look || !look.states || !look.palette) return false;
+    var names = Object.keys(look.states), rows = look.states[state] || look.states[names[0]];
+    if (!rows) return false;
+    scale = scale || 1;
+    for (var r = 0; r < rows.length; r++) for (var c = 0; c < rows[r].length; c++) {
+      var col = look.palette[CH.indexOf(rows[r].charAt(c))];
+      if (!col) continue;
+      g.fillStyle = col; g.fillRect(Math.round(x + c * scale), Math.round(y + r * scale), Math.ceil(scale), Math.ceil(scale));
+    }
+    return true;
+  };
+  window.dshLookSize = function(look){
+    if (typeof look === 'string') { var el = window.dshElements[look]; look = el && el.look }
+    var rows = look && look.states && look.states[Object.keys(look.states)[0]];
+    return rows ? { w: rows[0].length, h: rows.length } : { w: 0, h: 0 };
+  };
+})();`;
+/** Blank when the first canvas, scaled to 32×32 through a 2D context, holds one color. */
+const BLANK_PROBE = `(() => {
+  const c = document.querySelector('canvas');
+  if (!c || c.width <= 0 || c.height <= 0) return null;
+  const probe = document.createElement('canvas'); probe.width = 32; probe.height = 32;
+  const p = probe.getContext('2d'); p.drawImage(c, 0, 0, 32, 32);
+  const d = p.getImageData(0, 0, 32, 32).data; const distinct = new Set();
+  for (let i = 0; i < d.length; i += 4) { distinct.add(d[i] + ',' + d[i + 1] + ',' + d[i + 2]); if (distinct.size > 1) break; }
+  return distinct.size <= 1;
+})()`;
+/** The 2D canvas kit. */
+const CANVAS_2D = {
+	id: "2d-canvas",
+	version: 1,
+	label: "2D 画布",
+	runtimeFiles: () => ({ [KIT_RUNTIME_FILE]: {
+		type: "text/javascript",
+		text: RUNTIME
+	} }),
+	normalizeLook,
+	lookHint: PIXEL_LOOK_HINT,
+	blankProbe: BLANK_PROBE,
+	styles: ART_STYLES,
+	skillSection: `## 运行环境
+- 只有 2D：原生 canvas 加 HTML/CSS 做界面。不能联网、不能引外部 CDN（沙箱 CSP 全拦），所有代码和资源都放项目里。
+- 存档用 \`localStorage\`（面板替你保存在用户浏览器里）。
+- 没有文生图：画面全部用代码画（canvas 绘制、像素数组、SVG）。严格按 game.json 的 artStyle 画：
+${ART_STYLES.map((s) => `- \`${s.id}\` ${s.label}：${s.look}`).join("\n")}
+- 外观 look 的格式：\`{ "palette": ["#1a1c2c", "#ffcd75", …], "states": { "idle": ["..00..", ".0110.", …], "move": [...] } }\`。每行一个字符串，\`.\` 透明，\`0-9a-z\` 是 palette 下标；同一状态各行等宽，常用 16×16。颜色优先取 game.json 的 \`palette\`（来自美术风格）。画的时候用 \`dshDraw(ctx2d, 元素id或look, 状态名, x, y, 放大倍数)\`，尺寸用 \`dshLookSize(元素id)\`。
+`
+};
+//#endregion
+//#region lib/types/look3d.js
+/**
+* Validation for 3D looks (`parts3d` recipes and `gltf` files). Pure data,
+* no three.js: the store, the tools and the browser half all use it, and the
+* 3d-three kit's `dsh3d.build` trusts what passes here.
+*
+* Normalizing is forgiving the way the pixel-look normalizer is: unknown
+* keys drop, numbers clamp into range, bad colors drop; only a look with no
+* usable body (an unknown base, or a gltf path that leaves the project) is
+* rejected outright.
+* @module @khorsheed/dsh-game
+*/
+const HEX = /^#[0-9a-f]{6}$/i;
+const MOTIONS = [
+	"tailSway",
+	"breath",
+	"flap",
+	"swim",
+	"bob"
+];
+/** Proportions that are counts (六足, 多首, a serpent's segments), with their integer ranges. */
+const COUNTS = {
+	legs: [0, 8],
+	heads: [1, 9],
+	segments: [3, 40]
+};
+/** What a usable 3D look needs, worded for the model. */
+const LOOK3D_HINT = `look 不可用：3D 外观要么是 { kind: "parts3d", base: ${BODY_BASES.map((b) => `"${b}"`).join(" / ")} 或项目里 defineBase 注册的名字, proportions, parts, palette, motion }，要么是 { kind: "gltf", src: "assets/….glb" }（路径在项目里）`;
+function clamp(value, min, max) {
+	return typeof value === "number" && Number.isFinite(value) ? Math.min(max, Math.max(min, value)) : void 0;
+}
+function record(raw) {
+	return raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : void 0;
+}
+/** A name a project may register with `defineBase` / `definePart`: lowercase identifier. */
+const NAME = /^[a-z][\w-]{0,31}$/;
+function part(raw) {
+	const r = record(raw);
+	if (r === void 0 || typeof r.type !== "string" || !NAME.test(r.type)) return void 0;
+	const out = { type: r.type };
+	const count = clamp(r.count, 1, 12);
+	if (count !== void 0) out.count = Math.round(count);
+	for (const [key, min, max] of [
+		[
+			"size",
+			.01,
+			3
+		],
+		[
+			"length",
+			.01,
+			5
+		],
+		[
+			"fan",
+			0,
+			360
+		],
+		[
+			"thickness",
+			.005,
+			1
+		]
+	]) {
+		const v = clamp(r[key], min, max);
+		if (v !== void 0) out[key] = v;
+	}
+	if (typeof r.color === "string" && r.color.length <= 24) out.color = r.color;
+	if (typeof r.style === "string" && r.style.length <= 24) out.style = r.style;
+	if (!PART_TYPES.includes(r.type)) {
+		const extra = {};
+		for (const [k, v] of Object.entries(r).slice(0, 16)) {
+			if (k in out || k === "type" || !NAME.test(k)) continue;
+			if (typeof v === "number" && Number.isFinite(v)) extra[k] = Math.min(1e3, Math.max(-1e3, v));
+			else if (typeof v === "string" && v.length <= 40) extra[k] = v;
+		}
+		if (Object.keys(extra).length > 0) out.extra = extra;
+	}
+	return out;
+}
+function parts3d(r) {
+	if (typeof r.base !== "string" || !NAME.test(r.base)) return null;
+	const proportions = {};
+	for (const [k, v] of Object.entries(record(r.proportions) ?? {}).slice(0, 16)) {
+		const count = COUNTS[k];
+		const n = count === void 0 ? clamp(v, .01, 5) : clamp(v, count[0], count[1]);
+		if (n !== void 0 && k.length <= 24) proportions[k] = count === void 0 ? n : Math.round(n);
+	}
+	const palette = {};
+	for (const [k, v] of Object.entries(record(r.palette) ?? {}).slice(0, 12)) if (typeof v === "string" && HEX.test(v) && k.length <= 24) palette[k] = v.toLowerCase();
+	const motion = {};
+	for (const name of MOTIONS) {
+		const m = record(record(r.motion)?.[name]);
+		if (m === void 0) continue;
+		const amplitude = clamp(m.amplitude, 0, 90), period = clamp(m.period, .1, 20);
+		motion[name] = {
+			...amplitude === void 0 ? {} : { amplitude },
+			...period === void 0 ? {} : { period }
+		};
+	}
+	const refine = {};
+	for (const [k, v] of Object.entries(record(r.refine) ?? {}).slice(0, 8)) {
+		const n = clamp(v, 0, 1e5);
+		if (n !== void 0) refine[k] = n;
+	}
+	const scale = clamp(r.scale, .05, 50);
+	return {
+		kind: "parts3d",
+		base: r.base,
+		proportions,
+		parts: (Array.isArray(r.parts) ? r.parts : []).slice(0, 16).map(part).filter((p) => p !== void 0),
+		palette,
+		motion,
+		...scale === void 0 ? {} : { scale },
+		...previewOf(r),
+		...Object.keys(refine).length === 0 ? {} : { refine }
+	};
+}
+/** A look's `preview` angle (degrees), when it has a usable one. */
+function previewOf(r) {
+	const p = record(r.preview);
+	if (p === void 0) return {};
+	const yaw = clamp(p.yaw, -360, 360), pitch = clamp(p.pitch, -10, 80);
+	const out = {
+		...yaw === void 0 ? {} : { yaw },
+		...pitch === void 0 ? {} : { pitch }
+	};
+	return Object.keys(out).length === 0 ? {} : { preview: out };
+}
+/** Names the model chose (materials, bones, shape keys): any text, bounded. */
+const PART_NAME = /^[^\u0000-\u001f]{1,60}$/;
+/** A glTF look's named tweaks: tint, bones, morphs (each kept only when usable, at most 64 names). */
+function tweaksOf(r) {
+	const entries = (raw) => Object.entries(record(raw) ?? {}).filter(([k]) => PART_NAME.test(k)).slice(0, 64);
+	const tint = Object.fromEntries(entries(r.tint).filter(([, v]) => typeof v === "string" && HEX.test(v)).map(([k, v]) => [k, v.toLowerCase()]));
+	const morphs = Object.fromEntries(entries(r.morphs).map(([k, v]) => [k, clamp(v, -1, 2)]).filter(([, v]) => v !== void 0));
+	const bones = {};
+	for (const [k, v] of entries(r.bones)) {
+		const b = record(v);
+		if (b === void 0) continue;
+		const triple = (raw, min, max) => {
+			if (!Array.isArray(raw) || raw.length !== 3) return void 0;
+			const t = raw.map((x) => clamp(x, min, max));
+			return t.every((x) => x !== void 0) ? t : void 0;
+		};
+		const scale = typeof b.scale === "number" ? clamp(b.scale, .1, 5) : triple(b.scale, .1, 5);
+		const rotate = triple(b.rotate, -180, 180);
+		if (scale !== void 0 || rotate !== void 0) bones[k] = {
+			...scale === void 0 ? {} : { scale },
+			...rotate === void 0 ? {} : { rotate }
+		};
+	}
+	return {
+		...Object.keys(tint).length === 0 ? {} : { tint },
+		...Object.keys(bones).length === 0 ? {} : { bones },
+		...Object.keys(morphs).length === 0 ? {} : { morphs }
+	};
+}
+function gltf(r) {
+	const src = typeof r.src === "string" ? r.src.trim().replace(/^\.\//, "") : "";
+	if (!/\.(glb|gltf)$/i.test(src) || src.startsWith("/") || src.split("/").includes("..")) return null;
+	const scale = clamp(r.scale, .05, 50);
+	const recipe = record(r.recipe);
+	const baked = recipe === void 0 ? null : parts3d(recipe);
+	const material = r.material === "original" || r.material === "toon" ? r.material : void 0;
+	return {
+		kind: "gltf",
+		src,
+		...scale === void 0 ? {} : { scale },
+		...material === void 0 ? {} : { material },
+		...typeof r.outline === "boolean" ? { outline: r.outline } : {},
+		...typeof r.animation === "string" && r.animation.trim() !== "" ? { animation: r.animation.trim().slice(0, 80) } : {},
+		...previewOf(r),
+		...tweaksOf(r),
+		...baked === null ? {} : { recipe: baked }
+	};
+}
+/**
+* Normalize a 3D look; null when it has no usable body.
+* @param raw - the element's `look` as written.
+*/
+function normalizeLook3d(raw) {
+	const r = record(raw);
+	if (r === void 0) return null;
+	if (r.kind === "parts3d") return parts3d(r);
+	if (r.kind === "gltf") return gltf(r);
+	return null;
+}
+//#endregion
+//#region lib/types/kits/three3d.js
+/**
+* The `3d-three` kit (proposal 2026-10-21-game-3d §4): three.js plus the
+* package's own thin runtime `dsh3d` (parts-recipe models with an open
+* body/part set, style as data with two starting presets, a 45° camera, and
+* the workbench hooks pick / pause / highlight).
+*
+* Both modules ride every bundle under `_dsh/` and resolve through the
+* loader's bare-import map, so a game writes `import * as THREE from 'three'`
+* and `import { createWorld, build } from 'dsh3d'`. They are read from disk
+* once, on first use: three.js from the pinned `three` dependency, dsh3d from
+* this package's `runtime/` folder. A missing file degrades to a runtime that
+* reports why, so the smoke check names the problem instead of crashing.
+*
+* three's own add-ons (`three/addons/…`: GLTFLoader, EffectComposer, …) map
+* to `_dsh/addons/` too, but only the ones a project's code imports ride its
+* bundle, with whatever they import in turn: the whole add-on tree is far too
+* big to carry on every load.
+* @module @khorsheed/dsh-game
+*/
+const THREE_FILE = "_dsh/three.module.js";
+/** The 2D probe after one render: under the checks dsh3d's \`step\` advances logic only, so the canvas is drawn on demand here. */
+const BLANK_PROBE_3D = `(window.dsh3dWorld && window.dsh3dWorld.render(), ${BLANK_PROBE})`;
+const DSH3D_FILE = "_dsh/dsh3d.js";
+/** `runtime/dsh3d.js` beside the package root: one level up from `lib/`, two from `src/kits/`. */
+function dsh3dPath() {
+	const here = dirname(fileURLToPath(import.meta.url));
+	return [join(here, "..", "runtime", "dsh3d.js"), join(here, "..", "..", "runtime", "dsh3d.js")].find((p) => existsSync(p));
+}
+/** The pinned three.js module build (the package's exports only expose the unminified one). */
+function threePath() {
+	try {
+		const entry = createRequire(import.meta.url).resolve("three");
+		const min = join(dirname(entry), "three.module.min.js");
+		return existsSync(min) ? min : void 0;
+	} catch {
+		return;
+	}
+}
+let cached;
+function load() {
+	if (cached !== void 0) return cached;
+	const three = threePath(), dsh3d = dsh3dPath();
+	if (three === void 0 || dsh3d === void 0) {
+		const missing = [three === void 0 ? "three.js" : "", dsh3d === void 0 ? "dsh3d" : ""].filter(Boolean).join("、");
+		return { [KIT_RUNTIME_FILE]: {
+			type: "text/javascript",
+			text: `console.error(${JSON.stringify(`3D 套件缺文件：${missing}（插件安装不完整）`)})`
+		} };
+	}
+	cached = {
+		[THREE_FILE]: {
+			type: "text/javascript",
+			text: readFileSync(three, "utf8")
+		},
+		[DSH3D_FILE]: {
+			type: "text/javascript",
+			text: readFileSync(dsh3d, "utf8")
+		},
+		...addonFiles({ "dsh3d.js": {
+			type: "text/javascript",
+			text: "import 'three/addons/loaders/GLTFLoader.js'"
+		} }),
+		[KIT_IMPORTS_FILE]: {
+			type: "application/json",
+			text: JSON.stringify({
+				three: THREE_FILE,
+				dsh3d: DSH3D_FILE,
+				"three/addons/": ADDONS_DIR
+			})
+		}
+	};
+	return cached;
+}
+const ADDONS_DIR = "_dsh/addons/";
+/** An add-on set larger than this is cut off (the loader then reports the missing module). */
+const ADDONS_MAX_BYTES = 6291456;
+/** three's `examples/jsm` folder (what `three/addons/` names). */
+function addonsRoot() {
+	try {
+		const dir = join(dirname(createRequire(import.meta.url).resolve("three")), "..", "examples", "jsm");
+		return existsSync(dir) ? dir : void 0;
+	} catch {
+		return;
+	}
+}
+const SPECIFIER = /(?:\bimport\s*\(\s*|\bfrom\s*|\bimport\s+)(['"])([^'"]+)\1/g;
+/**
+* The add-on files a project's scripts import (`three/addons/x`), plus the
+* add-on files those import relatively, as bundle entries under `_dsh/addons/`.
+* @param project - the project's bundle files.
+* @returns the entries to add to the bundle.
+*/
+function addonFiles(project) {
+	const root = addonsRoot();
+	if (root === void 0) return {};
+	const queue = [];
+	for (const [path, file] of Object.entries(project)) {
+		if (!/\.m?js$/.test(path) || !("text" in file)) continue;
+		for (const m of file.text.matchAll(SPECIFIER)) if (m[2].startsWith("three/addons/")) queue.push(m[2].slice(13));
+	}
+	const out = {};
+	let total = 0;
+	while (queue.length > 0) {
+		const rel = posix.normalize(queue.shift());
+		if (rel.startsWith("..") || rel.startsWith("/") || out[ADDONS_DIR + rel] !== void 0) continue;
+		const full = normalize(join(root, rel));
+		if (!full.startsWith(root) || !existsSync(full)) continue;
+		const text = readFileSync(full, "utf8");
+		if (total + text.length > ADDONS_MAX_BYTES) break;
+		total += text.length;
+		out[ADDONS_DIR + rel] = {
+			type: "text/javascript",
+			text
+		};
+		for (const m of text.matchAll(SPECIFIER)) {
+			const spec = m[2];
+			if (spec.startsWith("./") || spec.startsWith("../")) queue.push(posix.join(posix.dirname(rel), spec));
+		}
+	}
+	return out;
+}
+//#endregion
+//#region lib/types/kits/index.js
+/** Every shipped kit, by id. */
+const KITS = {
+	"2d-canvas": CANVAS_2D,
+	"3d-three": {
+		id: "3d-three",
+		version: 1,
+		label: "3D（three.js）",
+		runtimeFiles: (project) => project === void 0 ? load() : {
+			...load(),
+			...addonFiles(project)
+		},
+		normalizeLook: normalizeLook3d,
+		lookHint: LOOK3D_HINT,
+		blankProbe: BLANK_PROBE_3D,
+		styles: ART_STYLES_3D,
+		skillSection: `## 运行环境 · 3D 套件（game.json 的 runtime.kit 是 3d-three）
+- three.js 0.170 已内置，再加插件的薄运行时 dsh3d。代码里直接写 \`import * as THREE from 'three'\` 和 \`import { createWorld, build, defineBase, definePart, ink, toon, flat } from 'dsh3d'\`（不要写路径、不要引 CDN）。
+- 题材、世界、角色全由用户的描述决定；插件只给机制和几个起点，别往用户没提的题材上靠。
+- **风格是数据**：写在 game.json 的 \`style3d\`，按用户描述的画风生成，createWorld 自动读取：
+  \`{ "preset": "ink", "bg": "#efe7d6", "ground": "#e5dbc5", "ground2": "#d6c9ac", "water": "#a7bab4", "outline": "#2a2622", "outlineWidth": 0.032, "shades": 3, "fog": [26, 62], "light": 1.1 }\`
+  preset 是起点（下面两个），其余键覆盖它；outlineWidth 为 0 就没有描边，shades 是卡通明暗层数（2 硬朗 … 5 柔和）。用户说「霓虹赛博」「糖果色」「黑白剪影」之类，就据此调颜色、描边和层数；artStyle 写 custom:用户的描述。现成起点：
+${ART_STYLES_3D.map((s) => `- \`${s.id}\` ${s.label}：${s.look}`).join("\n")}
+  自己加的物体用 \`ink(geometry, toon('#颜色'))\`（卡通材质 + 描边），地面起伏、石头、树这类场景用 \`flat('#颜色')\`，这样换 style3d 时全场跟着变。别用写实贴图和 PBR 材质。
+- 世界：\`const world = createWorld({ region: (x, z) => '区域名' })\`，然后
+  - \`world.terrain({ size, height: (x, z) => 高度 })\` 地形；\`world.place(obj, x, z)\` 放到地面上
+  - **能站上去的模型**（楼梯、平台、桥、屋顶）：\`world.add(obj, { walkable: true })\` 或 \`world.walkable(obj)\`。角色移动时用 \`world.groundAt(x, z, 脚底高度 + 台阶高)\` 取落脚高度：只认这个高度以下最高的面，所以能一级级爬楼梯，不会被吸到头顶的屋顶上。要挡墙就再问一次不设上限的 \`groundAt(x, z)\`，比脚底高出一个台阶以上就别走过去。它只管「站在哪」，不管撞墙、滑坡。
+  - \`world.add(obj, { id: 元素id, inst: 实例id, name, state: () => '当前在干什么' })\` 登记实体（右栏「指一下」靠它认出东西）
+  - \`world.scatter(元素id, 数量或位置列表, { seed, spread, center, scale: [0.85, 1.15] })\` 把一种元素批量撒在地面上：外观只生成一次、批量绘制，每棵按地形高度落地、随机朝向和大小（同一个 seed 每次摆得一样）；点到任意一棵，「指一下」认出是哪个元素、第几棵。树林、石滩、草地都用它，别自己循环 clone。加 \`sway: { amplitude: 0.06, period: 2.4 }\` 让草木随风摆（越高处摆得越大，每棵错开；影子不跟着摆）；除此之外撒出来的是静物，没有逐棵动效。
+  - **多个场景**（地图上的几座山、室内外）：\`world.enterScene('场景名', w => { w.terrain(…); w.scatter(…); w.add(…); w.onUpdate(…) })\`。切到下一个场景时，上一个场景里登记的地形、实体、批量物件、onUpdate 全部移除并释放；在任何场景之外登记的（玩家、镜头跟随）保留。各场景的底色、地面颜色、水色、雾、光照写在 game.json 的 \`style3d.scenes\`：\`{ "北坡": { "bg": "#cfd6dc", "ground": "#d8dcd6", "fog": [12, 40], "light": 0.8 } }\`（名字由游戏自己定；明暗层数和描边全局共用，不能按场景换）。别在同一个场景里堆所有区域，也别手动去删 scene 里的东西。
+  - \`world.follow(玩家)\` 镜头跟随（俯视斜 45° 正交镜头）；\`world.onUpdate((dt, t) => {...})\` 写游戏逻辑
+  - \`world.step(dt)\` 推进一帧（dshGame.step 就调它），\`world.start()\` 开始实时播放
+  - \`world.pick(x, y)\`、\`world.pause(on)\`、\`world.highlight(list)\` 是给面板用的，dshGame 里转发即可
+- 外观 look（3D）：部件配方，\`build(元素id或look)\` 拼出模型并自带程序动效。例子（一只长尾猫）：
+  \`{ "kind": "parts3d", "base": "quadruped", "proportions": { "bodyLength": 0.9, "bodyHeight": 0.4, "legLength": 0.3, "headSize": 0.34, "snout": 0.1 }, "parts": [{ "type": "ear", "count": 2 }, { "type": "tail", "count": 1, "length": 0.9, "thickness": 0.06 }], "palette": { "body": "#f2a65a", "accent": "#7a4a2a", "eye": "#1d1d1f" }, "motion": { "tailSway": { "amplitude": 20, "period": 1.4 }, "breath": { "amplitude": 0.02, "period": 2.4 } } }\`
+  - 内置身体 base：${BODY_BASES.join(" / ")}（四足、禽、鱼、蛇形、人形）。比例：bodyLength、bodyHeight、legLength、headSize、snout、legs（足数）、heads（头数）；禽另有 beak；蛇形是 length、thickness、segments；人形是 height。
+  - 内置部件 parts：ear、horn、tail（count/length/fan/thickness）、wing（count/size）、fin、eye（count）、face（style: "human"）。color 写 palette 的键或 #rrggbb。
+  - palette 的键：body、accent、eye，另可 belly、horn、wing、beak、face、skin。motion：tailSway、breath、flap、swim、bob（amplitude 角度，breath/bob 是比例；period 秒）。
+  - **内置的不够就自己注册**（机器人、史莱姆、车、建筑……）。注册代码一律放 \`src/looks.js\`（入口先 \`import './looks.js'\` 再 build）——右栏的外观预览只加载这个文件，写在别处面板就拼不出来：
+    \`defineBase('robot', (look, kit) => { const g = new kit.THREE.Group(), body = new kit.THREE.Group(); g.add(body); body.add(kit.ink(new kit.THREE.BoxGeometry(0.8, 0.6, 0.5), kit.toon(kit.color('body', '#888888')))); return { g, body } })\`
+    \`definePart('antenna', ({ spec, anchors, kit }) => { const a = kit.ink(new kit.THREE.CylinderGeometry(0.02, 0.02, spec.length ?? 0.4), kit.toon(kit.color(spec.color ?? 'accent', '#ff0000'))); a.position.y = 0.5; anchors.body.add(a); return { update: t => { a.rotation.z = 0.2 * Math.sin(t * 3) } } })\`
+    之后配方里就能写 \`"base": "robot"\`、\`{ "type": "antenna", "length": 0.5 }\`（自定义部件的其他参数在 spec.extra 里）。注册过的名字用户在面板里同样能调。
+  - **场景物件也走配方**：树、石头、草丛、远山、建筑这类有形状的元素，同样在 \`src/looks.js\` 里 defineBase 注册造型（用 \`kit.flat(kit.color('body', '#…'))\`，尺寸读 \`look.proportions\`），元素文件写 \`look\`，成片的用 \`world.scatter(元素id, …)\` 撒开、单个的 \`build(元素id)\`（数量、分布范围这类仍是元素字段）。别在 main.js 里直接手写几何体——那样右栏看不到它的样子，用户也没法调。只有地面高度场（world.terrain）和水面这种铺满整个场景的不算元素。
+  - 面数预算：单个元素 1 万三角面以内，同屏一个场景 15 万以内（\`world.stats()\` 可查，批量物件按份数算）。这是建议不是硬限制，超了先看帧率。
+- 贴图与素材：图片放 \`assets/\`，\`new THREE.TextureLoader().load('assets/xx.png')\` 就能用（贴到 toon/flat 材质的 map 上）；纸纹、墨晕这类也可以用 canvas 现画，再 \`new THREE.CanvasTexture(canvas)\`，不用另存文件。
+- **模型文件做外观（glTF）**：Blender 做的角色、建筑导出成 .glb 放进 \`assets/\`，元素文件写 \`"look": { "kind": "gltf", "src": "assets/yumin.glb", "scale": 1, "material": "toon" }\`。代码里照样 \`build('yumin')\`：它立刻返回，模型加载完自己出现（要等就 \`await model.userData.loaded\` 或 \`await loaded()\`）。\`material\` 取 \`toon\`（默认：套当前风格的卡通明暗和描边，保留模型的颜色、顶点色和贴图）或 \`original\`（模型自己的材质，默认不描边）；\`outline: true/false\` 单独开关描边。右栏能预览、切换材质、调大小。导出建议：Y 轴朝上、单位米、原点在脚底、**脸朝 +X**（插件的约定，内置的异兽也是；在 Blender 里就是让角色面向 +X 轴，glTF 默认的 +Z 朝向要转过来）、贴图打包进 .glb、单个模型 1 万面以内。右栏预览按这个约定拍正面偏 3/4；某个元素想换默认角度，写 \`"preview": { "yaw": 35, "pitch": 18 }\`（度数：yaw 0 正面、90 侧面、180 背面，pitch 往下看的角度），配方外观也能写。检查会等模型加载完再截图、跑测试；外观引用的文件不在项目里，检查会拦下。用现成的 CC0 素材时，在 \`assets/LICENSES.md\` 记下来源和授权。
+  - 骨骼动画：Blender 里每个动作做成一个 Action（名字就是动画名，如 idle、walk），导出时勾选动画。模型加载后自动循环播放 \`look.animation\` 指定的那个，没写就挑名字带 idle / 待机 / stand 的，再没有就第一个。代码里 \`model.userData.play('walk')\` 切换（默认 0.2 秒过渡；\`{ loop: false }\` 只播一遍），\`model.userData.animations\` 是全部动画名（加载完才有）。动画跟着 world 的时钟走：模型要 \`world.add\` 登记（或者自己每帧调 \`model.userData.update(world.time)\`），测试里 \`step\` 照样推进动画。描边跟着骨骼动；「指一下」能点中摆着姿势的角色。右栏转盘下面列出全部动画，点一下就播。
+  - 按名字微调（游戏和右栏一致，都由 build 生效）：\`"tint": { "冠": "#c9a23a" }\` 按材质名换基础色（材质用了顶点色时是相乘，会偏暗）；\`"bones": { "head": { "scale": 1.2, "rotate": [0, 10, 0] } }\` 按骨头名缩放（一个数或 [x,y,z]，子骨头跟着变）、加旋转（度），叠在动画之上，播动作也不会被冲掉；\`"morphs": { "smile": 0.6 }\` 按形态键名设权重，描边跟着变形。所以 Blender 里材质、骨头、形态键要起有意义的名字（羽_青、冠、head、wing.L、smile……）。右栏「细调外观」读出模型里的这些名字，列成色块和滑块（带 DEF-/MCH-/ORG- 前缀的绑定辅助骨默认不列，可以搜）。代码里加载后改了的东西右栏看不到，能写进外观的就写进外观。
+- three 自带的扩展直接引：\`import { GLTFLoader } from 'three/addons/loaders/GLTFLoader.js'\`，后期处理 \`three/addons/postprocessing/EffectComposer.js\` 等都行（只打包你引用到的文件）。
+- 镜头：默认是 45° 俯视的正交镜头。第三人称跟随直接用现成的：\`const rig = world.followCamera({ target: player, distance: 7, height: 1.4, mouse: true })\`（\`mouse: true\` 点画面锁定鼠标、移动鼠标转视角，Esc 退出），\`rig.yaw\` / \`rig.pitch\` / \`rig.distance\` 随时可改，dshGame 上写 \`look: (dx, dy) => rig.look(dx, dy)\`，测试里用 \`drag\` 模拟；角色朝镜头前方走时用 \`rig.yaw\` 换算方向。要别的镜头就自己建 \`new THREE.PerspectiveCamera(…)\`，\`world.setCamera(cam)\`，然后每帧（onUpdate 里）自己摆位置、朝向；「指一下」、高亮圈都跟着这台镜头走，\`world.setCamera(null)\` 换回默认。鼠标转视角可以在点击里 \`canvas.requestPointerLock()\`（Esc 退出），并在 dshGame 上提供 \`look(dx, dy)\`，测试里用 \`drag(dx, dy)\` 模拟拖动。
+- 光与投影：\`world.lights.hemi\`（天光）、\`world.lights.sun\`（太阳）可以直接调；style3d 里写 \`"shadows": true\` 开太阳投影（之后 world.add / scatter 进来的东西都投影、受影）；\`"rim": 0.6\`（0–2）加轮廓光，角色边缘亮一圈、从地面上「浮」出来，\`"rimColor"\` 换颜色。
+- 后期处理（泛光、调色）：\`world.onRender(({ renderer, scene, camera }) => composer.render())\` 接管绘制，返回的函数交还。泛光（狐火、灯笼）这样接：\`import { EffectComposer } from 'three/addons/postprocessing/EffectComposer.js'\`、\`RenderPass\`、\`UnrealBloomPass\`、\`OutputPass\`（同目录），建 composer 依次 addPass(new RenderPass(world.scene, world.camera))、addPass(new UnrealBloomPass(new THREE.Vector2(w, h), 强度 0.6, 半径 0.4, 阈值 0.85))、addPass(new OutputPass())，然后 onRender 里 \`composer.render()\`；发光的东西用 \`toon(颜色, { own: true, emissive: 颜色 })\`。换镜头后记得把 RenderPass 的 camera 一起换。
+- 材质：toon / flat 按颜色共用一份。要让某一个东西单独发光、变色、淡出：\`toon('#ff8a3d', { own: true, emissive: '#ff8a3d' })\` 拿一份自己的。
+- 加载资源时（glb、大贴图）先挂 \`window.dshGame = { ready: false, loading: true, … }\`，加载完再设 \`ready = true\`：检查会等最多 20 秒（不写 loading 只等 4 秒）。
+- 检查里（\`window.__GAMEDEV_TEST__\`）\`step\` 推进逻辑和镜头但不画画面，测试可以放心多跑帧；要读像素时先 \`world.render()\`。
+- dshGame 约定照旧，3D 推荐这样接：
+\`\`\`js
+window.dshGame = {
+  ready: true,
+  step: dt => world.step(dt),
+  input(key, down) { /* 记到按键状态里，onUpdate 里读 */ },
+  state: () => ({ player: { x: player.position.x, z: player.position.z } }),
+  pick: (x, y) => world.pick(x, y),
+  pause: on => world.pause(on),
+  highlight: list => world.highlight(list),
+}
+world.start()
+\`\`\`
+`
+	}
+};
+/** The kit a project without a `runtime` field runs on. */
+const DEFAULT_KIT = CANVAS_2D;
+/**
+* The kit a project runs on.
+* @param ref - the manifest's `runtime` (absent on projects made before kits).
+* @returns the kit; unknown ids fall back to the default.
+*/
+function kitOf(ref) {
+	return ref !== void 0 && isKitId(ref.kit) ? KITS[ref.kit] : DEFAULT_KIT;
+}
+/**
+* A bundle with the kit's runtime files added. The project's own files win
+* on a path clash (a project should never write under `_dsh/`, but if it
+* does, its file is what it meant to ship).
+*/
+function withKitRuntime(files, kit) {
+	return {
+		...kit.runtimeFiles(files),
+		...files
+	};
+}
+//#endregion
+//#region lib/types/trash.js
+/**
+* Moving a deleted project folder to the system trash, so a delete from the
+* panel is complete (gone from the workspace and the plugin) yet recoverable.
+*
+* - macOS: a rename into `~/.Trash`, de-duplicated with a timestamp suffix.
+* - Linux: the freedesktop trash (`$XDG_DATA_HOME/Trash`, default
+*   `~/.local/share/Trash`): the folder goes to `files/`, a `.trashinfo`
+*   record to `info/` so the file manager can restore it to where it was.
+* - Elsewhere, or across volumes (a rename cannot cross devices), the move is
+*   refused and nothing is touched: the panel then offers "remove from the
+*   list only". A project folder is never deleted outright.
+* @module @khorsheed/dsh-game
+*/
+/** A free name inside `dir` for `name`, suffixed with the time when taken. */
+async function freeName(dir, name) {
+	const taken = async (candidate) => stat(join(dir, candidate)).then(() => true, () => false);
+	if (!await taken(name)) return name;
+	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+	for (let n = 0;; n++) {
+		const candidate = `${name} ${stamp}${n === 0 ? "" : `-${n}`}`;
+		if (!await taken(candidate)) return candidate;
+	}
+}
+/** Rename, turning a cross-device failure into the refusal the panel explains. */
+async function move(from, to) {
+	try {
+		await rename(from, to);
+	} catch (error) {
+		if (error.code === "EXDEV") throw new Error("项目和废纸篓不在同一块磁盘上，没法移过去");
+		throw error;
+	}
+}
+/** The system trash mover for this platform (`home` is a test seam). */
+function systemTrash(home = homedir(), platform = process.platform) {
+	if (platform === "darwin") return async (folder) => {
+		const dir = join(home, ".Trash");
+		await mkdir(dir, { recursive: true });
+		const target = join(dir, await freeName(dir, basename(folder)));
+		await move(folder, target);
+		return target;
+	};
+	if (platform === "linux") return async (folder) => {
+		const root = join(process.env.XDG_DATA_HOME || join(home, ".local", "share"), "Trash");
+		await mkdir(join(root, "files"), { recursive: true });
+		await mkdir(join(root, "info"), { recursive: true });
+		const name = await freeName(join(root, "files"), basename(folder));
+		const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19);
+		await writeFile(join(root, "info", `${name}.trashinfo`), `[Trash Info]\nPath=${encodeURI(folder)}\nDeletionDate=${date}\n`);
+		await move(folder, join(root, "files", name));
+		return join(root, "files", name);
+	};
+	return async () => {
+		throw new Error("这个系统上插件不会动项目文件夹");
+	};
+}
+//#endregion
+//#region lib/types/fsutil.js
+/**
+* File helpers the game service builds on: atomic writes, tolerant reads, the
+* bounded project walk, and the sandbox bundle form of walked files.
+* @module @khorsheed/dsh-game
+*/
+/** Walk limits for one project read: enough for a small game, bounded for a stray huge folder. */
+const MAX_FILES = 600;
+const MAX_FILE_BYTES = 8388608;
+const MAX_TOTAL_BYTES = 50331648;
+/** Whether `child` is `parent` or inside it. */
+function inside(parent, child) {
+	const rel = relative(parent, child);
+	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
+}
+/** Write a file atomically (tmp + rename), creating its directory. */
+async function writeAtomic(path, data) {
+	await mkdir(dirname(path), { recursive: true });
+	const tmp = `${path}.${randomBytes(4).toString("hex")}.tmp`;
+	await writeFile(tmp, data);
+	await rename(tmp, path);
+}
+/** Read a text file, undefined when absent or unreadable. */
+async function readText(path) {
+	try {
+		return await readFile(path, "utf8");
+	} catch {
+		return;
+	}
+}
+/** Read JSON, undefined when absent or broken. */
+async function readJson(path) {
+	const text = await readText(path);
+	if (text === void 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/**
+* Walk a directory (dot-entries skipped), bounded by the walk limits.
+* @param root - directory to walk.
+* @param keep - project-relative path filter.
+* @returns the files, sorted by path.
+*/
+async function walk(root, keep) {
+	const out = [];
+	let total = 0;
+	const visit = async (dir) => {
+		let entries;
+		try {
+			entries = await readdir(dir, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+			if (out.length >= MAX_FILES || entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const full = join(dir, entry.name);
+			const rel = relative(root, full).split(sep).join("/");
+			if (entry.isDirectory()) {
+				await visit(full);
+				continue;
+			}
+			if (!entry.isFile() || !keep(rel)) continue;
+			const info = await stat(full).catch(() => void 0);
+			if (info === void 0 || info.size > MAX_FILE_BYTES || total + info.size > MAX_TOTAL_BYTES) continue;
+			total += info.size;
+			out.push({
+				path: rel,
+				data: await readFile(full)
+			});
+		}
+	};
+	await visit(root);
+	return out;
+}
+/** The sandbox bundle form of walked files. */
+function bundleOf(files) {
+	const out = {};
+	for (const f of files) out[f.path] = isTextFile(f.path) ? {
+		type: mimeOf(f.path),
+		text: f.data.toString("utf8")
+	} : {
+		type: mimeOf(f.path),
+		b64: f.data.toString("base64")
+	};
+	return out;
+}
+/** A content fingerprint over (path, bytes) pairs. */
+function fingerprintOf(files) {
+	const hash = createHash("sha1");
+	for (const f of files) {
+		hash.update(f.path);
+		hash.update("\0");
+		hash.update(createHash("sha1").update(f.data).digest());
+	}
+	return hash.digest("hex").slice(0, 16);
+}
+//#endregion
+//#region lib/types/store.js
+/**
+* The game service core (`ctx.gameStore`): the project registry, session
+* binding, reading a project for the tools and the panel, the end-of-turn
+* check flow, versions and the playtest log.
+*
+* Storage (proposal §3): a project is a plain directory in the session's
+* workspace — `game.json`, `index.html`, `src/`, `assets/`, `elements/`,
+* `design/`, `tests/` — and the plugin's own state lives inside it under
+* `.game/` (versions, the last check, the playtest log), so the project moves
+* as one folder. Only the registry (which projects exist, which session is
+* bound to which) is deployment-level, at `$DSH_HOME/state/game/`.
+*
+* The agent writes project files with the ordinary fs tools; the plugin
+* writes only the manifest and the first chapter at creation (through the
+* mounted `ctx.fs` with the calling session's policy, so the fence applies)
+* and its own `.game/` state. Version snapshots copy binary assets, which
+* `ctx.fs` cannot write, so they go through node behind the same checks the
+* canvas uses: the session's mode is not read-only and the target sits inside
+* the project.
+* @module @khorsheed/dsh-game
+*/
+/** Versions kept under `.game/versions/`; older ones are pruned. */
+const KEEP_VERSIONS = 10;
+/**
+* Resolve the registry root: explicit value, then `$DSH_HOME/state/game`,
+* then `<cwd>/.dsh-game` (the canvas precedent).
+*/
+function resolveGameStateRoot(configured) {
+	if (configured !== void 0 && configured !== "") return configured;
+	const home = process.env.DSH_HOME;
+	if (home !== void 0 && home !== "") return join(home, "state", "game");
+	return join(process.cwd(), ".dsh-game");
+}
+/** Format a number the way the dock shows it (no float noise). */
+function num(value) {
+	return String(Math.round(value * 1e3) / 1e3);
+}
+/** A change this recent means someone is still writing (a CLI member gives no other sign). */
+const BUSY_QUIET_MS = 2e4;
+/** Build-file paths under a folder with their modification times (no contents read). */
+async function statWalk(root, keep) {
+	const out = [];
+	const visit = async (dir) => {
+		const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+		for (const entry of entries) {
+			if (out.length >= 600 || entry.name.startsWith(".") || entry.name === "node_modules") continue;
+			const full = join(dir, entry.name);
+			const rel = relative(root, full).split(sep).join("/");
+			if (entry.isDirectory()) {
+				await visit(full);
+				continue;
+			}
+			if (!entry.isFile() || !keep(rel)) continue;
+			const info = await stat(full).catch(() => void 0);
+			if (info !== void 0) out.push({
+				path: rel,
+				mtimeMs: info.mtimeMs
+			});
+		}
+	};
+	await visit(root);
+	return out;
+}
+/** The game service core. */
+var GameService = class {
+	ctx;
+	static inject = ["fs"];
+	stateRoot;
+	sandboxPolicy;
+	checker;
+	/** Serializes registry read-modify-write cycles. */
+	registryLock = Promise.resolve();
+	listeners = /* @__PURE__ */ new Set();
+	/**
+	* @param ctx - host context (the mounted `ctx.fs`; `sandboxPolicy` probed).
+	* @param config - plugin config.
+	* @param deps - seams the specs replace.
+	*/
+	constructor(ctx, config = {}, deps = {}) {
+		this.ctx = ctx;
+		this.stateRoot = resolveGameStateRoot(config.stateRoot);
+		this.sandboxPolicy = ctx.fs?.sandboxMode === void 0 ? void 0 : ctx.get("sandboxPolicy");
+		this.checker = deps.checker ?? new ChromeChecker(config.chromePath);
+		if (deps.writer !== void 0) this.writeFenced = deps.writer;
+		this.trash = deps.trash ?? systemTrash();
+	}
+	/** Where a deleted project folder goes (the system trash; specs swap a fake). */
+	trash;
+	/** Release the checker's browser. */
+	async dispose() {
+		await this.checker.dispose();
+	}
+	/** Subscribe to project changes (the Remote face forwards nothing yet; specs and hooks use it). */
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	notify(projectId) {
+		for (const listener of this.listeners) listener(projectId);
+	}
+	/** Default fenced write: the mounted fs, stamped with the caller's policy. */
+	writeFenced = async (path, content, session) => {
+		const policy = this.sandboxPolicy?.resolve({ session });
+		const target = await this.ctx.fs.resolve(path);
+		await this.ctx.fs.writeText(target, content, { kind: "createIfAbsent" }, void 0, policy);
+	};
+	/** Whether the session may have the plugin write into its workspace. */
+	writable(session) {
+		if (session === void 0) return true;
+		return this.sandboxPolicy?.resolve({ session })?.mode !== "read-only";
+	}
+	registryPath() {
+		return join(this.stateRoot, "registry.json");
+	}
+	async readRegistry() {
+		const raw = await readJson(this.registryPath());
+		return {
+			projects: Array.isArray(raw?.projects) ? raw.projects.filter((p) => typeof p?.id === "string" && typeof p.root === "string") : [],
+			bindings: raw?.bindings !== null && typeof raw?.bindings === "object" ? { ...raw.bindings } : {}
+		};
+	}
+	/** Read-modify-write the registry under the lock. */
+	async updateRegistry(change) {
+		const run = this.registryLock.then(async () => {
+			const registry = await this.readRegistry();
+			const result = change(registry);
+			await writeAtomic(this.registryPath(), `${JSON.stringify(registry, null, 2)}\n`);
+			return result;
+		});
+		this.registryLock = run.catch(() => {});
+		return run;
+	}
+	/** Every registered project, most recently updated first. */
+	async listProjects() {
+		const { projects } = await this.readRegistry();
+		return [...projects].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+	}
+	/** Element files parsed per id, for turn diffs. */
+	async elementIndex(root) {
+		const out = /* @__PURE__ */ new Map();
+		for (const f of await walk(join(root, "elements"), (p) => p.endsWith(".json"))) {
+			let raw;
+			try {
+				raw = JSON.parse(f.data.toString("utf8"));
+			} catch {
+				continue;
+			}
+			for (const item of Array.isArray(raw) ? raw : [raw]) {
+				if (item === null || typeof item !== "object") continue;
+				const r = item;
+				if (typeof r.id !== "string") continue;
+				const fields = {};
+				for (const [k, v] of Object.entries(r)) if (k !== "look" && k !== "id") fields[k] = JSON.stringify(v);
+				out.set(r.id, {
+					name: typeof r.name === "string" ? r.name : r.id,
+					json: JSON.stringify(r),
+					look: JSON.stringify(r.look ?? null),
+					fields
+				});
+			}
+		}
+		return out;
+	}
+	/** Snapshot the bound project when a turn starts (undefined when unbound). */
+	async turnBaseline(sessionId) {
+		const row = await this.boundProject(sessionId);
+		if (row === void 0) return void 0;
+		const files = new Map((await walk(row.root, () => true)).map((f) => [f.path, createHash("sha1").update(f.data).digest("hex")]));
+		const manifest = await this.manifestOf(row.root);
+		return {
+			at: Date.now(),
+			projectId: row.id,
+			files,
+			elements: await this.elementIndex(row.root),
+			params: Object.fromEntries((manifest?.params ?? []).map((p) => [p.key, p.value])),
+			current: (await readJson(join(row.root, STATE_DIR, "current.json")))?.version,
+			candidate: (await readJson(join(row.root, STATE_DIR, "candidate.json")))?.version
+		};
+	}
+	turnsPath(sessionId) {
+		return join(this.stateRoot, "turns", `${sessionId.replace(/[^\w.-]/g, "_")}.json`);
+	}
+	/**
+	* Compare the project with its turn-start snapshot and store what the turn
+	* changed. Nothing is stored for a turn that changed nothing.
+	*/
+	async recordTurn(sessionId, turn, base) {
+		const row = await this.row(base.projectId);
+		if (row === void 0) return void 0;
+		const now = new Map((await walk(row.root, () => true)).map((f) => [f.path, createHash("sha1").update(f.data).digest("hex")]));
+		const changed = [...now.keys()].filter((p) => base.files.get(p) !== now.get(p));
+		const removed = [...base.files.keys()].filter((p) => !now.has(p));
+		const elementsNow = await this.elementIndex(row.root);
+		const elements = [];
+		for (const [id, e] of elementsNow) {
+			const before = base.elements.get(id);
+			if (before === void 0) {
+				elements.push({
+					id,
+					name: e.name,
+					what: "new"
+				});
+				continue;
+			}
+			if (before.json === e.json) continue;
+			const fields = [.../* @__PURE__ */ new Set([...Object.keys(e.fields), ...Object.keys(before.fields)])].filter((k) => e.fields[k] !== before.fields[k]);
+			if (before.look !== e.look) {
+				const looks = /"kind":"(parts3d|gltf)"/.test(e.look) && e.look.length < 8e3 && before.look.length < 8e3 ? { looks: {
+					before: before.look === "null" ? null : before.look,
+					after: e.look
+				} } : {};
+				elements.push({
+					id,
+					name: e.name,
+					what: "look",
+					...fields.length > 0 ? { fields } : {},
+					...looks
+				});
+			} else elements.push({
+				id,
+				name: e.name,
+				what: "fields",
+				fields
+			});
+		}
+		for (const [id, e] of base.elements) if (!elementsNow.has(id)) elements.push({
+			id,
+			name: e.name,
+			what: "removed"
+		});
+		const manifest = await this.manifestOf(row.root);
+		const params = (manifest?.params ?? []).filter((p) => base.params[p.key] !== p.value).map((p) => ({
+			key: p.key,
+			label: p.label,
+			to: p.value,
+			...base.params[p.key] === void 0 ? {} : { from: base.params[p.key] }
+		}));
+		const chapters = CHAPTERS.filter((c) => c.generated !== true && [...changed, ...removed].includes(c.file)).map((c) => ({
+			id: c.id,
+			title: c.title
+		}));
+		const code = [...changed, ...removed].filter((p) => isBuildFile(p) && !p.startsWith("elements/") && p !== "game.json");
+		const tests = changed.filter((p) => p.startsWith("tests/"));
+		const current = (await readJson(join(row.root, STATE_DIR, "current.json")))?.version;
+		const candidate = (await readJson(join(row.root, STATE_DIR, "candidate.json")))?.version;
+		const version = candidate !== void 0 && candidate !== base.candidate ? {
+			kind: "candidate",
+			version: candidate
+		} : current !== void 0 && current !== base.current ? {
+			kind: "deployed",
+			version: current
+		} : null;
+		const last = await readJson(join(row.root, STATE_DIR, "checks.json"));
+		const check = last !== void 0 && new Date(last.at).getTime() >= base.at ? {
+			ok: last.ok,
+			fixes: last.attempt,
+			gaveUp: last.gaveUp === true,
+			passed: last.passed,
+			failures: last.failures.length
+		} : null;
+		if (elements.length + params.length + chapters.length + code.length + tests.length === 0 && version === null && check === null) return void 0;
+		const report = {
+			turn,
+			projectId: row.id,
+			title: manifest?.title ?? row.title,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			version,
+			check,
+			elements,
+			chapters,
+			params,
+			code: code.slice(0, 20),
+			tests
+		};
+		const path = this.turnsPath(sessionId);
+		const all = await readJson(path) ?? {};
+		all[String(turn)] = report;
+		const keys = Object.keys(all).map(Number).sort((a, b) => b - a);
+		for (const k of keys.slice(200)) delete all[String(k)];
+		await writeAtomic(path, `${JSON.stringify(all)}\n`);
+		this.notify(row.id);
+		return report;
+	}
+	/** A stored turn report. */
+	async turnReport(sessionId, turn) {
+		return (await readJson(this.turnsPath(sessionId)))?.[String(turn)] ?? null;
+	}
+	/** Every project as a switcher card (manifest summary, live version, last screenshot), most recent first. */
+	async projectCards() {
+		const cards = [];
+		for (const row of await this.listProjects()) {
+			const manifest = await this.manifestOf(row.root);
+			const current = await readJson(join(row.root, STATE_DIR, "current.json"));
+			const elementFiles = await walk(join(row.root, "elements"), (p) => p.endsWith(".json"));
+			const { elements } = validateElements(Object.fromEntries(elementFiles.map((f) => [`elements/${f.path}`, f.data.toString("utf8")])), [], kitOf(manifest?.runtime));
+			const thumb = await readFile(join(row.root, STATE_DIR, "last-check.webp")).catch(() => void 0);
+			cards.push({
+				id: row.id,
+				title: manifest?.title ?? row.title,
+				root: row.root,
+				updatedAt: row.updatedAt,
+				pitch: manifest?.pitch ?? "",
+				artStyle: manifest?.artStyle ?? "",
+				version: current?.version ?? null,
+				elements: elements.length,
+				...thumb === void 0 || thumb.length > 4e5 ? {} : { thumb: thumb.toString("base64") }
+			});
+		}
+		return cards;
+	}
+	/** The project a session is bound to, if any. */
+	async boundProject(sessionId) {
+		const registry = await this.readRegistry();
+		const id = registry.bindings[sessionId];
+		return id === void 0 ? void 0 : registry.projects.find((p) => p.id === id);
+	}
+	/** Bind a session to a project (or unbind with null). */
+	async bind(sessionId, projectId) {
+		return this.updateRegistry((registry) => {
+			if (projectId === null) {
+				delete registry.bindings[sessionId];
+				return { ok: true };
+			}
+			if (!registry.projects.some((p) => p.id === projectId)) return {
+				ok: false,
+				error: "not-found"
+			};
+			registry.bindings[sessionId] = projectId;
+			return { ok: true };
+		});
+	}
+	async touch(projectId) {
+		await this.updateRegistry((registry) => {
+			const row = registry.projects.find((p) => p.id === projectId);
+			if (row !== void 0) Object.assign(row, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+		}).catch(() => {});
+		this.notify(projectId);
+	}
+	/**
+	* Register an existing folder that holds a `game.json` (a project copied
+	* in, or one whose registry row was lost).
+	*/
+	async adopt(root) {
+		const manifestText = await readText(join(root, MANIFEST_FILE));
+		if (manifestText === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const parsed = parseManifest(manifestText);
+		if (!parsed.ok) return {
+			ok: false,
+			error: "invalid"
+		};
+		return this.updateRegistry((registry) => {
+			const existing = registry.projects.find((p) => p.root === root || p.id === parsed.manifest.id);
+			if (existing !== void 0) return {
+				ok: true,
+				project: existing
+			};
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const row = {
+				id: parsed.manifest.id,
+				title: parsed.manifest.title,
+				root,
+				createdAt: parsed.manifest.createdAt || now,
+				updatedAt: now
+			};
+			registry.projects.push(row);
+			return {
+				ok: true,
+				project: row
+			};
+		});
+	}
+	/**
+	* Delete a project from the panel. `trash` takes it out of the plugin
+	* (registry row and every session binding) AND moves its folder to the
+	* system trash — complete, yet recoverable; `forget` only takes it out of
+	* the plugin and leaves the folder (re-adopt with `game_open path`).
+	*
+	* Guards, checked before anything changes: the folder must still hold the
+	* project's own `game.json` (never trash an arbitrary directory a registry
+	* row happens to point at), must not be the calling session's workspace
+	* itself, and a read-only session may do neither. A failed move changes
+	* nothing, so the panel can offer `forget` instead.
+	*/
+	async deleteProject(projectId, mode, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		let trashedTo;
+		if (mode === "trash") {
+			const manifest = await this.manifestOf(row.root);
+			const cwd = session?.header?.cwd;
+			if (manifest === void 0 || manifest.id !== projectId) return {
+				ok: false,
+				error: "not-a-project"
+			};
+			if (cwd !== void 0 && resolve(cwd) === resolve(row.root)) return {
+				ok: false,
+				error: "is-workspace"
+			};
+			try {
+				trashedTo = await this.trash(row.root);
+			} catch (error) {
+				return {
+					ok: false,
+					error: "trash-failed",
+					reason: error.message.split("\n")[0] ?? ""
+				};
+			}
+		}
+		await this.updateRegistry((registry) => {
+			registry.projects = registry.projects.filter((p) => p.id !== projectId);
+			for (const [sid, bound] of Object.entries(registry.bindings)) if (bound === projectId) delete registry.bindings[sid];
+		});
+		this.notify(projectId);
+		return {
+			ok: true,
+			...trashedTo === void 0 ? {} : { trashedTo }
+		};
+	}
+	/**
+	* Create a project in the session's workspace behind the light gate, and
+	* bind the session to it.
+	* @param request - the gate's inputs.
+	* @param session - the calling session (its workspace and fence).
+	* @returns the new row, the gate's missing items, or a failure.
+	*/
+	async create(request, session) {
+		const verdict = gate(request);
+		if (!verdict.ok) return {
+			ok: false,
+			missing: verdict.missing
+		};
+		const cwd = session.header?.cwd;
+		if (cwd === void 0 || cwd === "") return {
+			ok: false,
+			error: "这个会话没有工作区，项目没处放。请用户先给会话选一个工作区。"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "这个会话是只读模式，不能新建项目。"
+		};
+		const registry = await this.readRegistry();
+		const base = slugOf(verdict.manifest.title);
+		let folder = base;
+		for (let n = 2; registry.projects.some((p) => p.root === join(cwd, folder)) || await stat(join(cwd, folder)).then(() => true, () => false); n++) folder = `${base}-${n}`;
+		const root = join(cwd, folder);
+		const id = `g_${randomBytes(4).toString("hex")}`;
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const manifest = {
+			...verdict.manifest,
+			id,
+			createdAt: now
+		};
+		try {
+			await this.writeFenced(join(root, MANIFEST_FILE), serializeManifest(manifest), session);
+		} catch (error) {
+			return {
+				ok: false,
+				error: `写不进工作区：${error.message.split("\n")[0]}`
+			};
+		}
+		const row = {
+			id,
+			title: manifest.title,
+			root,
+			createdAt: now,
+			updatedAt: now
+		};
+		await this.updateRegistry((r) => {
+			r.projects.push(row);
+			r.bindings[session.id] = id;
+		});
+		this.notify(id);
+		return {
+			ok: true,
+			project: row
+		};
+	}
+	async row(projectId) {
+		return (await this.readRegistry()).projects.find((p) => p.id === projectId);
+	}
+	/**
+	* Everything the panel and `game_read` show about one project.
+	* @param projectId - registry id.
+	* @returns the view, or undefined for an unknown id.
+	*/
+	async view(projectId) {
+		const row = await this.row(projectId);
+		if (row === void 0) return void 0;
+		const manifestText = await readText(join(row.root, MANIFEST_FILE));
+		const parsed = manifestText === void 0 ? void 0 : parseManifest(manifestText);
+		const manifest = parsed?.ok === true ? parsed.manifest : null;
+		const elementFiles = await walk(join(row.root, "elements"), (p) => p.endsWith(".json"));
+		const { elements, failures } = validateElements(Object.fromEntries(elementFiles.map((f) => [`elements/${f.path}`, f.data.toString("utf8")])), manifest?.elementTypes ?? [], kitOf(manifest?.runtime));
+		const playtest = await this.playtestText(row.root);
+		const chapters = [];
+		for (const spec of CHAPTERS) {
+			const text = spec.id === "elements" ? elementsChapter(elements, manifest?.elementTypes ?? []) : spec.id === "lore" ? loreChapter(elements, manifest?.elementTypes ?? []) : spec.id === "playtest" ? playtest : spec.id === "pillars" ? pillarNotes(await readText(join(row.root, spec.file)) ?? "", manifest) : await readText(join(row.root, spec.file)) ?? "";
+			const source = spec.id === "playtest" ? join(row.root, STATE_DIR, "playtest-log.jsonl") : spec.id === "elements" || spec.id === "lore" ? join(row.root, "elements") : join(row.root, spec.file);
+			const mtime = await stat(source).then((info) => info.mtimeMs, () => 0);
+			chapters.push({
+				id: spec.id,
+				title: spec.title,
+				file: spec.file,
+				text,
+				generated: spec.generated === true,
+				mtime,
+				status: spec.generated === true ? text === "" ? "todo" : "draft" : chapterStatus(text)
+			});
+		}
+		const state = join(row.root, STATE_DIR);
+		const user = await this.userLayer(row.root);
+		const params = manifest?.params ?? [];
+		const paramOverrides = Object.fromEntries(Object.entries(user.params).filter(([key, value]) => {
+			const param = params.find((p) => p.key === key);
+			return param !== void 0 && param.value !== value;
+		}));
+		return {
+			id: row.id,
+			title: manifest?.title ?? row.title,
+			root: row.root,
+			manifest,
+			...manifestText === void 0 ? { manifestError: `${MANIFEST_FILE} 不见了` } : parsed?.ok === false ? { manifestError: parsed.error } : {},
+			chapters,
+			elements,
+			elementErrors: failures,
+			current: await readJson(join(state, "current.json")) ?? null,
+			candidate: await readJson(join(state, "candidate.json")) ?? null,
+			lastCheck: await readJson(join(state, "checks.json")) ?? null,
+			hasEntry: await stat(join(row.root, "index.html")).then(() => true, () => false),
+			paramOverrides,
+			pending: user.pending,
+			uncommitted: user.edits,
+			proposals: await this.proposals(row.root),
+			versions: await this.versionRows(row.root),
+			log: await this.logEntries(row.root),
+			...user.restyleTo === void 0 ? {} : { restyleTo: user.restyleTo },
+			candidateDiff: await this.candidateDiff(row.root)
+		};
+	}
+	/** Elements the waiting candidate changed or added against the live version (null without both). */
+	async candidateDiff(root) {
+		const current = await readJson(join(root, STATE_DIR, "current.json"));
+		const candidate = await readJson(join(root, STATE_DIR, "candidate.json"));
+		if (current === void 0 || candidate === void 0) return null;
+		const before = await this.elementIndex(join(root, STATE_DIR, "versions", String(current.version)));
+		const after = await this.elementIndex(join(root, STATE_DIR, "versions", String(candidate.version)));
+		const changed = [], added = [];
+		for (const [id, e] of after) {
+			const was = before.get(id);
+			if (was === void 0) added.push(id);
+			else if (was.json !== e.json) changed.push(id);
+		}
+		return {
+			changed,
+			added
+		};
+	}
+	/** The tab's state for one session. */
+	async sessionState(sessionId) {
+		const bound = await this.boundProject(sessionId);
+		return {
+			bound: bound === void 0 ? null : await this.view(bound.id) ?? null,
+			projects: await this.listProjects()
+		};
+	}
+	/**
+	* One build file as it is in the working folder now (a model the user just
+	* exported, say), for a panel preview ahead of any version. Build files only,
+	* inside the project, 8 MB at most.
+	*/
+	async workingFile(projectId, path) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const rel = path.replace(/^\.\//, "");
+		const full = resolve(row.root, rel);
+		if (!isBuildFile(rel) || !inside(row.root, full)) return {
+			ok: false,
+			error: "invalid"
+		};
+		const info = await stat(full).catch(() => void 0);
+		if (info === void 0 || !info.isFile() || info.size > 8388608) return {
+			ok: false,
+			error: "not-found"
+		};
+		return {
+			ok: true,
+			file: bundleOf([{
+				path: rel,
+				data: await readFile(full)
+			}])[rel]
+		};
+	}
+	/** The files of a deployed (or candidate) version, for the play area. */
+	async bundle(projectId, which = "current") {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const record = await readJson(join(row.root, STATE_DIR, `${which}.json`));
+		if (record === void 0) return {
+			ok: false,
+			error: "no-version"
+		};
+		const files = await walk(join(row.root, STATE_DIR, "versions", String(record.version)), () => true);
+		if (files.length === 0) return {
+			ok: false,
+			error: "no-version"
+		};
+		return {
+			ok: true,
+			bundle: {
+				projectId,
+				version: record.version,
+				files: withKitRuntime(bundleOf(files), this.snapshotKit(files))
+			}
+		};
+	}
+	/** One specific version's files. */
+	async versionBundle(projectId, version) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const files = await walk(join(row.root, STATE_DIR, "versions", String(Math.floor(version))), () => true);
+		if (files.length === 0) return {
+			ok: false,
+			error: "no-version"
+		};
+		return {
+			ok: true,
+			bundle: {
+				projectId,
+				version,
+				files: withKitRuntime(bundleOf(files), this.snapshotKit(files))
+			}
+		};
+	}
+	/** The kit a snapshot was built for: its own `game.json`'s runtime. */
+	snapshotKit(files) {
+		const manifest = files.find((f) => f.path === MANIFEST_FILE);
+		const parsed = manifest === void 0 ? void 0 : parseManifest(manifest.data.toString("utf8"));
+		return kitOf(parsed?.ok === true ? parsed.manifest.runtime : void 0);
+	}
+	/** The kit a project runs on now (its working `game.json`). */
+	async kitFor(root) {
+		return kitOf((await this.manifestOf(root))?.runtime);
+	}
+	/** The build and test files as they are on disk now, plus their fingerprint. */
+	async snapshot(root) {
+		const build = await walk(root, isBuildFile);
+		const tests = await walk(join(root, "tests"), (p) => p.endsWith(".test.js"));
+		return {
+			build,
+			tests,
+			fingerprint: fingerprintOf([...build, ...tests.map((t) => ({
+				path: `tests/${t.path}`,
+				data: t.data
+			}))])
+		};
+	}
+	/**
+	* The end-of-turn evaluation for a bound session: skip when nothing
+	* playable changed since the last check, else run the checks, persist the
+	* record, and on a pass deploy (auto-confirm) or leave a candidate.
+	* @param session - the session whose turn is closing.
+	* @param attempt - which automatic fix round this is (0 = the turn's own work).
+	* @param cap - the fix-round cap (a failure at the cap is recorded as given up).
+	* @returns what the hook should do.
+	*/
+	async checkTurn(session, attempt, cap, by = "turn") {
+		const row = await this.boundProject(session.id);
+		if (row === void 0) return { kind: "skip" };
+		return this.checkRow(row, session, attempt, cap, by);
+	}
+	/**
+	* 提交为新版本: the user commits the panel edits sitting in the working
+	* files. Runs the same checks as the end of a turn (no fix cap — nothing
+	* is steered); a pass cuts the version, whose note lists the edits.
+	*/
+	async commit(projectId, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const outcome = await this.checkRow(row, session, 0, Number.POSITIVE_INFINITY, "user");
+		this.notify(projectId);
+		if (outcome.kind === "fail") return {
+			ok: true,
+			kind: "failed",
+			failures: outcome.record.failures.slice(0, 8).map((f) => ({
+				where: f.where,
+				message: f.message.slice(0, 300)
+			}))
+		};
+		if (outcome.kind === "pass") {
+			if (outcome.deployed !== null) return {
+				ok: true,
+				kind: "deployed",
+				version: outcome.deployed.version
+			};
+			if (outcome.candidate !== null) return {
+				ok: true,
+				kind: "candidate",
+				version: outcome.candidate.version
+			};
+			return {
+				ok: false,
+				error: "denied"
+			};
+		}
+		if (!await stat(join(row.root, "index.html")).then(() => true, () => false)) return {
+			ok: true,
+			kind: "no-entry"
+		};
+		const last = await readJson(join(row.root, STATE_DIR, "checks.json"));
+		if (last !== void 0 && !last.ok) return {
+			ok: true,
+			kind: "failed",
+			failures: last.failures.slice(0, 8).map((f) => ({
+				where: f.where,
+				message: f.message.slice(0, 300)
+			}))
+		};
+		const user = await this.userLayer(row.root);
+		user.edits = [];
+		await this.saveUserLayer(row.root, user);
+		return {
+			ok: true,
+			kind: "unchanged"
+		};
+	}
+	async checkRow(row, session, attempt, cap, by) {
+		const root = row.root;
+		if (!await stat(join(root, "index.html")).then(() => true, () => false)) return { kind: "skip" };
+		const { build, tests, fingerprint } = await this.snapshot(root);
+		const last = await readJson(join(root, STATE_DIR, "checks.json"));
+		if (last?.fingerprint === fingerprint && (last.ok || last.gaveUp === true)) return { kind: "skip" };
+		const failures = [];
+		const manifestText = await readText(join(root, MANIFEST_FILE));
+		const parsed = manifestText === void 0 ? void 0 : parseManifest(manifestText);
+		if (parsed === void 0) failures.push({
+			where: "data",
+			message: `${MANIFEST_FILE} 不见了`
+		});
+		else if (!parsed.ok) failures.push({
+			where: "data",
+			message: parsed.error
+		});
+		const kit = kitOf(parsed?.ok === true ? parsed.manifest.runtime : void 0);
+		const elementFiles = build.filter((f) => f.path.startsWith("elements/") && f.path.endsWith(".json"));
+		const validated = validateElements(Object.fromEntries(elementFiles.map((f) => [f.path, f.data.toString("utf8")])), parsed?.ok === true ? parsed.manifest.elementTypes : [], kit);
+		failures.push(...validated.failures);
+		const shipped = new Set(build.map((f) => f.path));
+		for (const e of validated.elements) if (e.look3d?.kind === "gltf" && !shipped.has(e.look3d.src)) failures.push({
+			where: e.file,
+			message: `「${e.name}」的外观引用了 ${e.look3d.src}，项目里没有这个文件（放进 assets/ 再引用）`
+		});
+		const browser = await this.checker.run(withKitRuntime(bundleOf(build), kit), Object.fromEntries(tests.map((t) => [`tests/${t.path}`, t.data.toString("utf8")])), { blankProbe: kit.blankProbe });
+		failures.push(...browser.failures);
+		const ok = failures.length === 0;
+		const record = {
+			fingerprint,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			ok,
+			failures,
+			passed: browser.passed,
+			attempt,
+			...browser.skipped === void 0 ? {} : { skipped: browser.skipped },
+			...!ok && attempt >= cap ? { gaveUp: true } : {}
+		};
+		const writable = this.writable(session);
+		if (writable) {
+			await writeAtomic(join(root, STATE_DIR, "checks.json"), `${JSON.stringify(record, null, 2)}\n`);
+			if (browser.screenshot !== void 0) await writeAtomic(join(root, STATE_DIR, "last-check.webp"), Buffer.from(browser.screenshot, "base64"));
+		}
+		if (!ok) {
+			if (record.gaveUp === true) await this.log(root, writable, `检查仍未通过，已停止自动修复（${failures.length} 项）：${failures.slice(0, 2).map((f) => f.where).join("、")}`);
+			await this.touch(row.id);
+			return {
+				kind: "fail",
+				record
+			};
+		}
+		if (!writable) return {
+			kind: "pass",
+			record,
+			deployed: null,
+			candidate: null
+		};
+		const version = await this.nextVersion(root);
+		await this.copyVersion(root, build, version);
+		if (browser.screenshot !== void 0) await writeAtomic(join(root, STATE_DIR, "shots", `${version}.webp`), Buffer.from(browser.screenshot, "base64"));
+		const user = await this.userLayer(root);
+		const restyle = user.restyleTo;
+		const edits = user.edits.map((e) => e.text);
+		const versionRecord = {
+			version,
+			at: record.at,
+			fingerprint,
+			by,
+			note: restyle !== void 0 ? `换成「${artStyleLabel(restyle)}」风格` : edits.length > 0 ? `面板修改：${edits.join("、")}` : browser.passed > 0 ? `通过检查（${browser.passed} 个用例）` : "通过检查"
+		};
+		await this.appendVersion(root, {
+			...versionRecord,
+			passed: browser.passed
+		});
+		const autoConfirm = (parsed?.ok === true ? parsed.manifest.autoConfirm : true) && restyle === void 0;
+		if (restyle !== void 0 || edits.length > 0) {
+			delete user.restyleTo;
+			user.edits = [];
+			await this.saveUserLayer(root, user);
+		}
+		if (autoConfirm) {
+			await writeAtomic(join(root, STATE_DIR, "current.json"), `${JSON.stringify(versionRecord, null, 2)}\n`);
+			await rm(join(root, STATE_DIR, "candidate.json"), { force: true });
+			await this.log(root, true, `v${version} 通过检查${browser.passed > 0 ? `（${browser.passed} 个用例）` : ""}，已进试玩区`);
+		} else {
+			await writeAtomic(join(root, STATE_DIR, "candidate.json"), `${JSON.stringify(versionRecord, null, 2)}\n`);
+			await this.log(root, true, `v${version} 通过检查，等用户确认${restyle === void 0 ? "" : `（换风格：${artStyleLabel(restyle)}）`}`);
+		}
+		await this.prune(root);
+		await this.touch(row.id);
+		return {
+			kind: "pass",
+			record,
+			deployed: autoConfirm ? versionRecord : null,
+			candidate: autoConfirm ? null : versionRecord
+		};
+	}
+	async nextVersion(root) {
+		const numbers = (await readdir(join(root, STATE_DIR, "versions")).catch(() => [])).map(Number).filter((n) => Number.isInteger(n) && n > 0);
+		return (numbers.length === 0 ? 0 : Math.max(...numbers)) + 1;
+	}
+	async copyVersion(root, build, version) {
+		const dir = join(root, STATE_DIR, "versions", String(version));
+		for (const f of build) {
+			const target = resolve(dir, f.path);
+			if (!inside(dir, target)) continue;
+			await mkdir(dirname(target), { recursive: true });
+			await writeFile(target, f.data);
+		}
+	}
+	/** Keep the newest versions plus whatever current/candidate point at. */
+	async prune(root) {
+		const versionsDir = join(root, STATE_DIR, "versions");
+		const names = (await readdir(versionsDir).catch(() => [])).map(Number).filter((n) => Number.isInteger(n) && n > 0).sort((a, b) => b - a);
+		const pinned = /* @__PURE__ */ new Set();
+		for (const which of ["current", "candidate"]) {
+			const r = await readJson(join(root, STATE_DIR, `${which}.json`));
+			if (r !== void 0) pinned.add(r.version);
+		}
+		for (const n of names.slice(KEEP_VERSIONS)) {
+			if (pinned.has(n)) continue;
+			await rm(join(versionsDir, String(n)), {
+				recursive: true,
+				force: true
+			});
+			await rm(join(root, STATE_DIR, "shots", `${n}.webp`), { force: true });
+		}
+	}
+	/** Promote the candidate to current (the user's 确认 when auto-confirm is off). */
+	async confirm(projectId, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const candidate = await readJson(join(row.root, STATE_DIR, "candidate.json"));
+		if (candidate === void 0) return {
+			ok: false,
+			error: "no-version"
+		};
+		await writeAtomic(join(row.root, STATE_DIR, "current.json"), `${JSON.stringify(candidate, null, 2)}\n`);
+		await rm(join(row.root, STATE_DIR, "candidate.json"), { force: true });
+		await this.log(row.root, true, `用户确认 v${candidate.version}，已进试玩区`);
+		await this.touch(projectId);
+		return {
+			ok: true,
+			version: candidate.version
+		};
+	}
+	/**
+	* Turn auto-confirm on or off in `game.json` (the panel's switch). The
+	* manifest is the project's own file, so this goes through node behind the
+	* same writable check.
+	*/
+	async setAutoConfirm(projectId, on, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const text = await readText(join(row.root, MANIFEST_FILE));
+		const parsed = text === void 0 ? void 0 : parseManifest(text);
+		if (parsed === void 0 || !parsed.ok) return {
+			ok: false,
+			error: "invalid"
+		};
+		await writeAtomic(join(row.root, MANIFEST_FILE), serializeManifest({
+			...parsed.manifest,
+			autoConfirm: on
+		}));
+		await this.touch(projectId);
+		return { ok: true };
+	}
+	/** Throw the candidate away (the user's 退回); the model hears about it on the next send. */
+	async reject(projectId, reason, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const candidate = await readJson(join(row.root, STATE_DIR, "candidate.json"));
+		if (candidate === void 0) return {
+			ok: false,
+			error: "no-version"
+		};
+		await rm(join(row.root, STATE_DIR, "candidate.json"), { force: true });
+		await this.updateVersions(row.root, (list) => list.map((v) => v.version === candidate.version ? {
+			...v,
+			rejected: true
+		} : v));
+		const why = reason.trim().slice(0, 200);
+		await this.log(row.root, true, `用户退回 v${candidate.version}${why === "" ? "" : `：${why}`}`);
+		await this.addPending(row.root, {
+			key: `reject:${candidate.version}`,
+			text: `退回了候选 v${candidate.version}${why === "" ? "" : `（${why}）`}，试玩区仍是上一版`
+		});
+		await this.touch(projectId);
+		return { ok: true };
+	}
+	/** Put an older version back into the play area. */
+	async rollback(projectId, version, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const entry = (await this.readVersions(row.root)).find((v) => v.version === version);
+		const exists = await stat(join(row.root, STATE_DIR, "versions", String(version))).then(() => true, () => false);
+		if (entry === void 0 || !exists) return {
+			ok: false,
+			error: "no-version"
+		};
+		const { passed: _passed, rejected: _rejected, ...record } = entry;
+		await writeAtomic(join(row.root, STATE_DIR, "current.json"), `${JSON.stringify(record, null, 2)}\n`);
+		await this.log(row.root, true, `试玩区切回 v${version}`);
+		await this.addPending(row.root, {
+			key: "rollback",
+			text: `把试玩区切回了 v${version}（工作目录里的代码没动）`
+		});
+		await this.touch(projectId);
+		return { ok: true };
+	}
+	/** Files that differ between two versions' snapshots. */
+	async diff(projectId, from, to) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const hashes = async (version) => {
+			const dir = join(row.root, STATE_DIR, "versions", String(version));
+			if (!await stat(dir).then(() => true, () => false)) return void 0;
+			return new Map((await walk(dir, () => true)).map((f) => [f.path, createHash("sha1").update(f.data).digest("hex")]));
+		};
+		const a = await hashes(from), b = await hashes(to);
+		if (a === void 0 || b === void 0) return {
+			ok: false,
+			error: "no-version"
+		};
+		return {
+			ok: true,
+			diff: {
+				added: [...b.keys()].filter((k) => !a.has(k)),
+				removed: [...a.keys()].filter((k) => !b.has(k)),
+				changed: [...b.keys()].filter((k) => a.has(k) && a.get(k) !== b.get(k))
+			}
+		};
+	}
+	async userLayer(root) {
+		const raw = await readJson(join(root, STATE_DIR, "user.json"));
+		return {
+			params: raw?.params !== null && typeof raw?.params === "object" ? { ...raw.params } : {},
+			pending: Array.isArray(raw?.pending) ? raw.pending.filter((p) => typeof p?.key === "string" && typeof p.text === "string" && !p.key.startsWith("param:")) : [],
+			edits: Array.isArray(raw?.edits) ? raw.edits.filter((p) => typeof p?.key === "string" && typeof p.text === "string") : [],
+			...typeof raw?.restyleTo === "string" ? { restyleTo: raw.restyleTo } : {}
+		};
+	}
+	async saveUserLayer(root, user) {
+		await writeAtomic(join(root, STATE_DIR, "user.json"), `${JSON.stringify(user, null, 2)}\n`);
+	}
+	/** Add (or replace by key) one pending change; `text: ''` removes it. */
+	async addPending(root, change) {
+		const user = await this.userLayer(root);
+		user.pending = user.pending.filter((p) => p.key !== change.key);
+		if (change.text !== "") user.pending.push(change);
+		await this.saveUserLayer(root, user);
+	}
+	/** Sessions whose agent turn is running now (the turn hooks keep it). */
+	activeTurns = /* @__PURE__ */ new Set();
+	/** The turn hooks report a bound session's turn starting and ending. */
+	setTurnActive(sessionId, active) {
+		if (active) this.activeTurns.add(sessionId);
+		else this.activeTurns.delete(sessionId);
+	}
+	/**
+	* What the working files hold that the play area does not: build files
+	* added, changed or removed against the waiting candidate (else the live
+	* version), whoever wrote them — the panel, the agent, a CLI member, the
+	* user's own editor. Modification times pick the suspects; only those are
+	* compared byte for byte, so an unchanged project costs a stat walk.
+	*/
+	async changes(projectId) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const root = row.root;
+		const state = join(root, STATE_DIR);
+		const base = await readJson(join(state, "candidate.json")) ?? await readJson(join(state, "current.json"));
+		const hasEntry = await stat(join(root, "index.html")).then(() => true, () => false);
+		const working = await statWalk(root, isBuildFile);
+		const files = [];
+		let lastMs = 0;
+		if (base === void 0) for (const f of working) {
+			files.push({
+				path: f.path,
+				kind: "added"
+			});
+			lastMs = Math.max(lastMs, f.mtimeMs);
+		}
+		else {
+			const snapshot = join(state, "versions", String(base.version));
+			const since = Date.parse(base.at) - 6e4;
+			for (const f of working) {
+				if (f.mtimeMs < since) continue;
+				const before = await readFile(join(snapshot, f.path)).catch(() => void 0);
+				if (before === void 0) files.push({
+					path: f.path,
+					kind: "added"
+				});
+				else if (!before.equals(await readFile(join(root, f.path)).catch(() => Buffer.alloc(0)))) files.push({
+					path: f.path,
+					kind: "changed"
+				});
+				else continue;
+				lastMs = Math.max(lastMs, f.mtimeMs);
+			}
+			const present = new Set(working.map((f) => f.path));
+			for (const f of await statWalk(snapshot, () => true)) if (!present.has(f.path)) files.push({
+				path: f.path,
+				kind: "removed"
+			});
+		}
+		const user = await this.userLayer(root);
+		const registry = await this.readRegistry();
+		const turn = Object.entries(registry.bindings).some(([sid, pid]) => pid === projectId && this.activeTurns.has(sid));
+		const lastAt = lastMs > 0 ? new Date(lastMs).toISOString() : null;
+		const busy = turn ? "turn" : lastMs > 0 && Date.now() - lastMs < BUSY_QUIET_MS ? "recent" : null;
+		const last = await readJson(join(state, "checks.json"));
+		const failed = files.length > 0 && last !== void 0 && !last.ok && Date.parse(last.at) >= lastMs ? last.failures.slice(0, 8).map((f) => ({
+			where: f.where,
+			message: f.message.slice(0, 300)
+		})) : null;
+		return {
+			ok: true,
+			against: base?.version ?? null,
+			hasEntry,
+			count: files.length,
+			files: files.slice(0, 30),
+			lastAt,
+			busy,
+			edits: user.edits,
+			failed
+		};
+	}
+	/** Add (or replace by key) one uncommitted panel edit. */
+	async addEdit(root, change) {
+		const user = await this.userLayer(root);
+		user.edits = [...user.edits.filter((p) => p.key !== change.key), change];
+		await this.saveUserLayer(root, user);
+	}
+	/** The agent has read the pending list (`game_read`): it is no longer news. */
+	async clearPending(projectId) {
+		const row = await this.row(projectId);
+		if (row === void 0) return;
+		const user = await this.userLayer(row.root);
+		if (user.pending.length === 0) return;
+		user.pending = [];
+		await this.saveUserLayer(row.root, user);
+	}
+	/** Drop one pending change by key (the dock's ×). */
+	async dropPending(projectId, key, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		await this.addPending(row.root, {
+			key,
+			text: ""
+		});
+		this.notify(projectId);
+		return { ok: true };
+	}
+	/**
+	* The user sent a message carrying the panel's change list (it starts
+	* with {@link PANEL_CHANGES_MARK}): drop exactly the changes it lists.
+	* Changes made after the list was written stay pending.
+	* @param sessionId - the sending session.
+	* @param text - the user message's text.
+	* @returns how many changes were cleared.
+	*/
+	async clearSent(sessionId, text) {
+		if (!text.includes("【面板改动】")) return 0;
+		const row = await this.boundProject(sessionId);
+		if (row === void 0) return 0;
+		const user = await this.userLayer(row.root);
+		const kept = user.pending.filter((p) => !text.includes(p.text));
+		const cleared = user.pending.length - kept.length;
+		if (cleared === 0) return 0;
+		user.pending = kept;
+		await this.saveUserLayer(row.root, user);
+		this.notify(row.id);
+		return cleared;
+	}
+	/** The manifest of a project, or undefined. */
+	async manifestOf(root) {
+		const text = await readText(join(root, MANIFEST_FILE));
+		const parsed = text === void 0 ? void 0 : parseManifest(text);
+		return parsed?.ok === true ? parsed.manifest : void 0;
+	}
+	/** Set one slider value (user layer; the play frame gets it live from the panel). */
+	async setParam(projectId, key, value, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const param = (await this.manifestOf(row.root))?.params.find((p) => p.key === key);
+		if (param === void 0 || !Number.isFinite(value)) return {
+			ok: false,
+			error: "invalid"
+		};
+		const clamped = Math.min(param.max, Math.max(param.min, value));
+		const user = await this.userLayer(row.root);
+		if (clamped === param.value) delete user.params[key];
+		else user.params[key] = clamped;
+		await this.saveUserLayer(row.root, user);
+		this.notify(projectId);
+		return { ok: true };
+	}
+	/** 定稿: write the slider values into game.json as the new defaults. */
+	async finalizeParams(projectId, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const manifest = await this.manifestOf(row.root);
+		if (manifest === void 0) return {
+			ok: false,
+			error: "invalid"
+		};
+		const user = await this.userLayer(row.root);
+		const changed = manifest.params.filter((p) => user.params[p.key] !== void 0 && user.params[p.key] !== p.value);
+		if (changed.length === 0) return { ok: true };
+		const params = manifest.params.map((p) => user.params[p.key] === void 0 ? p : {
+			...p,
+			value: user.params[p.key]
+		});
+		await writeAtomic(join(row.root, MANIFEST_FILE), serializeManifest({
+			...manifest,
+			params
+		}));
+		const summary = changed.map((p) => `${p.label} ${num(p.value)}→${num(user.params[p.key])}`).join("、");
+		user.params = {};
+		user.pending = user.pending.filter((p) => !p.key.startsWith("param:"));
+		user.pending.push({
+			key: "params-final",
+			text: `定稿参数：${summary}（已写进 game.json）`
+		});
+		user.edits = [...user.edits.filter((e) => e.key !== "params"), {
+			key: "params",
+			text: `参数定稿 ${summary}`
+		}];
+		await this.saveUserLayer(row.root, user);
+		await this.log(row.root, true, `定稿参数：${summary}`);
+		await this.touch(projectId);
+		return { ok: true };
+	}
+	/** 还原: drop every slider override. */
+	async resetParams(projectId, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const user = await this.userLayer(row.root);
+		user.params = {};
+		user.pending = user.pending.filter((p) => !p.key.startsWith("param:"));
+		await this.saveUserLayer(row.root, user);
+		this.notify(projectId);
+		return { ok: true };
+	}
+	/**
+	* Edit one element in the working files — its look, or scalar fields
+	* (`lore`, the 设定 text, included). The play area keeps its version until
+	* the user commits (`commit`); the edit is listed as uncommitted, and as
+	* pending for the agent.
+	*/
+	async editElement(projectId, elementId, patch, session, note) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const files = await walk(join(row.root, "elements"), (p) => p.endsWith(".json"));
+		const changes = {};
+		if (patch.look !== void 0) {
+			const look = (await this.kitFor(row.root)).normalizeLook(patch.look);
+			if (look === null) return {
+				ok: false,
+				error: "invalid"
+			};
+			changes.look = look;
+		}
+		for (const [key, value] of Object.entries(patch.fields ?? {})) {
+			if (key === "id" || key === "look" || key.length > 40) continue;
+			changes[key] = value === null ? void 0 : key === "lore" && typeof value === "string" ? value.slice(0, LORE_MAX) : value;
+		}
+		for (const f of files) {
+			const next = patchElementText(f.data.toString("utf8"), elementId, changes);
+			if (next === void 0) continue;
+			await writeAtomic(join(row.root, "elements", f.path), next);
+			const parsed = JSON.parse(next);
+			const element = (Array.isArray(parsed) ? parsed : [parsed]).find((e) => e.id === elementId);
+			const name = typeof element.name === "string" ? element.name : elementId;
+			if (changes.look !== void 0) {
+				await this.addPending(row.root, {
+					key: `look:${elementId}`,
+					text: note ?? `改了「${name}」的外观（elements 文件里的 look 已更新）`
+				});
+				await this.addEdit(row.root, {
+					key: `look:${elementId}`,
+					text: `${name}的外观`
+				});
+			}
+			if ("lore" in changes) {
+				await this.addPending(row.root, {
+					key: `lore:${elementId}`,
+					text: `改了「${name}」的设定（elements 文件里的 lore），按新设定调整它的行为和文案`
+				});
+				await this.addEdit(row.root, {
+					key: `lore:${elementId}`,
+					text: `${name}的设定`
+				});
+			}
+			const fieldKeys = Object.keys(changes).filter((k) => k !== "look" && k !== "lore");
+			if (fieldKeys.length > 0) {
+				await this.addPending(row.root, {
+					key: `fields:${elementId}`,
+					text: `改了「${name}」的字段：${fieldKeys.map((k) => `${k}=${changes[k] === void 0 ? "（删除）" : String(changes[k])}`).join("、")}`
+				});
+				await this.addEdit(row.root, {
+					key: `fields:${elementId}`,
+					text: `${name}的${fieldKeys.join("、")}`
+				});
+			}
+			await this.log(row.root, true, note ?? `用户编辑了元素「${name}」`);
+			await this.touch(projectId);
+			return {
+				ok: true,
+				element
+			};
+		}
+		return {
+			ok: false,
+			error: "not-found"
+		};
+	}
+	/** Write one design chapter (the user's direct edit). */
+	async writeChapter(projectId, chapterId, text, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const spec = CHAPTERS.find((c) => c.id === chapterId);
+		if (spec === void 0 || spec.generated === true) return {
+			ok: false,
+			error: "invalid"
+		};
+		await writeAtomic(join(row.root, spec.file), text.endsWith("\n") ? text : `${text}\n`);
+		await this.addPending(row.root, {
+			key: `design:${chapterId}`,
+			text: `直接改了策划《${spec.title}》（${spec.file}），以文件为准`
+		});
+		await this.touch(projectId);
+		return { ok: true };
+	}
+	/** Edit the one-pager in game.json (pitch, element types, pillars) — the user's direct edit. */
+	async setOnePager(projectId, patch, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const manifest = await this.manifestOf(row.root);
+		if (manifest === void 0) return {
+			ok: false,
+			error: "invalid"
+		};
+		const pitch = patch.pitch === void 0 ? manifest.pitch : patch.pitch.trim().slice(0, 400);
+		const elementTypes = patch.elementTypes === void 0 ? manifest.elementTypes : listOf(patch.elementTypes).slice(0, 12);
+		const pillars = patch.pillars === void 0 ? manifest.pillars : listOf(patch.pillars.split(/\n/)).slice(0, 5);
+		if (pitch === "" || elementTypes.length === 0) return {
+			ok: false,
+			error: "invalid"
+		};
+		const parts = [];
+		if (pitch !== manifest.pitch) parts.push(`玩法「${pitch}」`);
+		if (elementTypes.join("、") !== manifest.elementTypes.join("、")) parts.push(`元素类型 ${elementTypes.join("、")}`);
+		if (pillars.join("；") !== manifest.pillars.join("；")) parts.push(`支柱 ${pillars.map((p, i) => `${i + 1}.${p}`).join(" ")}`);
+		if (parts.length === 0) return { ok: true };
+		await writeAtomic(join(row.root, MANIFEST_FILE), serializeManifest({
+			...manifest,
+			pitch,
+			elementTypes,
+			pillars
+		}));
+		await this.addPending(row.root, {
+			key: "onepager",
+			text: `改了一页纸（game.json）：${parts.join("；")}`
+		});
+		await this.log(row.root, true, `用户改了一页纸：${parts.join("；")}`);
+		await this.touch(projectId);
+		return { ok: true };
+	}
+	/** Ask for a restyle: the next passing version becomes a candidate. The panel puts the request into the composer. */
+	async requestRestyle(projectId, styleId, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		if (!this.writable(session)) return {
+			ok: false,
+			error: "denied"
+		};
+		const style = resolveArtStyle(styleId);
+		if (style === void 0) return {
+			ok: false,
+			error: "invalid"
+		};
+		const user = await this.userLayer(row.root);
+		user.restyleTo = style;
+		await this.saveUserLayer(row.root, user);
+		this.notify(projectId);
+		return { ok: true };
+	}
+	async proposals(root) {
+		const list = await readJson(join(root, STATE_DIR, "proposals.json"));
+		return Array.isArray(list) ? list.slice(-12).reverse() : [];
+	}
+	/**
+	* Store up to 3 appearance variants for an element (the `game_propose`
+	* tool); the user picks one in the panel.
+	*/
+	async proposeLooks(sessionId, elementId, request, variants) {
+		const row = await this.boundProject(sessionId);
+		if (row === void 0) return {
+			ok: false,
+			error: "本会话还没有游戏项目"
+		};
+		const element = (await this.view(row.id))?.elements.find((e) => e.id === elementId);
+		if (element === void 0) return {
+			ok: false,
+			error: `没有 id 为「${elementId}」的元素`
+		};
+		const clean = [];
+		const bad = [];
+		const kit = await this.kitFor(row.root);
+		variants.slice(0, 3).forEach((v, i) => {
+			const look = kit.normalizeLook(v.look);
+			if (look === null) bad.push(i + 1);
+			else clean.push({
+				label: (v.label ?? "").trim().slice(0, 20) || "ABC"[i],
+				note: (v.note ?? "").trim().slice(0, 120),
+				look
+			});
+		});
+		if (clean.length === 0) return {
+			ok: false,
+			error: `方案都不可用（第 ${bad.join("、")} 个）：${kit.lookHint}`
+		};
+		const all = await readJson(join(row.root, STATE_DIR, "proposals.json"));
+		const list = (Array.isArray(all) ? all : []).filter((p) => !(p.elementId === elementId && p.picked === void 0));
+		list.push({
+			elementId,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			request: request.trim().slice(0, 200),
+			variants: clean
+		});
+		await writeAtomic(join(row.root, STATE_DIR, "proposals.json"), `${JSON.stringify(list.slice(-20), null, 2)}\n`);
+		await this.touch(row.id);
+		return {
+			ok: true,
+			count: clean.length,
+			name: element.name
+		};
+	}
+	/** The user picks a variant: it replaces the element's look at once; the others stay in the history. */
+	async pickProposal(projectId, elementId, at, index, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const all = await readJson(join(row.root, STATE_DIR, "proposals.json"));
+		const list = Array.isArray(all) ? all : [];
+		const proposal = list.find((p) => p.elementId === elementId && p.at === at);
+		const variant = proposal?.variants[index];
+		if (proposal === void 0 || variant === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const edited = await this.editElement(projectId, elementId, { look: variant.look }, session, `外观方案：用户选了「${variant.label}」${variant.note === "" ? "" : `（${variant.note}）`}，已写进元素文件`);
+		if (!edited.ok) return edited;
+		await writeAtomic(join(row.root, STATE_DIR, "proposals.json"), `${JSON.stringify(list.map((p) => p === proposal ? {
+			...p,
+			picked: index
+		} : p), null, 2)}\n`);
+		this.notify(projectId);
+		return { ok: true };
+	}
+	async readVersions(root) {
+		const list = await readJson(join(root, STATE_DIR, "versions.json"));
+		return Array.isArray(list) ? list.filter((v) => typeof v?.version === "number") : [];
+	}
+	async updateVersions(root, change) {
+		await writeAtomic(join(root, STATE_DIR, "versions.json"), `${JSON.stringify(change(await this.readVersions(root)), null, 2)}\n`);
+	}
+	async appendVersion(root, entry) {
+		await this.updateVersions(root, (list) => [...list.filter((v) => v.version !== entry.version), entry].slice(-50));
+	}
+	/** The 版本 view's rows, newest first: only versions whose snapshot still exists. */
+	async versionRows(root) {
+		const current = await readJson(join(root, STATE_DIR, "current.json"));
+		const candidate = await readJson(join(root, STATE_DIR, "candidate.json"));
+		const kept = new Set((await readdir(join(root, STATE_DIR, "versions")).catch(() => [])).map(Number));
+		return (await this.readVersions(root)).filter((v) => kept.has(v.version)).reverse().map((v) => ({
+			version: v.version,
+			at: v.at,
+			fingerprint: v.fingerprint,
+			...v.by === void 0 ? {} : { by: v.by },
+			...v.note === void 0 ? {} : { note: v.note },
+			...v.passed === void 0 ? {} : { passed: v.passed },
+			status: v.version === current?.version ? "current" : v.version === candidate?.version ? "candidate" : v.rejected === true ? "rejected" : "past"
+		}));
+	}
+	/** The last check's screenshot (webp, base64), if any. */
+	async checkShot(projectId, version) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const data = (version === void 0 ? void 0 : await readFile(join(row.root, ".game", "shots", `${Math.floor(version)}.webp`)).catch(() => void 0)) ?? (version === void 0 ? await readFile(join(row.root, ".game", "last-check.webp")).catch(() => void 0) : void 0);
+		return data === void 0 ? {
+			ok: false,
+			error: "no-version"
+		} : {
+			ok: true,
+			webp: data.toString("base64")
+		};
+	}
+	/** Append one line to the project's playtest log (`.game/playtest-log.jsonl`). */
+	async log(root, writable, text) {
+		if (!writable) return;
+		const path = join(root, STATE_DIR, "playtest-log.jsonl");
+		await mkdir(dirname(path), { recursive: true });
+		await appendFile(path, `${JSON.stringify({
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			text
+		})}\n`).catch(() => {});
+	}
+	/** Record what the panel saw during one play session (errors, length). */
+	async logPlay(projectId, entry, session) {
+		const row = await this.row(projectId);
+		if (row === void 0) return {
+			ok: false,
+			error: "not-found"
+		};
+		const seconds = Math.max(0, Math.round(entry.seconds));
+		const errors = entry.errors.slice(0, 3).map((e) => String(e).slice(0, 160));
+		const text = errors.length === 0 ? `试玩 v${entry.version} ${seconds} 秒，无报错` : `试玩 v${entry.version} ${seconds} 秒，报错 ${entry.errors.length} 次：${errors.join("；")}`;
+		await this.log(row.root, this.writable(session), text);
+		this.notify(projectId);
+		return { ok: true };
+	}
+	/** The playtest log, newest first (last 60). */
+	async logEntries(root) {
+		const text = await readText(join(root, STATE_DIR, "playtest-log.jsonl"));
+		if (text === void 0) return [];
+		return text.split("\n").filter(Boolean).map((line) => {
+			try {
+				return JSON.parse(line);
+			} catch {
+				return;
+			}
+		}).filter((r) => r !== void 0 && typeof r.text === "string").slice(-60).reverse();
+	}
+	/** The generated 试玩记录 chapter, newest first. */
+	async playtestText(root) {
+		const rows = (await this.logEntries(root)).slice(0, 40);
+		if (rows.length === 0) return "";
+		const local = (iso) => {
+			const d = new Date(iso);
+			const pad = (n) => String(n).padStart(2, "0");
+			return Number.isNaN(d.getTime()) ? iso : `${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+		};
+		return [
+			"# 试玩记录",
+			"",
+			...rows.map((r) => `- ${local(r.at)} ${r.text}`),
+			""
+		].join("\n");
+	}
+};
+//#endregion
+//#region lib/types/index.js
+/** Cordis plugin name used by loader diagnostics. */
+const name = "game";
+/** The service core writes through the mounted filesystem. */
+const inject = ["fs"];
+/**
+* Plugin body.
+* @param ctx - owning Cordis Context.
+* @param config - plugin config.
+*/
+function apply(ctx, config = {}) {
+	const store = new GameService(ctx, config);
+	ctx.provide("gameStore", store);
+	ctx.effect(() => () => {
+		store.dispose();
+	}, "game: checker browser");
+	ctx.plugin(GameRemoteService, {});
+	registerTurnHooks(ctx, store);
+}
+//#endregion
+export { ART_STYLES, ART_STYLES_3D, BODY_BASES, CHAPTERS, GameRemoteService, GameService, LOOK_CHARS, LORE_MAX, MANIFEST_FILE, PANEL_CHANGES_MARK, PART_TYPES, STATE_DIR, apply, inject, isPixelLook, name, resolveGameStateRoot };