dsh-poker 0.1.0

package/lib/index.js

@@ -0,0 +1,3051 @@
+import { a as MAX_ROOM_TITLE, c as SUBPROTOCOL, i as MAX_FRAME_BYTES, n as MAX_CHAT, o as MAX_SPECTATORS, r as MAX_DISPLAY_NAME } from "./invariant-C3ZiFskw.js";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
+import z from "@deepseek-ai/schemastery";
+import { createHash, randomBytes } from "node:crypto";
+import { z as z$1 } from "zod";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { WebSocket, WebSocketServer } from "ws";
+
+//#region src/settle/math.ts
+const STAKE_LADDER_M = [
+	1,
+	2,
+	5,
+	10,
+	20,
+	50,
+	100
+];
+const ATOMS_PER_M = 1000000n;
+const ATOMS_PER_B = 1000000000n;
+function perFarmerCapAtoms(stakeAtoms, maxMultiplier) {
+	return stakeAtoms * 3n * BigInt(maxMultiplier) * 2n;
+}
+function seatCapAtoms(stakeAtoms, maxMultiplier, seatCount = 3) {
+	return BigInt(seatCount - 1) * perFarmerCapAtoms(stakeAtoms, maxMultiplier);
+}
+/** Display token atoms as AI-token units: M (million) or B (billion). Never dump raw zeros. */
+function formatM(atoms) {
+	const sign = atoms < 0n ? "-" : "";
+	const abs = atoms < 0n ? -atoms : atoms;
+	if (abs >= ATOMS_PER_B) return `${sign}${formatScaled(abs, ATOMS_PER_B)}B`;
+	return `${sign}${formatScaled(abs, ATOMS_PER_M)}M`;
+}
+function formatScaled(abs, unit) {
+	const whole = abs / unit;
+	const rem = abs % unit;
+	if (rem === 0n) return whole.toString();
+	const decimals = unit.toString().length - 1;
+	const frac = rem.toString().padStart(decimals, "0").replace(/0+$/, "");
+	return `${whole.toString()}.${frac}`;
+}
+
+//#endregion
+//#region src/config.ts
+const DEFAULT_STAKE_M = 1;
+const DEFAULT_MAX_MULTIPLIER = 8;
+const DEFAULT_WELCOME_ATOMS = "200000000";
+const DEFAULT_SEAT_COUNT = 3;
+const DEFAULT_TURN_TIMEOUT_MS = 12e4;
+const MAX_MULTIPLIER_OPTIONS = [
+	8,
+	16,
+	32,
+	64
+];
+const Config = z.object({
+	enabled: z.boolean().default(true),
+	welcomeAtoms: z.string().default(DEFAULT_WELCOME_ATOMS),
+	defaultStakeM: z.number().default(DEFAULT_STAKE_M),
+	defaultMaxMultiplier: z.number().default(DEFAULT_MAX_MULTIPLIER),
+	defaultSeatCount: z.union([z.const(3), z.const(4)]).default(DEFAULT_SEAT_COUNT),
+	defaultLaiZi: z.boolean().default(false),
+	publicBaseUrl: z.string().default(""),
+	maxRooms: z.number().default(32),
+	allowSpectators: z.boolean().default(true),
+	spectatorCardCounter: z.boolean().default(false),
+	houseEnabled: z.boolean().default(false),
+	reconnectWindowMs: z.number().default(12e4),
+	turnTimeoutMs: z.number().default(DEFAULT_TURN_TIMEOUT_MS),
+	doubleWindowMs: z.number().default(8e3),
+	heartbeatMs: z.number().default(15e3),
+	disconnectAfterMs: z.number().default(6e4),
+	retainClosedRoomsHours: z.number().default(24),
+	inviteTtlHours: z.number().default(24),
+	routePrefix: z.string().default("/doudizhu")
+});
+function resolveConfig(config) {
+	const welcomeAtoms = parseWelcome(config.welcomeAtoms ?? DEFAULT_WELCOME_ATOMS);
+	const defaultStakeM = config.defaultStakeM ?? DEFAULT_STAKE_M;
+	const defaultMaxMultiplier = config.defaultMaxMultiplier ?? DEFAULT_MAX_MULTIPLIER;
+	return {
+		enabled: config.enabled !== false,
+		welcomeAtoms,
+		defaultStakeM,
+		defaultMaxMultiplier,
+		defaultSeatCount: config.defaultSeatCount === 4 ? 4 : 3,
+		defaultLaiZi: config.defaultLaiZi === true,
+		publicBaseUrl: (config.publicBaseUrl ?? "").replace(/\/+$/, ""),
+		maxRooms: config.maxRooms ?? 32,
+		allowSpectators: config.allowSpectators !== false,
+		spectatorCardCounter: config.spectatorCardCounter === true,
+		houseEnabled: false,
+		reconnectWindowMs: config.reconnectWindowMs ?? 12e4,
+		turnTimeoutMs: config.turnTimeoutMs ?? DEFAULT_TURN_TIMEOUT_MS,
+		doubleWindowMs: config.doubleWindowMs ?? 8e3,
+		heartbeatMs: config.heartbeatMs ?? 15e3,
+		disconnectAfterMs: config.disconnectAfterMs ?? 6e4,
+		retainClosedRoomsHours: config.retainClosedRoomsHours ?? 24,
+		inviteTtlHours: config.inviteTtlHours ?? 24,
+		routePrefix: normalizePrefix(config.routePrefix ?? "/doudizhu")
+	};
+}
+function parseWelcome(value) {
+	if (!/^\d+$/.test(value)) throw new Error("welcomeAtoms must be a non-negative decimal string");
+	return BigInt(value);
+}
+function validatePublicBaseUrl(value) {
+	if (value === "") return "";
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new Error("publicBaseUrl must be an absolute http(s) origin");
+	}
+	if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new Error("publicBaseUrl must be http or https");
+	if (parsed.origin !== value.replace(/\/+$/, "")) throw new Error("publicBaseUrl must be an origin with no path, query, or trailing slash");
+	return parsed.origin;
+}
+function assertCreateEconomy(welcomeAtoms, stakeM, maxMultiplier, seatCount = 3) {
+	if (!STAKE_LADDER_M.includes(stakeM)) throw new Error(`stakeM must be one of ${STAKE_LADDER_M.join(",")}`);
+	if (!MAX_MULTIPLIER_OPTIONS.includes(maxMultiplier)) throw new Error(`maxMultiplier must be one of ${MAX_MULTIPLIER_OPTIONS.join(",")}`);
+	if (seatCount !== 3 && seatCount !== 4) throw new Error("seatCount must be 3 or 4");
+	if (welcomeAtoms < seatCapAtoms(BigInt(stakeM) * 1000000n, maxMultiplier, seatCount)) throw failWelcome();
+}
+function failWelcome() {
+	return Object.assign(/* @__PURE__ */ new Error("welcome-below-seatcap"), {
+		name: "welcome-below-seatcap",
+		code: "insufficient"
+	});
+}
+function normalizePrefix(prefix) {
+	if (!prefix.startsWith("/")) return `/${prefix.replace(/\/+$/, "")}`;
+	return prefix.replace(/\/+$/, "") || "/doudizhu";
+}
+
+//#endregion
+//#region src/crypto.ts
+function randomId(prefix) {
+	return `${prefix}_${randomBytes(10).toString("hex")}`;
+}
+function randomRoomCode() {
+	return (randomBytes(4).readUInt32BE(0) % 1e6).toString().padStart(6, "0");
+}
+function randomToken() {
+	return randomBytes(32).toString("base64url").replace(/=+$/, "");
+}
+function sha256Hex(value) {
+	return createHash("sha256").update(value).digest("hex");
+}
+function inviteHash(roomSecret, domain, token) {
+	return sha256Hex(`${roomSecret}|${domain}|${token}`);
+}
+function cookieValue() {
+	return randomBytes(24).toString("base64url");
+}
+function nowIso(date = /* @__PURE__ */ new Date()) {
+	return date.toISOString();
+}
+function addHours(hours, date = /* @__PURE__ */ new Date()) {
+	return new Date(date.getTime() + hours * 36e5).toISOString();
+}
+
+//#endregion
+//#region src/types.ts
+function asTokenAtomString(value) {
+	return String(value);
+}
+function parseAtoms(value) {
+	if (!/^-?\d+$/.test(value)) throw new Error(`invalid atom string: ${value}`);
+	return BigInt(value);
+}
+function asCardId(value) {
+	return value;
+}
+function asPlayerId(value) {
+	return value;
+}
+function asRoomId(value) {
+	return value;
+}
+function asHandId(value) {
+	return value;
+}
+function asGrantId(value) {
+	return value;
+}
+function asSettlementId(value) {
+	return value;
+}
+function asEntryId(value) {
+	return value;
+}
+function nextSeat(seat, count = 3) {
+	return (seat + 1) % count;
+}
+function prevSeat(seat, count = 3) {
+	return (seat + count - 1) % count;
+}
+function decksFor(count) {
+	return count === 3 ? 1 : 2;
+}
+function holeCount(count) {
+	return count === 3 ? 3 : 8;
+}
+function dealtHandSize(count) {
+	return count === 3 ? 17 : 25;
+}
+function landlordHandSize(count) {
+	return dealtHandSize(count) + holeCount(count);
+}
+
+//#endregion
+//#region src/engine/cards.ts
+const SUITS = [
+	"S",
+	"H",
+	"C",
+	"D"
+];
+const RANK_ORDER = [
+	"3",
+	"4",
+	"5",
+	"6",
+	"7",
+	"8",
+	"9",
+	"10",
+	"J",
+	"Q",
+	"K",
+	"A",
+	"2",
+	"BJ",
+	"RJ"
+];
+const RANK_VALUE = Object.fromEntries(RANK_ORDER.map((rank, index) => [rank, index]));
+function cardBase(card) {
+	return String(card).split("~")[0] ?? String(card);
+}
+function rankOf(card) {
+	const raw = cardBase(card);
+	if (raw === "BJ" || raw === "RJ") return raw;
+	if (raw.startsWith("S") || raw.startsWith("H") || raw.startsWith("C") || raw.startsWith("D")) return raw.slice(1);
+	throw new Error(`invalid card: ${raw}`);
+}
+function rankValue(rank) {
+	const value = RANK_VALUE[rank];
+	if (value === void 0) throw new Error(`invalid rank: ${rank}`);
+	return value;
+}
+function cardValue(card) {
+	return rankValue(rankOf(card));
+}
+function compareCards(a, b) {
+	const byRank = cardValue(a) - cardValue(b);
+	if (byRank !== 0) return byRank;
+	return a.localeCompare(b);
+}
+function sortCards(cards) {
+	return [...cards].sort(compareCards);
+}
+function fullDeck(copy = 0) {
+	const suffix = copy === 0 ? "" : `~${copy}`;
+	const cards = [];
+	for (const suit of SUITS) for (const rank of RANK_ORDER) {
+		if (rank === "BJ" || rank === "RJ") continue;
+		cards.push(asCardId(`${suit}${rank}${suffix}`));
+	}
+	cards.push(asCardId(`BJ${suffix}`), asCardId(`RJ${suffix}`));
+	return cards;
+}
+function stackedDeck(decks) {
+	const cards = [];
+	for (let copy = 0; copy < decks; copy += 1) cards.push(...fullDeck(copy));
+	return cards;
+}
+const WILDABLE_RANKS = RANK_ORDER.filter((rank) => rank !== "BJ" && rank !== "RJ");
+function isJokerRank(rank) {
+	return rank === "BJ" || rank === "RJ";
+}
+function isWildCard(card, wildRanks) {
+	if (wildRanks.length === 0) return false;
+	const rank = rankOf(card);
+	return !isJokerRank(rank) && wildRanks.includes(rank);
+}
+function shuffle(items, random) {
+	const next = [...items];
+	for (let i = next.length - 1; i > 0; i -= 1) {
+		const j = Math.floor(random() * (i + 1));
+		const a = next[i];
+		const b = next[j];
+		if (a === void 0 || b === void 0) continue;
+		next[i] = b;
+		next[j] = a;
+	}
+	return next;
+}
+function countRanks(cards) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const card of cards) {
+		const rank = rankOf(card);
+		const bucket = groups.get(rank);
+		if (bucket) bucket.push(card);
+		else groups.set(rank, [card]);
+	}
+	return groups;
+}
+function isNaturalSeqRank(rank) {
+	return rank !== "2" && rank !== "BJ" && rank !== "RJ";
+}
+
+//#endregion
+//#region src/engine/random.ts
+function cryptoUnit() {
+	return randomBytes(4).readUInt32BE(0) / 4294967296;
+}
+
+//#endregion
+//#region src/engine/deal.ts
+function dealCards(seatCount = 3, random = cryptoUnit) {
+	const deck = shuffle(stackedDeck(seatCount === 3 ? 1 : 2), random);
+	const hole = holeCount(seatCount);
+	const per = (deck.length - hole) / seatCount;
+	return {
+		hands: Array.from({ length: seatCount }, (_, index) => deck.slice(index * per, (index + 1) * per).map(asCardId)),
+		bottom: deck.slice(seatCount * per, seatCount * per + hole).map(asCardId)
+	};
+}
+function giveBottom(hands, bottom, landlord) {
+	return hands.map((hand, index) => index === landlord ? [...hand, ...bottom] : [...hand]);
+}
+function randomSeat(count = 3, random = cryptoUnit) {
+	return Math.floor(random() * count);
+}
+function pickLaiZiRanks(count, random = cryptoUnit, exclude = []) {
+	const pool = WILDABLE_RANKS.filter((rank) => !exclude.includes(rank));
+	const picked = [];
+	const available = [...pool];
+	for (let i = 0; i < count && available.length > 0; i += 1) {
+		const index = Math.floor(random() * available.length);
+		const rank = available.splice(index, 1)[0];
+		if (rank) picked.push(rank);
+	}
+	return picked;
+}
+
+//#endregion
+//#region src/engine/hands.ts
+function classify(cards, laiZiRanks = []) {
+	if (laiZiRanks.length === 0) return classifyNatural(cards);
+	const wilds = [];
+	const naturals = [];
+	for (const card of cards) if (isWildCard(card, laiZiRanks)) wilds.push(card);
+	else naturals.push(card);
+	if (wilds.length === 0) return classifyNatural(cards);
+	return classifyWithWilds(cards, naturals, wilds.length);
+}
+function classifyNatural(cards) {
+	const sorted = sortCards(cards);
+	if (sorted.length === 0) return null;
+	const ranks = countRanks(sorted);
+	const entries = [...ranks.entries()].sort((a, b) => rankValue(a[0]) - rankValue(b[0]));
+	if (jokerCount(ranks) === sorted.length && sorted.length >= 2) return {
+		type: "rocket",
+		cards: sorted,
+		key: rankValue("RJ"),
+		length: sorted.length,
+		wingLength: 0
+	};
+	if (sorted.length === 1) return {
+		type: "solo",
+		cards: sorted,
+		key: cardValue(sorted[0]),
+		length: 1,
+		wingLength: 0
+	};
+	if (sorted.length === 2 && entries.length === 1) return {
+		type: "pair",
+		cards: sorted,
+		key: rankValue(entries[0][0]),
+		length: 2,
+		wingLength: 0
+	};
+	if (sorted.length === 3 && entries.length === 1) return {
+		type: "trio",
+		cards: sorted,
+		key: rankValue(entries[0][0]),
+		length: 3,
+		wingLength: 0
+	};
+	if (sorted.length >= 4 && entries.length === 1) return {
+		type: "bomb",
+		cards: sorted,
+		key: rankValue(entries[0][0]),
+		length: sorted.length,
+		wingLength: 0
+	};
+	const trioSolo = classifyTrioSolo(sorted, entries);
+	if (trioSolo) return trioSolo;
+	const trioPair = classifyTrioPair(sorted, entries);
+	if (trioPair) return trioPair;
+	const seq = classifySeq(sorted, entries);
+	if (seq) return seq;
+	const seqPair = classifySeqPair(sorted, entries);
+	if (seqPair) return seqPair;
+	const plane = classifyBarePlane(sorted, entries);
+	if (plane) return plane;
+	const planePair = classifyPlanePair(sorted, entries);
+	if (planePair) return planePair;
+	const planeSolo = classifyPlaneSolo(sorted, entries);
+	if (planeSolo) return planeSolo;
+	const fourDualPair = classifyFourDualPair(sorted, entries);
+	if (fourDualPair) return fourDualPair;
+	const fourDualSolo = classifyFourDualSolo(sorted, entries);
+	if (fourDualSolo) return fourDualSolo;
+	return null;
+}
+function beats(prev, next, decks = 1) {
+	const nextBomb = next.type === "bomb" || next.type === "rocket";
+	const prevBomb = prev.type === "bomb" || prev.type === "rocket";
+	if (next.type === "rocket" && decks === 1) return prev.type !== "rocket";
+	if (prev.type === "rocket" && decks === 1) return false;
+	if (nextBomb && prevBomb) {
+		if (next.length !== prev.length) return next.length > prev.length;
+		if (!!next.wild !== !!prev.wild) return !next.wild && !!prev.wild;
+		if (next.type !== prev.type) return next.type === "rocket";
+		return next.key > prev.key;
+	}
+	if (nextBomb) return true;
+	if (prevBomb) return false;
+	if (next.type !== prev.type || next.length !== prev.length || next.wingLength !== prev.wingLength) return false;
+	return next.key > prev.key;
+}
+function enumerateLegal(hand, lead, laiZiRanks = [], decks = 1) {
+	const sorted = sortCards(hand);
+	const combos = [];
+	const seen = /* @__PURE__ */ new Set();
+	const push = (type, cards) => {
+		const key = `${type}:${sortCards(cards).join(",")}`;
+		if (seen.has(key)) return;
+		seen.add(key);
+		combos.push({
+			type,
+			cards: sortCards(cards)
+		});
+	};
+	if (lead === null) {
+		for (const subset of generateCandidates(sorted)) {
+			const classified = classify(subset, laiZiRanks);
+			if (classified) push(classified.type, classified.cards);
+		}
+		return capCombos(combos);
+	}
+	if (!(lead.type === "rocket" && decks === 1)) {
+		for (const bomb of findBombs(sorted, laiZiRanks)) {
+			const classified = classify(bomb, laiZiRanks);
+			if (classified && beats(lead, classified, decks)) push(classified.type, classified.cards);
+		}
+		const rocket = sorted.filter((card) => isJokerRank(rankOf(card)));
+		if (rocket.length >= 2) push("rocket", rocket);
+	}
+	for (const subset of generateFollowCandidates(sorted, lead)) {
+		const classified = classify(subset, laiZiRanks);
+		if (classified && beats(lead, classified, decks)) push(classified.type, classified.cards);
+	}
+	return capCombos(combos);
+}
+function smallestSolo(hand) {
+	return sortCards(hand)[0] ?? null;
+}
+function classifyTrioSolo(cards, entries) {
+	if (cards.length !== 4) return null;
+	const trio = entries.find(([, group]) => group.length === 3);
+	const kicker = entries.find(([, group]) => group.length === 1);
+	if (!trio || !kicker) return null;
+	if (kicker[0] === "BJ" && entries.some(([rank]) => rank === "RJ")) return null;
+	if (kicker[0] === "RJ" && entries.some(([rank]) => rank === "BJ")) return null;
+	return {
+		type: "trioSolo",
+		cards,
+		key: rankValue(trio[0]),
+		length: 4,
+		wingLength: 1
+	};
+}
+function classifyTrioPair(cards, entries) {
+	if (cards.length !== 5) return null;
+	const trio = entries.find(([, group]) => group.length === 3);
+	const pair = entries.find(([, group]) => group.length === 2);
+	if (!trio || !pair || pair[0] === trio[0]) return null;
+	return {
+		type: "trioPair",
+		cards,
+		key: rankValue(trio[0]),
+		length: 5,
+		wingLength: 2
+	};
+}
+function classifySeq(cards, entries) {
+	if (cards.length < 5) return null;
+	if (!entries.every(([, group]) => group.length === 1)) return null;
+	if (!isConsecutive(entries.map(([rank]) => rank), 1)) return null;
+	return {
+		type: "seq",
+		cards,
+		key: rankValue(entries[entries.length - 1][0]),
+		length: cards.length,
+		wingLength: 0
+	};
+}
+function classifySeqPair(cards, entries) {
+	if (cards.length < 6 || cards.length % 2 !== 0) return null;
+	if (!entries.every(([, group]) => group.length === 2)) return null;
+	if (!isConsecutive(entries.map(([rank]) => rank), 1)) return null;
+	if (entries.length < 3) return null;
+	return {
+		type: "seqPair",
+		cards,
+		key: rankValue(entries[entries.length - 1][0]),
+		length: cards.length,
+		wingLength: 0
+	};
+}
+function classifyBarePlane(cards, entries) {
+	const trios = entries.filter(([, group]) => group.length === 3).map(([rank]) => rank);
+	if (trios.length < 2) return null;
+	if (entries.some(([, group]) => group.length !== 3)) return null;
+	if (!isConsecutive(trios, 1)) return null;
+	return {
+		type: "plane",
+		cards,
+		key: rankValue(trios[trios.length - 1]),
+		length: cards.length,
+		wingLength: 0
+	};
+}
+function classifyPlaneSolo(cards, entries = [...countRanks(cards).entries()].sort((a, b) => rankValue(a[0]) - rankValue(b[0]))) {
+	const available = entries.filter(([rank, group]) => group.length >= 3 && isNaturalSeqRank(rank) && rank !== "2").map(([rank]) => rank).sort((a, b) => rankValue(a) - rankValue(b));
+	const maxK = Math.min(available.length, Math.floor(cards.length / 4));
+	for (let k = maxK; k >= 2; k -= 1) {
+		if (cards.length !== k * 4) continue;
+		const found = [];
+		for (const body of consecutiveRuns(available, k)) {
+			const leftover = leftoverAfterBody(cards, body, 3);
+			if (leftover.length !== k) continue;
+			if (containsConsecutiveTrios(leftover)) continue;
+			found.push({
+				type: "planeSolo",
+				cards,
+				key: rankValue(body[body.length - 1]),
+				length: cards.length,
+				wingLength: k
+			});
+		}
+		if (found.length > 0) {
+			found.sort((a, b) => b.key - a.key);
+			return found[0] ?? null;
+		}
+	}
+	return null;
+}
+function classifyPlanePair(cards, entries) {
+	entries.filter(([, group]) => group.length >= 3 && isNaturalSeqRank(group[0] ? rankOf(group[0]) : "3") && rankOf(group[0]) !== "2");
+	const trioRanks = entries.filter(([rank, group]) => group.length >= 3 && isNaturalSeqRank(rank) && rank !== "2").map(([rank]) => rank).sort((a, b) => rankValue(a) - rankValue(b));
+	for (let k = Math.min(trioRanks.length, Math.floor(cards.length / 5)); k >= 2; k -= 1) {
+		if (cards.length !== k * 5) continue;
+		for (const body of consecutiveRuns(trioRanks, k)) if (pairWings(cards, body) === k) return {
+			type: "planePair",
+			cards,
+			key: rankValue(body[body.length - 1]),
+			length: cards.length,
+			wingLength: k
+		};
+	}
+	return null;
+}
+function classifyFourDualSolo(cards, entries) {
+	if (cards.length !== 6) return null;
+	const quad = entries.find(([, group]) => group.length === 4);
+	if (!quad) return null;
+	const leftovers = cards.filter((card) => rankOf(card) !== quad[0]);
+	if (leftovers.length !== 2) return null;
+	if (hasRocket(countRanks(leftovers))) return null;
+	return {
+		type: "fourDualSolo",
+		cards,
+		key: rankValue(quad[0]),
+		length: 6,
+		wingLength: 2
+	};
+}
+function classifyFourDualPair(cards, entries) {
+	if (cards.length !== 8) return null;
+	const quad = entries.find(([, group]) => group.length === 4);
+	if (!quad) return null;
+	const leftoverGroups = [...countRanks(leftoverAfterBody(cards, [quad[0]], 4)).entries()];
+	if (leftoverGroups.some(([rank, group]) => rank === quad[0] || group.length !== 2)) return null;
+	if (leftoverGroups.length !== 2) return null;
+	return {
+		type: "fourDualPair",
+		cards,
+		key: rankValue(quad[0]),
+		length: 8,
+		wingLength: 4
+	};
+}
+function hasRocket(ranks) {
+	return (ranks.get("BJ")?.length ?? 0) >= 1 && (ranks.get("RJ")?.length ?? 0) >= 1;
+}
+function jokerCount(ranks) {
+	return (ranks.get("BJ")?.length ?? 0) + (ranks.get("RJ")?.length ?? 0);
+}
+function classifyWithWilds(original, naturals, wildCount) {
+	if (wildCount <= 0) return classifyNatural(original);
+	const ranksToTry = wildAssignmentRanks(naturals, wildCount);
+	let best = null;
+	const choice = new Array(wildCount).fill(0);
+	const walk = () => {
+		const virtuals = choice.map((index) => asCardId(`S${ranksToTry[index]}`));
+		const result = classifyNatural([...naturals, ...virtuals]);
+		if (!result) return;
+		const hand = {
+			...result,
+			cards: sortCards(original),
+			wild: true
+		};
+		if (!best || wildPreference(hand, best) > 0) best = hand;
+	};
+	const rec = (depth) => {
+		if (depth === wildCount) {
+			walk();
+			return;
+		}
+		for (let i = 0; i < ranksToTry.length; i += 1) {
+			choice[depth] = i;
+			rec(depth + 1);
+		}
+	};
+	rec(0);
+	return best;
+}
+function wildAssignmentRanks(naturals, wildCount) {
+	if (naturals.length === 0) return wildCount >= 4 ? ["2"] : [...WILDABLE_RANKS];
+	const present = new Set(naturals.map((card) => rankOf(card)));
+	if (wildCount >= 5) return WILDABLE_RANKS.filter((rank) => present.has(rank) || neighborsOf(present).has(rank));
+	return [...WILDABLE_RANKS];
+}
+function neighborsOf(present) {
+	const out = /* @__PURE__ */ new Set();
+	for (const rank of present) {
+		const value = rankValue(rank);
+		for (const candidate of WILDABLE_RANKS) if (Math.abs(rankValue(candidate) - value) === 1) out.add(candidate);
+	}
+	return out;
+}
+function wildPreference(next, prev) {
+	const bombScore = (hand) => {
+		if (hand.type === "rocket") return 200 + hand.length;
+		if (hand.type === "bomb") return 100 + hand.length;
+		return 0;
+	};
+	const byBomb = bombScore(next) - bombScore(prev);
+	if (byBomb !== 0) return byBomb;
+	if (next.length !== prev.length) return next.length - prev.length;
+	return next.key - prev.key;
+}
+function isConsecutive(ranks, step) {
+	if (ranks.some((rank) => !isNaturalSeqRank(rank))) return false;
+	for (let i = 1; i < ranks.length; i += 1) if (rankValue(ranks[i]) - rankValue(ranks[i - 1]) !== step) return false;
+	return ranks.length > 0;
+}
+function consecutiveRuns(ranks, length) {
+	const runs = [];
+	for (let i = 0; i + length <= ranks.length; i += 1) {
+		const slice = ranks.slice(i, i + length);
+		if (isConsecutive(slice, 1)) runs.push(slice);
+	}
+	return runs;
+}
+function containsConsecutiveTrios(cards) {
+	return consecutiveRuns([...countRanks(cards).entries()].filter(([, group]) => group.length >= 3).map(([rank]) => rank).filter((rank) => isNaturalSeqRank(rank) && rank !== "2").sort((a, b) => rankValue(a) - rankValue(b)), 2).length > 0;
+}
+function pairWings(cards, body) {
+	const groups = countRanks(leftoverAfterBody(cards, body, 3));
+	if ([...groups.values()].some((group) => group.length !== 2 && group.length !== 4)) return null;
+	let pairs = 0;
+	for (const [rank, group] of groups) {
+		if (body.includes(rank)) return null;
+		if (group.length === 2) pairs += 1;
+		else if (group.length === 4) pairs += 2;
+		else return null;
+	}
+	return pairs;
+}
+function leftoverAfterBody(cards, body, take) {
+	const used = /* @__PURE__ */ new Map();
+	for (const rank of body) used.set(rank, take);
+	const leftover = [];
+	for (const card of cards) {
+		const rank = rankOf(card);
+		const remaining = used.get(rank) ?? 0;
+		if (remaining > 0) used.set(rank, remaining - 1);
+		else leftover.push(card);
+	}
+	return leftover;
+}
+function findBombs(hand, laiZiRanks = []) {
+	const bombs = [];
+	const ranks = countRanks(hand);
+	const wilds = laiZiRanks.length === 0 ? [] : hand.filter((card) => isWildCard(card, laiZiRanks));
+	for (const [rank, group] of ranks) {
+		if (isJokerRank(rank)) continue;
+		const natural = laiZiRanks.includes(rank) ? group.filter((card) => !isWildCard(card, laiZiRanks)) : group;
+		const total = natural.length + wilds.length;
+		if (natural.length + (laiZiRanks.includes(rank) ? 0 : 0) >= 4 || total >= 4) {
+			if (natural.length >= 4) bombs.push(natural.slice(0, Math.max(4, natural.length)));
+			if (wilds.length > 0 && total >= 4) bombs.push([...natural, ...wilds].slice(0, total));
+		}
+	}
+	const jokers = hand.filter((card) => isJokerRank(rankOf(card)));
+	if (jokers.length >= 2) bombs.push(jokers);
+	return bombs;
+}
+function generateCandidates(hand) {
+	const out = [];
+	const ranks = countRanks(hand);
+	for (const group of ranks.values()) for (let n = 1; n <= group.length; n += 1) out.push(group.slice(0, n));
+	const rocket = hand.filter((card) => isJokerRank(rankOf(card)));
+	if (rocket.length === 2) out.push(rocket);
+	appendSeqs(out, ranks, 1, 5);
+	appendSeqs(out, ranks, 2, 3);
+	appendPlanes(out, hand, ranks);
+	appendKickers(out, hand, ranks);
+	return out;
+}
+function generateFollowCandidates(hand, lead) {
+	return generateCandidates(hand).filter((subset) => subset.length === lead.length);
+}
+function appendSeqs(out, ranks, copies, minLen) {
+	const usable = [...ranks.entries()].filter(([rank, group]) => isNaturalSeqRank(rank) && group.length >= copies).sort((a, b) => rankValue(a[0]) - rankValue(b[0]));
+	for (let len = minLen; len <= usable.length; len += 1) for (let i = 0; i + len <= usable.length; i += 1) {
+		const slice = usable.slice(i, i + len);
+		if (!isConsecutive(slice.map(([rank]) => rank), 1)) continue;
+		out.push(slice.flatMap(([, group]) => group.slice(0, copies)));
+	}
+}
+function appendPlanes(out, hand, ranks) {
+	const trioRanks = [...ranks.entries()].filter(([rank, group]) => group.length >= 3 && isNaturalSeqRank(rank) && rank !== "2").map(([rank]) => rank).sort((a, b) => rankValue(a) - rankValue(b));
+	for (let k = 2; k <= trioRanks.length; k += 1) for (const body of consecutiveRuns(trioRanks, k)) {
+		const bodyCards = leftoverInverse(hand, body, 3);
+		out.push(bodyCards);
+		const rest = leftoverAfterBody(hand, body, 3);
+		for (const wings of combinations(rest, k)) out.push([...bodyCards, ...wings]);
+		const pairs = pairCombinations(rest, k);
+		for (const wings of pairs) out.push([...bodyCards, ...wings]);
+	}
+}
+function leftoverInverse(hand, body, take) {
+	const used = /* @__PURE__ */ new Map();
+	for (const rank of body) used.set(rank, take);
+	const taken = [];
+	for (const card of hand) {
+		const rank = rankOf(card);
+		const remaining = used.get(rank) ?? 0;
+		if (remaining > 0) {
+			used.set(rank, remaining - 1);
+			taken.push(card);
+		}
+	}
+	return taken;
+}
+function appendKickers(out, hand, ranks) {
+	for (const [rank, group] of ranks) {
+		if (group.length >= 3) {
+			const trio = group.slice(0, 3);
+			for (const card of hand) {
+				if (rankOf(card) === rank) continue;
+				out.push([...trio, card]);
+			}
+			for (const [other, otherGroup] of ranks) {
+				if (other === rank || otherGroup.length < 2) continue;
+				out.push([...trio, ...otherGroup.slice(0, 2)]);
+			}
+		}
+		if (group.length === 4) {
+			const rest = hand.filter((card) => rankOf(card) !== rank);
+			for (const wings of combinations(rest, 2)) out.push([...group, ...wings]);
+			const pairRanks = [...ranks.entries()].filter(([r, g]) => r !== rank && g.length >= 2);
+			for (let i = 0; i < pairRanks.length; i += 1) for (let j = i + 1; j < pairRanks.length; j += 1) out.push([
+				...group,
+				...pairRanks[i][1].slice(0, 2),
+				...pairRanks[j][1].slice(0, 2)
+			]);
+		}
+	}
+}
+function combinations(items, k) {
+	const out = [];
+	const walk = (start, acc) => {
+		if (acc.length === k) {
+			out.push([...acc]);
+			return;
+		}
+		for (let i = start; i < items.length; i += 1) {
+			acc.push(items[i]);
+			walk(i + 1, acc);
+			acc.pop();
+		}
+	};
+	if (k <= items.length) walk(0, []);
+	return out;
+}
+function pairCombinations(items, k) {
+	const groups = [...countRanks(items).entries()].filter(([, group]) => group.length >= 2);
+	const out = [];
+	const walk = (start, acc, taken) => {
+		if (taken === k) {
+			out.push([...acc]);
+			return;
+		}
+		for (let i = start; i < groups.length; i += 1) {
+			const group = groups[i][1];
+			acc.push(...group.slice(0, 2));
+			walk(i + 1, acc, taken + 1);
+			acc.splice(acc.length - 2, 2);
+			if (group.length >= 4 && taken + 2 <= k) {
+				acc.push(...group.slice(0, 4));
+				walk(i + 1, acc, taken + 2);
+				acc.splice(acc.length - 4, 4);
+			}
+		}
+	};
+	walk(0, [], 0);
+	return out;
+}
+function capCombos(combos) {
+	if (combos.length <= 200) return combos;
+	return combos.slice(0, 200);
+}
+
+//#endregion
+//#region src/engine/play.ts
+function createHand(roomId, dealerSeat, seq, options = {}) {
+	const seatCount = options.seatCount ?? 3;
+	const laiZi = options.laiZi === true;
+	const deal = dealCards(seatCount);
+	const start = dealerSeat ?? randomSeat(seatCount);
+	const laiZiRanks = laiZi ? pickLaiZiRanks(2) : [];
+	return {
+		phase: "bidding",
+		seatCount,
+		laiZi,
+		hand: {
+			handId: asHandId(`hand_${roomId}_${seq}`),
+			roomId,
+			dealerSeat: start,
+			bottom: [...deal.bottom],
+			hands: deal.hands.map((cards) => [...cards]),
+			bid: 0,
+			landlordSeat: null,
+			farmerDoubledBySeat: {},
+			landlordReDouble: 1,
+			mingPaiBySeat: {},
+			mingPaiMult: 1,
+			bombCount: 0,
+			rocketCount: 0,
+			spring: "none",
+			table: [],
+			turnSeat: start,
+			leadSeat: start,
+			laiZiRanks
+		},
+		firstLeadSeq: null,
+		successfulLandlordPlaysAfterLead: 0,
+		farmerPlayed: Array.from({ length: seatCount }, () => false),
+		bids: Array.from({ length: seatCount }, () => null),
+		bidTurn: start,
+		called: false,
+		actedBid: Array.from({ length: seatCount }, () => false),
+		refusedCall: Array.from({ length: seatCount }, () => false),
+		robBackDone: false,
+		highestBidder: null,
+		passesInRow: 0,
+		doubleDeadlineAt: 0,
+		farmerDoubleDone: Array.from({ length: seatCount }, () => false),
+		landlordDoubleDone: false
+	};
+}
+function applyBid(state, seat, action) {
+	if (state.phase !== "bidding") return {
+		ok: false,
+		code: "phase",
+		reason: "not bidding"
+	};
+	if (state.bidTurn !== seat) return {
+		ok: false,
+		code: "not-your-turn",
+		reason: "not your bid"
+	};
+	const robBack = state.actedBid[seat] === true;
+	if (robBack && action === "call") return {
+		ok: false,
+		code: "illegal",
+		reason: "already called"
+	};
+	if (action === "call") {
+		if (state.called) return {
+			ok: false,
+			code: "illegal",
+			reason: "already called"
+		};
+		state.called = true;
+		state.highestBidder = seat;
+		state.hand.bid = 1;
+		if (state.refusedCall.filter(Boolean).length === state.seatCount - 1) {
+			state.bids[seat] = action;
+			state.actedBid[seat] = true;
+			lockLandlord(state, seat, 1);
+			return {
+				ok: true,
+				play: dummyPlay(seat),
+				emptied: false
+			};
+		}
+	} else if (action === "rob") {
+		if (!state.called) return {
+			ok: false,
+			code: "illegal",
+			reason: "nobody called yet"
+		};
+		if (state.refusedCall[seat]) return {
+			ok: false,
+			code: "illegal",
+			reason: "passed call cannot rob"
+		};
+		state.highestBidder = seat;
+		state.hand.bid = Math.max(1, state.hand.bid) * 2;
+	} else if (!state.called) state.refusedCall[seat] = true;
+	state.bids[seat] = action;
+	if (robBack) state.robBackDone = true;
+	else state.actedBid[seat] = true;
+	const next = nextBidder(state, seat);
+	if (next === null) {
+		if (!state.called || state.highestBidder === null || state.hand.bid === 0) {
+			state.phase = "redeal";
+			return {
+				ok: true,
+				play: dummyPlay(seat),
+				emptied: false
+			};
+		}
+		lockLandlord(state, state.highestBidder, state.hand.bid);
+		return {
+			ok: true,
+			play: dummyPlay(seat),
+			emptied: false
+		};
+	}
+	state.bidTurn = next;
+	return {
+		ok: true,
+		play: dummyPlay(seat),
+		emptied: false
+	};
+}
+function applyMingPai(state, seat) {
+	if (state.hand.mingPaiBySeat[seat]) return {
+		ok: false,
+		code: "illegal",
+		reason: "already ming pai"
+	};
+	if (state.phase === "bidding" && state.hand.landlordSeat === null) {
+		state.hand.mingPaiBySeat[seat] = true;
+		state.hand.mingPaiMult = Math.max(state.hand.mingPaiMult, 3);
+		if (!state.called && state.actedBid.every((acted) => !acted)) state.bidTurn = seat;
+		return {
+			ok: true,
+			play: dummyPlay(seat),
+			emptied: false
+		};
+	}
+	if (state.phase === "doubling" || state.phase === "playing") {
+		state.hand.mingPaiBySeat[seat] = true;
+		state.hand.mingPaiMult = Math.max(state.hand.mingPaiMult, 2);
+		return {
+			ok: true,
+			play: dummyPlay(seat),
+			emptied: false
+		};
+	}
+	return {
+		ok: false,
+		code: "phase",
+		reason: "cannot ming pai now"
+	};
+}
+function applyDouble(state, seat, action, now = Date.now()) {
+	if (state.phase !== "doubling") return {
+		ok: false,
+		code: "phase",
+		reason: "not doubling"
+	};
+	if (now > state.doubleDeadlineAt) {
+		finishDoubling(state);
+		return {
+			ok: false,
+			code: "phase",
+			reason: "double window closed"
+		};
+	}
+	const landlord = state.hand.landlordSeat;
+	if (landlord === null) return {
+		ok: false,
+		code: "phase",
+		reason: "no landlord"
+	};
+	const factor = action === "reDouble" ? 4 : action === "double" ? 2 : 1;
+	if (seat === landlord) {
+		if (state.landlordDoubleDone) return {
+			ok: false,
+			code: "illegal",
+			reason: "already answered"
+		};
+		state.hand.landlordReDouble = factor;
+		state.landlordDoubleDone = true;
+		if (farmersFinished(state)) finishDoubling(state);
+		return {
+			ok: true,
+			play: dummyPlay(seat),
+			emptied: false
+		};
+	}
+	if (state.farmerDoubleDone[seat]) return {
+		ok: false,
+		code: "illegal",
+		reason: "already answered"
+	};
+	state.farmerDoubleDone[seat] = true;
+	if (factor > 1) state.hand.farmerDoubledBySeat[seat] = factor;
+	if (farmersFinished(state) && state.landlordDoubleDone) finishDoubling(state);
+	return {
+		ok: true,
+		play: dummyPlay(seat),
+		emptied: false
+	};
+}
+function expireDoubling(state, now = Date.now()) {
+	if (state.phase !== "doubling") return;
+	if (now >= state.doubleDeadlineAt) finishDoubling(state);
+}
+function applyPlay(state, seat, cards, seq, ts) {
+	if (state.phase !== "playing") return {
+		ok: false,
+		code: "phase",
+		reason: "not playing"
+	};
+	if (state.hand.turnSeat !== seat) return {
+		ok: false,
+		code: "not-your-turn",
+		reason: "not your turn"
+	};
+	if (!containsAll(state.hand.hands[seat] ?? [], cards)) return {
+		ok: false,
+		code: "illegal",
+		reason: "cards not in hand"
+	};
+	const classified = classify(cards, state.hand.laiZiRanks);
+	if (!classified) return {
+		ok: false,
+		code: "illegal",
+		reason: "unknown hand type"
+	};
+	const lead = currentLead(state);
+	if (lead === null || state.hand.leadSeat === seat) return {
+		ok: true,
+		play: commitPlay(state, seat, classified, seq, ts),
+		emptied: state.hand.hands[seat].length === 0
+	};
+	if (!beats(lead, classified, decksFor(state.seatCount))) return {
+		ok: false,
+		code: "illegal",
+		reason: "does not beat lead"
+	};
+	return {
+		ok: true,
+		play: commitPlay(state, seat, classified, seq, ts),
+		emptied: (state.hand.hands[seat] ?? []).length === 0
+	};
+}
+function applyPass(state, seat, seq, ts) {
+	if (state.phase !== "playing") return {
+		ok: false,
+		code: "phase",
+		reason: "not playing"
+	};
+	if (state.hand.turnSeat !== seat) return {
+		ok: false,
+		code: "not-your-turn",
+		reason: "not your turn"
+	};
+	if (state.hand.leadSeat === seat || currentLead(state) === null) return {
+		ok: false,
+		code: "illegal",
+		reason: "cannot pass when leading"
+	};
+	const play = {
+		seat,
+		type: "pass",
+		cards: [],
+		seq,
+		ts
+	};
+	state.hand.table.push(play);
+	state.passesInRow += 1;
+	if (state.passesInRow >= state.seatCount - 1) {
+		state.hand.leadSeat = nextSeat(seat, state.seatCount);
+		state.hand.turnSeat = state.hand.leadSeat;
+		state.passesInRow = 0;
+	} else state.hand.turnSeat = nextSeat(seat, state.seatCount);
+	return {
+		ok: true,
+		play,
+		emptied: false
+	};
+}
+function autoTimeout(state, seq, ts) {
+	if (state.phase !== "playing") return null;
+	const seat = state.hand.turnSeat;
+	if (state.hand.leadSeat === seat || currentLead(state) === null) {
+		const card = smallestSolo(state.hand.hands[seat] ?? []);
+		if (!card) return null;
+		return applyPlay(state, seat, [card], seq, ts);
+	}
+	return applyPass(state, seat, seq, ts);
+}
+function legalFor(state, seat) {
+	if (state.phase !== "playing" || state.hand.turnSeat !== seat) return {
+		canPass: false,
+		combos: []
+	};
+	const lead = currentLead(state);
+	return {
+		canPass: !(state.hand.leadSeat === seat || lead === null),
+		combos: enumerateLegal(state.hand.hands[seat] ?? [], lead, state.hand.laiZiRanks, decksFor(state.seatCount))
+	};
+}
+function finishHand(state, winnerSeat) {
+	const landlord = state.hand.landlordSeat;
+	if (landlord === null) return;
+	const landlordEmptied = winnerSeat === landlord;
+	const farmersNeverPlayed = state.hand.hands.map((_, seat) => seat).filter((seat) => seat !== landlord).every((seat) => !state.farmerPlayed[seat]);
+	const spring = landlordEmptied && farmersNeverPlayed;
+	const anti = !landlordEmptied && state.successfulLandlordPlaysAfterLead === 0;
+	state.hand.spring = spring ? "spring" : anti ? "anti" : "none";
+	state.phase = "settled";
+}
+function snapshotHand(state) {
+	return {
+		...state.hand,
+		hands: state.hand.hands.map((cards) => sortCards(cards)),
+		bottom: [...state.hand.bottom],
+		table: [...state.hand.table],
+		farmerDoubledBySeat: { ...state.hand.farmerDoubledBySeat },
+		mingPaiBySeat: { ...state.hand.mingPaiBySeat },
+		laiZiRanks: [...state.hand.laiZiRanks]
+	};
+}
+function nextBidder(state, from) {
+	let seat = nextSeat(from, state.seatCount);
+	for (let i = 0; i < state.seatCount; i += 1) {
+		if (!state.actedBid[seat]) return seat;
+		seat = nextSeat(seat, state.seatCount);
+	}
+	const caller = firstCaller(state);
+	if (state.called && !state.robBackDone && caller !== null && state.highestBidder !== caller && !state.refusedCall[caller]) return caller;
+	return null;
+}
+function firstCaller(state) {
+	const index = state.bids.findIndex((bid) => bid === "call");
+	return index >= 0 ? index : null;
+}
+function lockLandlord(state, seat, bid) {
+	state.hand.landlordSeat = seat;
+	state.hand.bid = bid;
+	state.hand.hands = giveBottom(state.hand.hands, state.hand.bottom, seat);
+	state.hand.turnSeat = seat;
+	state.hand.leadSeat = seat;
+	state.phase = "doubling";
+	state.doubleDeadlineAt = Date.now() + 8e3;
+}
+function finishDoubling(state) {
+	if (state.phase !== "doubling") return;
+	state.phase = "playing";
+	state.passesInRow = 0;
+}
+function farmersFinished(state) {
+	const landlord = state.hand.landlordSeat;
+	return state.hand.hands.every((_, index) => {
+		const seat = index;
+		return seat === landlord || state.farmerDoubleDone[seat];
+	});
+}
+function currentLead(state) {
+	for (let i = state.hand.table.length - 1; i >= 0; i -= 1) {
+		const play = state.hand.table[i];
+		if (!play || play.type === "pass") continue;
+		return classify(play.cards, state.hand.laiZiRanks);
+	}
+	return null;
+}
+function commitPlay(state, seat, classified, seq, ts) {
+	const play = {
+		seat,
+		type: classified.type,
+		cards: classified.cards,
+		seq,
+		ts
+	};
+	const held = state.hand.hands[seat];
+	if (!held) return play;
+	removeCards(held, classified.cards);
+	state.hand.table.push(play);
+	if (classified.type === "bomb") state.hand.bombCount += 1;
+	if (classified.type === "rocket") state.hand.rocketCount += 1;
+	const landlord = state.hand.landlordSeat;
+	if (landlord !== null && seat !== landlord) state.farmerPlayed[seat] = true;
+	if (state.firstLeadSeq === null) state.firstLeadSeq = seq;
+	else if (landlord !== null && seat === landlord) state.successfulLandlordPlaysAfterLead += 1;
+	state.hand.leadSeat = seat;
+	state.hand.turnSeat = nextSeat(seat, state.seatCount);
+	state.passesInRow = 0;
+	if ((state.hand.hands[seat] ?? []).length === 0) finishHand(state, seat);
+	return play;
+}
+function containsAll(hand, cards) {
+	const bag = /* @__PURE__ */ new Map();
+	for (const card of hand) bag.set(card, (bag.get(card) ?? 0) + 1);
+	for (const card of cards) {
+		const count = bag.get(card) ?? 0;
+		if (count === 0) return false;
+		bag.set(card, count - 1);
+	}
+	return true;
+}
+function removeCards(hand, cards) {
+	for (const card of cards) {
+		const index = hand.indexOf(card);
+		if (index >= 0) hand.splice(index, 1);
+	}
+}
+function dummyPlay(seat) {
+	return {
+		seat,
+		type: "pass",
+		cards: [],
+		seq: 0,
+		ts: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+
+//#endregion
+//#region src/engine/score.ts
+function personalMult(value) {
+	if (value === true) return 2n;
+	if (typeof value === "number" && value > 1) return BigInt(value);
+	return 1n;
+}
+function scoreHand(input) {
+	const { hand, stakeAtoms, maxMultiplier, winner, playerIds } = input;
+	if (hand.landlordSeat === null) throw new Error("cannot score without a landlord");
+	if (hand.bid === 0) throw new Error("cannot score a void bid");
+	const springFlag = hand.spring === "none" ? 0 : 1;
+	const ming = hand.mingPaiMult > 1 ? hand.mingPaiMult : 1;
+	const raw = Math.max(1, hand.bid) * 2 ** (hand.bombCount + hand.rocketCount + springFlag) * ming;
+	const multiplier = Math.min(raw, maxMultiplier);
+	const unitAtoms = stakeAtoms * BigInt(multiplier);
+	const landlord = hand.landlordSeat;
+	const landlordPersonal = personalMult(hand.landlordReDouble);
+	const farmers = playerIds.map((_, index) => index).filter((seat) => seat !== landlord);
+	const farmerPays = /* @__PURE__ */ new Map();
+	for (const seat of farmers) farmerPays.set(seat, unitAtoms * personalMult(hand.farmerDoubledBySeat[seat]) * landlordPersonal);
+	const sign = winner === "landlord" ? 1n : -1n;
+	const landlordTotal = farmers.reduce((sum, seat) => sum + (farmerPays.get(seat) ?? 0n), 0n);
+	const deltas = playerIds.map((playerId, index) => {
+		const seat = index;
+		if (seat === landlord) return {
+			seat,
+			playerId,
+			atoms: asTokenAtomString(sign * landlordTotal)
+		};
+		return {
+			seat,
+			playerId,
+			atoms: asTokenAtomString(-sign * (farmerPays.get(seat) ?? 0n))
+		};
+	});
+	const formula = [
+		`${formatM(stakeAtoms)} × min(叫抢${hand.bid} × 2^(${hand.bombCount}炸 + ${hand.rocketCount}王炸 + ${springFlag}春天) × 明牌${ming}, ${maxMultiplier})`,
+		landlordPersonal > 1n ? `× 地主${landlordPersonal.toString()}` : "",
+		`= ${formatM(unitAtoms)}`
+	].filter(Boolean).join(" ");
+	return {
+		settlementId: asSettlementId(`set_${hand.handId}`),
+		handId: hand.handId,
+		winner,
+		unitAtoms: asTokenAtomString(unitAtoms),
+		deltas,
+		rakeAtoms: asTokenAtomString(0n),
+		formula
+	};
+}
+
+//#endregion
+//#region src/identity/player.ts
+function newPlayerId() {
+	return asPlayerId(randomId("pl"));
+}
+function sanitizeDisplayName(raw) {
+	const trimmed = raw.trim().replace(/\s+/g, " ");
+	if (trimmed.length === 0) return "玩家";
+	return trimmed.slice(0, MAX_DISPLAY_NAME);
+}
+function sanitizeRoomTitle(raw, fallback = "好友局") {
+	const trimmed = raw.trim().replace(/\s+/g, " ");
+	if (trimmed.length === 0) return fallback;
+	return trimmed.slice(0, MAX_ROOM_TITLE);
+}
+function sanitizeAvatarUrl(raw, routePrefix) {
+	if (typeof raw !== "string" || raw.length === 0) return null;
+	if (raw.startsWith(`${routePrefix}/api/avatars/`)) return raw;
+	try {
+		const url = new URL(raw);
+		if (url.protocol !== "https:") return null;
+		return url.toString();
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/persist/schemas.ts
+const TokenAtomString = z$1.string().regex(/^-?\d+$/);
+const RoomRecordSchema = z$1.object({
+	roomId: z$1.string(),
+	roomCode: z$1.string(),
+	title: z$1.string().default("好友局"),
+	hostPlayerId: z$1.string(),
+	phase: z$1.enum([
+		"waiting",
+		"dealing",
+		"bidding",
+		"doubling",
+		"playing",
+		"settling",
+		"void",
+		"closed"
+	]),
+	stakeAtoms: TokenAtomString,
+	maxMultiplier: z$1.number().int().positive(),
+	seatCount: z$1.union([z$1.literal(3), z$1.literal(4)]).default(3),
+	laiZi: z$1.boolean().default(false),
+	inviteExpiresAt: z$1.string(),
+	createdAt: z$1.string(),
+	shareable: z$1.boolean(),
+	roomSecret: z$1.string(),
+	sitInviteHash: z$1.string(),
+	watchInviteHash: z$1.string(),
+	lastLandlordSeat: z$1.number().int().min(0).max(3).nullable()
+});
+const PlayerRecordSchema = z$1.object({
+	playerId: z$1.string(),
+	displayName: z$1.string(),
+	avatarUrl: z$1.string().url().nullable(),
+	availableAtoms: TokenAtomString,
+	welcomeGranted: z$1.boolean(),
+	createdAt: z$1.string()
+});
+const TokenGrantSchema = z$1.object({
+	grantId: z$1.string(),
+	playerId: z$1.string(),
+	roomId: z$1.string(),
+	maxExposureAtoms: TokenAtomString,
+	issuedAt: z$1.string(),
+	expiresAt: z$1.string(),
+	source: z$1.literal("host-welcome"),
+	issuedBy: z$1.literal("room-host")
+});
+const LedgerEntrySchema = z$1.object({
+	entryId: z$1.string(),
+	ts: z$1.string(),
+	roomId: z$1.string().optional(),
+	handId: z$1.string().optional(),
+	settlementId: z$1.string().optional(),
+	from: z$1.string(),
+	to: z$1.string(),
+	atoms: TokenAtomString,
+	reason: z$1.enum([
+		"welcome",
+		"freeze",
+		"unfreeze",
+		"settle",
+		"void"
+	]),
+	prevHash: z$1.string(),
+	hash: z$1.string()
+});
+const HandCheckpointSchema = z$1.object({
+	handId: z$1.string(),
+	roomId: z$1.string(),
+	sealedHands: z$1.string(),
+	publicJson: z$1.string(),
+	seq: z$1.number().int()
+});
+
+//#endregion
+//#region src/persist/domain.ts
+var MemoryKv = class {
+	map = /* @__PURE__ */ new Map();
+	get(key) {
+		return this.map.get(key);
+	}
+	async put(key, value) {
+		this.map.set(key, value);
+	}
+	async delete(key) {
+		return this.map.delete(key);
+	}
+	entries() {
+		return this.map.entries();
+	}
+};
+function createMemoryDomain() {
+	return {
+		tables: {
+			rooms: new MemoryKv(),
+			players: new MemoryKv(),
+			grants: new MemoryKv(),
+			ledger: new MemoryKv(),
+			hands: new MemoryKv()
+		},
+		async close() {}
+	};
+}
+async function openDoudizhuDomain(storage) {
+	if (!storage || typeof storage !== "object") return null;
+	const facility = storage;
+	if (typeof facility.open !== "function") return null;
+	try {
+		const spec = {
+			name: "doudizhu",
+			version: 1,
+			tables: {
+				rooms: { valueSchema: RoomRecordSchema },
+				players: { valueSchema: PlayerRecordSchema },
+				grants: { valueSchema: TokenGrantSchema },
+				ledger: { valueSchema: LedgerEntrySchema },
+				hands: { valueSchema: HandCheckpointSchema }
+			}
+		};
+		const domain = await facility.open(spec);
+		return {
+			tables: {
+				rooms: domain.table("rooms"),
+				players: domain.table("players"),
+				grants: domain.table("grants"),
+				ledger: domain.table("ledger"),
+				hands: domain.table("hands")
+			},
+			close: () => domain.close()
+		};
+	} catch {
+		return null;
+	}
+}
+
+//#endregion
+//#region src/settle/audit.ts
+function createCounters(startedAt = Date.now()) {
+	return {
+		startedAt,
+		roomsActive: 0,
+		handsStarted: 0,
+		handsVoided: 0,
+		wsConnected: 0,
+		cmdRejected: 0,
+		settlementsCommitted: 0,
+		needsAudit: false,
+		get uptimeMs() {
+			return Date.now() - startedAt;
+		},
+		bump(key) {
+			this[key] += 1;
+		}
+	};
+}
+
+//#endregion
+//#region src/settle/grant.ts
+function issueHostGrant(playerId, roomId, maxExposureAtoms, ttlHours = 24) {
+	const issuedAt = nowIso();
+	return {
+		grantId: asGrantId(randomId("gr")),
+		playerId,
+		roomId,
+		maxExposureAtoms: asTokenAtomString(maxExposureAtoms),
+		issuedAt,
+		expiresAt: addHours(ttlHours),
+		source: "host-welcome",
+		issuedBy: "room-host"
+	};
+}
+async function persistGrant(domain, grant) {
+	const record = { ...grant };
+	await domain.tables.grants.put(grant.grantId, record);
+}
+
+//#endregion
+//#region src/settle/ledger.ts
+var Ledger = class {
+	tipHash = "0".repeat(64);
+	escrow = /* @__PURE__ */ new Map();
+	constructor(domain, welcomeAtoms) {
+		this.domain = domain;
+		this.welcomeAtoms = welcomeAtoms;
+		for (const [, entry] of domain.tables.ledger.entries()) this.tipHash = entry.hash;
+	}
+	getAvailable(playerId) {
+		const row = this.domain.tables.players.get(playerId);
+		return row ? parseAtoms(row.availableAtoms) : 0n;
+	}
+	getEscrow(playerId) {
+		return this.escrow.get(playerId) ?? 0n;
+	}
+	snapshot(playerId) {
+		const entries = [...this.domain.tables.ledger.entries()].map(([, entry]) => entry).filter((entry) => entry.from === playerId || entry.to === playerId);
+		return {
+			availableAtoms: asTokenAtomString(this.getAvailable(playerId)),
+			escrowAtoms: asTokenAtomString(this.getEscrow(playerId)),
+			entries
+		};
+	}
+	async ensurePlayer(playerId, displayName, avatarUrl) {
+		const existing = this.domain.tables.players.get(playerId);
+		if (existing) {
+			if (existing.displayName !== displayName) {
+				const next = {
+					...existing,
+					displayName
+				};
+				await this.domain.tables.players.put(playerId, next);
+				return next;
+			}
+			return existing;
+		}
+		const created = {
+			playerId,
+			displayName,
+			avatarUrl,
+			availableAtoms: "0",
+			welcomeGranted: false,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		await this.domain.tables.players.put(playerId, created);
+		return this.grantWelcome(asPlayerId(playerId), created);
+	}
+	async grantWelcome(playerId, row = this.domain.tables.players.get(playerId)) {
+		if (!row) throw new Error(`unknown player ${playerId}`);
+		if (row.welcomeGranted) return row;
+		const granted = {
+			...await this.applyAvailable(playerId, this.welcomeAtoms, {
+				reason: "welcome",
+				from: "host",
+				to: playerId
+			}),
+			welcomeGranted: true
+		};
+		await this.domain.tables.players.put(playerId, granted);
+		return granted;
+	}
+	async freeze(playerId, atoms, roomId) {
+		if (atoms <= 0n) throw new Error("freeze amount must be positive");
+		if (this.getAvailable(playerId) < atoms) throw Object.assign(/* @__PURE__ */ new Error("insufficient"), { code: "insufficient" });
+		await this.applyAvailable(playerId, -atoms, {
+			reason: "freeze",
+			from: playerId,
+			to: `escrow:${roomId}`,
+			roomId
+		});
+		this.escrow.set(playerId, this.getEscrow(playerId) + atoms);
+	}
+	async unfreeze(playerId, atoms, roomId, reason = "unfreeze") {
+		const held = this.getEscrow(playerId);
+		const amount = atoms < held ? atoms : held;
+		if (amount <= 0n) return;
+		this.escrow.set(playerId, held - amount);
+		await this.applyAvailable(playerId, amount, {
+			reason,
+			from: `escrow:${roomId}`,
+			to: playerId,
+			roomId
+		});
+	}
+	async settleTransfer(from, to, atoms, meta) {
+		if (atoms <= 0n) return;
+		const held = this.getEscrow(from);
+		if (held < atoms) throw Object.assign(/* @__PURE__ */ new Error("escrow insufficient"), { code: "needsAudit" });
+		this.escrow.set(from, held - atoms);
+		await this.append({
+			from,
+			to,
+			atoms: asTokenAtomString(atoms),
+			reason: "settle",
+			roomId: meta.roomId,
+			handId: meta.handId,
+			settlementId: meta.settlementId
+		});
+		const winner = this.domain.tables.players.get(to);
+		if (!winner) throw new Error(`unknown winner ${to}`);
+		const next = {
+			...winner,
+			availableAtoms: (parseAtoms(winner.availableAtoms) + atoms).toString()
+		};
+		await this.domain.tables.players.put(to, next);
+	}
+	replaceWelcome(welcomeAtoms) {
+		this.welcomeAtoms = welcomeAtoms;
+	}
+	async applyAvailable(playerId, delta, meta) {
+		const row = this.domain.tables.players.get(playerId);
+		if (!row) throw new Error(`unknown player ${playerId}`);
+		const nextAvailable = parseAtoms(row.availableAtoms) + delta;
+		if (nextAvailable < 0n) throw Object.assign(/* @__PURE__ */ new Error("insufficient"), { code: "insufficient" });
+		const next = {
+			...row,
+			availableAtoms: nextAvailable.toString()
+		};
+		await this.domain.tables.players.put(playerId, next);
+		await this.append({
+			from: meta.from,
+			to: meta.to,
+			atoms: asTokenAtomString(delta < 0n ? -delta : delta),
+			reason: meta.reason,
+			roomId: meta.roomId,
+			handId: meta.handId,
+			settlementId: meta.settlementId
+		});
+		return next;
+	}
+	async append(partial) {
+		const entryId = asEntryId(randomId("led"));
+		const ts = (/* @__PURE__ */ new Date()).toISOString();
+		const prevHash = this.tipHash;
+		const material = JSON.stringify({
+			...partial,
+			entryId,
+			ts,
+			prevHash
+		});
+		const hash = createHash("sha256").update(material).digest("hex");
+		const entry = {
+			...partial,
+			entryId,
+			ts,
+			prevHash,
+			hash
+		};
+		await this.domain.tables.ledger.put(entryId, entry);
+		this.tipHash = hash;
+		return entry;
+	}
+};
+
+//#endregion
+//#region src/room/RoomManager.ts
+var RoomManager = class {
+	config;
+	domain;
+	ledger;
+	rooms = /* @__PURE__ */ new Map();
+	roomsByCode = /* @__PURE__ */ new Map();
+	sessions = /* @__PURE__ */ new Map();
+	tickets = /* @__PURE__ */ new Map();
+	hostCookies = /* @__PURE__ */ new Set();
+	listeners = /* @__PURE__ */ new Set();
+	timers = /* @__PURE__ */ new Set();
+	counters = createCounters();
+	persistReady;
+	constructor(ctx, config, storage) {
+		this.ctx = ctx;
+		this.config = resolveConfig(config);
+		this.domain = createMemoryDomain();
+		this.ledger = new Ledger(this.domain, this.config.welcomeAtoms);
+		this.persistReady = this.hydrate(storage);
+		const tick = setInterval(() => {
+			this.onTick(Date.now());
+		}, 250);
+		this.timers.add(tick);
+		if (typeof tick === "object" && "unref" in tick) tick.unref();
+	}
+	async ready() {
+		await this.persistReady;
+	}
+	replaceConfig(config) {
+		this.config = resolveConfig(config);
+		this.ledger.replaceWelcome(this.config.welcomeAtoms);
+	}
+	getConfig() {
+		return this.config;
+	}
+	onEvent(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	async dispose() {
+		for (const timer of this.timers) clearInterval(timer);
+		this.timers.clear();
+		await this.domain.close();
+	}
+	health() {
+		return {
+			roomsActive: [...this.rooms.values()].filter((room) => room.room.phase !== "closed").length,
+			handsStarted: this.counters.handsStarted,
+			handsVoided: this.counters.handsVoided,
+			wsConnected: this.counters.wsConnected,
+			cmdRejected: this.counters.cmdRejected,
+			settlementsCommitted: this.counters.settlementsCommitted,
+			needsAudit: [...this.rooms.values()].some((room) => room.needsAudit) || this.counters.needsAudit,
+			uptimeMs: this.counters.uptimeMs
+		};
+	}
+	async createRoom(req, hostCookie) {
+		await this.ready();
+		if (!this.config.enabled) throw fail("phase", "plugin disabled");
+		if (this.rooms.size >= this.config.maxRooms) throw fail("room-full", "too many rooms");
+		const seatCount = req.seatCount === 4 ? 4 : 3;
+		const laiZi = req.laiZi === true;
+		assertCreateEconomy(this.config.welcomeAtoms, req.stakeM, req.maxMultiplier, seatCount);
+		const publicBase = this.config.publicBaseUrl ? validatePublicBaseUrl(this.config.publicBaseUrl) : "";
+		const roomId = asRoomId(randomId("rm"));
+		const roomCode = this.uniqueCode();
+		const secret = randomToken();
+		const sitToken = randomToken();
+		const watchToken = randomToken();
+		const hostPlayerId = newPlayerId();
+		const displayName = sanitizeDisplayName(req.hostDisplayName ?? "房主");
+		const title = sanitizeRoomTitle(req.title ?? "好友局");
+		await this.ledger.ensurePlayer(hostPlayerId, displayName, null);
+		const stakeAtoms = BigInt(req.stakeM) * 1000000n;
+		const now = nowIso();
+		const room = {
+			roomId,
+			roomCode,
+			title,
+			hostPlayerId,
+			phase: "waiting",
+			stakeAtoms,
+			maxMultiplier: req.maxMultiplier,
+			seatCount,
+			laiZi,
+			seats: Array.from({ length: seatCount }, (_, index) => emptySeat(index)),
+			spectatorIds: [],
+			currentHandId: null,
+			createdAt: now,
+			inviteExpiresAt: addHours(this.config.inviteTtlHours),
+			shareable: publicBase !== ""
+		};
+		const live = {
+			room,
+			secret,
+			sitInviteHash: inviteHash(secret, "sit", sitToken),
+			sitToken,
+			watchInviteHash: inviteHash(secret, "watch", watchToken),
+			watchToken,
+			sitConsumed: false,
+			lastLandlordSeat: null,
+			engine: null,
+			deadlineAt: null,
+			seq: 0,
+			events: [],
+			chat: [],
+			nonces: /* @__PURE__ */ new Set(),
+			disconnectedAt: /* @__PURE__ */ new Map(),
+			autoPlay: /* @__PURE__ */ new Set(),
+			lastSettlement: null,
+			needsAudit: false
+		};
+		this.rooms.set(roomId, live);
+		this.roomsByCode.set(roomCode, roomId);
+		await this.persistRoom(live);
+		const cookie = hostCookie ?? cookieValue();
+		this.hostCookies.add(cookie);
+		this.sessions.set(cookie, {
+			cookie,
+			playerId: hostPlayerId,
+			roomId,
+			kind: "host",
+			expiresAt: Date.now() + 864e5
+		});
+		await this.sitInternal(live, hostPlayerId, 0, displayName, true);
+		const origin = publicBase || `http://127.0.0.1:${this.listenPort()}`;
+		return {
+			roomId,
+			roomCode,
+			sitUrl: `${origin}${this.config.routePrefix}/join?code=${roomCode}&invite=${sitToken}`,
+			watchUrl: `${origin}${this.config.routePrefix}/join?code=${roomCode}&invite=${watchToken}&role=watch`,
+			seatCapAtoms: seatCapAtoms(stakeAtoms, req.maxMultiplier, seatCount).toString(),
+			shareable: room.shareable,
+			hostCookie: cookie,
+			hostPlayerId,
+			view: this.viewFor(live, hostPlayerId)
+		};
+	}
+	async join(req) {
+		await this.ready();
+		const live = this.roomByCode(req.roomCode);
+		if (!live || live.room.phase === "closed") throw fail("expired", "room not found");
+		if (Date.parse(live.room.inviteExpiresAt) < Date.now()) throw fail("expired", "invite expired");
+		const displayName = sanitizeDisplayName(req.displayName);
+		const playerId = newPlayerId();
+		await this.ledger.ensurePlayer(playerId, displayName, sanitizeAvatarUrl(null, this.config.routePrefix));
+		const invite = req.invite.trim();
+		const sitOk = invite ? sha256Hex(`${live.secret}|sit|${invite}`) === live.sitInviteHash : Boolean(req.local);
+		const watchOk = invite ? sha256Hex(`${live.secret}|watch|${invite}`) === live.watchInviteHash : false;
+		if (!sitOk && !watchOk) throw fail("auth", invite ? "invalid invite" : "room not found");
+		const empty = this.firstEmptySeat(live);
+		const canSit = live.room.phase === "waiting" && empty !== null && req.role !== "watch";
+		let seat = null;
+		if (canSit) {
+			await this.sitInternal(live, playerId, empty, displayName, true);
+			seat = empty;
+			if (this.firstEmptySeat(live) === null) live.sitConsumed = true;
+			await this.maybeDeal(live);
+		} else {
+			if (!this.config.allowSpectators) throw fail("auth", "spectators disabled");
+			live.sitConsumed = live.sitConsumed || empty === null || live.room.phase !== "waiting";
+			this.addSpectator(live, playerId);
+		}
+		const cookie = cookieValue();
+		this.sessions.set(cookie, {
+			cookie,
+			playerId,
+			roomId: live.room.roomId,
+			kind: seat === null ? "watch" : "seat",
+			expiresAt: Date.now() + 864e5
+		});
+		this.broadcast(live);
+		return {
+			playerId,
+			roomId: live.room.roomId,
+			seat,
+			wsTicket: this.issueTicket(playerId, live.room.roomId),
+			cookie,
+			view: this.viewFor(live, playerId)
+		};
+	}
+	sessionByCookie(cookie) {
+		if (!cookie) return void 0;
+		const session = this.sessions.get(cookie);
+		if (!session || session.expiresAt < Date.now()) return void 0;
+		return session;
+	}
+	isHostCookie(cookie) {
+		return Boolean(cookie && this.hostCookies.has(cookie) && this.sessionByCookie(cookie));
+	}
+	consumeTicket(ticket) {
+		const found = this.tickets.get(ticket);
+		this.tickets.delete(ticket);
+		if (!found || found.expiresAt < Date.now()) return void 0;
+		return found;
+	}
+	issueTicket(playerId, roomId) {
+		const ticket = randomToken();
+		this.tickets.set(ticket, {
+			playerId,
+			roomId,
+			expiresAt: Date.now() + 6e4
+		});
+		return ticket;
+	}
+	view(roomId, playerId) {
+		return this.viewFor(this.requireRoom(roomId), playerId);
+	}
+	eventsSince(roomId, playerId, seq) {
+		const live = this.requireRoom(roomId);
+		const events = [];
+		if (live.seq > seq) events.push({
+			type: "snapshot",
+			seq: live.seq,
+			view: this.viewFor(live, playerId)
+		});
+		if (live.lastSettlement) events.push({
+			type: "settled",
+			seq: live.seq,
+			settlement: live.lastSettlement
+		});
+		if (events.length === 0) events.push({
+			type: "snapshot",
+			seq: live.seq,
+			view: this.viewFor(live, playerId)
+		});
+		return {
+			events,
+			untilSeq: live.seq
+		};
+	}
+	ledgerFor(playerId) {
+		return this.ledger.snapshot(playerId);
+	}
+	async command(roomId, playerId, command, isHost = false) {
+		const live = this.requireRoom(roomId);
+		try {
+			if ("nonce" in command && command.nonce) {
+				if (live.nonces.has(command.nonce)) throw fail("duplicate-nonce", "duplicate play nonce");
+				live.nonces.add(command.nonce);
+			}
+			switch (command.type) {
+				case "sit":
+					await this.sitInternal(live, playerId, command.seat, sanitizeDisplayName(command.displayName), false);
+					break;
+				case "stand":
+					this.stand(live, playerId);
+					break;
+				case "ready":
+					await this.setReady(live, playerId, command.ready);
+					break;
+				case "bid":
+					this.bid(live, playerId, command.action);
+					break;
+				case "double":
+					this.double(live, playerId, command.action);
+					break;
+				case "mingPai":
+					this.mingPai(live, playerId);
+					break;
+				case "rename":
+					this.rename(live, playerId, command.title, isHost);
+					break;
+				case "play":
+					this.play(live, playerId, command.cards);
+					break;
+				case "pass":
+					this.pass(live, playerId);
+					break;
+				case "chat":
+					this.chat(live, playerId, command.text);
+					break;
+				case "rematch":
+					await this.rematch(live, playerId);
+					break;
+				case "hostKick":
+					if (!isHost && live.room.hostPlayerId !== playerId) throw fail("auth", "host only");
+					this.kick(live, command.playerId);
+					break;
+				case "hostClose":
+					if (!isHost && live.room.hostPlayerId !== playerId) throw fail("auth", "host only");
+					await this.closeRoom(live);
+					break;
+				case "ping":
+					this.emit(live, {
+						type: "pong",
+						ts: Date.now()
+					}, playerId);
+					return { seq: live.seq };
+				default: throw fail("illegal", "unknown command");
+			}
+			this.broadcast(live);
+			return { seq: live.seq };
+		} catch (error) {
+			this.counters.bump("cmdRejected");
+			throw error;
+		}
+	}
+	markConnected(playerId, roomId) {
+		const live = this.rooms.get(roomId);
+		if (!live) return;
+		live.disconnectedAt.delete(playerId);
+		live.autoPlay.delete(this.seatOf(live, playerId) ?? 0);
+		this.setConnected(live, playerId, true);
+		this.broadcast(live);
+	}
+	markDisconnected(playerId, roomId) {
+		const live = this.rooms.get(roomId);
+		if (!live) return;
+		live.disconnectedAt.set(playerId, Date.now());
+		this.setConnected(live, playerId, false);
+		this.broadcast(live);
+	}
+	listenPort = () => this.ctx?.webServer?.port ?? 3080;
+	async hydrate(storage) {
+		const opened = await openDoudizhuDomain(storage);
+		if (!opened) return;
+		this.domain = opened;
+		this.ledger = new Ledger(this.domain, this.config.welcomeAtoms);
+	}
+	uniqueCode() {
+		for (let i = 0; i < 20; i += 1) {
+			const code = randomRoomCode();
+			if (!this.roomsByCode.has(code)) return code;
+		}
+		throw new Error("could not allocate room code");
+	}
+	roomByCode(code) {
+		const id = this.roomsByCode.get(code);
+		return id ? this.rooms.get(id) : void 0;
+	}
+	requireRoom(roomId) {
+		const live = this.rooms.get(roomId);
+		if (!live) throw fail("expired", "room not found");
+		return live;
+	}
+	firstEmptySeat(live) {
+		const empty = live.room.seats.find((seat) => seat.playerId === null);
+		return empty ? empty.seat : null;
+	}
+	addSpectator(live, playerId) {
+		if (live.room.spectatorIds.includes(playerId)) return;
+		if (live.room.spectatorIds.length >= MAX_SPECTATORS) throw fail("room-full", "too many spectators");
+		live.room = {
+			...live.room,
+			spectatorIds: [...live.room.spectatorIds, playerId]
+		};
+	}
+	async sitInternal(live, playerId, seat, displayName, isHost) {
+		if (live.room.phase !== "waiting") throw fail("phase", "cannot sit now");
+		const target = live.room.seats[seat];
+		if (!target) throw fail("illegal", "no such seat");
+		if (target.playerId && target.playerId !== playerId) throw fail("room-full", "seat taken");
+		this.stand(live, playerId, false);
+		const cap = seatCapAtoms(live.room.stakeAtoms, live.room.maxMultiplier, live.room.seatCount);
+		const grant = issueHostGrant(playerId, live.room.roomId, cap);
+		await persistGrant(this.domain, grant);
+		const ready = isHost || live.room.phase === "waiting";
+		if (ready && this.ledger.getEscrow(playerId) < cap) {
+			if (this.ledger.getAvailable(playerId) < cap) throw fail("insufficient", "need more welcome atoms");
+			await this.ledger.freeze(playerId, cap, live.room.roomId);
+		}
+		const seats = live.room.seats.map((item) => item.seat === seat ? {
+			...item,
+			playerId,
+			displayName,
+			avatarUrl: null,
+			ready,
+			connected: true,
+			role: "empty",
+			grantId: grant.grantId,
+			cardsLeft: 0
+		} : item);
+		live.room = {
+			...live.room,
+			seats,
+			spectatorIds: live.room.spectatorIds.filter((id) => id !== playerId)
+		};
+	}
+	stand(live, playerId, persist = true) {
+		if (live.room.phase !== "waiting" && persist) throw fail("phase", "cannot stand now");
+		const seats = live.room.seats.map((item) => item.playerId === playerId ? emptySeat(item.seat) : item);
+		live.room = {
+			...live.room,
+			seats
+		};
+		live.sitConsumed = live.room.phase !== "waiting" || this.firstEmptySeat(live) === null;
+		if (persist && this.ledger.getEscrow(playerId) > 0n) this.ledger.unfreeze(playerId, this.ledger.getEscrow(playerId), live.room.roomId);
+	}
+	async setReady(live, playerId, ready) {
+		if (live.room.phase !== "waiting") throw fail("phase", "not waiting");
+		const seat = this.seatOf(live, playerId);
+		if (seat === null) throw fail("illegal", "not seated");
+		if (ready) {
+			const cap = seatCapAtoms(live.room.stakeAtoms, live.room.maxMultiplier, live.room.seatCount);
+			if (this.ledger.getAvailable(playerId) < cap) throw fail("insufficient", "need more welcome atoms");
+			if (this.ledger.getEscrow(playerId) < cap) await this.ledger.freeze(playerId, cap, live.room.roomId);
+		} else if (this.ledger.getEscrow(playerId) > 0n) await this.ledger.unfreeze(playerId, this.ledger.getEscrow(playerId), live.room.roomId);
+		this.patchSeat(live, seat, { ready });
+		await this.maybeDeal(live);
+	}
+	async maybeDeal(live) {
+		const seated = live.room.seats;
+		if (!seated.every((seat) => seat.playerId && seat.ready && seat.grantId)) return;
+		const dealer = live.lastLandlordSeat === null ? null : nextSeat(live.lastLandlordSeat, live.room.seatCount);
+		live.engine = createHand(live.room.roomId, dealer, this.counters.handsStarted + 1, {
+			seatCount: live.room.seatCount,
+			laiZi: live.room.laiZi
+		});
+		this.counters.bump("handsStarted");
+		live.room = {
+			...live.room,
+			phase: "bidding",
+			currentHandId: live.engine.hand.handId,
+			seats: seated.map((seat) => ({
+				...seat,
+				role: "farmer",
+				cardsLeft: dealtHandSize(live.room.seatCount)
+			}))
+		};
+		live.deadlineAt = Date.now() + this.config.turnTimeoutMs;
+	}
+	bid(live, playerId, action) {
+		const engine = this.requireEngine(live, "bidding");
+		const result = applyBid(engine, this.requireSeat(live, playerId), action);
+		if (!result.ok) throw fail(result.code, result.reason);
+		if (engine.phase === "redeal") {
+			const dealer = engine.hand.dealerSeat;
+			live.engine = createHand(live.room.roomId, dealer, this.counters.handsStarted + 1, {
+				seatCount: live.room.seatCount,
+				laiZi: live.room.laiZi
+			});
+			this.counters.bump("handsStarted");
+			live.room = {
+				...live.room,
+				currentHandId: live.engine.hand.handId,
+				phase: "bidding"
+			};
+			live.deadlineAt = Date.now() + this.config.turnTimeoutMs;
+			return;
+		}
+		if (engine.phase === "doubling" && engine.hand.landlordSeat !== null) {
+			this.patchSeat(live, engine.hand.landlordSeat, {
+				role: "landlord",
+				cardsLeft: landlordHandSize(live.room.seatCount)
+			});
+			live.room = {
+				...live.room,
+				phase: "doubling"
+			};
+			live.deadlineAt = engine.doubleDeadlineAt;
+		}
+	}
+	mingPai(live, playerId) {
+		if (!live.engine) throw fail("phase", "no hand");
+		const seat = this.requireSeat(live, playerId);
+		const result = applyMingPai(live.engine, seat);
+		if (!result.ok) throw fail(result.code, result.reason);
+	}
+	rename(live, playerId, title, isHost) {
+		if (!isHost && live.room.hostPlayerId !== playerId) throw fail("auth", "host only");
+		live.room = {
+			...live.room,
+			title: sanitizeRoomTitle(title, live.room.title)
+		};
+		this.persistRoom(live);
+	}
+	double(live, playerId, action) {
+		const engine = this.requireEngine(live, "doubling");
+		const result = applyDouble(engine, this.requireSeat(live, playerId), action);
+		if (!result.ok) throw fail(result.code, result.reason);
+		if (engine.phase === "playing") {
+			live.room = {
+				...live.room,
+				phase: "playing"
+			};
+			live.deadlineAt = Date.now() + this.config.turnTimeoutMs;
+		}
+	}
+	play(live, playerId, cards) {
+		const engine = this.requireEngine(live, "playing");
+		const seat = this.requireSeat(live, playerId);
+		const result = applyPlay(engine, seat, cards, live.seq + 1, nowIso());
+		if (!result.ok) throw fail(result.code, result.reason);
+		this.patchSeat(live, seat, { cardsLeft: engine.hand.hands[seat]?.length ?? 0 });
+		if (engine.phase === "settled") this.settle(live);
+		else live.deadlineAt = Date.now() + this.config.turnTimeoutMs;
+	}
+	pass(live, playerId) {
+		const result = applyPass(this.requireEngine(live, "playing"), this.requireSeat(live, playerId), live.seq + 1, nowIso());
+		if (!result.ok) throw fail(result.code, result.reason);
+		live.deadlineAt = Date.now() + this.config.turnTimeoutMs;
+	}
+	chat(live, playerId, text) {
+		const cleaned = text.replace(/[\u0000-\u001f]/g, "").slice(0, MAX_CHAT);
+		if (!cleaned) return;
+		const name$1 = this.displayNameOf(live, playerId);
+		live.chat.push({
+			playerId,
+			displayName: name$1,
+			text: cleaned,
+			ts: nowIso()
+		});
+		live.chat = live.chat.slice(-50);
+	}
+	async rematch(live, playerId) {
+		if (live.room.phase !== "waiting") throw fail("phase", "not waiting");
+		if (!(this.seatOf(live, playerId) !== null || live.room.hostPlayerId === playerId)) throw fail("illegal", "not seated");
+		for (const seat of live.room.seats) if (seat.playerId) await this.setReady(live, seat.playerId, true);
+	}
+	kick(live, playerId) {
+		if (live.room.phase !== "waiting") throw fail("phase", "cannot kick now");
+		this.stand(live, playerId);
+		live.room = {
+			...live.room,
+			spectatorIds: live.room.spectatorIds.filter((id) => id !== playerId)
+		};
+		this.persistRoom(live);
+	}
+	async closeRoom(live) {
+		if (live.engine && (live.room.phase === "playing" || live.room.phase === "bidding" || live.room.phase === "doubling")) await this.voidHand(live);
+		for (const seat of live.room.seats) if (seat.playerId && this.ledger.getEscrow(seat.playerId) > 0n) await this.ledger.unfreeze(seat.playerId, this.ledger.getEscrow(seat.playerId), live.room.roomId);
+		live.room = {
+			...live.room,
+			phase: "closed"
+		};
+	}
+	async settle(live) {
+		const engine = live.engine;
+		if (!engine || engine.hand.landlordSeat === null) return;
+		live.room = {
+			...live.room,
+			phase: "settling"
+		};
+		const playerIds = live.room.seats.map((seat) => seat.playerId);
+		if (playerIds.some((id) => !id)) return;
+		const landlord = engine.hand.landlordSeat;
+		const winner = (engine.hand.hands[landlord] ?? []).length === 0 ? "landlord" : "farmers";
+		const settlement = scoreHand({
+			hand: snapshotHand(engine),
+			stakeAtoms: live.room.stakeAtoms,
+			maxMultiplier: live.room.maxMultiplier,
+			winner,
+			playerIds
+		});
+		try {
+			const landlordId = playerIds[landlord];
+			if (!landlordId) throw fail("illegal", "missing landlord");
+			if (winner === "landlord") for (const delta of settlement.deltas) {
+				const atoms = parseAtoms(delta.atoms);
+				if (atoms < 0n) await this.ledger.settleTransfer(delta.playerId, landlordId, -atoms, {
+					roomId: live.room.roomId,
+					handId: settlement.handId,
+					settlementId: settlement.settlementId
+				});
+			}
+			else for (const delta of settlement.deltas) {
+				const atoms = parseAtoms(delta.atoms);
+				if (atoms > 0n) await this.ledger.settleTransfer(landlordId, delta.playerId, atoms, {
+					roomId: live.room.roomId,
+					handId: settlement.handId,
+					settlementId: settlement.settlementId
+				});
+			}
+			for (const seat of live.room.seats) if (seat.playerId) await this.ledger.unfreeze(seat.playerId, this.ledger.getEscrow(seat.playerId), live.room.roomId);
+		} catch (error) {
+			live.needsAudit = true;
+			this.counters.needsAudit = true;
+			this.ctx?.logger?.warn(error);
+			throw fail("illegal", "settlement failed");
+		}
+		const publicSettlement = {
+			...settlement,
+			trustNote: "好友局信任房主机器上的账本。积分 ≠ DeepSeek 平台余额。"
+		};
+		live.lastSettlement = publicSettlement;
+		live.lastLandlordSeat = landlord;
+		this.counters.bump("settlementsCommitted");
+		live.engine = null;
+		live.room = {
+			...live.room,
+			phase: "waiting",
+			currentHandId: null,
+			seats: live.room.seats.map((seat) => ({
+				...seat,
+				ready: false,
+				role: "empty",
+				cardsLeft: 0
+			}))
+		};
+		live.deadlineAt = null;
+		this.push(live, {
+			type: "settled",
+			seq: ++live.seq,
+			settlement: publicSettlement
+		});
+	}
+	async voidHand(live) {
+		for (const seat of live.room.seats) if (seat.playerId) await this.ledger.unfreeze(seat.playerId, this.ledger.getEscrow(seat.playerId), live.room.roomId, "void");
+		live.engine = null;
+		live.room = {
+			...live.room,
+			phase: "waiting",
+			currentHandId: null,
+			seats: live.room.seats.map((seat) => ({
+				...seat,
+				ready: false,
+				role: "empty",
+				cardsLeft: 0
+			}))
+		};
+		this.counters.bump("handsVoided");
+	}
+	onTick(now) {
+		for (const live of this.rooms.values()) {
+			if (live.room.phase === "doubling" && live.engine) {
+				expireDoubling(live.engine, now);
+				if (live.engine.phase === "playing") {
+					live.room = {
+						...live.room,
+						phase: "playing"
+					};
+					live.deadlineAt = now + this.config.turnTimeoutMs;
+					this.broadcast(live);
+				}
+			}
+			if (live.deadlineAt && now >= live.deadlineAt && live.engine && live.room.phase === "playing") {
+				if (autoTimeout(live.engine, live.seq + 1, nowIso())) {
+					const seat = live.engine.hand.turnSeat;
+					const previous = prevSeat(seat, live.room.seatCount);
+					this.patchSeat(live, previous, { cardsLeft: live.engine.hand.hands[previous].length });
+					if (live.engine.phase === "settled") this.settle(live);
+					else live.deadlineAt = now + this.config.turnTimeoutMs;
+					this.broadcast(live);
+				}
+			}
+			for (const [playerId, at] of live.disconnectedAt) {
+				if (now - at < this.config.reconnectWindowMs) continue;
+				const seat = this.seatOf(live, playerId);
+				if (seat !== null && (live.room.phase === "playing" || live.room.phase === "bidding" || live.room.phase === "doubling")) live.autoPlay.add(seat);
+			}
+			const seated = live.room.seats.filter((seat) => seat.playerId);
+			if (seated.length > 0 && seated.every((seat) => !seat.connected) && live.disconnectedAt.size === live.room.seatCount) {
+				if (now - Math.min(...live.disconnectedAt.values()) > this.config.reconnectWindowMs && live.engine) {
+					this.voidHand(live);
+					this.broadcast(live);
+				}
+			}
+		}
+	}
+	requireEngine(live, phase) {
+		if (!live.engine || live.engine.phase !== phase) throw fail("phase", `expected ${phase}`);
+		return live.engine;
+	}
+	requireSeat(live, playerId) {
+		const seat = this.seatOf(live, playerId);
+		if (seat === null) throw fail("illegal", "not seated");
+		return seat;
+	}
+	seatOf(live, playerId) {
+		return live.room.seats.find((seat) => seat.playerId === playerId)?.seat ?? null;
+	}
+	displayNameOf(live, playerId) {
+		return live.room.seats.find((seat) => seat.playerId === playerId)?.displayName ?? "玩家";
+	}
+	patchSeat(live, seat, patch) {
+		live.room = {
+			...live.room,
+			seats: live.room.seats.map((item) => item.seat === seat ? {
+				...item,
+				...patch
+			} : item)
+		};
+	}
+	setConnected(live, playerId, connected) {
+		const seat = this.seatOf(live, playerId);
+		if (seat !== null) this.patchSeat(live, seat, { connected });
+	}
+	viewFor(live, playerId) {
+		const seat = this.seatOf(live, playerId);
+		const spectator = seat === null;
+		const engine = live.engine;
+		const cards = seat !== null && engine ? [...engine.hand.hands[seat] ?? []] : [];
+		const legal = seat !== null && engine ? legalFor(engine, seat) : {
+			canPass: false,
+			combos: []
+		};
+		const bottomRevealed = Boolean(engine && engine.hand.landlordSeat !== null);
+		const remainingRanks = spectator && this.config.spectatorCardCounter ? this.remainingRanks(live) : null;
+		return {
+			room: {
+				...live.room,
+				stakeAtoms: asTokenAtomString(live.room.stakeAtoms),
+				seats: live.room.seats.map((item) => ({
+					...item,
+					cardsLeft: engine ? engine.hand.hands[item.seat]?.length ?? 0 : item.cardsLeft,
+					role: engine?.hand.landlordSeat === item.seat ? "landlord" : item.playerId ? engine ? "farmer" : item.role : "empty"
+				}))
+			},
+			you: {
+				playerId,
+				seat,
+				spectator,
+				cards
+			},
+			publicHands: live.room.seats.map((item, index) => engine ? engine.hand.hands[index]?.length ?? 0 : item.cardsLeft),
+			lastPlays: engine ? engine.hand.table.slice(-6) : [],
+			bottom: bottomRevealed && engine ? [...engine.hand.bottom] : null,
+			laiZiRanks: engine?.hand.laiZiRanks ?? [],
+			bid: engine?.hand.bid ?? 0,
+			auction: engine && engine.phase === "bidding" ? {
+				kind: engine.called ? "rob" : "call",
+				multiplier: Math.max(1, engine.hand.bid)
+			} : null,
+			revealedBySeat: this.revealedHands(live),
+			mingPaiBySeat: engine ? { ...engine.hand.mingPaiBySeat } : {},
+			turnSeat: engine?.hand.turnSeat ?? null,
+			leadSeat: engine?.hand.leadSeat ?? null,
+			deadlineAt: live.deadlineAt ? new Date(live.deadlineAt).toISOString() : null,
+			yourAvailableAtoms: asTokenAtomString(this.ledger.getAvailable(playerId)),
+			yourEscrowAtoms: asTokenAtomString(this.ledger.getEscrow(playerId)),
+			legal,
+			remainingRanks,
+			chat: live.chat.slice(-20)
+		};
+	}
+	revealedHands(live) {
+		const engine = live.engine;
+		if (!engine) return {};
+		const out = {};
+		for (const [raw, shown] of Object.entries(engine.hand.mingPaiBySeat)) {
+			if (!shown) continue;
+			const seat = Number(raw);
+			out[seat] = [...engine.hand.hands[seat] ?? []];
+		}
+		return out;
+	}
+	remainingRanks(live) {
+		if (!live.engine) return null;
+		const seen = /* @__PURE__ */ new Map();
+		const bump = (card) => {
+			const rank = rankOf(card);
+			seen.set(rank, (seen.get(rank) ?? 0) + 1);
+		};
+		for (const play of live.engine.hand.table) for (const card of play.cards) bump(card);
+		if (live.engine.hand.landlordSeat !== null) for (const card of live.engine.hand.bottom) bump(card);
+		const decks = decksFor(live.room.seatCount);
+		const totals = {
+			"3": 4 * decks,
+			"4": 4 * decks,
+			"5": 4 * decks,
+			"6": 4 * decks,
+			"7": 4 * decks,
+			"8": 4 * decks,
+			"9": 4 * decks,
+			"10": 4 * decks,
+			J: 4 * decks,
+			Q: 4 * decks,
+			K: 4 * decks,
+			A: 4 * decks,
+			"2": 4 * decks,
+			BJ: decks,
+			RJ: decks
+		};
+		const remaining = {};
+		for (const [rank, total] of Object.entries(totals)) remaining[rank] = total - (seen.get(rank) ?? 0);
+		return remaining;
+	}
+	async persistRoom(live) {
+		await this.domain.tables.rooms.put(live.room.roomId, {
+			roomId: live.room.roomId,
+			roomCode: live.room.roomCode,
+			title: live.room.title,
+			hostPlayerId: live.room.hostPlayerId,
+			phase: live.room.phase,
+			stakeAtoms: live.room.stakeAtoms.toString(),
+			maxMultiplier: live.room.maxMultiplier,
+			seatCount: live.room.seatCount,
+			laiZi: live.room.laiZi,
+			inviteExpiresAt: live.room.inviteExpiresAt,
+			createdAt: live.room.createdAt,
+			shareable: live.room.shareable,
+			roomSecret: live.secret,
+			sitInviteHash: live.sitInviteHash,
+			watchInviteHash: live.watchInviteHash,
+			lastLandlordSeat: live.lastLandlordSeat
+		});
+	}
+	broadcast(live) {
+		live.seq += 1;
+		const ids = new Set([...live.room.seats.map((seat) => seat.playerId).filter((id) => Boolean(id)), ...live.room.spectatorIds]);
+		for (const playerId of ids) this.emit(live, {
+			type: "snapshot",
+			seq: live.seq,
+			view: this.viewFor(live, playerId)
+		}, playerId);
+	}
+	push(live, event) {
+		live.events.push(event);
+		live.events = live.events.slice(-200);
+		const ids = new Set([...live.room.seats.map((seat) => seat.playerId).filter((id) => Boolean(id)), ...live.room.spectatorIds]);
+		for (const playerId of ids) this.emit(live, event, playerId);
+	}
+	emit(_live, event, playerId) {
+		for (const listener of this.listeners) listener(playerId, event);
+	}
+};
+function emptySeat(seat) {
+	return {
+		seat,
+		playerId: null,
+		displayName: null,
+		avatarUrl: null,
+		ready: false,
+		connected: false,
+		role: "empty",
+		grantId: null,
+		cardsLeft: 0
+	};
+}
+function fail(code, reason) {
+	return Object.assign(new Error(reason), { code });
+}
+
+//#endregion
+//#region src/net/auth.ts
+function isLoopbackHost(hostHeader, remoteAddress) {
+	const host = (hostHeader ?? "").split(":")[0]?.replace(/^\[|\]$/g, "").toLowerCase();
+	const remote = (remoteAddress ?? "").replace(/^::ffff:/, "");
+	const loopbackHosts = new Set([
+		"127.0.0.1",
+		"localhost",
+		"::1"
+	]);
+	const loopbackRemotes = new Set([
+		"127.0.0.1",
+		"::1",
+		"::ffff:127.0.0.1"
+	]);
+	return loopbackHosts.has(host ?? "") || loopbackRemotes.has(remote);
+}
+function requestOrigin(req) {
+	const origin = header(req, "origin");
+	if (origin) try {
+		return new URL(origin).origin;
+	} catch {
+		return null;
+	}
+	const referer = header(req, "referer");
+	if (referer) try {
+		return new URL(referer).origin;
+	} catch {
+		return null;
+	}
+	return null;
+}
+function originAllowed(origin, publicBaseUrl, browser) {
+	if (!origin) return !browser;
+	if (isLoopbackOrigin(origin)) return true;
+	if (publicBaseUrl && origin === publicBaseUrl) return true;
+	return false;
+}
+function isLoopbackOrigin(origin) {
+	try {
+		const url = new URL(origin);
+		return url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1" || url.hostname === "[::1]";
+	} catch {
+		return false;
+	}
+}
+function isBrowserRequest(req) {
+	return Boolean(header(req, "origin") || header(req, "sec-fetch-site"));
+}
+function assertOrigin(req, publicBaseUrl) {
+	if (header(req, "sec-fetch-site") === "cross-site") throw Object.assign(/* @__PURE__ */ new Error("cross-site forbidden"), {
+		status: 403,
+		code: "auth"
+	});
+	if (!originAllowed(requestOrigin(req), publicBaseUrl, isBrowserRequest(req))) throw Object.assign(/* @__PURE__ */ new Error("origin not allowed"), {
+		status: 403,
+		code: "auth"
+	});
+}
+function assertMutatingHeaders(req) {
+	const requested = header(req, "x-requested-with");
+	const contentType = header(req, "content-type") ?? "";
+	if (requested === "doudizhu") return;
+	if (contentType.includes("application/json")) return;
+	throw Object.assign(/* @__PURE__ */ new Error("missing csrf header"), {
+		status: 403,
+		code: "auth"
+	});
+}
+function parseCookies(req) {
+	const raw = header(req, "cookie") ?? "";
+	const out = {};
+	for (const part of raw.split(";")) {
+		const index = part.indexOf("=");
+		if (index < 0) continue;
+		const key = part.slice(0, index).trim();
+		const value = part.slice(index + 1).trim();
+		if (key) out[key] = decodeURIComponent(value);
+	}
+	return out;
+}
+function cookieHeader(name$1, value, opts) {
+	const parts = [
+		`${name$1}=${encodeURIComponent(value)}`,
+		"Path=/doudizhu",
+		"HttpOnly",
+		`SameSite=${opts.sameSite}`,
+		`Max-Age=${opts.maxAge ?? 86400}`
+	];
+	if (opts.secure) parts.push("Secure");
+	return parts.join("; ");
+}
+function header(req, name$1) {
+	const value = req.headers[name$1];
+	return Array.isArray(value) ? value[0] : value;
+}
+
+//#endregion
+//#region src/net/json.ts
+/** JSON wire encoding: bigint atoms become decimal strings. */
+function encodeJson(body) {
+	return JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value);
+}
+
+//#endregion
+//#region src/net/join-page.ts
+const here = dirname(fileURLToPath(import.meta.url));
+function joinPageHtml() {
+	const candidates = [
+		join(here, "join/index.html"),
+		join(here, "../join/index.html"),
+		join(process.cwd(), "lib/join/index.html"),
+		join(process.cwd(), "src/join/join.html")
+	];
+	for (const path of candidates) try {
+		return readFileSync(path, "utf8");
+	} catch {}
+	return `<!doctype html><html><head><meta charset="utf-8"><title>斗地主</title></head><body><p>加入页尚未构建。请运行 pnpm build。</p></body></html>`;
+}
+function joinAsset(name$1) {
+	const candidates = [
+		join(here, "join", name$1),
+		join(here, "../join", name$1),
+		join(process.cwd(), "lib/join", name$1),
+		join(process.cwd(), "src/client/assets", name$1)
+	];
+	for (const path of candidates) try {
+		return {
+			body: readFileSync(path),
+			type: typeOf(name$1)
+		};
+	} catch {}
+	return null;
+}
+function typeOf(name$1) {
+	if (name$1.endsWith(".js")) return "application/javascript; charset=utf-8";
+	if (name$1.endsWith(".css")) return "text/css; charset=utf-8";
+	if (name$1.endsWith(".svg")) return "image/svg+xml";
+	if (name$1.endsWith(".jpg") || name$1.endsWith(".jpeg")) return "image/jpeg";
+	if (name$1.endsWith(".png")) return "image/png";
+	if (name$1.endsWith(".map")) return "application/json";
+	return "application/octet-stream";
+}
+
+//#endregion
+//#region src/net/routes.ts
+function registerDouDizhuHttp(server, manager) {
+	const prefix = manager.getConfig().routePrefix;
+	return [server.register({
+		kind: "prefix",
+		path: prefix,
+		handler: (req, res) => handle(req, res, manager, prefix)
+	})];
+}
+async function handle(req, res, manager, prefix) {
+	try {
+		const url = new URL(req.url ?? "/", "http://127.0.0.1");
+		const path = url.pathname;
+		if (req.method === "GET" && (path === prefix || path === `${prefix}/` || path === `${prefix}/join`)) {
+			html(res, joinPageHtml());
+			return;
+		}
+		if (req.method === "GET" && path.startsWith(`${prefix}/assets/`)) {
+			const asset = joinAsset(path.slice(`${prefix}/assets/`.length));
+			if (!asset) {
+				send$1(res, 404, "");
+				return;
+			}
+			send$1(res, 200, asset.body, {
+				"content-type": asset.type,
+				"cache-control": "no-store"
+			});
+			return;
+		}
+		if (req.method === "GET" && (path === `${prefix}/join.js` || path === `${prefix}/index.js`)) {
+			const asset = joinAsset("index.js");
+			if (!asset) {
+				send$1(res, 404, "");
+				return;
+			}
+			send$1(res, 200, asset.body, {
+				"content-type": asset.type,
+				"cache-control": "no-store"
+			});
+			return;
+		}
+		if (path.startsWith(`${prefix}/api/`)) {
+			await handleApi(req, res, manager, prefix, url);
+			return;
+		}
+		send$1(res, 404, encodeJson({
+			error: "expired",
+			message: "not found"
+		}), { "content-type": "application/json" });
+	} catch (error) {
+		writeError(res, error);
+	}
+}
+async function handleApi(req, res, manager, prefix, url) {
+	const config = manager.getConfig();
+	const path = url.pathname.slice(prefix.length);
+	const cookies = parseCookies(req);
+	const secure = config.publicBaseUrl.startsWith("https://");
+	if (req.method === "POST" && path === "/api/join") {
+		assertOrigin(req, config.publicBaseUrl);
+		assertMutatingHeaders(req);
+		const body = await readJson(req);
+		const loopback = isLoopbackHost(header(req, "host"), req.socket.remoteAddress);
+		const result = await manager.join({
+			roomCode: String(body.roomCode ?? ""),
+			invite: String(body.invite ?? ""),
+			displayName: String(body.displayName ?? ""),
+			role: body.role === "watch" ? "watch" : "sit",
+			local: loopback
+		});
+		json(res, 200, {
+			playerId: result.playerId,
+			roomId: result.roomId,
+			seat: result.seat,
+			wsTicket: result.wsTicket,
+			view: result.view
+		}, [cookieHeader("ddz_seat", result.cookie, {
+			secure,
+			sameSite: "Lax"
+		})]);
+		return;
+	}
+	if (req.method === "POST" && path === "/api/rooms") {
+		assertOrigin(req, config.publicBaseUrl);
+		assertMutatingHeaders(req);
+		if (!isLoopbackHost(header(req, "host"), req.socket.remoteAddress) && !manager.isHostCookie(cookies.ddz_host)) throw Object.assign(/* @__PURE__ */ new Error("createRoom requires loopback or host cookie"), {
+			status: 403,
+			code: "auth"
+		});
+		const body = await readJson(req);
+		try {
+			const created = await manager.createRoom({
+				stakeM: Number(body.stakeM ?? config.defaultStakeM),
+				maxMultiplier: Number(body.maxMultiplier ?? config.defaultMaxMultiplier),
+				seatCount: body.seatCount === 4 ? 4 : 3,
+				laiZi: body.laiZi === true,
+				...body.hostDisplayName ? { hostDisplayName: body.hostDisplayName } : {},
+				...body.title ? { title: body.title } : {}
+			}, cookies.ddz_host);
+			json(res, 200, {
+				roomId: created.roomId,
+				roomCode: created.roomCode,
+				sitUrl: created.sitUrl,
+				watchUrl: created.watchUrl,
+				seatCapAtoms: created.seatCapAtoms,
+				shareable: created.shareable,
+				hostPlayerId: created.hostPlayerId,
+				view: created.view,
+				wsTicket: manager.issueTicket(created.hostPlayerId, created.roomId)
+			}, [cookieHeader("ddz_host", created.hostCookie, {
+				secure,
+				sameSite: "Strict"
+			}), cookieHeader("ddz_seat", created.hostCookie, {
+				secure,
+				sameSite: "Lax"
+			})]);
+		} catch (error) {
+			if (error instanceof Error && error.name === "welcome-below-seatcap") throw Object.assign(error, {
+				status: 409,
+				code: "insufficient"
+			});
+			throw error;
+		}
+		return;
+	}
+	if (req.method === "GET" && path === "/api/health") {
+		if (!manager.isHostCookie(cookies.ddz_host)) throw Object.assign(/* @__PURE__ */ new Error("host only"), {
+			status: 403,
+			code: "auth"
+		});
+		json(res, 200, manager.health());
+		return;
+	}
+	if (req.method === "GET" && path === "/api/me/ledger") {
+		const session$1 = manager.sessionByCookie(cookies.ddz_seat);
+		if (!session$1) throw Object.assign(/* @__PURE__ */ new Error("not joined"), {
+			status: 403,
+			code: "auth"
+		});
+		json(res, 200, manager.ledgerFor(session$1.playerId));
+		return;
+	}
+	const roomMatch = /^\/api\/rooms\/([^/]+)(?:\/(since|command))?$/.exec(path);
+	if (!roomMatch) {
+		send$1(res, 404, encodeJson({
+			error: "expired",
+			message: "not found"
+		}), { "content-type": "application/json" });
+		return;
+	}
+	const roomId = roomMatch[1];
+	const tail = roomMatch[2];
+	const session = manager.sessionByCookie(cookies.ddz_seat);
+	if (!session || session.roomId !== roomId) throw Object.assign(/* @__PURE__ */ new Error("not in this room"), {
+		status: 403,
+		code: "auth"
+	});
+	if (req.method === "GET" && !tail) {
+		json(res, 200, manager.view(session.roomId, session.playerId));
+		return;
+	}
+	if (req.method === "GET" && tail === "since") {
+		const seq = Number(url.searchParams.get("seq") ?? "0");
+		json(res, 200, manager.eventsSince(session.roomId, session.playerId, Number.isFinite(seq) ? seq : 0));
+		return;
+	}
+	if (req.method === "POST" && tail === "command") {
+		assertOrigin(req, config.publicBaseUrl);
+		assertMutatingHeaders(req);
+		const command = await readJson(req);
+		try {
+			json(res, 200, await manager.command(session.roomId, session.playerId, command, manager.isHostCookie(cookies.ddz_host)));
+		} catch (error) {
+			send$1(res, 409, encodeJson({
+				error: error.code ?? "illegal",
+				message: error instanceof Error ? error.message : "conflict"
+			}), { "content-type": "application/json" });
+		}
+		return;
+	}
+	send$1(res, 404, "");
+}
+async function readJson(req) {
+	const chunks = [];
+	let size = 0;
+	await new Promise((resolve, reject) => {
+		req.on("data", (chunk) => {
+			const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+			size += buf.length;
+			if (size > 64 * 1024) {
+				reject(Object.assign(/* @__PURE__ */ new Error("payload too large"), {
+					status: 400,
+					code: "illegal"
+				}));
+				return;
+			}
+			chunks.push(buf);
+		});
+		req.on("end", () => {
+			resolve();
+		});
+		req.on("error", reject);
+	});
+	if (chunks.length === 0) return {};
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		throw Object.assign(/* @__PURE__ */ new Error("invalid json"), {
+			status: 400,
+			code: "illegal"
+		});
+	}
+}
+function json(res, status, body, cookies) {
+	const headers = {
+		"content-type": "application/json; charset=utf-8",
+		"cache-control": "no-store"
+	};
+	if (cookies && cookies.length > 0) headers["set-cookie"] = cookies;
+	send$1(res, status, encodeJson(body), headers);
+}
+function html(res, body) {
+	send$1(res, 200, body, {
+		"content-type": "text/html; charset=utf-8",
+		"cache-control": "no-store"
+	});
+}
+function send$1(res, status, body, headers = {}) {
+	if (res.headersSent) return;
+	res.writeHead(status, headers);
+	res.end(body);
+}
+function writeError(res, error) {
+	const status = error.status ?? (error.code === "auth" ? 403 : 400);
+	const code = error.code ?? "illegal";
+	if (error instanceof Error && error.message === "welcome-below-seatcap") {
+		send$1(res, 409, encodeJson({
+			error: "insufficient",
+			message: "welcome-below-seatcap"
+		}), { "content-type": "application/json" });
+		return;
+	}
+	const coded = error;
+	if (error instanceof Error && coded.code) {
+		send$1(res, statusFrom(coded), encodeJson({
+			error: coded.code,
+			message: error.message
+		}), { "content-type": "application/json" });
+		return;
+	}
+	send$1(res, status, encodeJson({
+		error: code,
+		message: error instanceof Error ? error.message : "error"
+	}), { "content-type": "application/json" });
+}
+function statusFrom(error) {
+	if (error.code === "auth") return 403;
+	if (error.code === "expired") return 404;
+	if (error.code === "room-full" || error.code === "insufficient" || error.code === "phase" || error.code === "duplicate-nonce") return 409;
+	return 400;
+}
+
+//#endregion
+//#region src/net/ws.ts
+function registerDouDizhuSocket(server, manager) {
+	const wss = new WebSocketServer({
+		noServer: true,
+		handleProtocols: (protocols) => protocols.has(SUBPROTOCOL) ? SUBPROTOCOL : false
+	});
+	const sockets = /* @__PURE__ */ new Map();
+	const off = manager.onEvent((playerId, event) => {
+		for (const [ws, state] of sockets) if (state.playerId === playerId && ws.readyState === WebSocket.OPEN) send(ws, event);
+	});
+	const heartbeat = setInterval(() => {
+		const now = Date.now();
+		for (const [ws, state] of sockets) if (now - state.lastSeen > manager.getConfig().disconnectAfterMs) ws.close();
+	}, manager.getConfig().heartbeatMs);
+	if (typeof heartbeat === "object" && "unref" in heartbeat) heartbeat.unref();
+	const disposeRoute = server.registerUpgrade({
+		path: `${manager.getConfig().routePrefix}/ws`,
+		handler: (req, socket, head) => {
+			try {
+				assertOrigin(req, manager.getConfig().publicBaseUrl);
+			} catch {
+				socket.write("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n");
+				socket.destroy();
+				return;
+			}
+			const ticket = new URL(req.url ?? "/", "http://127.0.0.1").searchParams.get("ticket") ?? "";
+			const consumed = manager.consumeTicket(ticket);
+			if (!consumed) {
+				socket.write("HTTP/1.1 401 Unauthorized\r\nConnection: close\r\n\r\n");
+				socket.destroy();
+				return;
+			}
+			wss.handleUpgrade(req, socket, head, (ws) => {
+				const state = {
+					playerId: consumed.playerId,
+					roomId: consumed.roomId,
+					lastSeen: Date.now()
+				};
+				sockets.set(ws, state);
+				manager.counters.wsConnected += 1;
+				manager.markConnected(state.playerId, state.roomId);
+				send(ws, {
+					type: "snapshot",
+					seq: 0,
+					view: manager.view(state.roomId, state.playerId)
+				});
+				ws.on("message", (data) => {
+					if (Buffer.byteLength(data.toString()) > MAX_FRAME_BYTES) {
+						ws.close();
+						return;
+					}
+					state.lastSeen = Date.now();
+					onMessage(ws, state, data.toString(), manager);
+				});
+				ws.on("close", () => {
+					sockets.delete(ws);
+					manager.counters.wsConnected = Math.max(0, manager.counters.wsConnected - 1);
+					manager.markDisconnected(state.playerId, state.roomId);
+				});
+			});
+		}
+	});
+	return () => {
+		clearInterval(heartbeat);
+		off();
+		disposeRoute();
+		wss.close();
+	};
+}
+async function onMessage(ws, state, raw, manager) {
+	let command;
+	try {
+		command = JSON.parse(raw);
+	} catch {
+		send(ws, {
+			type: "reject",
+			code: "illegal",
+			reason: "invalid json"
+		});
+		return;
+	}
+	try {
+		await manager.command(state.roomId, state.playerId, command);
+		if (command.type === "ping") send(ws, {
+			type: "pong",
+			ts: Date.now()
+		});
+	} catch (error) {
+		error.code;
+		send(ws, {
+			type: "reject",
+			code: error.code ?? "illegal",
+			reason: error instanceof Error ? error.message : "rejected"
+		});
+	}
+}
+function send(ws, event) {
+	if (ws.readyState === WebSocket.OPEN) ws.send(encodeJson(event));
+}
+
+//#endregion
+//#region src/index.ts
+const name = "doudizhu";
+const inject = ["webServer", "settings"];
+const DOUDIZHU_NS = settingsNamespace("doudizhu");
+function apply(ctx, config) {
+	const manager = new RoomManager(ctx, config, ctx.get("storageDomain"));
+	manager.listenPort = () => ctx.webServer.port;
+	ctx.effect(() => {
+		const stop = [...registerDouDizhuHttp(ctx.webServer, manager), registerDouDizhuSocket(ctx.webServer, manager)];
+		return () => {
+			for (const dispose of stop) dispose();
+			manager.dispose();
+		};
+	});
+	let currentConfig = () => config;
+	installSettingsSection(ctx, DOUDIZHU_NS, Config, config, {
+		setSource: (current) => {
+			currentConfig = current;
+			manager.replaceConfig(current());
+		},
+		onChange: () => {
+			manager.replaceConfig(currentConfig());
+		},
+		validate: (value) => {
+			resolveConfig(value);
+		}
+	});
+	ctx.inject(["systemPrompt"], (promptCtx) => {
+		promptCtx.systemPrompt?.section({
+			name: "plugin:doudizhu",
+			order: 200,
+			text: "本机已安装 dsh-poker。开房走侧栏 New Session 下面的「斗地主」，首页可创建或加入，支持 3 人/4 人、经典/癞子。结算是 Host 欢迎积分账本，不是 DeepSeek 平台余额。"
+		});
+	});
+}
+
+//#endregion
+export { Config, DOUDIZHU_NS, apply, inject, name };
+//# sourceMappingURL=index.js.map