@linxin666/dsh-pet 0.3.3 → 0.3.4

package/lib/index.js

@@ -5,6 +5,7 @@ import { Service } from "@deepseek-ai/cordis";
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { homedir } from "node:os";
+import { isAbsolute as isAbsolute$1, join as join$1 } from "node:path/posix";
 import { fileURLToPath } from "node:url";
 import { readFile } from "node:fs/promises";
 //#region src/chatter.ts
@@ -1202,6 +1203,17 @@ var PetLedger = class {
 		};
 		this.dirty = true;
 	}
+	/** Replace one pet's gameplay state (validation/clamping stays a caller concern). */
+	setGameplay(petId, gameplay) {
+		this.current = {
+			...this.current,
+			gameplay: {
+				...this.current.gameplay,
+				[petId]: gameplay
+			}
+		};
+		this.dirty = true;
+	}
 	/** Replace one pet's display name (validation stays a caller concern). */
 	setPetName(petId, name) {
 		this.current = {
@@ -1237,6 +1249,40 @@ var PetLedger = class {
 		return true;
 	}
 	/**
+	* Grant gameplay treats into the shared stock (capped by the treat cap).
+	* This is the unified gameplay currency (wallet removed): work rewards,
+	* passive income and lottery prizes land here so one balance feeds the
+	* shop and the feeding economy. Returns true when the snapshot changed.
+	*/
+	grantTreats(amount) {
+		if (amount <= 0) return false;
+		const capped = Math.min(this.treatConfig.maxTreats, this.current.treats.treats + amount);
+		if (capped === this.current.treats.treats) return false;
+		this.current = {
+			...this.current,
+			treats: {
+				...this.current.treats,
+				treats: capped
+			}
+		};
+		this.dirty = true;
+		return true;
+	}
+	/** Spend gameplay treats from the shared stock; refuses when unaffordable. */
+	spendTreats(amount) {
+		const stock = this.current.treats.treats;
+		if (amount <= 0 || stock < amount) return { ok: false };
+		this.current = {
+			...this.current,
+			treats: {
+				...this.current.treats,
+				treats: stock - amount
+			}
+		};
+		this.dirty = true;
+		return { ok: true };
+	}
+	/**
 	* Award the completed-turn reward once per session+turn (idempotent) and
 	* run the treat settlement that work output feeds. Returns true when the
 	* snapshot changed.
@@ -1324,8 +1370,9 @@ var PetLedger = class {
 */
 /** Expand a leading ~ (or ~user) in a path, platform-style. */
 function expandHome(path, home = homedir()) {
+	const j = home.startsWith("/") ? join$1 : join;
 	if (path === "~") return home;
-	if (path.startsWith("~/") || path.startsWith("~\\")) return join(home, path.slice(2));
+	if (path.startsWith("~/") || path.startsWith("~\\")) return j(home, path.slice(2));
 	return path;
 }
 /**
@@ -1335,18 +1382,28 @@ function expandHome(path, home = homedir()) {
 * @returns the absolute DSH home path.
 */
 function resolveDshHome(env = process.env, home = homedir()) {
+	const isPosix = home.startsWith("/");
+	const j = isPosix ? join$1 : join;
+	const isAbs = isPosix ? isAbsolute$1 : isAbsolute;
 	const raw = env.DSH_HOME;
 	if (raw !== void 0 && raw.trim() !== "") {
 		const expanded = expandHome(raw.trim(), home);
-		return isAbsolute(expanded) ? expanded : join(process.cwd(), expanded);
+		return isAbs(expanded) ? expanded : j(process.cwd(), expanded);
 	}
-	return join(home, ".dsh");
+	return j(home, ".dsh");
 }
 /** Resolve the DSH home directory from the live environment. */
 function dshHome() {
 	return resolveDshHome();
 }
 //#endregion
+//#region src/defaults.ts
+/** Shared defaults used by registry selection and persisted-state migration. */
+/** Pet id that legacy single-pet installs and fresh registries resolve to. */
+const DEFAULT_PET_ID = "whale-girl";
+/** Default pet name used only when a manifest carries no displayName. */
+const DEFAULT_PET_NAME = "鲸鱼娘";
+//#endregion
 //#region src/persist.ts
 /**
 * Pet persistence — tiny JSON store for affinity + display config, written
@@ -1361,10 +1418,6 @@ const defaultDisplayConfig = {
 	bottom: 120
 };
 const DISPLAY_INSET_MAX = 1e4;
-/** Pet id the legacy single-pet installs resolve to on migration. */
-const DEFAULT_PET_ID = "whale-girl";
-/** Default pet name (used only when a manifest carries no displayName). */
-const DEFAULT_PET_NAME = "鲸鱼娘";
 /** Name constraints. */
 const PET_NAME_MAX_LENGTH = 20;
 function emptyPersist() {
@@ -1373,7 +1426,8 @@ function emptyPersist() {
 		names: {},
 		affinity: emptyAffinity(),
 		treats: emptyTreatLedger(),
-		display: { ...defaultDisplayConfig }
+		display: { ...defaultDisplayConfig },
+		gameplay: {}
 	};
 }
 /**
@@ -1404,6 +1458,35 @@ function loadPetNames(parsed) {
 function clamp(value, max) {
 	return Math.min(max, Math.max(0, value));
 }
+/** Absolute numeric ceilings applied at load (manifest clamps refine these). */
+const GAMEPLAY_LOAD_STAT_CAP = 1e6;
+const GAMEPLAY_LOAD_CURRENCY_CAP = 9999999;
+/** Sanitize the persisted per-pet gameplay map. */
+function loadGameplay(parsed) {
+	const result = {};
+	if (typeof parsed.gameplay !== "object" || parsed.gameplay === null) return result;
+	for (const [petId, raw] of Object.entries(parsed.gameplay)) {
+		if (petId === "" || typeof raw !== "object" || raw === null) continue;
+		const record = raw;
+		const stats = {};
+		if (typeof record.stats === "object" && record.stats !== null) for (const [key, value] of Object.entries(record.stats)) {
+			if (key === "" || typeof value !== "number" || !Number.isFinite(value)) continue;
+			stats[key] = Math.min(GAMEPLAY_LOAD_STAT_CAP, Math.max(0, value));
+		}
+		const currencies = {};
+		if (typeof record.currencies === "object" && record.currencies !== null) for (const [key, value] of Object.entries(record.currencies)) {
+			if (key === "" || typeof value !== "number" || !Number.isFinite(value)) continue;
+			currencies[key] = Math.min(GAMEPLAY_LOAD_CURRENCY_CAP, Math.max(0, Math.floor(value)));
+		}
+		result[petId] = {
+			stats,
+			currencies,
+			mode: record.mode === "work" || record.mode === "sleep" ? record.mode : null,
+			settledAt: clamp(finiteNum(record.settledAt, 0), Number.MAX_SAFE_INTEGER)
+		};
+	}
+	return result;
+}
 /** Load persisted state; missing or corrupt files fall back to defaults. */
 function loadPetPersist(dir = petHomeDir()) {
 	try {
@@ -1442,7 +1525,8 @@ function loadPetPersist(dir = petHomeDir()) {
 			names,
 			affinity,
 			treats,
-			display
+			display,
+			gameplay: loadGameplay(parsed)
 		};
 	} catch {
 		return emptyPersist();
@@ -1487,7 +1571,7 @@ const PLACEHOLDER_WHITELIST = {
 		"{points}"
 	]
 };
-function isRecord$2(value) {
+function isRecord$3(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /** Trim, length-cap and placeholder-check one copy line; undefined to drop. */
@@ -1548,7 +1632,7 @@ function normalizeWhisperRules(raw, onWarning = () => {}) {
 	if (raw.length > 32) onWarning("whispers.rules has more than 32 rules; extra rules are ignored");
 	const rules = [];
 	for (const item of raw.slice(0, 32)) {
-		if (!isRecord$2(item)) {
+		if (!isRecord$3(item)) {
 			onWarning("whisper rule must be an object");
 			continue;
 		}
@@ -1580,13 +1664,13 @@ function normalizeWhisperRules(raw, onWarning = () => {}) {
 }
 /** Normalize the panel block (labels / stats / actions; warn-and-drop). */
 function normalizePanel(raw, onWarning = () => {}) {
-	if (!isRecord$2(raw)) {
+	if (!isRecord$3(raw)) {
 		onWarning("panel must be an object");
 		return;
 	}
 	const panel = {};
 	const labelsRaw = raw.labels;
-	if (labelsRaw !== void 0) if (!isRecord$2(labelsRaw)) onWarning("panel.labels must be an object");
+	if (labelsRaw !== void 0) if (!isRecord$3(labelsRaw)) onWarning("panel.labels must be an object");
 	else {
 		const labels = {};
 		for (const key of PANEL_LABEL_KEYS) {
@@ -1602,7 +1686,7 @@ function normalizePanel(raw, onWarning = () => {}) {
 		if (Object.keys(labels).length > 0) panel.labels = labels;
 	}
 	const statsRaw = raw.stats;
-	if (statsRaw !== void 0) if (!isRecord$2(statsRaw)) onWarning("panel.stats must be an object");
+	if (statsRaw !== void 0) if (!isRecord$3(statsRaw)) onWarning("panel.stats must be an object");
 	else {
 		const stats = {};
 		for (const key of PANEL_STAT_KEYS) {
@@ -1652,7 +1736,7 @@ const WHISPER_KEYS = /* @__PURE__ */ new Set(["generic", "rules"]);
 */
 function normalizeVoicePack(raw, onWarning = () => {}) {
 	if (raw === void 0) return void 0;
-	if (!isRecord$2(raw)) {
+	if (!isRecord$3(raw)) {
 		onWarning("voice.json must be a JSON object; the file is ignored");
 		return;
 	}
@@ -1661,7 +1745,7 @@ function normalizeVoicePack(raw, onWarning = () => {}) {
 	if (version !== void 0 && (typeof version !== "number" || version !== 1)) onWarning("voicePackVersion " + String(version) + " is not supported; reading as v1 best-effort");
 	const overrides = {};
 	const statusRaw = raw.status;
-	if (statusRaw !== void 0) if (!isRecord$2(statusRaw)) onWarning("status must be an object");
+	if (statusRaw !== void 0) if (!isRecord$3(statusRaw)) onWarning("status must be an object");
 	else for (const key of Object.keys(statusRaw)) {
 		if (!STATUS_SCENES.includes(key)) {
 			onWarning("unknown status scene " + key + " ignored");
@@ -1674,7 +1758,7 @@ function normalizeVoicePack(raw, onWarning = () => {}) {
 		};
 	}
 	const toolsRaw = raw.tools;
-	if (toolsRaw !== void 0) if (!isRecord$2(toolsRaw)) onWarning("tools must be an object");
+	if (toolsRaw !== void 0) if (!isRecord$3(toolsRaw)) onWarning("tools must be an object");
 	else for (const key of Object.keys(toolsRaw)) {
 		if (!TOOL_CATEGORIES.includes(key)) {
 			onWarning("unknown tool family " + key + " ignored");
@@ -1692,7 +1776,7 @@ function normalizeVoicePack(raw, onWarning = () => {}) {
 		if (pool !== void 0 && pool.length > 0) overrides.toolRemaining = pool;
 	}
 	const whispersRaw = raw.whispers;
-	if (whispersRaw !== void 0) if (!isRecord$2(whispersRaw)) onWarning("whispers must be an object");
+	if (whispersRaw !== void 0) if (!isRecord$3(whispersRaw)) onWarning("whispers must be an object");
 	else {
 		for (const key of Object.keys(whispersRaw)) if (!WHISPER_KEYS.has(key)) onWarning("unknown whispers field " + key + " ignored");
 		const generic = normalizePool(whispersRaw.generic, "whisperGeneric", onWarning);
@@ -1757,8 +1841,585 @@ function mergeVoicePacks(...layers) {
 		...panelSeen && !panelEmpty ? { panel } : {}
 	};
 }
+//#endregion
+//#region src/gameplay.ts
+const KEBAB = /^[a-z0-9][a-z0-9-]*$/;
+const MAX_STATS = 16;
+const MAX_ZONES = 8;
+const MAX_BRANCHES = 8;
+const MAX_ACTS = 16;
+const MAX_SHOP_ITEMS = 32;
+const MAX_LOTTERY_TIERS = 16;
+const MAX_PHRASES = 64;
+const PHRASE_MAX_LENGTH = 120;
+const STAT_VALUE_MAX = 1e6;
+const CURRENCY_MAX = 9999999;
+const KNOWN_GAMEPLAY = /* @__PURE__ */ new Set([
+	"idleDirector",
+	"stats",
+	"hitBox",
+	"touch",
+	"work",
+	"sleep",
+	"passiveIncome",
+	"shop",
+	"dragState",
+	"dragEndState"
+]);
+const KNOWN_STAT = /* @__PURE__ */ new Set([
+	"max",
+	"initial",
+	"decayPerMinute",
+	"workingDecayPerMinute",
+	"idleDecayPerMinute"
+]);
+const KNOWN_ZONE = /* @__PURE__ */ new Set([
+	"name",
+	"y0",
+	"y1",
+	"branches"
+]);
+const KNOWN_TOUCH = /* @__PURE__ */ new Set(["zones", "clickBoost"]);
+const KNOWN_BRANCH = /* @__PURE__ */ new Set([
+	"probability",
+	"effects",
+	"state",
+	"stateMs",
+	"phrases"
+]);
+const KNOWN_EFFECT = /* @__PURE__ */ new Set([
+	"stat",
+	"currency",
+	"amount"
+]);
+const KNOWN_WORK = /* @__PURE__ */ new Set([
+	"state",
+	"successState",
+	"failState",
+	"tickMs",
+	"resultMs",
+	"successProbability",
+	"success",
+	"fail"
+]);
+const KNOWN_SLEEP = /* @__PURE__ */ new Set([
+	"state",
+	"wakeState",
+	"restore"
+]);
+const KNOWN_SHOP_ITEM = /* @__PURE__ */ new Set([
+	"id",
+	"label",
+	"image",
+	"price",
+	"currency",
+	"effects",
+	"lottery"
+]);
+const KNOWN_LOTTERY = /* @__PURE__ */ new Set([
+	"effects",
+	"currency",
+	"tiers"
+]);
+const KNOWN_IDLE_DIRECTOR = /* @__PURE__ */ new Set([
+	"intervalMs",
+	"maxMiss",
+	"idleWeight",
+	"acts"
+]);
+const KNOWN_ACT = /* @__PURE__ */ new Set([
+	"track",
+	"weight",
+	"phrases"
+]);
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unknownKeys$2(source, known) {
+	return Object.keys(source).filter((key) => !known.has(key));
+}
+function validName(name, max = 32) {
+	return typeof name === "string" && name.length <= max && KEBAB.test(name);
+}
+function intIn(value, min, max) {
+	return typeof value === "number" && Number.isInteger(value) && value >= min && value <= max;
+}
+function numIn(value, min, max) {
+	return typeof value === "number" && Number.isFinite(value) && value >= min && value <= max;
+}
+function parseEffects(raw, field, stats, hooks) {
+	if (raw === void 0) return void 0;
+	if (!Array.isArray(raw) || raw.length === 0) {
+		hooks.error(field + " must be a non-empty array of effects");
+		return;
+	}
+	const effects = [];
+	for (const entry of raw) {
+		if (!isRecord$2(entry)) {
+			hooks.error(field + ": every effect must be an object");
+			continue;
+		}
+		const extra = unknownKeys$2(entry, KNOWN_EFFECT);
+		if (extra.length > 0) hooks.error(field + ": unknown effect field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+		const hasStat = typeof entry.stat === "string";
+		const hasCurrency = typeof entry.currency === "string";
+		if (hasStat === hasCurrency) {
+			hooks.error(field + ": an effect needs exactly one of stat or currency");
+			continue;
+		}
+		if (!intIn(entry.amount, -1e6, STAT_VALUE_MAX) || entry.amount === 0) {
+			hooks.error(field + ": effect amount must be a non-zero integer within ±1000000");
+			continue;
+		}
+		if (hasStat && stats[entry.stat] === void 0) {
+			hooks.error(field + ": effect references undeclared stat " + JSON.stringify(entry.stat));
+			continue;
+		}
+		if (hasCurrency && !validName(entry.currency, 24)) {
+			hooks.error(field + ": effect currency must be a kebab id");
+			continue;
+		}
+		effects.push({
+			...hasStat ? { stat: entry.stat } : {},
+			...hasCurrency ? { currency: entry.currency } : {},
+			amount: entry.amount
+		});
+	}
+	return effects.length === 0 ? void 0 : effects;
+}
+function parsePhrases(raw, field, hooks) {
+	if (raw === void 0) return void 0;
+	if (!Array.isArray(raw) || raw.length === 0 || raw.length > MAX_PHRASES || raw.some((line) => typeof line !== "string" || line.trim() === "" || line.length > PHRASE_MAX_LENGTH)) {
+		hooks.error(field + " must be 1..64 non-empty lines of at most 120 chars");
+		return;
+	}
+	return raw;
+}
+function parseStateRef(raw, field, hooks) {
+	if (raw === void 0) return void 0;
+	if (typeof raw !== "string" || !hooks.stateNames.has(raw)) {
+		hooks.error(field + " must name a declared frames2d track");
+		return;
+	}
+	return raw;
+}
+/**
+* Validate the manifest 'gameplay' block (fail-closed). Only frames2d pets
+* may declare gameplay today: every state reference checks against the
+* declared track names.
+*/
+function parseGameplayManifest(raw, hooks) {
+	const error = (message) => hooks.error(message);
+	if (!isRecord$2(raw)) {
+		error("gameplay must be an object");
+		return;
+	}
+	const extra = unknownKeys$2(raw, KNOWN_GAMEPLAY);
+	if (extra.length > 0) error("gameplay: unknown field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+	let failed = false;
+	const fail = (message) => {
+		failed = true;
+		error(message);
+	};
+	const stats = {};
+	if (raw.stats !== void 0) if (!isRecord$2(raw.stats)) fail("gameplay.stats must be an object keyed by stat id");
+	else {
+		const entries = Object.entries(raw.stats);
+		if (entries.length > MAX_STATS) fail("gameplay.stats declares too many stats (max 16)");
+		for (const [name, value] of entries) {
+			if (!validName(name, 24)) {
+				fail("gameplay.stats: invalid stat id " + JSON.stringify(name));
+				continue;
+			}
+			if (!isRecord$2(value)) {
+				fail("gameplay.stats." + name + " must be an object");
+				continue;
+			}
+			const statExtra = unknownKeys$2(value, KNOWN_STAT);
+			if (statExtra.length > 0) fail("gameplay.stats." + name + ": unknown field(s) " + statExtra.map((k) => JSON.stringify(k)).join(", "));
+			if (!intIn(value.max, 1, STAT_VALUE_MAX)) {
+				fail("gameplay.stats." + name + ".max must be an integer in [1, 1000000]");
+				continue;
+			}
+			const def = { max: value.max };
+			if (value.initial !== void 0) if (!numIn(value.initial, 0, value.max)) fail("gameplay.stats." + name + ".initial must be within [0, max]");
+			else def.initial = value.initial;
+			for (const key of [
+				"decayPerMinute",
+				"workingDecayPerMinute",
+				"idleDecayPerMinute"
+			]) if (value[key] !== void 0) if (!numIn(value[key], 0, 1e3)) fail("gameplay.stats." + name + "." + key + " must be a number in [0, 1000]");
+			else def[key] = value[key];
+			stats[name] = def;
+		}
+	}
+	const block = {};
+	if (Object.keys(stats).length > 0) block.stats = stats;
+	if (raw.idleDirector !== void 0) if (!isRecord$2(raw.idleDirector) || !Array.isArray(raw.idleDirector.acts)) fail("gameplay.idleDirector must be an object with an acts array");
+	else {
+		const d = raw.idleDirector;
+		const dExtra = unknownKeys$2(d, KNOWN_IDLE_DIRECTOR);
+		if (dExtra.length > 0) fail("gameplay.idleDirector: unknown field(s) " + dExtra.map((k) => JSON.stringify(k)).join(", "));
+		if (d.intervalMs !== void 0 && !intIn(d.intervalMs, 1e3, 6e4)) fail("gameplay.idleDirector.intervalMs must be an integer in [1000, 60000]");
+		if (d.maxMiss !== void 0 && !intIn(d.maxMiss, 0, 10)) fail("gameplay.idleDirector.maxMiss must be an integer in [0, 10]");
+		if (d.idleWeight !== void 0 && !intIn(d.idleWeight, 0, 1e4)) fail("gameplay.idleDirector.idleWeight must be an integer in [0, 10000]");
+		if (d.acts.length === 0 || d.acts.length > MAX_ACTS) fail("gameplay.idleDirector.acts must declare 1..16 acts");
+		const acts = [];
+		for (const act of d.acts) {
+			if (!isRecord$2(act) || !intIn(act.weight, 1, 1e4)) {
+				fail("gameplay.idleDirector.acts entries need a weight integer in [1, 10000]");
+				continue;
+			}
+			const aExtra = unknownKeys$2(act, KNOWN_ACT);
+			if (aExtra.length > 0) fail("gameplay.idleDirector.acts: unknown field(s) " + aExtra.map((k) => JSON.stringify(k)).join(", "));
+			const track = parseStateRef(act.track, "gameplay.idleDirector.acts.track", hooks);
+			if (track === void 0) continue;
+			const entry = {
+				track,
+				weight: act.weight
+			};
+			const phrases = parsePhrases(act.phrases, "gameplay.idleDirector.acts.phrases", hooks);
+			if (phrases !== void 0) entry.phrases = phrases;
+			acts.push(entry);
+		}
+		if (acts.length > 0) block.idleDirector = {
+			intervalMs: intIn(d.intervalMs, 1e3, 6e4) ? d.intervalMs : 5e3,
+			maxMiss: intIn(d.maxMiss, 0, 10) ? d.maxMiss : 2,
+			idleWeight: intIn(d.idleWeight, 0, 1e4) ? d.idleWeight : 0,
+			acts
+		};
+	}
+	if (raw.hitBox !== void 0) {
+		const b = raw.hitBox;
+		if (!isRecord$2(b) || !numIn(b.x0, 0, 1) || !numIn(b.x1, 0, 1) || !numIn(b.y0, 0, 1) || !numIn(b.y1, 0, 1) || !(b.x0 < b.x1) || !(b.y0 < b.y1)) fail("gameplay.hitBox must be { x0, y0, x1, y1 } fractions with x0 < x1 and y0 < y1");
+		else block.hitBox = {
+			x0: b.x0,
+			y0: b.y0,
+			x1: b.x1,
+			y1: b.y1
+		};
+	}
+	if (raw.touch !== void 0) if (!isRecord$2(raw.touch) || !Array.isArray(raw.touch.zones)) fail("gameplay.touch must be an object with a zones array");
+	else {
+		const tExtra = unknownKeys$2(raw.touch, KNOWN_TOUCH);
+		if (tExtra.length > 0) fail("gameplay.touch: unknown field(s) " + tExtra.map((k) => JSON.stringify(k)).join(", "));
+		let clickBoost;
+		if (raw.touch.clickBoost !== void 0) {
+			const cb = raw.touch.clickBoost;
+			if (!isRecord$2(cb) || typeof cb.stat !== "string" || stats[cb.stat] === void 0 || !intIn(cb.min, 0, 1e3) || !intIn(cb.max, 0, 1e3) || cb.min > cb.max) fail("gameplay.touch.clickBoost must be { stat (declared), min, max } integers with 0 <= min <= max <= 1000");
+			else clickBoost = {
+				stat: cb.stat,
+				min: cb.min,
+				max: cb.max
+			};
+		}
+		const zones = [];
+		if (raw.touch.zones.length === 0 || raw.touch.zones.length > MAX_ZONES) fail("gameplay.touch.zones must declare 1..8 zones");
+		for (const zoneRaw of raw.touch.zones) {
+			if (!isRecord$2(zoneRaw) || !validName(zoneRaw.name) || !numIn(zoneRaw.y0, 0, 1) || !numIn(zoneRaw.y1, 0, 1) || !(zoneRaw.y0 < zoneRaw.y1)) {
+				fail("gameplay.touch.zones entries need a kebab name and 0 <= y0 < y1 <= 1");
+				continue;
+			}
+			const zExtra = unknownKeys$2(zoneRaw, KNOWN_ZONE);
+			if (zExtra.length > 0) fail("gameplay.touch." + zoneRaw.name + ": unknown field(s) " + zExtra.map((k) => JSON.stringify(k)).join(", "));
+			if (!Array.isArray(zoneRaw.branches) || zoneRaw.branches.length === 0 || zoneRaw.branches.length > MAX_BRANCHES) {
+				fail("gameplay.touch." + zoneRaw.name + ".branches must declare 1..8 branches");
+				continue;
+			}
+			let probabilitySum = 0;
+			const branches = [];
+			for (const branchRaw of zoneRaw.branches) {
+				if (!isRecord$2(branchRaw) || !numIn(branchRaw.probability, 0, 1) || branchRaw.probability === 0) {
+					fail("gameplay.touch." + zoneRaw.name + ".branches entries need a probability in (0, 1]");
+					continue;
+				}
+				const bExtra = unknownKeys$2(branchRaw, KNOWN_BRANCH);
+				if (bExtra.length > 0) fail("gameplay.touch." + zoneRaw.name + ": unknown branch field(s) " + bExtra.map((k) => JSON.stringify(k)).join(", "));
+				probabilitySum += branchRaw.probability;
+				const branch = { probability: branchRaw.probability };
+				const effects = parseEffects(branchRaw.effects, "gameplay.touch." + zoneRaw.name + ".effects", stats, hooks);
+				if (effects !== void 0) branch.effects = effects;
+				const state = parseStateRef(branchRaw.state, "gameplay.touch." + zoneRaw.name + ".state", hooks);
+				if (state !== void 0) branch.state = state;
+				if (branchRaw.stateMs !== void 0) if (!intIn(branchRaw.stateMs, 200, 1e4)) fail("gameplay.touch." + zoneRaw.name + ".stateMs must be an integer in [200, 10000]");
+				else branch.stateMs = branchRaw.stateMs;
+				const phrases = parsePhrases(branchRaw.phrases, "gameplay.touch." + zoneRaw.name + ".phrases", hooks);
+				if (phrases !== void 0) branch.phrases = phrases;
+				branches.push(branch);
+			}
+			if (probabilitySum > 1.000000001) fail("gameplay.touch." + zoneRaw.name + ": branch probabilities must sum to at most 1");
+			if (branches.length > 0) zones.push({
+				name: zoneRaw.name,
+				y0: zoneRaw.y0,
+				y1: zoneRaw.y1,
+				branches
+			});
+		}
+		if (zones.length > 0 || clickBoost !== void 0) block.touch = {
+			zones,
+			...clickBoost === void 0 ? {} : { clickBoost }
+		};
+	}
+	if (raw.work !== void 0) {
+		const w = raw.work;
+		if (!isRecord$2(w)) fail("gameplay.work must be an object");
+		else {
+			const wExtra = unknownKeys$2(w, KNOWN_WORK);
+			if (wExtra.length > 0) fail("gameplay.work: unknown field(s) " + wExtra.map((k) => JSON.stringify(k)).join(", "));
+			const state = parseStateRef(w.state, "gameplay.work.state", hooks);
+			const successState = parseStateRef(w.successState, "gameplay.work.successState", hooks);
+			const failState = parseStateRef(w.failState, "gameplay.work.failState", hooks);
+			if (!intIn(w.tickMs, 1e3, 6e4)) fail("gameplay.work.tickMs must be an integer in [1000, 60000]");
+			if (!numIn(w.successProbability, 0, 1)) fail("gameplay.work.successProbability must be a number in [0, 1]");
+			if (state !== void 0 && successState !== void 0 && failState !== void 0 && intIn(w.tickMs, 1e3, 6e4) && numIn(w.successProbability, 0, 1)) {
+				const work = {
+					state,
+					successState,
+					failState,
+					tickMs: w.tickMs,
+					successProbability: w.successProbability
+				};
+				if (w.resultMs !== void 0) if (!isRecord$2(w.resultMs) || !intIn(w.resultMs.success, 200, 1e4) || !intIn(w.resultMs.fail, 200, 1e4)) fail("gameplay.work.resultMs must be { success, fail } integers in [200, 10000]");
+				else work.resultMs = {
+					success: w.resultMs.success,
+					fail: w.resultMs.fail
+				};
+				for (const key of ["success", "fail"]) if (w[key] !== void 0) if (!isRecord$2(w[key])) fail("gameplay.work." + key + " must be an object { effects }");
+				else {
+					const effects = parseEffects(w[key].effects, "gameplay.work." + key + ".effects", stats, hooks);
+					if (effects !== void 0) work[key] = { effects };
+				}
+				block.work = work;
+			}
+		}
+	}
+	if (raw.sleep !== void 0) {
+		const s = raw.sleep;
+		if (!isRecord$2(s) || !isRecord$2(s.restore)) fail("gameplay.sleep must be an object with a restore block");
+		else {
+			const sExtra = unknownKeys$2(s, KNOWN_SLEEP);
+			if (sExtra.length > 0) fail("gameplay.sleep: unknown field(s) " + sExtra.map((k) => JSON.stringify(k)).join(", "));
+			const state = parseStateRef(s.state, "gameplay.sleep.state", hooks);
+			const wakeState = parseStateRef(s.wakeState, "gameplay.sleep.wakeState", hooks);
+			const restoreStat = typeof s.restore.stat === "string" && stats[s.restore.stat] !== void 0 ? s.restore.stat : void 0;
+			if (restoreStat === void 0) fail("gameplay.sleep.restore.stat must reference a declared stat");
+			if (!intIn(s.restore.amount, 1, 1e3)) fail("gameplay.sleep.restore.amount must be an integer in [1, 1000]");
+			if (!intIn(s.restore.intervalMs, 1e3, 6e5)) fail("gameplay.sleep.restore.intervalMs must be an integer in [1000, 600000]");
+			if (state !== void 0 && restoreStat !== void 0 && intIn(s.restore.amount, 1, 1e3) && intIn(s.restore.intervalMs, 1e3, 6e5)) block.sleep = {
+				state,
+				...wakeState === void 0 ? {} : { wakeState },
+				restore: {
+					stat: restoreStat,
+					amount: s.restore.amount,
+					intervalMs: s.restore.intervalMs
+				}
+			};
+		}
+	}
+	if (raw.passiveIncome !== void 0) {
+		const p = raw.passiveIncome;
+		if (!isRecord$2(p) || !validName(p.currency, 24) || !intIn(p.amount, 1, 1e4) || !intIn(p.intervalMs, 1e3, 864e5)) fail("gameplay.passiveIncome must be { currency (kebab), amount 1..10000, intervalMs 1000..86400000 }");
+		else block.passiveIncome = {
+			currency: p.currency,
+			amount: p.amount,
+			intervalMs: p.intervalMs
+		};
+	}
+	if (raw.shop !== void 0) {
+		const s = raw.shop;
+		if (!isRecord$2(s) || !Array.isArray(s.items) || s.items.length === 0 || s.items.length > MAX_SHOP_ITEMS) fail("gameplay.shop must be an object with 1..32 items");
+		else {
+			const shopState = parseStateRef(s.state, "gameplay.shop.state", hooks);
+			const items = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const itemRaw of s.items) {
+				if (!isRecord$2(itemRaw) || !validName(itemRaw.id, 24)) {
+					fail("gameplay.shop.items entries need a kebab id");
+					continue;
+				}
+				if (seen.has(itemRaw.id)) {
+					fail("gameplay.shop: duplicate item id " + JSON.stringify(itemRaw.id));
+					continue;
+				}
+				seen.add(itemRaw.id);
+				const iExtra = unknownKeys$2(itemRaw, KNOWN_SHOP_ITEM);
+				if (iExtra.length > 0) fail("gameplay.shop." + itemRaw.id + ": unknown field(s) " + iExtra.map((k) => JSON.stringify(k)).join(", "));
+				if (typeof itemRaw.label !== "string" || itemRaw.label.trim() === "" || itemRaw.label.length > 80) {
+					fail("gameplay.shop." + itemRaw.id + ".label must be a non-empty string of at most 80 chars");
+					continue;
+				}
+				if (!intIn(itemRaw.price, 1, 1e6)) {
+					fail("gameplay.shop." + itemRaw.id + ".price must be an integer in [1, 1000000]");
+					continue;
+				}
+				if (!validName(itemRaw.currency, 24)) {
+					fail("gameplay.shop." + itemRaw.id + ".currency must be a kebab id");
+					continue;
+				}
+				const item = {
+					id: itemRaw.id,
+					label: itemRaw.label.trim(),
+					price: itemRaw.price,
+					currency: itemRaw.currency
+				};
+				if (itemRaw.image !== void 0) if (typeof itemRaw.image !== "string" || itemRaw.image.includes("..") || itemRaw.image.includes("\\") || itemRaw.image.startsWith("/")) fail("gameplay.shop." + itemRaw.id + ".image must be a safe manifest-relative frame path");
+				else item.image = itemRaw.image;
+				const effects = parseEffects(itemRaw.effects, "gameplay.shop." + itemRaw.id + ".effects", stats, hooks);
+				if (effects !== void 0) item.effects = effects;
+				if (itemRaw.lottery !== void 0) {
+					const l = itemRaw.lottery;
+					if (!isRecord$2(l) || !Array.isArray(l.tiers) || l.tiers.length === 0 || l.tiers.length > MAX_LOTTERY_TIERS) fail("gameplay.shop." + itemRaw.id + ".lottery needs 1..16 tiers");
+					else {
+						const lExtra = unknownKeys$2(l, KNOWN_LOTTERY);
+						if (lExtra.length > 0) fail("gameplay.shop." + itemRaw.id + ".lottery: unknown field(s) " + lExtra.map((k) => JSON.stringify(k)).join(", "));
+						if (l.currency !== void 0 && !validName(l.currency, 24)) fail("gameplay.shop." + itemRaw.id + ".lottery.currency must be a kebab id");
+						let tierSum = 0;
+						const tiers = [];
+						for (const tierRaw of l.tiers) {
+							if (!isRecord$2(tierRaw) || !numIn(tierRaw.probability, 0, 1) || tierRaw.probability === 0 || !intIn(tierRaw.prize, 0, 1e9)) {
+								fail("gameplay.shop." + itemRaw.id + ".lottery.tiers entries need probability (0,1] and prize 0..1e9");
+								continue;
+							}
+							tierSum += tierRaw.probability;
+							const tier = {
+								probability: tierRaw.probability,
+								prize: tierRaw.prize
+							};
+							if (tierRaw.currency !== void 0) if (!validName(tierRaw.currency, 24)) fail("gameplay.shop." + itemRaw.id + ".lottery tier currency must be a kebab id");
+							else tier.currency = tierRaw.currency;
+							tiers.push(tier);
+						}
+						if (tierSum > 1.000000001) fail("gameplay.shop." + itemRaw.id + ".lottery tier probabilities must sum to at most 1");
+						if (tiers.length > 0) {
+							const lotteryEffects = parseEffects(l.effects, "gameplay.shop." + itemRaw.id + ".lottery.effects", stats, hooks);
+							item.lottery = {
+								tiers,
+								...lotteryEffects === void 0 ? {} : { effects: lotteryEffects },
+								...validName(l.currency, 24) ? { currency: l.currency } : {}
+							};
+						}
+					}
+				}
+				if (item.effects === void 0 && item.lottery === void 0) {
+					fail("gameplay.shop." + itemRaw.id + " needs effects or a lottery");
+					continue;
+				}
+				items.push(item);
+			}
+			if (items.length > 0) block.shop = {
+				...shopState === void 0 ? {} : { state: shopState },
+				items
+			};
+		}
+	}
+	if (raw.dragState !== void 0) {
+		const state = parseStateRef(raw.dragState, "gameplay.dragState", hooks);
+		if (state !== void 0) block.dragState = state;
+	}
+	if (raw.dragEndState !== void 0) {
+		const state = parseStateRef(raw.dragEndState, "gameplay.dragEndState", hooks);
+		if (state !== void 0) block.dragEndState = state;
+	}
+	return failed ? void 0 : block;
+}
+/** Fresh state for one pet: stats at their initial (default max), no currency. */
+function initialGameplayState(manifest, now) {
+	const stats = {};
+	for (const [name, def] of Object.entries(manifest.stats ?? {})) stats[name] = def.initial ?? def.max;
+	return {
+		stats,
+		currencies: {},
+		mode: null,
+		settledAt: now
+	};
+}
+/** Clamp one stat value into [0, max]; currencies into [0, CURRENCY_MAX]. */
+function clampGameplay(state, manifest) {
+	for (const [name, def] of Object.entries(manifest.stats ?? {})) {
+		const value = state.stats[name];
+		if (value === void 0) state.stats[name] = def.initial ?? def.max;
+		else state.stats[name] = Math.min(def.max, Math.max(0, value));
+	}
+	for (const [name, value] of Object.entries(state.currencies)) state.currencies[name] = Math.min(CURRENCY_MAX, Math.max(0, Math.floor(value)));
+}
+/**
+* Lazy settle: apply stat decay, passive income and sleep restore for the
+* elapsed wall time since the last settle. Mirrors the treats.ts discipline
+* (no host timers; read paths settle). Returns whether anything changed.
+*/
+function settleGameplay(state, manifest, now, options) {
+	const elapsedMs = now - state.settledAt;
+	if (elapsedMs <= 0) return false;
+	const minutes = elapsedMs / 6e4;
+	let changed = false;
+	for (const [name, def] of Object.entries(manifest.stats ?? {})) {
+		const current = state.stats[name];
+		if (current === void 0 || current <= 0) continue;
+		let rate = def.decayPerMinute ?? 0;
+		if (state.mode === "work" && def.workingDecayPerMinute !== void 0) rate = def.workingDecayPerMinute;
+		if (!options.sessionActive) rate += def.idleDecayPerMinute ?? 0;
+		if (rate <= 0) continue;
+		const next = Math.max(0, current - rate * minutes);
+		if (next !== current) {
+			state.stats[name] = next;
+			changed = true;
+		}
+	}
+	if (manifest.passiveIncome !== void 0) {
+		const ticks = Math.floor(elapsedMs / manifest.passiveIncome.intervalMs);
+		if (ticks > 0) {
+			const currency = manifest.passiveIncome.currency;
+			state.currencies[currency] = (state.currencies[currency] ?? 0) + ticks * manifest.passiveIncome.amount;
+			changed = true;
+		}
+	}
+	if (state.mode === "sleep" && manifest.sleep !== void 0) {
+		const ticks = Math.floor(elapsedMs / manifest.sleep.restore.intervalMs);
+		if (ticks > 0) {
+			const stat = manifest.sleep.restore.stat;
+			state.stats[stat] = (state.stats[stat] ?? 0) + ticks * manifest.sleep.restore.amount;
+			changed = true;
+		}
+	}
+	state.settledAt = now;
+	clampGameplay(state, manifest);
+	return changed;
+}
+/** Apply one effect vector (touch/work/shop), clamped. */
+function applyGameplayEffects(state, manifest, effects) {
+	for (const effect of effects) if (effect.stat !== void 0) state.stats[effect.stat] = (state.stats[effect.stat] ?? 0) + effect.amount;
+	else if (effect.currency !== void 0) state.currencies[effect.currency] = (state.currencies[effect.currency] ?? 0) + effect.amount;
+	clampGameplay(state, manifest);
+}
+/** Roll one touch zone branch; undefined when the roll lands in no-op mass. */
+function rollTouchBranch(zone, rng) {
+	const roll = rng();
+	let acc = 0;
+	for (const branch of zone.branches) {
+		acc += branch.probability;
+		if (roll < acc) return branch;
+	}
+}
+/** Roll one work tick outcome. */
+function rollWorkOutcome(work, rng) {
+	return rng() < work.successProbability ? "success" : "fail";
+}
+/** Draw one lottery prize tier; uncovered mass falls through to the last tier. */
+function drawLotteryTier(lottery, rng) {
+	const roll = rng();
+	let acc = 0;
+	for (const tier of lottery.tiers) {
+		acc += tier.probability;
+		if (roll < acc) return tier;
+	}
+	return lottery.tiers[lottery.tiers.length - 1];
+}
 /** Renderer kinds the pet center knows how to dispatch (M1 §2). */
-const PET_RENDERER_KINDS = ["sprite2d", "live2d"];
+const PET_RENDERER_KINDS = [
+	"sprite2d",
+	"live2d",
+	"frames2d"
+];
 /** The seven ActivityPhase semantics (pet-center owned; M1 §1). */
 const PET_ACTIVITY_PHASES = [
 	"idle",
@@ -1790,8 +2451,10 @@ const KNOWN_TOP_LEVEL = /* @__PURE__ */ new Set([
 	"renderer",
 	"sprite2d",
 	"live2d",
+	"frames2d",
 	"sequences",
-	"remarks"
+	"remarks",
+	"gameplay"
 ]);
 /** sprite2d block field allow-list (drift-locked to the schema file). */
 const KNOWN_SPRITE2D = /* @__PURE__ */ new Set([
@@ -1812,6 +2475,20 @@ const KNOWN_LIVE2D = /* @__PURE__ */ new Set([
 	"hitAreas",
 	"lipSync"
 ]);
+/** frames2d block field allow-list (drift-locked to the schema file). */
+const KNOWN_FRAMES2D = /* @__PURE__ */ new Set([
+	"dir",
+	"defaultFrameMs",
+	"tracks",
+	"phases"
+]);
+/** frames2d track field allow-list (drift-locked to the schema file). */
+const KNOWN_FRAMES2D_TRACK = /* @__PURE__ */ new Set([
+	"frames",
+	"frameMs",
+	"loop",
+	"fallback"
+]);
 var Diagnostics$1 = class {
 	list = [];
 	source;
@@ -1958,6 +2635,106 @@ function parseLive2dBlock(raw, diag) {
 	else block.lipSync = raw.lipSync;
 	return diag.hasErrors ? void 0 : block;
 }
+const FRAMES2D_TRACK_NAME = /^[a-z0-9][a-z0-9-]*$/;
+const FRAMES2D_MAX_TRACKS = 64;
+const FRAMES2D_MAX_FRAMES = 64;
+const FRAMES2D_MIN_FRAME_MS = 16;
+const FRAMES2D_MAX_FRAME_MS = 5e3;
+const FRAMES2D_IMAGE_EXTENSIONS$1 = /* @__PURE__ */ new Set([
+	".webp",
+	".png",
+	".gif",
+	".jpg",
+	".jpeg"
+]);
+/** Validate one frames2d track name (kebab id, at most 32 chars). */
+function validTrackName(name) {
+	return name.length <= 32 && FRAMES2D_TRACK_NAME.test(name);
+}
+/** A frames2d frame entry is a single image file name inside the track directory. */
+function safeFrameName(raw) {
+	if (typeof raw !== "string" || raw.trim() === "") return void 0;
+	const value = raw.trim();
+	if (value.includes("/") || value.includes("\\") || !PATH_SEGMENT_PATTERN$2.test(value)) return void 0;
+	const dot = value.lastIndexOf(".");
+	if (dot <= 0) return void 0;
+	if (!FRAMES2D_IMAGE_EXTENSIONS$1.has(value.slice(dot).toLowerCase())) return void 0;
+	return value;
+}
+function parseFrames2dTrack(raw, field, diag) {
+	if (!isRecord$1(raw)) {
+		diag.error(field + " must be an object");
+		return;
+	}
+	const extra = unknownKeys$1(raw, KNOWN_FRAMES2D_TRACK);
+	if (extra.length > 0) diag.error(field + ": unknown field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+	const track = {};
+	if (raw.frames !== void 0) if (!Array.isArray(raw.frames) || raw.frames.length === 0) diag.error(field + ".frames must be a non-empty array of frame file names");
+	else if (raw.frames.length > FRAMES2D_MAX_FRAMES) diag.error(field + ".frames declares too many frames (" + raw.frames.length + ", max 64)");
+	else {
+		const frames = [];
+		for (const entry of raw.frames) {
+			const safe = safeFrameName(entry);
+			if (safe === void 0) diag.error(field + ".frames entry " + JSON.stringify(String(entry)) + " is not a safe image file name");
+			else frames.push(safe);
+		}
+		if (frames.length === raw.frames.length) track.frames = frames;
+	}
+	if (raw.frameMs !== void 0) if (!Array.isArray(raw.frameMs) || raw.frameMs.length === 0 || raw.frameMs.some((v) => typeof v !== "number" || !Number.isInteger(v) || v < FRAMES2D_MIN_FRAME_MS || v > FRAMES2D_MAX_FRAME_MS)) diag.error(field + ".frameMs must be a non-empty array of integer ms in [16, 5000]");
+	else if (track.frames === void 0) diag.error(field + ".frameMs requires a valid explicit frames list (directory tracks use filename-encoded ms or defaultFrameMs)");
+	else if (raw.frameMs.length !== track.frames.length) diag.error(field + ".frameMs must have the same length as frames");
+	else track.frameMs = raw.frameMs;
+	if (raw.loop !== void 0) if (typeof raw.loop !== "boolean") diag.error(field + ".loop must be a boolean");
+	else track.loop = raw.loop;
+	if (raw.fallback !== void 0) if (typeof raw.fallback !== "string" || !validTrackName(raw.fallback)) diag.error(field + ".fallback must be a track name");
+	else track.fallback = raw.fallback;
+	return diag.hasErrors ? void 0 : track;
+}
+function parseFrames2dBlock(raw, diag) {
+	if (!isRecord$1(raw)) {
+		diag.error("renderer frames2d requires a \"frames2d\" block object");
+		return;
+	}
+	const extra = unknownKeys$1(raw, KNOWN_FRAMES2D);
+	if (extra.length > 0) diag.error("frames2d: unknown field(s) " + extra.map((k) => JSON.stringify(k)).join(", "));
+	const block = {
+		tracks: {},
+		phases: { idle: "" }
+	};
+	if (raw.dir !== void 0) {
+		const dir = safeManifestPath(raw.dir);
+		if (dir === void 0) diag.error("frames2d.dir must be a safe manifest-relative directory");
+		else block.dir = dir;
+	}
+	if (raw.defaultFrameMs !== void 0) if (typeof raw.defaultFrameMs !== "number" || !Number.isInteger(raw.defaultFrameMs) || raw.defaultFrameMs < FRAMES2D_MIN_FRAME_MS || raw.defaultFrameMs > FRAMES2D_MAX_FRAME_MS) diag.error("frames2d.defaultFrameMs must be an integer in [16, 5000]");
+	else block.defaultFrameMs = raw.defaultFrameMs;
+	const tracks = {};
+	if (!isRecord$1(raw.tracks)) diag.error("frames2d.tracks is required and must be an object keyed by track name");
+	else {
+		const entries = Object.entries(raw.tracks);
+		if (entries.length === 0) diag.error("frames2d.tracks must declare at least one track");
+		if (entries.length > FRAMES2D_MAX_TRACKS) diag.error("frames2d.tracks declares too many tracks (" + entries.length + ", max 64)");
+		for (const [name, value] of entries) {
+			if (!validTrackName(name)) {
+				diag.error("frames2d.tracks: invalid track name " + JSON.stringify(name) + " (lowercase kebab, at most 32 chars)");
+				continue;
+			}
+			const track = parseFrames2dTrack(value, "frames2d.tracks." + name, diag);
+			if (track !== void 0) tracks[name] = track;
+		}
+	}
+	block.tracks = tracks;
+	const phases = parsePhaseStringMap(raw.phases, "frames2d.phases", diag);
+	if (raw.phases === void 0) diag.error("frames2d.phases is required (at least an \"idle\" mapping)");
+	else if (phases !== void 0 && phases.idle === void 0) diag.error("frames2d.phases.idle is required (unmapped phases fall back to it)");
+	const phasesValid = phases !== void 0 && phases.idle !== void 0;
+	if (phasesValid) block.phases = phases;
+	if (phasesValid) {
+		for (const [phase, target] of Object.entries(block.phases)) if (target !== void 0 && tracks[target] === void 0) diag.error("frames2d.phases." + phase + " references unknown track " + JSON.stringify(target));
+	}
+	for (const [name, track] of Object.entries(tracks)) if (track.fallback !== void 0 && tracks[track.fallback] === void 0) diag.error("frames2d.tracks." + name + ".fallback references unknown track " + JSON.stringify(track.fallback));
+	return diag.hasErrors ? void 0 : block;
+}
 /** v1 compat read: map the legacy flat manifest onto the v2 sprite2d shape. */
 function compatV1(source, diag) {
 	const id = parseStringBlock(source, "id", diag, true);
@@ -2017,10 +2794,25 @@ function parseV2(source, diag) {
 		const block = parseSprite2dBlock(source.sprite2d, diag);
 		if (block !== void 0) manifest.sprite2d = block;
 		if (source.live2d !== void 0) diag.error("renderer sprite2d must not declare a live2d block");
+		if (source.frames2d !== void 0) diag.error("renderer sprite2d must not declare a frames2d block");
 	} else if (renderer === "live2d") {
 		const block = parseLive2dBlock(source.live2d, diag);
 		if (block !== void 0) manifest.live2d = block;
 		if (source.sprite2d !== void 0) diag.error("renderer live2d must not declare a sprite2d block");
+		if (source.frames2d !== void 0) diag.error("renderer live2d must not declare a frames2d block");
+	} else if (renderer === "frames2d") {
+		const block = parseFrames2dBlock(source.frames2d, diag);
+		if (block !== void 0) manifest.frames2d = block;
+		if (source.sprite2d !== void 0) diag.error("renderer frames2d must not declare a sprite2d block");
+		if (source.live2d !== void 0) diag.error("renderer frames2d must not declare a live2d block");
+	}
+	if (source.gameplay !== void 0) if (renderer !== "frames2d") diag.error("gameplay currently requires renderer frames2d (its state references name frames2d tracks)");
+	else {
+		const gameplay = parseGameplayManifest(source.gameplay, {
+			stateNames: new Set(Object.keys(manifest.frames2d?.tracks ?? {})),
+			error: (message) => diag.error("gameplay: " + message)
+		});
+		if (gameplay !== void 0) manifest.gameplay = gameplay;
 	}
 	const sequences = parseSequences(source.sequences, diag);
 	if (sequences !== void 0) manifest.sequences = sequences;
@@ -2824,6 +3616,173 @@ function resolveLive2dEntry(manifest, dir, options) {
 		...remarks === void 0 ? {} : { remarks }
 	};
 }
+/** Filename-encoded frame duration tail ('<base>_<index>_<ms>.webp'). */
+const FRAMES2D_FILENAME_MS = /_(\d+)\.[^.]+$/;
+/** Trailing frame index, allowing an optional '_<ms>' duration tail after it. */
+const FRAMES2D_FRAME_INDEX = /(\d+)(?:_\d+)?\.[^.]+$/;
+/** Default per-frame duration when neither frameMs nor the filename encodes one. */
+const FRAMES2D_DEFAULT_FRAME_MS = 200;
+/** Image extensions a frames2d track directory may list. */
+const FRAMES2D_IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+	".webp",
+	".png",
+	".gif",
+	".jpg",
+	".jpeg"
+]);
+/**
+* Resolve a validated frames2d manifest into a renderable entry. Track frame
+* lists come from the manifest's explicit list or from listing
+* '<dir>/<track>/' in filename order; durations resolve frameMs[i] >
+* filename-encoded '_<ms>' tail > defaultFrameMs. Missing frames warn and
+* skip (the live2d closure discipline); a track left with zero frames is
+* dropped, and if the idle-mapped track ends up empty the entry is rejected
+* fail-closed. The sprite fields carry contract defaults: the chrome sizes
+* frames2d pets off 'display.size', not the atlas.
+*/
+function resolveFrames2dEntry(manifest, dir, options) {
+	const assetPrefix = options.assetPrefix ?? "/pet";
+	const record = (level, message) => {
+		options.diagnostics?.push({
+			level,
+			source: dir,
+			message
+		});
+		options.warnings?.push(message);
+	};
+	const block = manifest.frames2d;
+	if (block === void 0) {
+		record("error", "pet " + manifest.id + ": renderer frames2d requires a frames2d block");
+		return;
+	}
+	const root = block.dir ?? ".";
+	const defaultMs = block.defaultFrameMs ?? FRAMES2D_DEFAULT_FRAME_MS;
+	const idleTrack = block.phases.idle;
+	const tracks = {};
+	const servable = [];
+	const firstFrameRel = {};
+	for (const [name, track] of Object.entries(block.tracks)) {
+		const trackDir = root === "." ? name : root + "/" + name;
+		let relFrames = [];
+		if (track.frames !== void 0) for (const frame of track.frames) {
+			const rel = trackDir + "/" + frame;
+			if (!existsSync(join(dir, rel))) {
+				record("warning", "pet " + manifest.id + ": frames2d frame missing: " + rel);
+				continue;
+			}
+			relFrames.push(rel);
+		}
+		else {
+			let files = [];
+			try {
+				files = readdirSync(join(dir, trackDir)).filter((file) => {
+					if (file.startsWith(".")) return false;
+					const dot = file.lastIndexOf(".");
+					return dot > 0 && FRAMES2D_IMAGE_EXTENSIONS.has(file.slice(dot).toLowerCase());
+				});
+			} catch {
+				files = [];
+			}
+			files.sort((a, b) => {
+				const ia = FRAMES2D_FRAME_INDEX.exec(a)?.[1];
+				const ib = FRAMES2D_FRAME_INDEX.exec(b)?.[1];
+				if (ia !== void 0 && ib !== void 0 && ia !== ib) return Number(ia) - Number(ib);
+				return a < b ? -1 : a > b ? 1 : 0;
+			});
+			relFrames = files.map((file) => trackDir + "/" + file);
+		}
+		if (relFrames.length === 0) {
+			record("warning", "pet " + manifest.id + ": frames2d track " + JSON.stringify(name) + " has no frames on disk; dropped");
+			continue;
+		}
+		const durations = relFrames.map((rel, index) => {
+			if (track.frameMs !== void 0) return track.frameMs[index] ?? defaultMs;
+			const match = FRAMES2D_FILENAME_MS.exec(rel);
+			if (match !== null) {
+				const ms = Number(match[1]);
+				if (Number.isInteger(ms) && ms >= 16 && ms <= 5e3) return ms;
+			}
+			return defaultMs;
+		});
+		const loop = track.loop ?? true;
+		tracks[name] = {
+			frames: relFrames.map((rel) => assetUrl(assetPrefix, manifest.id, rel)),
+			durations,
+			loop,
+			...loop ? {} : { fallback: track.fallback ?? idleTrack }
+		};
+		firstFrameRel[name] = relFrames[0];
+		servable.push(...relFrames);
+	}
+	if (tracks[idleTrack] === void 0) {
+		record("error", "pet " + manifest.id + ": frames2d idle track " + JSON.stringify(idleTrack) + " has no frames on disk");
+		return;
+	}
+	const phases = { ...block.phases };
+	for (const [phase, target] of Object.entries(phases)) if (target !== void 0 && tracks[target] === void 0) {
+		record("warning", "pet " + manifest.id + ": frames2d phase " + phase + " maps to dropped track " + JSON.stringify(target) + "; using idle");
+		phases[phase] = idleTrack;
+	}
+	const remarks = normalizePetRemarks(manifest.remarks, (message) => record("warning", "pet " + manifest.id + ": " + message));
+	let gameplay;
+	if (manifest.gameplay !== void 0) {
+		gameplay = manifest.gameplay;
+		if (gameplay.shop !== void 0) {
+			const items = [];
+			for (const item of gameplay.shop.items) {
+				if (item.image === void 0) {
+					items.push(item);
+					continue;
+				}
+				if (!existsSync(join(dir, item.image))) {
+					record("warning", "pet " + manifest.id + ": gameplay shop item " + item.id + " image missing: " + item.image);
+					const { image, ...rest } = item;
+					items.push(rest);
+					continue;
+				}
+				servable.push(item.image);
+				items.push({
+					...item,
+					image: assetUrl(assetPrefix, manifest.id, item.image)
+				});
+			}
+			gameplay = {
+				...gameplay,
+				shop: {
+					...gameplay.shop,
+					items
+				}
+			};
+		}
+	}
+	const flatTracks = buildTracks(DEFAULT_FRAME_COUNTS, 8, {}, (message) => record("warning", "pet " + manifest.id + ": " + message));
+	if (flatTracks === void 0) return void 0;
+	const firstAbs = join(dir, firstFrameRel[idleTrack]);
+	const dims = existsSync(firstAbs) ? readImageDimensions(firstAbs) : void 0;
+	const cell = dims !== void 0 && dims.width >= 1 && dims.height >= 1 ? dims : { ...DEFAULT_PET_CELL };
+	return {
+		id: manifest.id,
+		displayName: manifest.displayName,
+		description: manifest.description ?? "",
+		renderer: "frames2d",
+		frames2d: {
+			tracks,
+			phases
+		},
+		...gameplay === void 0 ? {} : { gameplay },
+		cell,
+		columns: 8,
+		rows: [...DEFAULT_FRAME_COUNTS],
+		atlasRows: 9,
+		tracks: flatTracks,
+		atlasUrl: tracks[idleTrack].frames[0],
+		manifestUrl: assetUrl(assetPrefix, manifest.id, "pet.json"),
+		dir,
+		spritesheetPath: firstFrameRel[idleTrack],
+		servable,
+		...remarks === void 0 ? {} : { remarks }
+	};
+}
 /** Scan one directory of pet folders; entries come back in name order. */
 function scanPetDir(dir, options) {
 	if (!existsSync(dir)) return [];
@@ -2853,6 +3812,7 @@ function scanPetDir(dir, options) {
 		if (!verdict.ok) continue;
 		let entry;
 		if (verdict.manifest.renderer === "live2d") entry = resolveLive2dEntry(verdict.manifest, entryDir, options);
+		else if (verdict.manifest.renderer === "frames2d") entry = resolveFrames2dEntry(verdict.manifest, entryDir, options);
 		else {
 			const legacy = flattenV2Sprite2d(verdict.manifest);
 			if (legacy === void 0) {
@@ -3144,7 +4104,7 @@ function loadPetRegistry(options) {
 		warnings,
 		diagnostics,
 		byId: (id) => byId.get(id),
-		defaultEntry: () => entries.find((entry) => builtinIds.has(entry.id)) ?? entries[0],
+		defaultEntry: () => entries.find((entry) => entry.id === "whale-girl" && builtinIds.has(entry.id)) ?? entries.find((entry) => builtinIds.has(entry.id)) ?? entries[0],
 		...globalVoice === void 0 ? {} : { globalVoice },
 		decorations,
 		decorationById: (id) => decorationById.get(id)
@@ -3180,6 +4140,8 @@ function petEntryView(entry, globalVoice) {
 		description: entry.description,
 		renderer: entry.renderer,
 		...entry.live2d === void 0 ? {} : { live2d: entry.live2d },
+		...entry.frames2d === void 0 ? {} : { frames2d: entry.frames2d },
+		...entry.gameplay === void 0 ? {} : { gameplay: entry.gameplay },
 		cell: entry.cell,
 		columns: entry.columns,
 		rows: entry.rows,
@@ -3191,6 +4153,23 @@ function petEntryView(entry, globalVoice) {
 		...panel === void 0 ? {} : { panel }
 	};
 }
+//#endregion
+//#region src/service.ts
+/**
+* Pet host service — the `pet.*` RPC domain. A composition facade: it wires
+* the pure event projection (`event-projection`) onto the state machine,
+* delegates the affinity economy to the ledger (`ledger`), and routes
+* persistence through `persist`. The API gateway maps these methods onto
+* `pet.state` / `pet.pets` / `pet.interact` / `pet.setVisible` /
+* `pet.setConfig` / `pet.setName` / `pet.setPet` for browser consumers.
+*
+* Concurrent sessions each keep their own machine: the sprite animation
+* follows the most recent meaningful event (the display session) while the
+* state view carries one bubble per active session.
+* @module @linxin666/dsh-pet/service
+*/
+/** The unified gameplay currency: the shared treat (小鱼干) ledger. */
+const GAMEPLAY_TREATS_CURRENCY = "treats";
 /** Hard cap on simultaneously displayed session bubbles (most recent first). */
 const MAX_SESSION_BUBBLES = 12;
 /**
@@ -3442,6 +4421,205 @@ var PetService = class extends Service {
 		if (this.ledger.takeDirty()) this.flush();
 		return result;
 	}
+	/** The active pet's gameplay block, if it declares one. */
+	gameplayDef() {
+		return this.activeEntry().gameplay;
+	}
+	/** The persisted (or fresh) gameplay state of the selected pet. */
+	gameplayState(def, now) {
+		const petId = this.selectedPetId();
+		const stored = this.ledger.snapshot.gameplay[petId];
+		return {
+			petId,
+			state: stored === void 0 ? initialGameplayState(def, now) : {
+				stats: { ...stored.stats },
+				currencies: { ...stored.currencies },
+				mode: stored.mode,
+				settledAt: stored.settledAt
+			}
+		};
+	}
+	/** Display view of one gameplay state (rounded stats; treats ride the shared treat ledger). */
+	gameplayViewOf(state) {
+		const stats = {};
+		for (const [name, value] of Object.entries(state.stats)) stats[name] = Math.round(value);
+		return {
+			stats,
+			mode: state.mode
+		};
+	}
+	/**
+	* Move gameplay 'treats' currency (the unified post-wallet currency) from
+	* the engine's settle work area into the shared treat ledger, capped by
+	* the stock cap. The engine keeps its generic currency record for settle
+	* math; this drain is the only bridge to the wallet-free economy.
+	*/
+	drainGameplayTreats(state) {
+		const pending = Math.floor(state.currencies[GAMEPLAY_TREATS_CURRENCY] ?? 0);
+		delete state.currencies[GAMEPLAY_TREATS_CURRENCY];
+		if (pending > 0) this.ledger.grantTreats(pending);
+	}
+	/** Persist the mutated gameplay state of one verb call. */
+	commitGameplay(petId, state) {
+		this.ledger.setGameplay(petId, state);
+		if (this.ledger.takeDirty()) this.flush();
+	}
+	/**
+	* RPC: a touch on the pet. 'zone' names a touch zone (roll a branch);
+	* omitted means a plain click while a touch animation holds (clickBoost).
+	*/
+	async gameplayTouch(zone) {
+		const def = this.gameplayDef();
+		if (def === void 0) return {
+			ok: false,
+			error: "no-gameplay"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		if (zone === void 0) {
+			const boost = def.touch?.clickBoost;
+			if (boost === void 0) return {
+				ok: false,
+				error: "no-touch"
+			};
+			const amount = boost.min + Math.floor(Math.random() * (boost.max - boost.min + 1));
+			if (amount > 0) applyGameplayEffects(state, def, [{
+				stat: boost.stat,
+				amount
+			}]);
+			this.drainGameplayTreats(state);
+			this.commitGameplay(petId, state);
+			return {
+				ok: true,
+				hit: false,
+				view: this.gameplayViewOf(state)
+			};
+		}
+		const target = def.touch?.zones.find((entry) => entry.name === zone);
+		if (target === void 0) return {
+			ok: false,
+			error: "unknown-zone"
+		};
+		const branch = rollTouchBranch(target, Math.random);
+		if (branch === void 0) {
+			this.drainGameplayTreats(state);
+			this.commitGameplay(petId, state);
+			return {
+				ok: true,
+				hit: false,
+				view: this.gameplayViewOf(state)
+			};
+		}
+		if (branch.effects !== void 0) applyGameplayEffects(state, def, branch.effects);
+		const phrase = branch.phrases !== void 0 && branch.phrases.length > 0 ? branch.phrases[Math.floor(Math.random() * branch.phrases.length)] : void 0;
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			hit: true,
+			...branch.state === void 0 ? {} : { state: branch.state },
+			...branch.stateMs === void 0 ? {} : { stateMs: branch.stateMs },
+			...phrase === void 0 ? {} : { phrase },
+			view: this.gameplayViewOf(state)
+		};
+	}
+	/** RPC: enter or leave a gameplay mode ('work' | 'sleep' | null). */
+	async gameplaySetMode(mode) {
+		const def = this.gameplayDef();
+		if (def === void 0) return {
+			ok: false,
+			error: "no-gameplay"
+		};
+		if (mode === "work" && def.work === void 0) return {
+			ok: false,
+			error: "no-work"
+		};
+		if (mode === "sleep" && def.sleep === void 0) return {
+			ok: false,
+			error: "no-sleep"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		state.mode = mode;
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			view: this.gameplayViewOf(state)
+		};
+	}
+	/** RPC: one work-round adjudication (only while the work mode holds). */
+	async gameplayWorkTick() {
+		const def = this.gameplayDef();
+		if (def?.work === void 0) return {
+			ok: false,
+			error: "no-work"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		if (state.mode !== "work") return {
+			ok: false,
+			error: "not-working"
+		};
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		const outcome = rollWorkOutcome(def.work, Math.random);
+		const effects = outcome === "success" ? def.work.success?.effects : def.work.fail?.effects;
+		if (effects !== void 0) applyGameplayEffects(state, def, effects);
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			outcome,
+			view: this.gameplayViewOf(state)
+		};
+	}
+	/** RPC: buy one shop item (effects, currency swap, or a lottery draw). */
+	async gameplayBuy(itemId) {
+		const def = this.gameplayDef();
+		if (def === void 0) return {
+			ok: false,
+			error: "no-gameplay"
+		};
+		const item = def.shop?.items.find((entry) => entry.id === itemId);
+		if (item === void 0) return {
+			ok: false,
+			error: "unknown-item"
+		};
+		const now = Date.now();
+		const { petId, state } = this.gameplayState(def, now);
+		settleGameplay(state, def, now, { sessionActive: this.machine.render().sessionActive });
+		const treats = item.currency === GAMEPLAY_TREATS_CURRENCY;
+		const balance = treats ? this.ledger.snapshot.treats.treats : state.currencies[item.currency] ?? 0;
+		if (balance < item.price) return {
+			ok: false,
+			error: "insufficient-funds",
+			view: this.gameplayViewOf(state)
+		};
+		if (treats) this.ledger.spendTreats(item.price);
+		else state.currencies[item.currency] = balance - item.price;
+		if (item.effects !== void 0) applyGameplayEffects(state, def, item.effects);
+		let prize;
+		if (item.lottery !== void 0) {
+			if (item.lottery.effects !== void 0) applyGameplayEffects(state, def, item.lottery.effects);
+			const tier = drawLotteryTier(item.lottery, Math.random);
+			const prizeCurrency = tier.currency ?? item.lottery.currency ?? item.currency;
+			if (prizeCurrency === GAMEPLAY_TREATS_CURRENCY) this.ledger.grantTreats(tier.prize);
+			else state.currencies[prizeCurrency] = (state.currencies[prizeCurrency] ?? 0) + tier.prize;
+			prize = {
+				amount: tier.prize,
+				currency: prizeCurrency
+			};
+		}
+		this.drainGameplayTreats(state);
+		this.commitGameplay(petId, state);
+		return {
+			ok: true,
+			...prize === void 0 ? {} : { prize },
+			view: this.gameplayViewOf(state)
+		};
+	}
 	/** RPC: show or hide the pet. */
 	async setVisible(visible) {
 		this.ledger.setDisplay({
@@ -3551,6 +4729,13 @@ var PetService = class extends Service {
 		const whisper = (this.displaySession === void 0 ? void 0 : this.sessionActivity.get(this.displaySession))?.whisper;
 		const freshWhisper = whisper !== void 0 && Date.now() - whisper.at < 8e3 ? whisper.text : void 0;
 		const decoration = this.activeDecoration();
+		const gameplayDef = this.gameplayDef();
+		let gameplay;
+		if (gameplayDef !== void 0) {
+			const { state } = this.gameplayState(gameplayDef, Date.now());
+			settleGameplay(state, gameplayDef, Date.now(), { sessionActive: snapshot.sessionActive });
+			gameplay = this.gameplayViewOf(state);
+		}
 		return {
 			animation: snapshot.animation,
 			...snapshot.bubble === void 0 ? {} : { bubble: snapshot.bubble },
@@ -3570,7 +4755,8 @@ var PetService = class extends Service {
 			treats: {
 				stocked: this.ledger.snapshot.treats.treats,
 				max: this.ledger.treatMax
-			}
+			},
+			...gameplay === void 0 ? {} : { gameplay }
 		};
 	}
 	flush() {
@@ -4210,6 +5396,22 @@ function makePetRoutes(deps) {
 			const petId = body.petId;
 			if (typeof petId !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-pet"));
 			return service.setPetId(petId);
+		}),
+		postRoute(ctx, "/api/pet/gameplay/touch", (body) => {
+			const zone = body.zone;
+			if (zone !== void 0 && typeof zone !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-zone"));
+			return service.gameplayTouch(zone);
+		}),
+		postRoute(ctx, "/api/pet/gameplay/mode", (body) => {
+			const mode = body.mode;
+			if (mode !== null && mode !== "work" && mode !== "sleep") return Promise.reject(/* @__PURE__ */ new Error("invalid-mode"));
+			return service.gameplaySetMode(mode);
+		}),
+		postRoute(ctx, "/api/pet/gameplay/work-tick", () => service.gameplayWorkTick()),
+		postRoute(ctx, "/api/pet/gameplay/buy", (body) => {
+			const item = body.item;
+			if (typeof item !== "string") return Promise.reject(/* @__PURE__ */ new Error("invalid-item"));
+			return service.gameplayBuy(item);
 		})
 	];
 	const assetRoute = {