@joystyk/rooms 0.0.0 → 0.2.0

package/dist/node/registry.js

@@ -0,0 +1,43 @@
+import { createRoomCore } from "../core.js";
+//#region src/node/registry.ts
+/**
+* Builds a registry. For each game, the entry with the highest rules version is current;
+* the others are frozen engines kept for rooms already playing on them.
+*/
+var createEngineRegistry = (entries, rng, limits) => {
+	const cores = /* @__PURE__ */ new Map();
+	const current = /* @__PURE__ */ new Map();
+	const jobs = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const key = `${entry.pin.id}@${entry.pin.rulesVersion}`;
+		if (cores.has(key)) throw new Error(`${key} is registered twice.`);
+		const core = createRoomCore({
+			engine: entry.engine,
+			pin: entry.pin,
+			rng,
+			heavyAi: entry.heavyAi === true,
+			...limits ? { limits } : {}
+		});
+		cores.set(key, core);
+		const newest = current.get(entry.pin.id);
+		if (newest === void 0 || newest.pin.rulesVersion < entry.pin.rulesVersion) current.set(entry.pin.id, {
+			core,
+			pin: entry.pin,
+			policy: entry.policy
+		});
+		for (const [kind, url] of Object.entries(entry.jobs ?? {})) jobs.set(`${entry.pin.id}@${entry.pin.rulesVersion}/${kind}`, url);
+	}
+	return {
+		core: (gameId, rulesVersion) => cores.get(`${gameId}@${rulesVersion}`) ?? null,
+		current: (gameId) => current.get(gameId) ?? null,
+		games: () => [...current.keys()],
+		jobModule: (gameId, kind, rulesVersion) => {
+			const version = rulesVersion ?? current.get(gameId)?.pin.rulesVersion;
+			return version === void 0 ? null : jobs.get(`${gameId}@${version}/${kind}`) ?? null;
+		}
+	};
+};
+//#endregion
+export { createEngineRegistry };
+
+//# sourceMappingURL=registry.js.map

package/dist/node/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/node/registry.ts"],"sourcesContent":["// The engine registry (room-server.md sections 4.1 and 6.1): which games and rules versions\n// this build carries. A room pins its rules version for a match; frozen engines stay\n// registered until no live room needs them.\nimport type { AnyDiscreteEngine, Rng, RngState } from '@joystyk/contracts';\nimport { createRoomCore } from '../core.ts';\nimport type { CoreLimits, GamePin, RoomCore, RoomPolicy } from '../types.ts';\n\nexport type RegisteredEngine = {\n  readonly pin: GamePin;\n  readonly engine: AnyDiscreteEngine;\n  readonly policy: RoomPolicy;\n  /** The manifest's `ai.heavy`: choose on the worker pool with the `ai` job module. */\n  readonly heavyAi?: boolean;\n  /** Worker entry modules by job kind (a game's `jobs/<kind>.worker.ts`; `ai` for heavy AI). */\n  readonly jobs?: { readonly [kind: string]: URL };\n};\n\nexport type CurrentEngine = { readonly core: RoomCore; readonly pin: GamePin; readonly policy: RoomPolicy };\n\nexport interface EngineRegistry {\n  /** The core for a game at a rules version, or null if this build no longer carries it. */\n  core(gameId: string, rulesVersion: number): RoomCore | null;\n  /** The newest engine for a game: new rooms and rematches use it. */\n  current(gameId: string): CurrentEngine | null;\n  games(): readonly string[];\n  /** Pinned room work uses its rules version; unversioned probes select current. */\n  jobModule(gameId: string, kind: string, rulesVersion?: number): URL | null;\n}\n\n/**\n * Builds a registry. For each game, the entry with the highest rules version is current;\n * the others are frozen engines kept for rooms already playing on them.\n */\nexport const createEngineRegistry = (\n  entries: readonly RegisteredEngine[],\n  rng: (state: RngState) => Rng,\n  limits?: Partial<CoreLimits>,\n): EngineRegistry => {\n  const cores = new Map<string, RoomCore>();\n  const current = new Map<string, CurrentEngine>();\n  const jobs = new Map<string, URL>();\n  for (const entry of entries) {\n    const key = `${entry.pin.id}@${entry.pin.rulesVersion}`;\n    if (cores.has(key)) throw new Error(`${key} is registered twice.`);\n    const core = createRoomCore({\n      engine: entry.engine,\n      pin: entry.pin,\n      rng,\n      heavyAi: entry.heavyAi === true,\n      ...(limits ? { limits } : {}),\n    });\n    cores.set(key, core);\n    const newest = current.get(entry.pin.id);\n    if (newest === undefined || newest.pin.rulesVersion < entry.pin.rulesVersion)\n      current.set(entry.pin.id, { core, pin: entry.pin, policy: entry.policy });\n    for (const [kind, url] of Object.entries(entry.jobs ?? {}))\n      jobs.set(`${entry.pin.id}@${entry.pin.rulesVersion}/${kind}`, url);\n  }\n  return {\n    core: (gameId, rulesVersion) => cores.get(`${gameId}@${rulesVersion}`) ?? null,\n    current: (gameId) => current.get(gameId) ?? null,\n    games: () => [...current.keys()],\n    jobModule: (gameId, kind, rulesVersion) => {\n      const version = rulesVersion ?? current.get(gameId)?.pin.rulesVersion;\n      return version === undefined ? null : (jobs.get(`${gameId}@${version}/${kind}`) ?? null);\n    },\n  };\n};\n"],"mappings":";;;;;;AAiCA,IAAa,wBACX,SACA,KACA,WACmB;CACnB,MAAM,wBAAQ,IAAI,IAAsB;CACxC,MAAM,0BAAU,IAAI,IAA2B;CAC/C,MAAM,uBAAO,IAAI,IAAiB;CAClC,KAAK,MAAM,SAAS,SAAS;EAC3B,MAAM,MAAM,GAAG,MAAM,IAAI,GAAG,GAAG,MAAM,IAAI;EACzC,IAAI,MAAM,IAAI,GAAG,GAAG,MAAM,IAAI,MAAM,GAAG,IAAI,sBAAsB;EACjE,MAAM,OAAO,eAAe;GAC1B,QAAQ,MAAM;GACd,KAAK,MAAM;GACX;GACA,SAAS,MAAM,YAAY;GAC3B,GAAI,SAAS,EAAE,OAAO,IAAI,CAAC;EAC7B,CAAC;EACD,MAAM,IAAI,KAAK,IAAI;EACnB,MAAM,SAAS,QAAQ,IAAI,MAAM,IAAI,EAAE;EACvC,IAAI,WAAW,KAAA,KAAa,OAAO,IAAI,eAAe,MAAM,IAAI,cAC9D,QAAQ,IAAI,MAAM,IAAI,IAAI;GAAE;GAAM,KAAK,MAAM;GAAK,QAAQ,MAAM;EAAO,CAAC;EAC1E,KAAK,MAAM,CAAC,MAAM,QAAQ,OAAO,QAAQ,MAAM,QAAQ,CAAC,CAAC,GACvD,KAAK,IAAI,GAAG,MAAM,IAAI,GAAG,GAAG,MAAM,IAAI,aAAa,GAAG,QAAQ,GAAG;CACrE;CACA,OAAO;EACL,OAAO,QAAQ,iBAAiB,MAAM,IAAI,GAAG,OAAO,GAAG,cAAc,KAAK;EAC1E,UAAU,WAAW,QAAQ,IAAI,MAAM,KAAK;EAC5C,aAAa,CAAC,GAAG,QAAQ,KAAK,CAAC;EAC/B,YAAY,QAAQ,MAAM,iBAAiB;GACzC,MAAM,UAAU,gBAAgB,QAAQ,IAAI,MAAM,CAAC,EAAE,IAAI;GACzD,OAAO,YAAY,KAAA,IAAY,OAAQ,KAAK,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,MAAM,KAAK;EACrF;CACF;AACF"}

package/dist/node/server.d.ts

@@ -0,0 +1,59 @@
+import { type Server } from 'node:http';
+import type { MatchSeeds } from '../types.js';
+import { RoomHost } from './host.js';
+import { type JobPool } from './jobs.js';
+import type { EngineRegistry } from './registry.js';
+import { type RoomStore } from './store.js';
+import { type Clock, type Logger } from './support.js';
+export type ServerLimits = {
+    /** Incoming message size in bytes (`ws` maxPayload). */
+    readonly maxPayload: number;
+    readonly messagesPerSecond: number;
+    readonly messageBurst: number;
+    /** Over-limit messages tolerated before closing with 4008. */
+    readonly rateStrikes: number;
+    /** Only over-limit messages within this rolling window count toward closing. */
+    readonly rateStrikeWindowMs: number;
+    readonly roomsPerIpPerHour: number;
+    readonly joinMissesPerIpPer10Min: number;
+    readonly connectionsPerIp: number;
+    readonly maxConnections: number;
+    readonly maxRooms: number;
+    readonly outgoingBufferBytes: number;
+    readonly heartbeatMs: number;
+    readonly idleUnloadMs: number;
+    readonly maintenanceMs: number;
+    readonly createBodyBytes: number;
+    readonly drainJobsMs: number;
+    readonly persistRetryMs: number;
+    /** How long a heavy AI may choose on the pool before its seat times out. */
+    readonly aiTimeoutMs: number;
+};
+export declare const DEFAULT_SERVER_LIMITS: ServerLimits;
+export type RoomServerOptions = {
+    readonly store: RoomStore;
+    readonly registry: EngineRegistry;
+    /** Fresh engine and AI seeds from the CSPRNG, in the rng algorithm the registry's cores use. */
+    readonly seeds: () => MatchSeeds;
+    readonly pool?: JobPool;
+    readonly clock?: Clock;
+    readonly log?: Logger;
+    /** Exactly this origin may create rooms and open sockets. Null allows any (development only). */
+    readonly publicOrigin?: string | null;
+    /** Extra origins allowed in development, such as the Vite dev server. */
+    readonly devOrigins?: readonly string[];
+    /** Traefik's address or CIDR range; only it may report the client address. */
+    readonly trustedProxy?: string | null;
+    /** The header Traefik reports the client address in; otherwise the last X-Forwarded-For entry. */
+    readonly clientIpHeader?: string | null;
+    readonly limits?: Partial<ServerLimits>;
+};
+export interface RoomServer {
+    readonly http: Server;
+    readonly host: RoomHost;
+    /** Listens and resumes rooms with outstanding jobs. Resolves with the bound port. */
+    listen(port: number, hostname?: string): Promise<number>;
+    /** SIGTERM: refuse new work, let jobs finish, tell clients to reconnect, close the store. */
+    drain(): Promise<void>;
+}
+export declare const createRoomServer: (options: RoomServerOptions) => RoomServer;

package/dist/node/server.js

@@ -0,0 +1,577 @@
+import { nameReplacedMessage } from "../names.js";
+import { ClientMessageSchema, CreateRoomRequestSchema, RoomCode, SUPPORTED_PROTOCOLS } from "../protocol/schemas.js";
+import { CloseCode, RejectionCode, isSupportedProtocol } from "../protocol/index.js";
+import { expiresAt } from "./store.js";
+import { RoomHost } from "./host.js";
+import { inlineJobPool } from "./jobs.js";
+import { TokenBucket, WindowCounter, clientAddress, createLogger, hashToken, newRoomCode, newSeatToken, parseTrustedProxy, systemClock } from "./support.js";
+import { checkDisplayName } from "@joystyk/identity/names";
+import { createServer } from "node:http";
+import { rateLimitKey } from "@joystyk/ops";
+import { WebSocket, WebSocketServer } from "ws";
+//#region src/node/server.ts
+var DEFAULT_SERVER_LIMITS = {
+	maxPayload: 2048,
+	messagesPerSecond: 10,
+	messageBurst: 20,
+	rateStrikes: 20,
+	rateStrikeWindowMs: 6e4,
+	roomsPerIpPerHour: 20,
+	joinMissesPerIpPer10Min: 20,
+	connectionsPerIp: 16,
+	maxConnections: 2e3,
+	maxRooms: 1e3,
+	outgoingBufferBytes: 262144,
+	heartbeatMs: 25e3,
+	idleUnloadMs: 6e5,
+	maintenanceMs: 6e4,
+	createBodyBytes: 4096,
+	drainJobsMs: 1e4,
+	persistRetryMs: 5e3,
+	aiTimeoutMs: 3e4
+};
+/** Validates synchronously; schemas that answer with a Promise are refused (they would reorder messages). */
+var validate = (schema, value) => {
+	const result = schema["~standard"].validate(value);
+	if (result instanceof Promise || result.issues !== void 0) return { ok: false };
+	return {
+		ok: true,
+		value: result.value
+	};
+};
+var createRoomServer = (options) => {
+	const limits = {
+		...DEFAULT_SERVER_LIMITS,
+		...options.limits
+	};
+	const clock = options.clock ?? systemClock;
+	const log = options.log ?? createLogger();
+	const pool = options.pool ?? inlineJobPool(() => ({
+		ok: false,
+		reason: "failed"
+	}));
+	const { store, registry } = options;
+	const trusted = options.trustedProxy ? parseTrustedProxy(options.trustedProxy) : null;
+	const header = options.clientIpHeader ?? null;
+	const publicOrigin = options.publicOrigin ?? null;
+	const allowedOrigins = /* @__PURE__ */ new Set([...publicOrigin === null ? [] : [publicOrigin], ...options.devOrigins ?? []]);
+	let draining = false;
+	let connSequence = 0;
+	const host = new RoomHost({
+		store,
+		registry,
+		clock,
+		pool,
+		log,
+		maxRooms: limits.maxRooms,
+		outgoingBufferBytes: limits.outgoingBufferBytes,
+		persistRetryMs: limits.persistRetryMs,
+		aiTimeoutMs: limits.aiTimeoutMs,
+		draining: () => draining
+	});
+	const creations = new WindowCounter(36e5, limits.roomsPerIpPerHour);
+	const misses = new WindowCounter(6e5, limits.joinMissesPerIpPer10Min);
+	const perIp = /* @__PURE__ */ new Map();
+	const sockets = new WebSocketServer({
+		noServer: true,
+		maxPayload: limits.maxPayload,
+		perMessageDeflate: { threshold: 1024 }
+	});
+	const originAllowed = (origin) => {
+		if (origin === void 0) return true;
+		if (publicOrigin === null) return true;
+		return allowedOrigins.has(origin);
+	};
+	const rateLimited = (limit) => log.write("warn", "rate_limited", { limit });
+	const json = (res, status, value, headers = {}) => {
+		res.writeHead(status, {
+			"content-type": "application/json",
+			"cache-control": "no-store",
+			...headers
+		});
+		res.end(JSON.stringify(value));
+	};
+	const readBody = (req, max) => new Promise((resolve) => {
+		const chunks = [];
+		let size = 0;
+		let done = false;
+		req.on("data", (chunk) => {
+			if (done) return;
+			size += chunk.length;
+			if (size > max) {
+				done = true;
+				resolve(null);
+				req.resume();
+				return;
+			}
+			chunks.push(chunk);
+		});
+		req.on("end", () => {
+			if (!done) resolve(Buffer.concat(chunks).toString("utf8"));
+		});
+		req.on("error", () => {
+			if (!done) resolve(null);
+		});
+	});
+	const createRoom = async (req, res) => {
+		if (draining) return json(res, 503, { error: "The server is restarting. Try again in a moment." }, { "retry-after": "5" });
+		if (!originAllowed(req.headers.origin)) return json(res, 403, { error: "Origin refused." });
+		const body = await readBody(req, limits.createBodyBytes);
+		if (body === null) return json(res, 413, { error: "The request is too large." });
+		let raw;
+		try {
+			raw = JSON.parse(body);
+		} catch {
+			return json(res, 400, { error: "The request is not JSON." });
+		}
+		const parsed = CreateRoomRequestSchema.safeParse(raw);
+		if (!parsed.success) return json(res, 400, { error: "The request is not valid." });
+		const request = parsed.data;
+		const now = clock.now();
+		const ip = rateLimitKey(clientAddress(req, trusted, header));
+		if (!creations.allow(ip, now)) {
+			rateLimited("rooms-per-ip");
+			return json(res, 429, { error: "Too many rooms. Try again later." }, { "retry-after": "600" });
+		}
+		if (host.rooms.size >= limits.maxRooms) return json(res, 503, { error: "The server is full. Try again soon." }, { "retry-after": "30" });
+		const current = registry.current(request.game);
+		if (current === null) return json(res, 404, { error: "That game has no online rooms." });
+		const config = validate(current.core.engine.schemas.config, request.config ?? {});
+		if (!config.ok) return json(res, 400, { error: "That game configuration is not valid." });
+		const { decisionMs, bank } = request.settings ?? {};
+		let policy = current.policy;
+		if (decisionMs !== void 0) policy = {
+			...policy,
+			decisionMs,
+			...decisionMs === null ? {} : { bank: null }
+		};
+		if (bank !== void 0) policy = {
+			...policy,
+			bank,
+			...bank === null ? {} : { decisionMs: null }
+		};
+		let code = newRoomCode();
+		while (store.exists(code)) code = newRoomCode();
+		const token = newSeatToken();
+		const created = current.core.create({
+			code,
+			policy,
+			config: config.value,
+			seeds: options.seeds(),
+			creator: {
+				name: request.name,
+				tokenHash: hashToken(token)
+			}
+		}, now);
+		if (!created.ok) {
+			if (created.error.diagnostic !== void 0) log.write("error", "room_init_failed", {
+				game: current.pin.id,
+				...created.error.diagnostic
+			});
+			return json(res, 400, { error: created.error.message });
+		}
+		store.insert(created.value);
+		log.write("info", "room_created", {
+			room: code,
+			game: current.pin.id,
+			rules: current.pin.rulesVersion
+		});
+		const name = created.value.seats[0]?.claim?.name ?? request.name;
+		const checked = checkDisplayName(request.name);
+		const response = {
+			room: code,
+			token,
+			name,
+			...checked.ok ? {} : { notice: {
+				code: "name-replaced",
+				message: nameReplacedMessage(checked.error, name)
+			} },
+			game: current.pin,
+			expiresAt: expiresAt(created.value)
+		};
+		json(res, 201, response);
+	};
+	const roomInfo = (req, res, code) => {
+		const ip = rateLimitKey(clientAddress(req, trusted, header));
+		const now = clock.now();
+		if (!misses.allow(ip, now, false)) {
+			rateLimited("join-misses");
+			return json(res, 429, { error: "Too many unknown rooms. Try again later." });
+		}
+		const record = RoomCode.safeParse(code).success ? host.rooms.get(code)?.room.record ?? store.load(code) : null;
+		if (record === null || record.phase === "closed") {
+			misses.hit(ip, now);
+			return json(res, 404, { error: "No such room." });
+		}
+		const open = record.phase === "lobby" ? record.seats.filter((s) => s.claim === null && s.controller === "human").length : record.policy.lateJoin === "take-ai-seat" ? record.seats.filter((s) => s.claim === null && s.controller === "ai").length : 0;
+		const info = {
+			game: record.match?.game ?? record.game,
+			phase: record.phase,
+			seatsOpen: open,
+			spectatorsAllowed: record.policy.maxSpectators > 0
+		};
+		json(res, 200, info);
+	};
+	/** The games this build opens rooms for, and its protocol versions. Cheap and public, so it may be cached briefly. */
+	const hostedGames = (res) => {
+		const hosted = {
+			protocol: 1,
+			protocols: [...SUPPORTED_PROTOCOLS],
+			games: [...registry.games()]
+		};
+		json(res, 200, hosted, { "cache-control": "public, max-age=60" });
+	};
+	const http = createServer((req, res) => {
+		const path = new URL(req.url ?? "/", "http://rooms.invalid").pathname;
+		const route = async () => {
+			if (path === "/healthz") return json(res, 200, { ok: true });
+			if (path === "/readyz") return draining || !store.ping() ? json(res, 503, { ok: false }) : json(res, 200, { ok: true });
+			if (path === "/api/rooms" && req.method === "POST") return createRoom(req, res);
+			if (path === "/api/rooms/games" && req.method === "GET") return hostedGames(res);
+			const match = /^\/api\/rooms\/([^/]+)$/.exec(path);
+			if (match !== null && req.method === "GET") return roomInfo(req, res, match[1] ?? "");
+			json(res, 404, { error: "Not found." });
+		};
+		route().catch((error) => {
+			log.write("error", "http_error", {
+				path,
+				error: String(error)
+			});
+			if (!res.headersSent) json(res, 500, { error: "The room server could not complete this request." });
+			else res.end();
+		});
+	});
+	const refuseUpgrade = (socket, status, extra = "") => {
+		socket.end(`HTTP/1.1 ${status}\r\nConnection: close\r\nContent-Length: 0\r\n${extra}\r\n`);
+	};
+	http.on("upgrade", (req, socket, head) => {
+		if (new URL(req.url ?? "/", "http://rooms.invalid").pathname !== "/ws") return refuseUpgrade(socket, "404 Not Found");
+		if (draining) return refuseUpgrade(socket, "503 Service Unavailable", "Retry-After: 5\r\n");
+		if (!originAllowed(req.headers.origin)) return refuseUpgrade(socket, "403 Forbidden");
+		if (sockets.clients.size >= limits.maxConnections) return refuseUpgrade(socket, "503 Service Unavailable", "Retry-After: 10\r\n");
+		const ip = rateLimitKey(clientAddress(req, trusted, header));
+		if ((perIp.get(ip) ?? 0) >= limits.connectionsPerIp) {
+			rateLimited("connections-per-ip");
+			return refuseUpgrade(socket, "429 Too Many Requests");
+		}
+		sockets.handleUpgrade(req, socket, head, (ws) => accept(ws, ip));
+	});
+	const notice = (conn, code, message) => {
+		conn.send(JSON.stringify({
+			v: conn.protocol,
+			t: "notice",
+			code,
+			message
+		}));
+	};
+	/** Connection state per socket, for the heartbeat. */
+	const connOf = /* @__PURE__ */ new WeakMap();
+	const accept = (ws, ip) => {
+		perIp.set(ip, (perIp.get(ip) ?? 0) + 1);
+		connSequence += 1;
+		const conn = {
+			id: `conn-${connSequence}`,
+			protocol: 1,
+			pendingToken: null,
+			socket: ws,
+			ip,
+			bucket: new TokenBucket(limits.messagesPerSecond, limits.messageBurst, clock.now()),
+			room: null,
+			strikes: [],
+			alive: true,
+			get bufferedAmount() {
+				return ws.bufferedAmount;
+			},
+			send: (text) => {
+				if (ws.readyState === WebSocket.OPEN) ws.send(text);
+			},
+			close: (code, reason) => {
+				if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) ws.close(code, reason.slice(0, 120));
+			}
+		};
+		connOf.set(ws, conn);
+		ws.on("pong", () => {
+			conn.alive = true;
+		});
+		ws.on("message", (data, isBinary) => onMessage(conn, data, isBinary));
+		ws.on("error", () => ws.terminate());
+		ws.on("close", () => {
+			const count = (perIp.get(ip) ?? 1) - 1;
+			if (count <= 0) perIp.delete(ip);
+			else perIp.set(ip, count);
+			if (conn.room === null) return;
+			const live = host.rooms.get(conn.room);
+			if (live?.conns.get(conn.id) !== conn) return;
+			live.conns.delete(conn.id);
+			if (live.conns.size === 0) live.idleSince = clock.now();
+			host.dispatch(conn.room, {
+				type: "leave",
+				conn: conn.id
+			});
+		});
+	};
+	const onMessage = (conn, data, isBinary) => {
+		const now = clock.now();
+		if (!conn.bucket.take(now)) {
+			conn.strikes = conn.strikes.filter((at) => at > now - limits.rateStrikeWindowMs);
+			conn.strikes.push(now);
+			if (conn.strikes.length > limits.rateStrikes) {
+				rateLimited("messages");
+				conn.close(CloseCode.policy, "too fast");
+			} else notice(conn, "too-fast", "Slow down.");
+			return;
+		}
+		if (isBinary) return notice(conn, "bad-message", "Messages are JSON text.");
+		let raw;
+		try {
+			raw = JSON.parse(String(data));
+		} catch {
+			return notice(conn, "bad-message", "That message is not JSON.");
+		}
+		const version = typeof raw === "object" && raw !== null ? raw.v : void 0;
+		if (typeof version === "number" && !isSupportedProtocol(version)) {
+			notice(conn, "protocol-unsupported", "Reload the page to get the latest version.");
+			conn.close(CloseCode.policy, "protocol unsupported");
+			return;
+		}
+		const parsed = ClientMessageSchema.safeParse(raw);
+		if (!parsed.success) return notice(conn, "bad-message", "That message is not valid.");
+		const message = parsed.data;
+		if (message.t === "join") return join(conn, message, now);
+		const code = conn.room;
+		const live = code === null ? void 0 : host.rooms.get(code);
+		if (code === null || live === void 0) return notice(conn, "bad-message", "Join a room first.");
+		switch (message.t) {
+			case "act": {
+				const command = validate(live.core.engine.schemas.command, message.command);
+				if (!command.ok) {
+					conn.send(JSON.stringify({
+						v: conn.protocol,
+						t: "receipt",
+						id: message.id,
+						result: {
+							status: "rejected",
+							code: RejectionCode.badCommand,
+							message: "That move is not valid.",
+							revision: live.room.record.revision
+						}
+					}));
+					return;
+				}
+				host.dispatch(code, {
+					type: "act",
+					conn: conn.id,
+					id: message.id,
+					expectedRevision: message.rev,
+					command: command.value
+				});
+				return;
+			}
+			case "control": {
+				let control = message.control;
+				if (control.kind === "settings" && control.config !== void 0) {
+					const config = validate((registry.current(live.room.record.game.id)?.core.engine ?? live.core.engine).schemas.config, control.config);
+					if (!config.ok) {
+						conn.send(JSON.stringify({
+							v: conn.protocol,
+							t: "receipt",
+							id: message.id,
+							result: {
+								status: "rejected",
+								code: RejectionCode.badCommand,
+								message: "Those settings are not valid.",
+								revision: live.room.record.revision
+							}
+						}));
+						return;
+					}
+					control = {
+						...control,
+						config: config.value
+					};
+				}
+				host.dispatch(code, {
+					type: "control",
+					conn: conn.id,
+					id: message.id,
+					expectedRevision: message.rev,
+					control,
+					seeds: options.seeds()
+				});
+				return;
+			}
+			case "resync":
+				host.dispatch(code, {
+					type: "resync",
+					conn: conn.id
+				});
+				return;
+		}
+	};
+	const join = (conn, message, now) => {
+		if (conn.room !== null) return notice(conn, "bad-message", "This connection already joined a room.");
+		conn.protocol = message.v;
+		if (!misses.allow(conn.ip, now, false)) {
+			rateLimited("join-misses");
+			notice(conn, "too-fast", "Too many unknown rooms. Try again later.");
+			conn.close(CloseCode.policy, "too many misses");
+			return;
+		}
+		if (draining) {
+			conn.send(JSON.stringify({
+				v: conn.protocol,
+				t: "closing",
+				reason: "restart",
+				retryAfterMs: 2e3
+			}));
+			conn.close(CloseCode.restarting, "restarting");
+			return;
+		}
+		let loaded;
+		try {
+			loaded = host.load(message.room);
+		} catch (error) {
+			log.write("error", "room_load_failed", {
+				room: message.room,
+				error: String(error)
+			});
+			loaded = { problem: "busy" };
+		}
+		if ("problem" in loaded) {
+			if (loaded.problem === "busy") {
+				notice(conn, "server-busy", "The server is busy. Try again soon.");
+				conn.close(CloseCode.tryAgainLater, "busy");
+			} else if (loaded.problem === "engine-missing") {
+				conn.send(JSON.stringify({
+					v: conn.protocol,
+					t: "closing",
+					reason: "closed",
+					retryAfterMs: null
+				}));
+				conn.close(CloseCode.noSuchRoom, "closed");
+			} else {
+				misses.hit(conn.ip, now);
+				notice(conn, "no-such-room", "This room has closed.");
+				conn.close(CloseCode.noSuchRoom, "no such room");
+			}
+			return;
+		}
+		const live = loaded.live;
+		if (live.room.record.game.id !== message.game) {
+			misses.hit(conn.ip, now);
+			notice(conn, "no-such-room", "This room has closed.");
+			conn.close(CloseCode.noSuchRoom, "no such room");
+			return;
+		}
+		conn.room = message.room;
+		live.conns.set(conn.id, conn);
+		const fresh = newSeatToken();
+		conn.pendingToken = fresh;
+		host.dispatch(message.room, {
+			type: "join",
+			conn: conn.id,
+			name: message.name,
+			protocol: message.v,
+			presentedTokenHash: message.token === void 0 ? null : hashToken(message.token),
+			freshTokenHash: hashToken(fresh),
+			watch: message.watch ?? false
+		});
+		conn.pendingToken = null;
+	};
+	let heartbeat = null;
+	let maintenance = null;
+	const startTimers = () => {
+		heartbeat = setInterval(() => {
+			for (const ws of sockets.clients) {
+				const conn = connOf.get(ws);
+				if (conn === void 0) continue;
+				if (!conn.alive) {
+					ws.terminate();
+					continue;
+				}
+				conn.alive = false;
+				ws.ping();
+			}
+		}, limits.heartbeatMs);
+		maintenance = setInterval(() => {
+			const now = clock.now();
+			creations.prune(now);
+			misses.prune(now);
+			host.sweep(limits.idleUnloadMs);
+			try {
+				const pruned = store.prune(now);
+				if (pruned > 0) log.write("info", "rooms_pruned", { rooms: pruned });
+			} catch (error) {
+				log.write("error", "prune_failed", { error: String(error) });
+			}
+		}, limits.maintenanceMs);
+		heartbeat.unref();
+		maintenance.unref();
+	};
+	const listen = async (port, hostname = "0.0.0.0") => {
+		await new Promise((resolve, reject) => {
+			http.once("error", reject);
+			http.listen(port, hostname, () => {
+				http.off("error", reject);
+				resolve();
+			});
+		});
+		startTimers();
+		for (const code of store.withPendingJobs()) try {
+			host.load(code);
+		} catch (error) {
+			log.write("error", "room_load_failed", {
+				room: code,
+				error: String(error)
+			});
+		}
+		const address = http.address();
+		const bound = typeof address === "object" && address !== null ? address.port : port;
+		log.write("info", "listening", { port: bound });
+		return bound;
+	};
+	const drain = async () => {
+		if (draining) return;
+		draining = true;
+		log.write("info", "drain_started", {
+			rooms: host.rooms.size,
+			connections: sockets.clients.size
+		});
+		await pool.idle(limits.drainJobsMs);
+		const closing = JSON.stringify({
+			v: 1,
+			t: "closing",
+			reason: "restart",
+			retryAfterMs: 2e3
+		});
+		const open = [...sockets.clients];
+		for (const ws of open) {
+			if (ws.readyState === WebSocket.OPEN) ws.send(closing);
+			ws.close(CloseCode.restarting, "restarting");
+		}
+		for (const code of [...host.rooms.keys()]) host.unload(code, "drain");
+		if (heartbeat !== null) clearInterval(heartbeat);
+		if (maintenance !== null) clearInterval(maintenance);
+		const closed = Promise.all(open.map((ws) => ws.readyState === WebSocket.CLOSED ? Promise.resolve() : new Promise((resolve) => ws.once("close", () => resolve()))));
+		await Promise.race([closed, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+		for (const ws of sockets.clients) ws.terminate();
+		await new Promise((resolve) => sockets.close(() => resolve()));
+		await new Promise((resolve) => {
+			http.close(() => resolve());
+			http.closeAllConnections();
+		});
+		await pool.close();
+		store.close();
+		log.write("info", "drain_finished", {});
+	};
+	return {
+		http,
+		host,
+		listen,
+		drain
+	};
+};
+//#endregion
+export { DEFAULT_SERVER_LIMITS, createRoomServer };
+
+//# sourceMappingURL=server.js.map