@zaisma/game-server 0.0.1 → 1.0.0

package/src/room.js

@@ -0,0 +1,2192 @@
+/**
+ * The game server API and the room logic shared by Zaisma rooms (Durable Objects)
+ * and the Node runner, so a game behaves the same in both places.
+ *
+ * Words: the *client* is the game in the player's browser. The *game server* is the
+ * developer's code that holds the official game state. A *room* is one live match,
+ * running one copy of the game server. Names follow docs/NAMING.md.
+ */
+import { DatabaseError } from "./database.js";
+import { isRoomCode, roomCode } from "./names.js";
+import { readSchedules } from "./schedules.js";
+import { roomCallChecks } from "./room-calls.js";
+import { newStateTracker } from "./state-sync.js";
+function shownPlayer(player) {
+    return { id: player.id, name: player.name, kind: player.kind };
+}
+/**
+ * A restored room's restoreInfo, from when its state was saved and the version that saved it. A state
+ * saved as the room emptied (isSavedEmpty) lost nothing, however long ago: a kept world waking after a week
+ * reads savedAt for the time that passed.
+ */
+export function restoreInfoOf(savedAtMs, nowMs = Date.now(), savedVersionId = null, isSavedEmpty = false) {
+    return { savedAt: new Date(savedAtMs).toISOString(), lostDurationSec: isSavedEmpty ? 0 : Math.max(0, Math.round((nowMs - savedAtMs) / 1000)), savedVersionId };
+}
+function describeObject(given) {
+    try {
+        return (JSON.stringify(given) ?? "an object").slice(0, 80);
+    }
+    catch {
+        return "an object";
+    }
+}
+/**
+ * canJoin's answer as the room acts on it: let in, or turn away with a refusalMessage (null for the
+ * usual one). Answering nothing or anything else is a mistake (bad_handler_answer), described for the game server's errors.
+ */
+export function readJoinAnswer(answer) {
+    if (answer === true)
+        return { isAllowed: true };
+    if (answer === false)
+        return { isAllowed: false, refusalMessage: null };
+    const refusalMessage = typeof answer === "object" && answer !== null && !Array.isArray(answer) ? answer.refusalMessage : undefined;
+    if (typeof refusalMessage === "string" && Object.keys(answer).length === 1)
+        return { isAllowed: false, refusalMessage };
+    if (answer === undefined || answer === null) {
+        return { mistake: new GameServerError("bad_handler_answer", "canJoin", "canJoin answered nothing, so the player was turned away.", "Answer true to let them in, or { refusalMessage } to say why not.") };
+    }
+    const given = typeof answer === "string" ? `the text ${JSON.stringify(answer.slice(0, 60))}` : typeof answer === "object" ? describeObject(answer) : String(answer);
+    return { mistake: new GameServerError("bad_handler_answer", "canJoin", `canJoin answered ${given}, so the player was turned away.`, 'Answer true to let them in, false to turn them away, or { refusalMessage: "Wrong room password." } to turn them away with a message.') };
+}
+/** Everything a game server object may have, in the order the docs give them. Anything else is refused. */
+export const GAME_SERVER_OPTIONS = [
+    "maximumPlayerCount",
+    "maximumSpectatorCount",
+    "ticksPerSec",
+    "hostControlsEnabled",
+    "idleCheck",
+    "idleTimeoutSec",
+    "awayMode",
+    "seatHoldDurationSec",
+    "stateSyncEnabled",
+    "reconnectTimeoutSec",
+    "stateSaveIntervalSec",
+    "setup",
+    "onJoin",
+    "canJoin",
+    "onMoved",
+    "onLeave",
+    "onSpectatorJoin",
+    "onSpectatorLeave",
+    "onAway",
+    "onBack",
+    "onMessage",
+    "onBytes",
+    "onTick",
+    "onEnding",
+    "onRestored",
+    "stateView",
+    "onVersionUpdate",
+    "onRequest",
+    "schedules",
+    "onSchedule",
+    "onWebhook",
+];
+export const ROOM_LIMITS = {
+    /** Players in one room: what one room carries at 60 ticks a second (test/load/room-load.test.ts). */
+    maximumPlayerCount: 100,
+    defaultMaximumPlayerCount: 8,
+    /** Spectators in one room: each send costs the room time, so its audience is bounded like its players. Bigger audiences are a stream. */
+    maximumSpectatorCount: 100,
+    maximumTicksPerSec: 60,
+    /** A room's name, its labels, and each label's name and value. */
+    maximumNameCharacterCount: 40,
+    maximumLabelCount: 4,
+    maximumLabelNameCharacterCount: 16,
+    maximumLabelValueCharacterCount: 24,
+    /** Join data a player brings to a room, and setup data a reserved room starts with, as JSON. */
+    maximumJoinDataSizeBytes: 4 * 1024,
+    maximumSetupDataSizeBytes: 4 * 1024,
+    /** Rooms one room may reserve or move players to a minute: enough for a full lobby, not for a bug that does it every tick. */
+    maximumReservesPerMin: 20,
+    /** A kick's message, and a refusal's (canJoin's refusalMessage). */
+    maximumKickMessageCharacterCount: 200,
+    maximumRefusalMessageCharacterCount: 200,
+    /** Largest game message (or bytes) a client may send. */
+    maximumGameMessageSizeBytes: 16 * 1024,
+    /**
+     * Sustained game messages (and bytes) per second per player, with a short burst allowance. A game at
+     * 60 ticks sends two inputs in one message: incoming messages are what a room is billed for.
+     */
+    maximumGameMessagesPerSec: 30,
+    maximumGameMessageBurstCount: 60,
+    /** The idle check's default and range (idleTimeoutSec, joinRoom({ idleTimeoutSec })). */
+    defaultIdleTimeoutSec: 600,
+    minimumIdleTimeoutSec: 30,
+    maximumIdleTimeoutSec: 24 * 3600,
+    /** How long a game hidden in a real-time room counts before its player is away. */
+    hiddenTimeoutSec: 120,
+    /** How long a seat is held by default, and at most (seatHoldDurationSec). */
+    defaultSeatHoldDurationSec: 300,
+    maximumSeatHoldDurationSec: 1800,
+    /** How long a player whose connection dropped stays in the match by default, and at most (reconnectTimeoutSec). */
+    defaultReconnectTimeoutSec: 30,
+    maximumReconnectTimeoutSec: 300,
+    /** How often a real-time room saves its state by default, and the range (stateSaveIntervalSec). */
+    defaultStateSaveIntervalSec: 5,
+    minimumStateSaveIntervalSec: 1,
+    maximumStateSaveIntervalSec: 60,
+    /** A match moving to a version published "now": its notice without onVersionUpdate, and the longest onVersionUpdate can hold it. */
+    defaultVersionUpdateDelaySec: 10,
+    maximumVersionUpdateDelaySec: 300,
+    /** A real-time room's state bigger than this as JSON isn't saved, and a restart starts it fresh. */
+    maximumSavedStateSizeBytes: 32 * 1024 * 1024,
+    /** A player's view of the state as JSON (stateSyncEnabled): bigger views aren't sent, and the game's errors say so once. */
+    maximumStateViewSizeBytes: 1024 * 1024,
+    /** A latest-only message's latestKey. */
+    maximumLatestKeyCharacterCount: 40,
+    /** Latest-only messages waiting for a backed-up player, one per latestKey; past it, the oldest is dropped. */
+    maximumLatestOnlySlotCount: 64,
+};
+/**
+ * How rooms watch connections: when they probe, and when a player counts as backed up or dropped. Tuning,
+ * not contract: unlike ROOM_LIMITS, these may change in any version.
+ */
+export const ROOM_TUNING = {
+    /** How often a ticking room probes each player, for their ping and the room's clock. */
+    probeIntervalSec: 2,
+    /** A probe left unanswered this long drops the player: their connection stopped or fell too far behind. */
+    probeAnswerTimeoutSec: 8,
+    /** A player is also probed each time this much has gone out to them since their last probe. */
+    probeSentSizeBytes: 256 * 1024,
+    /** Bytes sent to a player since the last probe they answered; past it, they're dropped. */
+    maximumUnansweredSentSizeBytes: 2 * 1024 * 1024,
+    /** Unanswered probes the room remembers per player; the oldest is forgotten past it. */
+    maximumUnansweredProbeCount: 16,
+    /**
+     * A player is backed up with this much sent and not yet through: on your own server, the socket's
+     * bufferedAmount; in Zaisma rooms, sent since the last probe they answered, while a probe of theirs is
+     * backedUpDelayMs later than their ping. State sync skips them, and latest-only messages wait for them in slots.
+     */
+    backedUpSizeBytes: 64 * 1024,
+    backedUpDelayMs: 250,
+};
+/** The room protocol's version: hello and welcome say it, so either side can tell what the other speaks. */
+export const PROTOCOL_VERSION_NUMBER = 1;
+/** "Still there?" waits this long for an answer, and the room this much more before it decides for itself. */
+const IDLE_ASK_MS = 30_000;
+const IDLE_GRACE_MS = 60_000;
+const GAME_SERVER_ERROR_CODES = ["unknown_option", "bad_option", "bad_room_call", "room_call_limit", "room_call_unavailable", "bad_handler_answer"];
+/**
+ * A game server object that breaks the rules, with a code, the option at fault and what to do
+ * (like the developer API's errors, docs/NAMING.md).
+ */
+export class GameServerError extends Error {
+    code;
+    field;
+    fix;
+    constructor(code, field, message, fix) {
+        super(`${message} ${fix} (${code})`);
+        this.name = "GameServerError";
+        this.code = code;
+        this.field = field;
+        this.fix = fix;
+    }
+    /** True for any error named GameServerError with a known code, so instanceof works for the copy a game's sandbox has too. */
+    static [Symbol.hasInstance](candidate) {
+        return candidate instanceof Error && candidate.name === "GameServerError" && GAME_SERVER_ERROR_CODES.includes(candidate.code);
+    }
+}
+/** The checks every room call goes through, here and in a game's sandbox (room-calls.ts). */
+const checks = roomCallChecks(GameServerError, ROOM_LIMITS);
+/** The error for an option a game server doesn't take, naming the ones it does. */
+export function unknownOptionError(field) {
+    return new GameServerError("unknown_option", field, `${field} isn't a game server option.`, `A game server takes: ${GAME_SERVER_OPTIONS.join(", ")}.`);
+}
+/** The error for a room whose game server has no setup(): it only answers requests, runs on schedules or takes webhooks. */
+export function noSetupError() {
+    return new GameServerError("bad_option", "setup", "This game server has no setup(), so it can't run rooms; it only answers requests, runs on schedules or takes webhooks.", "Add setup: (setupData) => ({ ...your starting state }) to run rooms too.");
+}
+/** A game server's schedules, checked (readSchedules), or GameServerError for the field schedules. */
+export function checkSchedules(schedules, hasOnSchedule) {
+    const read = readSchedules(schedules, hasOnSchedule);
+    if ("message" in read)
+        throw new GameServerError("bad_option", "schedules", read.message, read.fix);
+    return read.schedules;
+}
+/** Check a game server's options once, when it's defined: unknown options and values out of range throw. */
+export function defineGameServer(server) {
+    for (const field of Object.keys(server ?? {}))
+        if (!GAME_SERVER_OPTIONS.includes(field))
+            throw unknownOptionError(field);
+    const bad = (field, message, fix) => new GameServerError("bad_option", field, message, fix);
+    if (typeof server?.setup !== "function" && typeof server?.onRequest !== "function" && typeof server?.onSchedule !== "function" && typeof server?.onWebhook !== "function") {
+        throw bad("setup", "A game server needs setup() to run rooms, onRequest() to answer requests, onSchedule() to run on schedules or onWebhook() to take webhooks, or more than one.", "Add setup: (setupData) => ({ ...your starting state }) for rooms, onRequest(player, request, server) for requests, schedules with onSchedule(run, server), or onWebhook(event, server) for webhooks.");
+    }
+    for (const field of GAME_SERVER_OPTIONS) {
+        if (field.startsWith("on") || field === "canJoin" || field === "setup" || field === "stateView") {
+            if (server[field] !== undefined && typeof server[field] !== "function")
+                throw bad(field, `${field} isn't a function.`, `Give ${field} as a function, or leave it out.`);
+        }
+    }
+    checkSchedules(server.schedules, typeof server.onSchedule === "function");
+    const { maximumPlayerCount, maximumSpectatorCount, ticksPerSec, hostControlsEnabled, idleCheck, idleTimeoutSec, awayMode, seatHoldDurationSec, reconnectTimeoutSec, stateSaveIntervalSec } = server;
+    if (maximumPlayerCount !== undefined && !(Number.isInteger(maximumPlayerCount) && maximumPlayerCount >= 1 && maximumPlayerCount <= ROOM_LIMITS.maximumPlayerCount)) {
+        throw bad("maximumPlayerCount", `maximumPlayerCount is ${JSON.stringify(maximumPlayerCount)}.`, `Give a whole number from 1 to ${ROOM_LIMITS.maximumPlayerCount}, like 8.`);
+    }
+    if (maximumSpectatorCount !== undefined && !(Number.isInteger(maximumSpectatorCount) && maximumSpectatorCount >= 0 && maximumSpectatorCount <= ROOM_LIMITS.maximumSpectatorCount)) {
+        throw bad("maximumSpectatorCount", `maximumSpectatorCount is ${JSON.stringify(maximumSpectatorCount)}.`, `Give a whole number from 0 to ${ROOM_LIMITS.maximumSpectatorCount}, like 20, or leave it out so nobody watches.`);
+    }
+    if (ticksPerSec !== undefined && !(typeof ticksPerSec === "number" && ticksPerSec > 0 && ticksPerSec <= ROOM_LIMITS.maximumTicksPerSec)) {
+        throw bad("ticksPerSec", `ticksPerSec is ${JSON.stringify(ticksPerSec)}.`, `Give a number above 0 and up to ${ROOM_LIMITS.maximumTicksPerSec}, like 30, or leave it out for a turn-based game.`);
+    }
+    if (hostControlsEnabled !== undefined && typeof hostControlsEnabled !== "boolean")
+        throw bad("hostControlsEnabled", "hostControlsEnabled isn't true or false.", "Give true or false.");
+    if (server.stateSyncEnabled !== undefined && typeof server.stateSyncEnabled !== "boolean")
+        throw bad("stateSyncEnabled", "stateSyncEnabled isn't true or false.", "Give true to send each player the state and then only what changes, or leave it out.");
+    if (server.stateView !== undefined && !server.stateSyncEnabled)
+        throw bad("stateView", "stateView only works with stateSyncEnabled.", "Add stateSyncEnabled: true, or leave stateView out.");
+    if (idleCheck !== undefined && idleCheck !== "server" && idleCheck !== "client" && idleCheck !== "off") {
+        throw bad("idleCheck", `idleCheck is ${JSON.stringify(idleCheck)}.`, 'Give "server" (the room checks, after idleTimeoutSec), "client" (each player\'s game decides) or "off".');
+    }
+    if (idleTimeoutSec !== undefined && !(typeof idleTimeoutSec === "number" && idleTimeoutSec >= ROOM_LIMITS.minimumIdleTimeoutSec && idleTimeoutSec <= ROOM_LIMITS.maximumIdleTimeoutSec)) {
+        throw bad("idleTimeoutSec", `idleTimeoutSec is ${JSON.stringify(idleTimeoutSec)}.`, `Give seconds from ${ROOM_LIMITS.minimumIdleTimeoutSec} to ${ROOM_LIMITS.maximumIdleTimeoutSec}, like 600; to turn the idle check off, give idleCheck: "off".`);
+    }
+    if (awayMode !== undefined && awayMode !== "hold" && awayMode !== "lobby")
+        throw bad("awayMode", `awayMode is ${JSON.stringify(awayMode)}.`, 'Give "hold" (hold their seat) or "lobby" (send them to the room that made this one).');
+    if (seatHoldDurationSec !== undefined && !(typeof seatHoldDurationSec === "number" && seatHoldDurationSec >= 0 && seatHoldDurationSec <= ROOM_LIMITS.maximumSeatHoldDurationSec)) {
+        throw bad("seatHoldDurationSec", `seatHoldDurationSec is ${JSON.stringify(seatHoldDurationSec)}.`, `Give seconds from 0 (no held seats) to ${ROOM_LIMITS.maximumSeatHoldDurationSec}, like 300.`);
+    }
+    if (reconnectTimeoutSec !== undefined && !(typeof reconnectTimeoutSec === "number" && reconnectTimeoutSec >= 0 && reconnectTimeoutSec <= ROOM_LIMITS.maximumReconnectTimeoutSec)) {
+        throw bad("reconnectTimeoutSec", `reconnectTimeoutSec is ${JSON.stringify(reconnectTimeoutSec)}.`, `Give seconds from 0 (leave at once) to ${ROOM_LIMITS.maximumReconnectTimeoutSec}, like 30.`);
+    }
+    if (stateSaveIntervalSec !== undefined && !(typeof stateSaveIntervalSec === "number" && stateSaveIntervalSec >= ROOM_LIMITS.minimumStateSaveIntervalSec && stateSaveIntervalSec <= ROOM_LIMITS.maximumStateSaveIntervalSec)) {
+        throw bad("stateSaveIntervalSec", `stateSaveIntervalSec is ${JSON.stringify(stateSaveIntervalSec)}.`, `Give a number of seconds from ${ROOM_LIMITS.minimumStateSaveIntervalSec} to ${ROOM_LIMITS.maximumStateSaveIntervalSec}, like ${ROOM_LIMITS.defaultStateSaveIntervalSec}, or leave it out for ${ROOM_LIMITS.defaultStateSaveIntervalSec}.`);
+    }
+    return server;
+}
+export const ERROR_TEXT = {
+    room_full: "This room is full.",
+    room_closed: "This room isn't taking new players.",
+    ended: "This match has ended.",
+    too_big: "Message too big.",
+    too_fast: "Too many messages. Slow down.",
+    bad_message: "The room couldn't read or use that message.",
+    bad_pass: "Your player pass isn't valid for this game.",
+    no_hello: "Send your player pass first.",
+    not_allowed: "Only the game server or the room's host can do that.",
+    game_unavailable: "This game isn't available right now.",
+    busy: "Rooms are busy. Try again soon.",
+    kept_out: "You were removed from this room.",
+    refused: "The game didn't let you into this room.",
+    room_not_running: "That room isn't running.",
+    hosting_paused: "This game's hosting is paused. It starts again when the month resets or its developer adds credit.",
+    account_needed: "Playing online needs a Zaisma account. Sign in on the game's page to play.",
+    game_not_open_to_player: "This game isn't open to this account.",
+    blocked_player_here: "Someone you blocked is in this room.",
+    other_version: "This room runs another version of the game, so the game reloads at it first.",
+    spectators_full: "Nobody else can watch this room right now.",
+    spectator_cannot_send: "Spectators watch; they can't send to the room.",
+    already_playing: "You're playing in this room, so you can't watch it too.",
+    bad_origin: "Rooms take players from the game's own page.",
+    // The SDK's own: sends waiting while it reconnects ran past its queue.
+    send_queue_full: "Up to 60 sends wait while reconnecting; older ones were dropped.",
+};
+/** What players are told when Zaisma ends a match at room.endsAt. */
+export const HOSTING_PAUSED_END_MESSAGE = "This game's hosting is paused, so this match has ended. New rooms open again when the month resets or its developer adds credit.";
+/** How long a room holds a seat for a player another room is sending. */
+const SEAT_MS = 60_000;
+/** room.secrets and server.secrets where a game has none. */
+export const NO_SECRETS = Object.freeze({});
+/** room.verifyReceipt and server.verifyReceipt where the runtime has no receipt keys. */
+export const NO_RECEIPT_CHECK = () => Promise.reject(new Error("Receipts can't be checked here: run the game server in Zaisma rooms or with the Node runner (npx @zaisma/game-server), or call verifyReceipt with the keys from https://rooms.zaisma.com/.well-known/receipt-jwks.json and issuer https://rooms.zaisma.com/receipts."));
+/** room.database where the room has no database: every call fails, saying so. */
+const NO_DATABASE = {
+    query: () => Promise.reject(new DatabaseError("database_unavailable", "This room has no game database.", "On your own server, start the Node runner with --database-file <file>, or pass database to startServer.")),
+    batch: () => Promise.reject(new DatabaseError("database_unavailable", "This room has no game database.", "On your own server, start the Node runner with --database-file <file>, or pass database to startServer.")),
+    erasePlayer: () => Promise.reject(new DatabaseError("database_unavailable", "This room has no game database.", "On your own server, start the Node runner with --database-file <file>, or pass database to startServer.")),
+};
+/**
+ * Plain JSON within maximumSizeBytes (ROOM_LIMITS.maximumJoinDataSizeBytes or maximumSetupDataSizeBytes), copied, or isValid false if it isn't.
+ * Nothing (undefined or null) is null. Players' data that fails this is refused.
+ */
+export function checkRoomData(given, maximumSizeBytes) {
+    return checks.checkRoomData(given, maximumSizeBytes);
+}
+/**
+ * An error for a client. message replaces the usual text, like the game's reason for turning a player away;
+ * details add what the code needs, like the room's versionId with other_version.
+ */
+export function errorMessage(code, message, details) {
+    return JSON.stringify({ type: "error", code, message: message || ERROR_TEXT[code], ...details });
+}
+/** WebSocket close code for a match that ended normally. */
+export const ENDED_CLOSE_CODE = 4000;
+/** Close code for a player refused or removed by the room: the SDK doesn't reconnect. */
+export const REMOVED_CLOSE_CODE = 4001;
+/** Close code for a player who walked away, once the room stops holding their seat. They may try to come back. */
+export const SEAT_GONE_CLOSE_CODE = 4002;
+/** Close code for a connection that stopped answering or fell too far behind; the SDK reconnects. */
+export const NO_ANSWER_CLOSE_CODE = 4003;
+/** Close code for a match switching to a version published "now"; the SDK reconnects, or the page reloads the game first. */
+export const VERSION_UPDATE_CLOSE_CODE = 4004;
+/** Close code (the WebSocket standard's "try again later") for rooms too busy to take the connection; the SDK tries again. */
+export const BUSY_CLOSE_CODE = 1013;
+/**
+ * A binary frame as the room sends it: one byte, the length of fromPlayerId in UTF-8 bytes (0 for the
+ * game server), then fromPlayerId, then the bytes.
+ */
+export function bytesFrame(bytes, fromPlayerId) {
+    const from = new TextEncoder().encode(fromPlayerId ?? "");
+    if (from.length > 255)
+        throw new Error("A player ID is too long to send bytes from");
+    const frame = new Uint8Array(1 + from.length + bytes.length);
+    frame[0] = from.length;
+    frame.set(from, 1);
+    frame.set(bytes, 1 + from.length);
+    return frame;
+}
+/**
+ * Marks a game server whose onMessage and onBytes only queue the input for its next call, like Zaisma's
+ * sandboxed real-time ones: the room hands each input over as it comes, outside the handlers waiting
+ * their turn, so ticks never wait behind input.
+ */
+export const QUEUES_INPUT = Symbol("queuesInput");
+/**
+ * On a room's API object, for Zaisma's sandbox: a count that goes up each time a block or friendship
+ * between the room's players may have changed, so the sandbox is sent the pairs again only then.
+ */
+export const PAIR_CHANGE_COUNT = Symbol("pairChangeCount");
+/** A room's method for a game server in a sandbox to reserve a room with the room code it already told the game. Zaisma's own: not on Room's type. */
+export const RESERVE_WITH_ROOM_CODE = Symbol("reserveWithRoomCode");
+/**
+ * Marks a game server that runs state sync itself, like Zaisma's sandboxed ones, whose state lives in the
+ * sandbox: its calls send their frames through the room's STATE_SYNC, and the room calls this, with the
+ * state and its API, when a round is due outside them (a player reconnecting, or catching up, in a turn-based room).
+ */
+export const SYNCS_STATE = Symbol("syncsState");
+/**
+ * On a room's API object, for a game server that runs state sync itself (SYNCS_STATE): viewers() says
+ * which players are backed up and which need a full copy (taken: each is said once), and send() sends a
+ * frame to some of them.
+ */
+export const STATE_SYNC = Symbol("stateSync");
+/** Messages a room's traffic counts by type: their data.type, like "move", or one of these. */
+export const NO_MESSAGE_TYPE = "(none)";
+export const BYTES_MESSAGE_TYPE = "(bytes)";
+export const ZAISMA_MESSAGE_TYPE = "(zaisma)";
+export const OTHER_MESSAGE_TYPE = "(other)";
+/** State sync's updates (stateSyncEnabled). */
+export const STATE_MESSAGE_TYPE = "(state)";
+/** Message types a room counts apart in each direction; any more count as OTHER_MESSAGE_TYPE. */
+const MAXIMUM_MESSAGE_TYPE_COUNT = 20;
+/** A game's message type: up to 40 letters, digits and _ - . : */
+const MESSAGE_TYPE_PATTERN = /^[A-Za-z0-9_\-.:]{1,40}$/;
+/** No traffic yet. */
+export function noTraffic() {
+    return { inboundSizeBytes: 0, outboundMessageCount: 0, outboundSizeBytes: 0, messageTypes: [] };
+}
+/** Two rooms' (or two hours') traffic added up, message types matched by type and direction. */
+export function addTraffic(first, second) {
+    const types = new Map(first.messageTypes.map((type) => [`${type.direction} ${type.messageType}`, { ...type }]));
+    for (const type of second.messageTypes) {
+        const key = `${type.direction} ${type.messageType}`;
+        const kept = types.get(key);
+        if (!kept)
+            types.set(key, { ...type, backedUpMessageCount: type.backedUpMessageCount ?? 0 });
+        else {
+            kept.messageCount += type.messageCount;
+            kept.sizeBytes += type.sizeBytes;
+            kept.largestSizeBytes = Math.max(kept.largestSizeBytes, type.largestSizeBytes);
+            // Traffic a room kept from before backed-up sends were counted has none.
+            kept.backedUpMessageCount = (kept.backedUpMessageCount ?? 0) + (type.backedUpMessageCount ?? 0);
+        }
+    }
+    return {
+        inboundSizeBytes: first.inboundSizeBytes + second.inboundSizeBytes,
+        outboundMessageCount: first.outboundMessageCount + second.outboundMessageCount,
+        outboundSizeBytes: first.outboundSizeBytes + second.outboundSizeBytes,
+        messageTypes: [...types.values()],
+    };
+}
+/** A game message's type for the traffic counts: its data.type when that's a short name, else NO_MESSAGE_TYPE. */
+function messageTypeOf(messageData) {
+    const type = messageData && typeof messageData === "object" ? messageData.type : undefined;
+    return typeof type === "string" && MESSAGE_TYPE_PATTERN.test(type) ? type : NO_MESSAGE_TYPE;
+}
+/** How many past players a room remembers, so they can come back to a closed room, and how many it keeps out: at least everyone a full room can hold, so blocks and friends are found among all of them. */
+const REMEMBERED_PLAYER_COUNT = ROOM_LIMITS.maximumPlayerCount;
+const NOBODY_JOINED = { fromRoomCode: null, isReturning: false, isSpectator: false };
+const WATCHING = { fromRoomCode: null, isReturning: false, isSpectator: true };
+/** Two players with a block between them, in either order (player IDs have no spaces). */
+const pairKey = (firstPlayerId, secondPlayerId) => (firstPlayerId < secondPlayerId ? `${firstPlayerId} ${secondPlayerId}` : `${secondPlayerId} ${firstPlayerId}`);
+/** One player's block of another: the blocker first. */
+const blockKey = (blockerPlayerId, blockedPlayerId) => `${blockerPlayerId} ${blockedPlayerId}`;
+export class RoomCore {
+    state;
+    players = new Map();
+    /** Spectators watching (maximumSpectatorCount): never in players, never counted as playing. */
+    spectators = new Map();
+    ended = false;
+    /** When Zaisma will end this match (room.endsAt), or null. */
+    endsAt = null;
+    /** Messages received from clients, for usage counts. */
+    messageCount = 0;
+    /** The rest of the room's traffic since takeTraffic, by "<direction> <type>". */
+    traffic = { inboundSizeBytes: 0, outboundMessageCount: 0, outboundSizeBytes: 0, messageTypes: new Map(), inboundTypeCount: 0, outboundTypeCount: 0 };
+    /** Goes up whenever a block or friendship between players may have changed (PAIR_CHANGE_COUNT). */
+    pairChangeCount = 0;
+    /** Set when the state changed and a sleeping room should save it. */
+    dirty = false;
+    /** A version published "now" this match is moving to, once the transport started it (startVersionUpdate). */
+    versionUpdate = null;
+    /** When a real-time room's state was last saved, set by the transport after each save; null until it has been. */
+    savedAtMs = null;
+    /** Hidden from room lists until its first player's hello asks for it (joinRoom's isListed, quickJoin), or a reserve does. */
+    isListed = false;
+    isOpen = true;
+    friendJoinsEnabled = true;
+    name = null;
+    labels = {};
+    /** Kept (room.setKept): the transport keeps its state when it empties. */
+    isKept = false;
+    /**
+     * Set when the player count, isListed, isOpen or isKept changed, so the room list can be brought up to date,
+     * and when the room's blocks changed, since a sleeping room's saved room is written with its listing.
+     */
+    listingChanged = false;
+    /** Players who have been in this room, newest last: they may come back after it closes. */
+    known = new Set();
+    /** Players kicked and kept out for the rest of the match, with the message they were given. */
+    keptOut = new Map();
+    /** Players other rooms are sending here (room.moveTo), with a seat each until they arrive. */
+    expected = new Map();
+    /** Seats held for players out of the match (walked away, or lost their connection) until they come back or it runs out. */
+    held = new Map();
+    /** Players who walked away that onAway kept in the room, and players whose connection dropped (lost), and why. */
+    kept = new Map();
+    /** Players whose connection dropped (kept as "lost"): when their time to reconnect runs out. */
+    reconnectUntilMs = new Map();
+    /** The room that made this one, where awayMode "lobby" sends players who walk away. */
+    lobbyRoomCode = null;
+    /** Blocks between players from their accounts (Zaisma's own record, or passes on your own server), either way: pairKey(first, second). */
+    accountBlocks = new Set();
+    /** Blocks players' games said they made, a guest's or one just made: blockKey(blocker, blocked). */
+    sessionBlocks = new Set();
+    /** Friendships between players from their accounts (Zaisma's own record, or passes on your own server): pairKey(first, second). */
+    friendships = new Set();
+    /** The blocks each player was last told of, so they're told again only when theirs change. */
+    toldBlocks = new Map();
+    /** When each player in the match was last heard from, when their game was hidden, and the idle check their game asked for. */
+    presence = new Map();
+    /** Players this room is sending to its lobby for walking away, so onMoved doesn't hear of it. */
+    sentAway = new Set();
+    /** What a reserved room started with, kept so a room that starts over starts the same way. */
+    setupData = null;
+    /** When this room last reserved rooms, for the limit. */
+    reservedAtMs = [];
+    buckets = new Map();
+    /** Probes this room has sent, to every player: each probe's number. */
+    probeCount = 0;
+    /** What each player was last sent of the state (stateSyncEnabled), unless the game server runs state sync itself (SYNCS_STATE). */
+    stateTracker;
+    /** For a game server that runs state sync itself: players with a new connection, who need a full copy. */
+    fullCopyPlayerIds = new Set();
+    /** A turn-based room's players state sync skipped as backed up, who get a full copy once they catch up. */
+    stateSkippedPlayerIds = new Set();
+    /** Latest-only messages waiting for each backed-up player, by "<kind>:<latestKey>", least recently replaced first. */
+    latestSlots = new Map();
+    now;
+    maximumPlayerCount;
+    maximumSpectatorCount;
+    api;
+    /** The room as canJoin and stateView see it: reading works, and any call that changes or sends throws room_call_unavailable. */
+    canJoinRoom;
+    stateViewRoom;
+    server;
+    transport;
+    /**
+     * Set once a handler returns a promise (a game server in a sandbox): from then on handlers run
+     * one after another, each with the state the last one left.
+     */
+    queue = null;
+    /** Handlers waiting in the queue, so ticks don't pile up behind a slow game server. */
+    waitingCount = 0;
+    /** Handlers running right now, and what waits for them to finish (a kicked player's onLeave). */
+    depth = 0;
+    afterHandler = [];
+    /**
+     * startOptions.start makes a reserved room: closed, open only to the players it was made for, and
+     * set up with its setup data. A saved room (startOptions.room) wakes as it was, with
+     * startOptions.presence saying when each of its players was last heard from and the idle check
+     * their game asked for. A restarted real-time room (startOptions.restoreInfo, with its saved state)
+     * skips setup: startOptions.lostPlayers, the players in its match at the save who aren't connected,
+     * come back as away (reason "lost"), and onRestored runs once. startOptions.spectators are spectators
+     * still connected to a room waking from sleep.
+     */
+    constructor(server, transport, startOptions = {}) {
+        this.server = server;
+        this.transport = transport;
+        this.now = startOptions.now ?? Date.now;
+        this.maximumPlayerCount = server.maximumPlayerCount ?? ROOM_LIMITS.defaultMaximumPlayerCount;
+        this.maximumSpectatorCount = server.maximumSpectatorCount ?? 0;
+        this.stateTracker = server.stateSyncEnabled && !server[SYNCS_STATE] ? newStateTracker(ROOM_LIMITS.maximumStateViewSizeBytes) : null;
+        for (const spectator of startOptions.spectators ?? []) {
+            this.spectators.set(spectator.id, spectator);
+            this.presence.set(spectator.id, newPresence(this.now(), {}));
+        }
+        for (const player of startOptions.players ?? []) {
+            this.players.set(player.id, player);
+            const was = startOptions.presence?.[player.id];
+            this.presence.set(player.id, newPresence(was?.seenAtMs ?? this.now(), clientIdle(was?.clientIdle)));
+        }
+        const saved = startOptions.room;
+        if (saved) {
+            this.isListed = saved.isListed !== false;
+            this.isOpen = saved.isOpen !== false;
+            this.friendJoinsEnabled = saved.friendJoinsEnabled !== false;
+            this.name = saved.name ?? null;
+            this.labels = saved.labels ?? {};
+            for (const id of saved.knownPlayerIds ?? [])
+                this.known.add(id);
+            this.setupData = saved.setupData ?? null;
+            this.keepOut(saved.keptOut);
+            for (const [id, expected] of Object.entries(saved.expected ?? {}))
+                this.expected.set(id, expected);
+            for (const [id, held] of Object.entries(saved.held ?? {}))
+                if (!this.players.has(id))
+                    this.held.set(id, held);
+            // A room waking with its state keeps players whose connection dropped: they have no connection to be found by.
+            if (startOptions.state !== undefined) {
+                for (const [id, reconnecting] of Object.entries(saved.reconnecting ?? {})) {
+                    if (this.players.has(id))
+                        continue;
+                    this.players.set(id, reconnecting.player);
+                    this.presence.set(id, newPresence(this.now(), {}));
+                    this.kept.set(id, "lost");
+                    this.reconnectUntilMs.set(id, reconnecting.untilMs);
+                }
+            }
+            for (const [id, reason] of Object.entries(saved.kept ?? {}))
+                if (this.players.has(id) && !this.kept.has(id) && reason !== "lost")
+                    this.kept.set(id, reason);
+            this.lobbyRoomCode = saved.lobbyRoomCode ?? null;
+            this.endsAt = saved.endsAt ?? null;
+            this.isKept = saved.isKept === true;
+            for (const [first, second] of saved.accountBlocks ?? [])
+                this.accountBlocks.add(pairKey(first, second));
+            for (const [blocker, blocked] of saved.sessionBlocks ?? [])
+                this.sessionBlocks.add(blockKey(blocker, blocked));
+            for (const [first, second] of saved.friendships ?? [])
+                this.friendships.add(pairKey(first, second));
+        }
+        else if (startOptions.start) {
+            const start = startOptions.start;
+            this.isOpen = false;
+            this.isListed = start.isListed;
+            this.friendJoinsEnabled = start.friendJoinsEnabled !== false;
+            this.name = start.name;
+            this.labels = start.labels;
+            for (const id of start.playerIds)
+                this.known.add(id);
+            this.setupData = start.setupData ?? null;
+            this.keepOut(start.keptOut);
+            this.lobbyRoomCode = start.lobbyRoomCode ?? null;
+            this.isKept = start.isKept === true;
+        }
+        // A restarted room's players who aren't connected: in the match until leave() below makes them away, as a dropped connection does.
+        const restoreInfo = startOptions.state !== undefined ? startOptions.restoreInfo : undefined;
+        const lostPlayers = restoreInfo ? (startOptions.lostPlayers ?? []).filter((player) => !startOptions.players?.some((connected) => connected.id === player.id) && !this.held.has(player.id)) : [];
+        for (const player of lostPlayers) {
+            this.players.set(player.id, player);
+            this.presence.set(player.id, newPresence(this.now(), {}));
+            this.kept.delete(player.id);
+            this.reconnectUntilMs.delete(player.id);
+        }
+        for (const player of this.players.values())
+            this.remember(player.id);
+        // A room waking up: its players were told their blocks before it slept.
+        for (const id of this.players.keys())
+            this.toldBlocks.set(id, JSON.stringify(this.blockedWith(id)));
+        if (startOptions.state !== undefined)
+            this.state = startOptions.state;
+        else {
+            if (typeof server.setup !== "function")
+                throw noSetupError();
+            const first = server.setup(this.setupData);
+            if (isPromise(first)) {
+                this.state = undefined;
+                this.run(() => first, "setup");
+            }
+            else
+                this.state = first;
+        }
+        const core = this;
+        this.api = {
+            roomCode: transport.roomCode,
+            get players() {
+                return [...core.players.values()];
+            },
+            get spectators() {
+                return [...core.spectators.values()];
+            },
+            broadcast: (message, broadcastOptions) => {
+                const checked = checks.checkBroadcast(message, broadcastOptions);
+                this.deliver(this.audienceOf(checked.audience).filter((id) => id !== checked.exceptPlayerId), { text: JSON.stringify({ type: "message", data: message, fromPlayerId: checked.fromPlayerId }), messageType: messageTypeOf(message) }, checked.delivery);
+            },
+            send: (playerId, message, sendOptions) => {
+                const checked = checks.checkSend(playerId, message, sendOptions);
+                const text = JSON.stringify({ type: "message", data: message, fromPlayerId: checked.fromPlayerId });
+                if (this.isViewer(checked.playerId))
+                    this.deliver([checked.playerId], { text, messageType: messageTypeOf(message) }, checked.delivery);
+            },
+            broadcastBytes: (bytes, broadcastOptions) => {
+                const checked = checks.checkBroadcastBytes(bytes, broadcastOptions);
+                this.deliver(this.audienceOf(checked.audience).filter((id) => id !== checked.exceptPlayerId), { frame: bytesFrame(checked.bytes, checked.fromPlayerId), messageType: BYTES_MESSAGE_TYPE }, checked.delivery);
+            },
+            sendBytes: (playerId, bytes, sendOptions) => {
+                const checked = checks.checkSendBytes(playerId, bytes, sendOptions);
+                if (this.isViewer(checked.playerId))
+                    this.deliver([checked.playerId], { frame: bytesFrame(checked.bytes, checked.fromPlayerId), messageType: BYTES_MESSAGE_TYPE }, checked.delivery);
+            },
+            end: (message) => this.end(checks.checkEnd(message) ?? "The match is over.", "game"),
+            get endsAt() {
+                return core.endsAt;
+            },
+            get isListed() {
+                return core.isListed;
+            },
+            setListed: (isListed) => this.settle({ isListed: Boolean(isListed) }),
+            get isOpen() {
+                return core.isOpen;
+            },
+            setOpen: (isOpen) => this.settle({ isOpen: Boolean(isOpen) }),
+            get friendJoinsEnabled() {
+                return core.friendJoinsEnabled;
+            },
+            setFriendJoinsEnabled: (isEnabled) => this.settle({ friendJoinsEnabled: Boolean(isEnabled) }),
+            get isKept() {
+                return core.isKept;
+            },
+            setKept: (isKept) => this.setKept(Boolean(isKept)),
+            get name() {
+                return core.name;
+            },
+            get labels() {
+                return { ...core.labels };
+            },
+            setInfo: (nameAndLabels) => this.settle(checks.checkSetInfo(nameAndLabels)),
+            reserve: (reserveOptions) => this.reserve(reserveOptions, null),
+            kick: (playerId, kickOptions) => {
+                const checked = checks.checkKick(playerId, kickOptions);
+                this.kick(checked.playerId, { message: checked.message, keepOut: checked.isKeptOut });
+            },
+            moveTo: (toRoomCode, moveOptions) => this.moveTo(toRoomCode, moveOptions),
+            database: transport.database ?? NO_DATABASE,
+            secrets: transport.secrets ?? NO_SECRETS,
+            verifyReceipt: transport.verifyReceipt ?? NO_RECEIPT_CHECK,
+            hasBlockBetween: (firstPlayerId, secondPlayerId) => this.hasBlockBetween(firstPlayerId, secondPlayerId),
+            areFriends: (firstPlayerId, secondPlayerId) => this.areFriends(firstPlayerId, secondPlayerId),
+            pingDurationMs: (playerId) => this.presence.get(playerId)?.pingDurationMs ?? null,
+            serverTimeMs: () => this.now(),
+            awayReason: (playerId) => (this.players.has(playerId) ? (this.kept.get(playerId) ?? null) : null),
+            applyVersionUpdate: () => {
+                if (this.versionUpdate)
+                    this.soon(() => this.transport.applyVersionUpdate?.());
+            },
+        };
+        // A game server in a sandbox picks the room code itself, since it tells the game at once.
+        Object.defineProperty(this.api, RESERVE_WITH_ROOM_CODE, { value: (reserveOptions, newRoomCode) => this.reserve(reserveOptions, newRoomCode) });
+        Object.defineProperty(this.api, PAIR_CHANGE_COUNT, { get: () => this.pairChangeCount });
+        Object.defineProperty(this.api, STATE_SYNC, { value: { viewers: () => this.stateViewers(), send: (playerIds, frame) => this.sendStateFrom(playerIds, frame) } });
+        this.canJoinRoom = readOnlyRoom(this.api, "canJoin");
+        this.stateViewRoom = readOnlyRoom(this.api, "stateView");
+        if (restoreInfo)
+            this.restored(restoreInfo, lostPlayers);
+    }
+    /**
+     * A restarted room's players who aren't connected are away as lost, with the whole reconnectTimeoutSec
+     * from now, whatever they had before the restart; then onRestored runs, and onAway for each.
+     */
+    restored(restoreInfo, lostPlayers) {
+        const reconnectTimeoutSec = this.server.reconnectTimeoutSec ?? ROOM_LIMITS.defaultReconnectTimeoutSec;
+        if (reconnectTimeoutSec > 0) {
+            for (const player of lostPlayers) {
+                this.kept.set(player.id, "lost");
+                this.reconnectUntilMs.set(player.id, this.now() + reconnectTimeoutSec * 1000);
+            }
+        }
+        this.run(() => this.server.onRestored?.(this.state, restoreInfo, this.api), "onRestored");
+        for (const player of lostPlayers) {
+            // With reconnectTimeoutSec 0, they leave at once, as a dropped connection does.
+            if (reconnectTimeoutSec === 0)
+                this.leave(player.id, "lost");
+            else if (this.server.onAway)
+                this.run(() => this.server.onAway(this.state, player, this.api, { reason: "lost" }), "onAway");
+        }
+        this.listingChanged = true;
+        this.dirty = true;
+        this.broadcastPlayers();
+    }
+    /** What a sleeping room saves besides the game's state. */
+    get saved() {
+        this.countHeldSeats();
+        return {
+            ...this.settings(),
+            knownPlayerIds: [...this.known],
+            ...(this.setupData !== null ? { setupData: this.setupData } : {}),
+            ...(this.keptOut.size ? { keptOut: Object.fromEntries(this.keptOut) } : {}),
+            ...(this.expected.size ? { expected: Object.fromEntries(this.expected) } : {}),
+            ...(this.held.size ? { held: Object.fromEntries(this.held) } : {}),
+            ...(this.kept.size ? { kept: Object.fromEntries(this.kept) } : {}),
+            ...(this.reconnectUntilMs.size ? { reconnecting: Object.fromEntries([...this.reconnectUntilMs].map(([id, untilMs]) => [id, { player: this.players.get(id), untilMs }])) } : {}),
+            ...(this.lobbyRoomCode ? { lobbyRoomCode: this.lobbyRoomCode } : {}),
+            ...(this.endsAt ? { endsAt: this.endsAt } : {}),
+            ...(this.isKept ? { isKept: true } : {}),
+            ...this.savedBlocks(),
+        };
+    }
+    /** The blocks worth keeping while the room sleeps: those between players it still remembers. */
+    savedBlocks() {
+        const remembered = (key) => key.split(" ").every((id) => this.known.has(id));
+        const accountBlocks = [...this.accountBlocks].filter(remembered).map((key) => key.split(" "));
+        const sessionBlocks = [...this.sessionBlocks].filter(remembered).map((key) => key.split(" "));
+        const friendships = [...this.friendships].filter(remembered).map((key) => key.split(" "));
+        return { ...(accountBlocks.length ? { accountBlocks } : {}), ...(sessionBlocks.length ? { sessionBlocks } : {}), ...(friendships.length ? { friendships } : {}) };
+    }
+    /** Whether two players are friends, from their accounts as the later of them joined. */
+    areFriends(firstPlayerId, secondPlayerId) {
+        return firstPlayerId !== secondPlayerId && this.friendships.has(pairKey(firstPlayerId, secondPlayerId));
+    }
+    /**
+     * A player's friends among the others this room remembers, from their accounts, as the room found them
+     * as the player joined (Zaisma's own record, or the passes on your own server): they replace what the
+     * room knew of that player's, so a friend removed since is gone. Call before join.
+     */
+    setFriends(playerId, friendPlayerIds) {
+        let isChanged = false;
+        for (const key of [...this.friendships]) {
+            if (!key.split(" ").includes(playerId))
+                continue;
+            this.friendships.delete(key);
+            isChanged = true;
+        }
+        for (const otherPlayerId of friendPlayerIds) {
+            if (otherPlayerId === playerId)
+                continue;
+            this.friendships.add(pairKey(playerId, otherPlayerId));
+            isChanged = true;
+        }
+        if (!isChanged)
+            return;
+        this.dirty = true;
+        this.pairChangeCount++;
+    }
+    /** Whether two players have a block between them, either way: from their accounts, or one a player's game said it made. */
+    hasBlockBetween(firstPlayerId, secondPlayerId) {
+        if (firstPlayerId === secondPlayerId)
+            return false;
+        return this.accountBlocks.has(pairKey(firstPlayerId, secondPlayerId)) || this.sessionBlocks.has(blockKey(firstPlayerId, secondPlayerId)) || this.sessionBlocks.has(blockKey(secondPlayerId, firstPlayerId));
+    }
+    /**
+     * The blocks between a player and the others this room remembers, from their accounts, as the room
+     * found them as the player joined (Zaisma's own record, or the passes on your own server): they replace
+     * what the room knew of that player's, so a block taken back since is gone. Call before join.
+     */
+    setAccountBlocks(playerId, blockPlayerIds) {
+        let isChanged = false;
+        for (const key of [...this.accountBlocks]) {
+            if (!key.split(" ").includes(playerId))
+                continue;
+            this.accountBlocks.delete(key);
+            isChanged = true;
+        }
+        for (const otherPlayerId of blockPlayerIds) {
+            if (otherPlayerId === playerId)
+                continue;
+            this.accountBlocks.add(pairKey(playerId, otherPlayerId));
+            isChanged = true;
+        }
+        if (!isChanged)
+            return;
+        this.dirty = true;
+        this.listingChanged = true;
+        this.pairChangeCount++;
+    }
+    /** The players in the room this one has a block with, either way. */
+    blockedWith(playerId) {
+        return [...this.players.keys()].filter((otherPlayerId) => this.hasBlockBetween(playerId, otherPlayerId));
+    }
+    /** Tell each player the players in the room they have a block with, when that changed. */
+    tellBlocks() {
+        for (const id of this.players.keys()) {
+            const playerIds = this.blockedWith(id);
+            const told = JSON.stringify(playerIds);
+            if ((this.toldBlocks.get(id) ?? "[]") === told)
+                continue;
+            this.toldBlocks.set(id, told);
+            this.sendText(id, JSON.stringify({ type: "blocks", playerIds }));
+        }
+    }
+    /** A player's game blocked a player in the room (a guest's block, or one just made), or took one back. */
+    sessionBlock(playerId, message, isBlocking) {
+        const otherPlayerId = message.playerId;
+        if (typeof otherPlayerId !== "string" || otherPlayerId === playerId || !this.known.has(otherPlayerId))
+            return "bad_message";
+        const key = blockKey(playerId, otherPlayerId);
+        if (isBlocking === this.sessionBlocks.has(key))
+            return null;
+        if (isBlocking)
+            this.sessionBlocks.add(key);
+        else
+            this.sessionBlocks.delete(key);
+        this.pairChangeCount++;
+        this.dirty = true;
+        this.listingChanged = true;
+        this.tellBlocks();
+        return null;
+    }
+    /** Players in the match who haven't walked away: what room lists and "playing now" count. */
+    get playingCount() {
+        return this.players.size - this.kept.size;
+    }
+    /** Seats the room holds for players on their way (room.moveTo) or out of the match for now. */
+    get heldSeatCount() {
+        return this.countHeldSeats();
+    }
+    /** Resolves once every handler started so far has finished (at once for game servers that answer at once). */
+    async settled() {
+        while (this.queue) {
+            const queued = this.queue;
+            await queued;
+            if (this.queue === queued)
+                return;
+        }
+    }
+    get ticking() {
+        return this.server.ticksPerSec !== undefined;
+    }
+    /** How many are watching. */
+    get spectatorCount() {
+        return this.spectators.size;
+    }
+    /**
+     * Whether a player may come in: the room's own rules (over, kept out, closed, full), then the game
+     * server's canJoin with the join data the player brought. Call before join; join checks the room's rules again.
+     * admitOptions.isSpectator: they come to watch, which a closed or full room still takes (spectatorDoor).
+     */
+    async admit(player, joinData = null, admitOptions = {}) {
+        if (admitOptions.isSpectator) {
+            const spectatorDoor = this.spectatorDoor(player.id);
+            if (spectatorDoor)
+                return spectatorDoor;
+            // A spectator reconnecting doesn't ask again.
+            return this.spectators.has(player.id) ? { isAllowed: true } : this.ask(player, joinData, WATCHING);
+        }
+        const door = this.door(player.id);
+        if (door)
+            return door;
+        // Players already in, players another room sent (asked when it sent them) and players coming back to a held seat don't ask again.
+        if (this.players.has(player.id) || this.seat(player.id) || this.holding(player.id))
+            return { isAllowed: true };
+        return this.ask(player, joinData, NOBODY_JOINED);
+    }
+    /** The game server's canJoin, then the room's rules again, since things may change while it decides. */
+    async ask(player, joinData, joinInfo) {
+        const isMoving = joinInfo.fromRoomCode !== null;
+        const door = () => (joinInfo.isSpectator ? this.spectatorDoor(player.id) : this.door(player.id, isMoving));
+        if (!this.server.canJoin)
+            return door() ?? { isAllowed: true };
+        await this.settled();
+        let answer;
+        try {
+            answer = await this.server.canJoin(this.state, player, this.canJoinRoom, joinData, joinInfo);
+        }
+        catch (error) {
+            console.error("Game server error:", error);
+            return { isAllowed: false, code: "refused" };
+        }
+        const read = readJoinAnswer(answer);
+        if ("mistake" in read) {
+            console.error("Game server error:", read.mistake);
+            return { isAllowed: false, code: "refused" };
+        }
+        if (!read.isAllowed) {
+            const message = checks.tidy(read.refusalMessage, ROOM_LIMITS.maximumRefusalMessageCharacterCount);
+            return { isAllowed: false, code: "refused", ...(message ? { message } : {}) };
+        }
+        return door() ?? { isAllowed: true };
+    }
+    /**
+     * The room's own rules for a player coming in, or null if they may. A player already in may always
+     * come back, and a player another room sent, or whose seat is held, has a seat. isMoving: the game is
+     * sending this player from another room, which a closed room still takes (closed keeps out
+     * strangers, not the game).
+     */
+    door(id, isMoving = false) {
+        if (this.ended)
+            return { isAllowed: false, code: "ended" };
+        const keptOutMessage = this.keptOut.get(id);
+        if (keptOutMessage !== undefined)
+            return { isAllowed: false, code: "kept_out", message: keptOutMessage };
+        if (this.players.has(id) || this.seat(id) || this.holding(id))
+            return null;
+        if (!isMoving && !this.isOpen && !this.known.has(id))
+            return { isAllowed: false, code: "room_closed" };
+        if (this.players.size + this.countHeldSeats() >= this.maximumPlayerCount)
+            return { isAllowed: false, code: "room_full" };
+        return null;
+    }
+    /**
+     * The room's own rules for a spectator coming in, or null if they may: a match that's over, and a player
+     * kept out, keep them out, and so does a full audience; a closed or full room doesn't, since watching a
+     * match under way is the point. A player in the match can't watch it too.
+     */
+    spectatorDoor(id) {
+        if (this.ended)
+            return { isAllowed: false, code: "ended" };
+        const keptOutMessage = this.keptOut.get(id);
+        if (keptOutMessage !== undefined)
+            return { isAllowed: false, code: "kept_out", message: keptOutMessage };
+        if (this.players.has(id))
+            return { isAllowed: false, code: "already_playing" };
+        if (this.spectators.has(id))
+            return null;
+        if (this.spectators.size >= this.maximumSpectatorCount)
+            return { isAllowed: false, code: "spectators_full" };
+        return null;
+    }
+    /** Whether this room is holding a place for a player: they've been in it, another room is sending them, or their seat is held. */
+    expects(id) {
+        return this.known.has(id) || this.seat(id) !== null || this.holding(id) !== null;
+    }
+    /** The seat held for a player out of the match, if it hasn't run out. */
+    holding(id) {
+        const held = this.held.get(id);
+        if (held && held.untilMs > this.now())
+            return held;
+        if (held) {
+            this.held.delete(id);
+            this.listingChanged = true;
+            this.dirty = true;
+        }
+        return null;
+    }
+    /** The seat held for a player another room is sending, if it hasn't run out. */
+    seat(id) {
+        const expected = this.expected.get(id);
+        if (expected && expected.untilMs > this.now())
+            return expected;
+        if (expected)
+            this.expected.delete(id);
+        return null;
+    }
+    /** Seats held for players other rooms are sending and players out of the match, dropping those that ran out. */
+    countHeldSeats() {
+        let heldSeatCount = 0;
+        for (const id of [...this.expected.keys()])
+            if (!this.players.has(id) && this.seat(id))
+                heldSeatCount++;
+        for (const id of [...this.held.keys()])
+            if (this.holding(id))
+                heldSeatCount++;
+        return heldSeatCount;
+    }
+    /**
+     * Another room of the game wants to send players here (its room.moveTo). Each is checked like a
+     * newcomer, with the room's rules and canJoin given the sending room's join data; those taken get a
+     * seat for a minute. Says who was taken and who wasn't, and why.
+     */
+    async expect(ask) {
+        const answer = { movedPlayerIds: [], refusals: [] };
+        const checked = checkRoomData(ask.joinData, ROOM_LIMITS.maximumJoinDataSizeBytes);
+        const joinData = checked.isValid ? checked.checkedData : null;
+        for (const player of ask.players) {
+            const verdict = this.players.has(player.id)
+                ? { isAllowed: false, code: "bad_message", message: "Already in that room." }
+                : await this.ask(player, joinData, { fromRoomCode: ask.fromRoomCode, isReturning: false, isSpectator: false });
+            if (verdict.isAllowed) {
+                this.expected.set(player.id, { joinData, fromRoomCode: ask.fromRoomCode, untilMs: this.now() + SEAT_MS });
+                answer.movedPlayerIds.push(player.id);
+            }
+            else
+                answer.refusals.push({ playerId: player.id, code: verdict.code, message: verdict.message || ERROR_TEXT[verdict.code] });
+        }
+        if (answer.movedPlayerIds.length)
+            this.dirty = true;
+        return answer;
+    }
+    /**
+     * A player arrives. Joining again with the same ID (a reconnect) keeps their place. The player who
+     * makes the room can hide it from the start (a private match), turn friends' Join off, and name and label it. joinData is
+     * what the player's game sent along, for onJoin; clientIdle is the idle check it asked for (idleCheck "client").
+     * isSpectator: they come to watch (watch).
+     */
+    join(player, joinOptions = {}) {
+        if (joinOptions.isSpectator)
+            return this.watch(player);
+        // A player whose time to reconnect ran out while the room slept comes back to their held seat instead.
+        this.expireReconnects();
+        const isRejoin = this.players.has(player.id);
+        const door = this.door(player.id);
+        if (door && !door.isAllowed)
+            return door;
+        // A spectator who joins the match stops watching first.
+        this.stopWatching(player.id);
+        // A player another room sent brings what that room's game server passed, not what their browser sent.
+        const seat = isRejoin ? null : this.seat(player.id);
+        const back = isRejoin || seat ? null : this.holding(player.id);
+        this.expected.delete(player.id);
+        if (back)
+            this.held.delete(player.id);
+        const joinData = seat ? seat.joinData : (joinOptions.joinData ?? null);
+        const joinInfo = seat ? { fromRoomCode: seat.fromRoomCode, isReturning: false, isSpectator: false } : back ? { fromRoomCode: null, isReturning: true, isSpectator: false } : NOBODY_JOINED;
+        if (this.known.size === 0) {
+            if (joinOptions.isListed === true)
+                this.isListed = true;
+            if (joinOptions.friendJoinsEnabled === false)
+                this.friendJoinsEnabled = false;
+            Object.assign(this, tidyRoomInfo({ name: joinOptions.name, labels: joinOptions.labels }));
+        }
+        // Back from a dropped connection: in the match again before the welcome, so it reaches them and lists them as playing.
+        const isReconnect = isRejoin && this.kept.get(player.id) === "lost";
+        if (isReconnect) {
+            this.kept.delete(player.id);
+            this.reconnectUntilMs.delete(player.id);
+        }
+        this.players.set(player.id, player);
+        this.remember(player.id);
+        this.presence.set(player.id, newPresence(this.now(), joinOptions.clientIdle === undefined ? (this.presence.get(player.id)?.clientIdle ?? {}) : clientIdle(joinOptions.clientIdle)));
+        const probeIntervalSec = this.ticking ? ROOM_TUNING.probeIntervalSec : null;
+        this.sendText(player.id, JSON.stringify({ type: "welcome", me: shownPlayer(player), isSpectator: false, players: this.list(), room: this.settings(), spectatorCount: this.spectators.size, hostPlayerId: this.hostPlayerId, awayChecks: this.checks(player.id), endsAt: this.endsAt, probeIntervalSec, protocolVersionNumber: PROTOCOL_VERSION_NUMBER }));
+        // Every room gets a first ping and clock sample right away, ticking or not.
+        this.probe(player.id);
+        // A new connection starts with nothing of the state: a full copy comes with the next round.
+        if (this.server.stateSyncEnabled) {
+            this.stateTracker?.forget(player.id);
+            this.fullCopyPlayerIds.add(player.id);
+        }
+        // A new connection hears its blocks afresh, and everyone else before the game or the player list says they're here.
+        this.toldBlocks.delete(player.id);
+        this.tellBlocks();
+        if (!isRejoin) {
+            this.listingChanged = true;
+            this.run(() => this.server.onJoin?.(this.state, player, this.api, joinData, joinInfo), "onJoin");
+            this.broadcastPlayers();
+        }
+        else if (isReconnect)
+            this.cameBack(player);
+        else if (this.kept.has(player.id))
+            this.back(player.id);
+        // A turn-based room has no tick to bring a returning connection its copy of the state.
+        if (isRejoin && !this.ticking)
+            this.syncSoon();
+        return { isAllowed: true, isRejoin };
+    }
+    /**
+     * A spectator comes to watch: welcomed with the players and the room, probed for their ping and the
+     * room's clock like a player, and the game hears it (onSpectatorJoin). Nothing they do counts as playing.
+     */
+    watch(spectator) {
+        const door = this.spectatorDoor(spectator.id);
+        if (door && !door.isAllowed)
+            return door;
+        const isRejoin = this.spectators.has(spectator.id);
+        this.spectators.set(spectator.id, spectator);
+        this.presence.set(spectator.id, newPresence(this.now(), {}));
+        const probeIntervalSec = this.ticking ? ROOM_TUNING.probeIntervalSec : null;
+        this.sendText(spectator.id, JSON.stringify({ type: "welcome", me: shownPlayer(spectator), isSpectator: true, players: this.list(), room: this.settings(), spectatorCount: this.spectators.size, hostPlayerId: this.hostPlayerId, awayChecks: { idleTimeoutSec: null, hiddenTimeoutSec: null }, endsAt: this.endsAt, probeIntervalSec, protocolVersionNumber: PROTOCOL_VERSION_NUMBER }));
+        this.probe(spectator.id);
+        // A new connection starts with nothing of the state: a full copy comes with the next round.
+        if (this.server.stateSyncEnabled) {
+            this.stateTracker?.forget(spectator.id);
+            this.fullCopyPlayerIds.add(spectator.id);
+        }
+        if (!isRejoin) {
+            this.listingChanged = true;
+            this.run(() => this.server.onSpectatorJoin?.(this.state, spectator, this.api), "onSpectatorJoin");
+            this.tellRoom();
+        }
+        // A turn-based room has no tick to bring them their copy of the state, nor a handler that did.
+        if (!this.ticking && (isRejoin || !this.server.onSpectatorJoin))
+            this.syncSoon();
+        return { isAllowed: true, isRejoin };
+    }
+    /** A spectator stops watching: gone at once, and the game hears it (onSpectatorLeave) once the handler running now is done. */
+    stopWatching(spectatorId) {
+        const spectator = this.spectators.get(spectatorId);
+        if (!spectator)
+            return;
+        this.spectators.delete(spectatorId);
+        this.presence.delete(spectatorId);
+        this.buckets.delete(spectatorId);
+        this.latestSlots.delete(spectatorId);
+        this.stateSkippedPlayerIds.delete(spectatorId);
+        this.fullCopyPlayerIds.delete(spectatorId);
+        this.listingChanged = true;
+        this.soon(() => {
+            if (this.ended)
+                return;
+            this.run(() => this.server.onSpectatorLeave?.(this.state, spectator, this.api), "onSpectatorLeave");
+            this.tellRoom();
+        });
+    }
+    /**
+     * A player's connection closed: they left (closed the game, or followed a move), or it was lost. A
+     * lost player stays in the match as away for reconnectTimeoutSec (onAway, reason "lost"), then
+     * leaves it with their seat held for a while, so they can still come straight back. A spectator just goes.
+     */
+    leave(playerId, reason = "left") {
+        if (this.spectators.has(playerId))
+            return this.stopWatching(playerId);
+        if (this.held.has(playerId)) {
+            // A player out of the match went for good: their seat is free. A lost connection keeps it held.
+            if (reason === "left") {
+                this.held.delete(playerId);
+                this.listingChanged = true;
+                this.dirty = true;
+            }
+            return;
+        }
+        const player = this.players.get(playerId);
+        if (!player)
+            return;
+        const reconnectTimeoutSec = this.server.reconnectTimeoutSec ?? ROOM_LIMITS.defaultReconnectTimeoutSec;
+        if (reason === "lost" && !this.ended && reconnectTimeoutSec > 0) {
+            // A second close, or the runtime's close after the room already dropped them, changes nothing.
+            if (this.kept.get(playerId) === "lost")
+                return;
+            this.kept.set(playerId, "lost");
+            this.reconnectUntilMs.set(playerId, this.now() + reconnectTimeoutSec * 1000);
+            this.presence.get(playerId)?.unansweredProbes.clear();
+            this.listingChanged = true;
+            this.dirty = true;
+            if (this.server.onAway)
+                this.run(() => this.server.onAway(this.state, player, this.api, { reason: "lost" }), "onAway");
+            this.broadcastPlayers();
+            return;
+        }
+        this.out(playerId);
+        if (this.ended)
+            return;
+        if (reason === "lost")
+            this.hold(player, "lost");
+        this.run(() => this.server.onLeave?.(this.state, player, this.api, { reason }), "onLeave");
+        this.broadcastPlayers();
+    }
+    /** Take a player out of the match, forgetting what the room knew about them while they were in. */
+    out(playerId) {
+        this.players.delete(playerId);
+        this.latestSlots.delete(playerId);
+        this.stateSkippedPlayerIds.delete(playerId);
+        this.fullCopyPlayerIds.delete(playerId);
+        this.kept.delete(playerId);
+        this.reconnectUntilMs.delete(playerId);
+        this.presence.delete(playerId);
+        this.buckets.delete(playerId);
+        this.listingChanged = true;
+        this.dirty = true;
+    }
+    /** Hold a seat for a player out of the match, for the game's seatHoldDurationSec. */
+    hold(player, reason) {
+        const seatHoldDurationSec = this.server.seatHoldDurationSec ?? ROOM_LIMITS.defaultSeatHoldDurationSec;
+        if (seatHoldDurationSec > 0)
+            this.held.set(player.id, { player, reason, untilMs: this.now() + seatHoldDurationSec * 1000 });
+        this.listingChanged = true;
+        this.dirty = true;
+        return seatHoldDurationSec;
+    }
+    /** When this room counts a player as away (welcome's awayChecks), by the game's settings and what their game asked for. */
+    checks(playerId) {
+        return { idleTimeoutSec: this.idleTimeoutSecFor(playerId), hiddenTimeoutSec: this.ticking ? ROOM_LIMITS.hiddenTimeoutSec : null };
+    }
+    /** Seconds without input before a player counts as idle, or null if nobody checks for them. */
+    idleTimeoutSecFor(playerId) {
+        const idleCheck = this.server.idleCheck ?? "server";
+        const serverTimeoutSec = this.server.idleTimeoutSec ?? ROOM_LIMITS.defaultIdleTimeoutSec;
+        if (idleCheck === "off")
+            return null;
+        if (idleCheck === "server")
+            return serverTimeoutSec;
+        const asked = this.presence.get(playerId)?.clientIdle ?? {};
+        if (asked.idleCheckEnabled === false)
+            return null;
+        return asked.idleTimeoutSec ?? serverTimeoutSec;
+    }
+    /**
+     * A player walked away: idle (they didn't answer "Still there?", or the room heard nothing for
+     * longer), or their game hidden too long in a real-time room. The game's onAway decides; otherwise
+     * they leave the match with their seat held, and with awayMode "lobby" are sent to the lobby.
+     */
+    walkAway(playerId, reason) {
+        const player = this.players.get(playerId);
+        if (!player || this.ended || this.kept.has(playerId))
+            return;
+        if (this.server.onAway) {
+            const presence = this.presence.get(playerId);
+            if (presence)
+                presence.hiddenAtMs = undefined;
+            this.kept.set(playerId, reason);
+            this.listingChanged = true;
+            this.dirty = true;
+            this.run(() => this.server.onAway(this.state, player, this.api, { reason }), "onAway");
+            return;
+        }
+        this.out(playerId);
+        const seatHoldDurationSec = this.hold(player, reason);
+        this.sendText(playerId, JSON.stringify({ type: "away", awayReason: reason, seatHoldDurationSec }));
+        this.run(() => this.server.onLeave?.(this.state, player, this.api, { reason }), "onLeave");
+        this.broadcastPlayers();
+        if (this.server.awayMode === "lobby" && this.lobbyRoomCode && this.transport.moveTo) {
+            this.sentAway.add(playerId);
+            this.transport.moveTo(this.lobbyRoomCode, { players: [player], joinData: null });
+        }
+        else if (!seatHoldDurationSec)
+            this.transport.close(playerId, SEAT_GONE_CLOSE_CODE, "Seat no longer held");
+    }
+    /** A player who walked away is back: kept in the room by onAway, or coming back to their held seat. */
+    back(playerId, joinData, asked) {
+        const player = this.players.get(playerId);
+        if (player) {
+            if (!this.kept.delete(playerId))
+                return null;
+            this.reconnectUntilMs.delete(playerId);
+            this.cameBack(player);
+            return null;
+        }
+        const held = this.holding(playerId);
+        if (!held)
+            return null;
+        const checked = checkRoomData(joinData, ROOM_LIMITS.maximumJoinDataSizeBytes);
+        const joined = this.join(held.player, { joinData: checked.isValid ? checked.checkedData : null, clientIdle: asked });
+        return joined.isAllowed ? null : joined.code;
+    }
+    /** A player kept away is playing again: the game hears it (onBack), and every player's list shows them playing. */
+    cameBack(player) {
+        this.listingChanged = true;
+        this.dirty = true;
+        this.run(() => this.server.onBack?.(this.state, player, this.api), "onBack");
+        this.broadcastPlayers();
+    }
+    /** Players whose time to reconnect ran out leave the match, with their seat held (onLeave, reason "lost"). */
+    expireReconnects() {
+        if (this.ended)
+            return;
+        const nowMs = this.now();
+        for (const [id, untilMs] of [...this.reconnectUntilMs]) {
+            if (untilMs > nowMs)
+                continue;
+            const player = this.players.get(id);
+            this.reconnectUntilMs.delete(id);
+            if (!player)
+                continue;
+            this.out(id);
+            this.hold(player, "lost");
+            this.run(() => this.server.onLeave?.(this.state, player, this.api, { reason: "lost" }), "onLeave");
+            this.broadcastPlayers();
+        }
+    }
+    /** When the first player whose connection dropped runs out of time to reconnect, or null if nobody is reconnecting. */
+    nextReconnectDeadlineMs() {
+        let deadlineMs = null;
+        for (const untilMs of this.reconnectUntilMs.values())
+            if (deadlineMs === null || untilMs < deadlineMs)
+                deadlineMs = untilMs;
+        return deadlineMs;
+    }
+    /** Whether a player is in the match without a connection: dropped, and still within reconnectTimeoutSec. */
+    isLost(playerId) {
+        return this.kept.get(playerId) === "lost";
+    }
+    /**
+     * Check on the room's players, every half a minute or so: players the room hasn't heard from in
+     * longer than the idle check allows (a game that doesn't ask "Still there?"), and players whose
+     * game has been hidden too long in a real-time room, walk away; held seats that ran out are freed,
+     * and those players' connections close.
+     */
+    sweep() {
+        if (this.ended)
+            return;
+        this.expireReconnects();
+        const nowMs = this.now();
+        for (const [id, presence] of [...this.presence]) {
+            // Spectators give no input, so they're never idle or away; a dead connection still drops them.
+            if (this.kept.has(id) || this.spectators.has(id))
+                continue;
+            const idleTimeoutSec = this.idleTimeoutSecFor(id);
+            if (idleTimeoutSec !== null && nowMs - presence.seenAtMs >= idleTimeoutSec * 1000 + IDLE_ASK_MS + IDLE_GRACE_MS)
+                this.walkAway(id, "idle");
+            else if (this.ticking && presence.hiddenAtMs !== undefined && nowMs - presence.hiddenAtMs >= ROOM_LIMITS.hiddenTimeoutSec * 1000)
+                this.walkAway(id, "hidden");
+        }
+        // Rooms that don't tick check their probes here.
+        for (const id of [...this.presence.keys()])
+            this.checkAnswers(id);
+        for (const [id, held] of [...this.held]) {
+            if (held.untilMs > nowMs)
+                continue;
+            this.held.delete(id);
+            this.listingChanged = true;
+            this.dirty = true;
+            this.transport.close(id, SEAT_GONE_CLOSE_CODE, "Seat no longer held");
+        }
+    }
+    /** A raw text message from a client. Returns an error code if it was refused. */
+    receive(playerId, text) {
+        if (this.spectators.has(playerId))
+            return this.receiveFromSpectator(playerId, text);
+        const player = this.players.get(playerId);
+        const isHeld = !player && this.held.has(playerId);
+        if ((!player && !isHeld) || this.ended)
+            return "ended";
+        const sizeBytes = text.length > ROOM_LIMITS.maximumGameMessageSizeBytes ? text.length : utf8ByteCount(text);
+        const isTooBig = sizeBytes > ROOM_LIMITS.maximumGameMessageSizeBytes;
+        let parsed;
+        let isParsed = false;
+        if (!isTooBig) {
+            try {
+                parsed = JSON.parse(text);
+                isParsed = true;
+            }
+            catch {
+                // Refused below, once it's counted.
+            }
+        }
+        const message = (parsed && typeof parsed === "object" ? parsed : {});
+        // A probe answer is automatic, not the player's input: it isn't counted, takes no token and doesn't count as seen.
+        if (message.type === "probe_answer" && this.answer(playerId, message.probeNumber))
+            return null;
+        this.messageCount++;
+        this.countTraffic("inbound", message.type === "message" ? messageTypeOf(message.data) : typeof message.type === "string" ? ZAISMA_MESSAGE_TYPE : NO_MESSAGE_TYPE, 1, sizeBytes);
+        if (isTooBig)
+            return "too_big";
+        if (!this.take(playerId))
+            return "too_fast";
+        if (!isParsed)
+            return "bad_message";
+        // Out of the match with their seat held, a player can only come back; anything else waits.
+        if (isHeld)
+            return message.type === "back" ? this.back(playerId, message.joinData, message) : null;
+        const presence = this.presence.get(playerId);
+        if (presence)
+            presence.seenAtMs = this.now();
+        switch (message.type) {
+            case "room":
+                return this.hostChange(playerId, message);
+            case "kick":
+                return this.hostKick(playerId, message);
+            case "here":
+                return null;
+            case "probe_answer":
+                // It answers no probe: counted and limited like any message, so answers can't dodge the limit.
+                return null;
+            case "idle":
+                this.walkAway(playerId, "idle");
+                return null;
+            case "hidden":
+                if (presence && this.ticking)
+                    presence.hiddenAtMs ??= this.now();
+                return null;
+            case "shown":
+                if (presence)
+                    presence.hiddenAtMs = undefined;
+                return this.kept.get(playerId) === "hidden" ? this.back(playerId) : null;
+            case "back":
+                return this.back(playerId);
+            case "message":
+                this.input(() => this.server.onMessage?.(this.state, player, this.api, message.data), "onMessage");
+                return null;
+            case "block":
+                return this.sessionBlock(playerId, message, true);
+            case "unblock":
+                return this.sessionBlock(playerId, message, false);
+            default:
+                // A type this room doesn't know, maybe from a newer SDK: counted and limited above, then ignored.
+                return typeof message.type === "string" ? null : "bad_message";
+        }
+    }
+    /** Bytes from a client (a binary frame). Returns an error code if they were refused. */
+    receiveBytes(playerId, bytes) {
+        // Spectators send nothing; limited like anyone's messages, so refusing them costs little.
+        if (this.spectators.has(playerId))
+            return this.ended ? "ended" : this.take(playerId) ? "spectator_cannot_send" : "too_fast";
+        const player = this.players.get(playerId);
+        const isHeld = !player && this.held.has(playerId);
+        if ((!player && !isHeld) || this.ended)
+            return "ended";
+        this.messageCount++;
+        this.countTraffic("inbound", BYTES_MESSAGE_TYPE, 1, bytes.length);
+        if (bytes.length > ROOM_LIMITS.maximumGameMessageSizeBytes)
+            return "too_big";
+        if (!this.take(playerId))
+            return "too_fast";
+        // Out of the match with their seat held, a player's bytes wait like their messages.
+        if (isHeld)
+            return null;
+        if (!this.server.onBytes)
+            return "bad_message";
+        const presence = this.presence.get(playerId);
+        if (presence)
+            presence.seenAtMs = this.now();
+        this.input(() => this.server.onBytes(this.state, player, this.api, bytes), "onBytes");
+        return null;
+    }
+    /**
+     * A spectator's text: answers to the room's probes, and nothing else (spectator_cannot_send). Kept out of
+     * the room's message count and traffic, so watching stays off the meter, and limited like anyone's messages.
+     */
+    receiveFromSpectator(spectatorId, text) {
+        if (this.ended)
+            return "ended";
+        if (text.length <= ROOM_LIMITS.maximumGameMessageSizeBytes) {
+            try {
+                const message = JSON.parse(text);
+                if (message?.type === "probe_answer" && this.answer(spectatorId, message.probeNumber))
+                    return null;
+            }
+            catch {
+                // Refused below.
+            }
+        }
+        return this.take(spectatorId) ? "spectator_cannot_send" : "too_fast";
+    }
+    /**
+     * A player's message or bytes for the game server: through the queue of handlers, or at once for a
+     * game server that only queues them for its next call (QUEUES_INPUT).
+     */
+    input(handler, handlerName) {
+        if (!this.server[QUEUES_INPUT])
+            return this.run(handler, handlerName);
+        try {
+            handler();
+        }
+        catch (error) {
+            console.error("Game server error:", error);
+        }
+    }
+    /** Count messages in or out for the room's traffic: how many, their bytes and the largest of them, and how many went to a backed-up player. */
+    countTraffic(direction, messageType, messageCount, sizeBytes, backedUpMessageCount = 0) {
+        if (messageCount === 0)
+            return;
+        const traffic = this.traffic;
+        if (direction === "inbound")
+            traffic.inboundSizeBytes += sizeBytes;
+        else {
+            traffic.outboundMessageCount += messageCount;
+            traffic.outboundSizeBytes += sizeBytes * messageCount;
+        }
+        let kept = traffic.messageTypes.get(`${direction} ${messageType}`);
+        if (!kept) {
+            const typeCountKey = direction === "inbound" ? "inboundTypeCount" : "outboundTypeCount";
+            if (traffic[typeCountKey] >= MAXIMUM_MESSAGE_TYPE_COUNT && messageType !== OTHER_MESSAGE_TYPE)
+                return this.countTraffic(direction, OTHER_MESSAGE_TYPE, messageCount, sizeBytes, backedUpMessageCount);
+            if (messageType !== OTHER_MESSAGE_TYPE)
+                traffic[typeCountKey]++;
+            kept = { messageType, direction, messageCount: 0, sizeBytes: 0, largestSizeBytes: 0, backedUpMessageCount: 0 };
+            traffic.messageTypes.set(`${direction} ${messageType}`, kept);
+        }
+        kept.messageCount += messageCount;
+        kept.sizeBytes += sizeBytes * messageCount;
+        kept.largestSizeBytes = Math.max(kept.largestSizeBytes, sizeBytes);
+        kept.backedUpMessageCount += backedUpMessageCount;
+    }
+    /** The room's traffic since the last time it was taken, and start counting afresh. */
+    takeTraffic() {
+        const traffic = this.traffic;
+        this.traffic = { inboundSizeBytes: 0, outboundMessageCount: 0, outboundSizeBytes: 0, messageTypes: new Map(), inboundTypeCount: 0, outboundTypeCount: 0 };
+        return { inboundSizeBytes: traffic.inboundSizeBytes, outboundMessageCount: traffic.outboundMessageCount, outboundSizeBytes: traffic.outboundSizeBytes, messageTypes: [...traffic.messageTypes.values()] };
+    }
+    /**
+     * The host: the room's first player, when the game server has host controls on. A host whose
+     * connection dropped hands over to the next player meanwhile, so host controls never wait on them.
+     */
+    get hostPlayerId() {
+        if (!this.server.hostControlsEnabled)
+            return null;
+        for (const id of this.players.keys())
+            if (!this.isLost(id))
+                return id;
+        return null;
+    }
+    /**
+     * The host kicks a player, when the game server allows it. Players can't type the message (no free
+     * text between strangers), so the kicked player is told the host removed them.
+     */
+    hostKick(playerId, message) {
+        if (this.hostPlayerId !== playerId)
+            return "not_allowed";
+        const kickedId = message.playerId;
+        if (typeof kickedId !== "string" || kickedId === playerId || !this.players.has(kickedId))
+            return "bad_message";
+        this.kick(kickedId, { message: "The host removed you from this room.", keepOut: message.keepOut === true });
+        return null;
+    }
+    /** The host hides, shows, opens, closes, turns friends' Join on or off, names or labels the room, when the game server allows it. */
+    hostChange(playerId, message) {
+        if (this.hostPlayerId !== playerId)
+            return "not_allowed";
+        const asked = message.room;
+        if (!asked || typeof asked !== "object" || Array.isArray(asked))
+            return "bad_message";
+        const room = asked;
+        const change = tidyRoomInfo(room);
+        if (typeof room.isListed === "boolean")
+            change.isListed = room.isListed;
+        if (typeof room.isOpen === "boolean")
+            change.isOpen = room.isOpen;
+        if (typeof room.friendJoinsEnabled === "boolean")
+            change.friendJoinsEnabled = room.friendJoinsEnabled;
+        this.settle(change);
+        this.dirty = true;
+        return null;
+    }
+    settings() {
+        return { isListed: this.isListed, isOpen: this.isOpen, friendJoinsEnabled: this.friendJoinsEnabled, name: this.name, labels: { ...this.labels } };
+    }
+    /** Change isListed, isOpen, friendJoinsEnabled, the name or labels, and tell everyone in the room. */
+    settle(change) {
+        const next = { ...this.settings(), ...change };
+        if (JSON.stringify(next) === JSON.stringify(this.settings()))
+            return;
+        this.isListed = next.isListed;
+        this.isOpen = next.isOpen;
+        this.friendJoinsEnabled = next.friendJoinsEnabled;
+        this.name = next.name;
+        this.labels = next.labels;
+        this.listingChanged = true;
+        this.tellRoom();
+    }
+    /** Tell every player and spectator the room's settings and how many are watching. */
+    tellRoom() {
+        this.sendEach(this.everyone(), JSON.stringify({ type: "room", room: this.settings(), spectatorCount: this.spectators.size }));
+    }
+    /** The players and the spectators: everyone the room tells what happens in it. */
+    everyone() {
+        return [...this.players.keys(), ...this.spectators.keys()];
+    }
+    /** Whether the room sends to this player: they're in the match, or watching. */
+    isViewer(playerId) {
+        return this.players.has(playerId) || this.spectators.has(playerId);
+    }
+    /** Who a broadcast reaches (BroadcastOptions.audience, already checked). */
+    audienceOf(audience) {
+        if (audience === "players")
+            return [...this.players.keys()];
+        if (audience === "spectators")
+            return [...this.spectators.keys()];
+        return this.everyone();
+    }
+    /**
+     * Keep the room, or stop keeping it (room.setKept). The transport may turn a keep back (a game past its
+     * free storage), so it hears through listingChanged; players are told nothing.
+     */
+    setKept(isKept) {
+        if (this.isKept === isKept || this.ended)
+            return;
+        this.isKept = isKept;
+        this.listingChanged = true;
+        this.dirty = true;
+    }
+    /** A room made for some of this room's players (room.reserve). Mistakes in the game's call throw. newRoomCode is the one a game server in a sandbox chose. */
+    reserve(reserveOptions, chosenRoomCode) {
+        this.requireCall("room.reserve", this.transport.reserve !== undefined);
+        const checked = checks.checkReserve(reserveOptions, [...this.players.keys()]);
+        this.limit("room.reserve");
+        const newRoomCode = chosenRoomCode !== null && isRoomCode(chosenRoomCode) ? chosenRoomCode : roomCode();
+        this.transport.reserve(newRoomCode, {
+            playerIds: checked.playerIds,
+            setupData: checked.setupData,
+            isListed: checked.isListed,
+            ...(checked.friendJoinsEnabled ? {} : { friendJoinsEnabled: false }),
+            ...(checked.isKept ? { isKept: true } : {}),
+            name: checked.name,
+            labels: checked.labels,
+            ...(this.keptOut.size ? { keptOut: Object.fromEntries(this.keptOut) } : {}),
+        });
+        return newRoomCode;
+    }
+    /** Send players to another room of the game (room.moveTo). Mistakes in the game's call throw. */
+    moveTo(toRoomCode, moveOptions) {
+        this.requireCall("room.moveTo", this.transport.moveTo !== undefined);
+        const checked = checks.checkMoveTo(toRoomCode, moveOptions, [...this.players.keys()]);
+        this.limit("room.moveTo");
+        const players = checked.playerIds.map((id) => this.players.get(id));
+        this.transport.moveTo(checked.toRoomCode, { players, joinData: checked.joinData });
+    }
+    /** A call that needs the transport to offer it and the room to be going: otherwise it throws room_call_unavailable. */
+    requireCall(call, isOffered) {
+        if (!isOffered)
+            throw new GameServerError("room_call_unavailable", call, `${call} isn't available here.`, "Reserving rooms and moving players need Zaisma's rooms or the Node runner.");
+        if (this.ended)
+            throw new GameServerError("room_call_unavailable", call, `${call} was called after this room ended.`, "Check room.endsAt, and stop making room calls once you've called room.end().");
+    }
+    /**
+     * The other room's answer to room.moveTo, for onMoved. Players it took who already left, or who
+     * aren't here, are left out.
+     */
+    moved(toRoomCode, answer, sent) {
+        // The room sending a player who walked away to its lobby: if the lobby turned them away, their seat
+        // here stays held, and with no seat held (seatHoldDurationSec: 0) there's nothing to stay connected for.
+        if (sent.length === 1 && this.sentAway.delete(sent[0].id)) {
+            const id = sent[0].id;
+            if (!answer.movedPlayerIds.includes(id) && !this.players.has(id) && !this.holding(id))
+                this.transport.close(id, SEAT_GONE_CLOSE_CODE, "Seat no longer held");
+            return;
+        }
+        if (this.ended || !this.server.onMoved)
+            return;
+        const who = new Map(sent.map((player) => [player.id, player]));
+        const moveResult = {
+            roomCode: toRoomCode,
+            movedPlayers: answer.movedPlayerIds.map((id) => who.get(id)).filter((player) => Boolean(player)),
+            refusals: answer.refusals.filter((refusal) => who.has(refusal.playerId)).map((refusal) => ({ player: who.get(refusal.playerId), code: refusal.code, message: refusal.message })),
+        };
+        this.run(() => this.server.onMoved(this.state, moveResult, this.api), "onMoved");
+    }
+    /** Reserving rooms and moving players share one limit a minute. */
+    limit(call) {
+        const nowMs = this.now();
+        this.reservedAtMs = this.reservedAtMs.filter((reservedAtMs) => nowMs - reservedAtMs < 60_000);
+        if (this.reservedAtMs.length >= ROOM_LIMITS.maximumReservesPerMin)
+            throw new GameServerError("room_call_limit", call, `A room can reserve rooms or move players up to ${ROOM_LIMITS.maximumReservesPerMin} times a minute.`, "Reserve one room for a whole group, or wait a minute.");
+        this.reservedAtMs.push(nowMs);
+    }
+    /** Remove a player (room.kick). Their onLeave runs once the handler that kicked them is done. */
+    kick(playerId, kickOptions) {
+        const player = this.players.get(playerId);
+        const held = this.held.get(playerId);
+        const isSpectator = this.spectators.has(playerId);
+        if ((!player && !held && !isSpectator) || this.ended)
+            return;
+        const message = kickOptions?.message || ERROR_TEXT.kept_out;
+        const isKeptOut = kickOptions?.keepOut === true;
+        if (isSpectator) {
+            if (isKeptOut)
+                this.keepOut({ [playerId]: message });
+            this.sendText(playerId, JSON.stringify({ type: "kicked", message, isKeptOut }));
+            this.transport.close(playerId, REMOVED_CLOSE_CODE, "Removed from the room");
+            this.stopWatching(playerId);
+            return;
+        }
+        this.known.delete(playerId);
+        if (isKeptOut)
+            this.keepOut({ [playerId]: message });
+        // A player whose connection dropped has none to tell or close.
+        if (!this.isLost(playerId)) {
+            this.sendText(playerId, JSON.stringify({ type: "kicked", message, isKeptOut }));
+            this.transport.close(playerId, REMOVED_CLOSE_CODE, "Removed from the room");
+        }
+        this.held.delete(playerId);
+        this.out(playerId);
+        // A player out of the match with their seat held already left it: there's no onLeave to run.
+        if (!player)
+            return;
+        this.soon(() => {
+            if (this.ended)
+                return;
+            this.run(() => this.server.onLeave?.(this.state, player, this.api, { reason: "kicked" }), "onLeave");
+            this.broadcastPlayers();
+        });
+    }
+    /** Keep players out, newest last, up to as many as the room remembers. */
+    keepOut(players) {
+        for (const [id, message] of Object.entries(players ?? {})) {
+            if (typeof message !== "string")
+                continue;
+            this.keptOut.delete(id);
+            this.keptOut.set(id, message.slice(0, ROOM_LIMITS.maximumKickMessageCharacterCount));
+            if (this.keptOut.size > REMEMBERED_PLAYER_COUNT)
+                this.keptOut.delete(this.keptOut.keys().next().value);
+        }
+    }
+    /** Run now, or once the handler running now is done, so a handler never runs inside another. */
+    soon(work) {
+        if (this.depth)
+            this.afterHandler.push(work);
+        else
+            work();
+    }
+    flush() {
+        while (!this.depth && this.afterHandler.length)
+            this.afterHandler.shift()();
+    }
+    remember(id) {
+        this.known.delete(id);
+        this.known.add(id);
+        // Forget the oldest who isn't here or holding a seat, so no player in the match drops out of what the room knows of them.
+        if (this.known.size > REMEMBERED_PLAYER_COUNT) {
+            for (const oldest of this.known) {
+                if (oldest === id || this.players.has(oldest) || this.holding(oldest) !== null)
+                    continue;
+                this.known.delete(oldest);
+                break;
+            }
+        }
+    }
+    tick(tickDurationSec) {
+        if (this.ended)
+            return;
+        this.expireReconnects();
+        this.probeDue();
+        this.catchUp();
+        // A room where everyone walked away stops running until someone's back.
+        if (this.playingCount === 0)
+            return;
+        // State sync's round comes after onTick; without one, every tick.
+        if (!this.server.onTick)
+            return this.syncState();
+        // A game server that hasn't caught up skips this tick; tickDurationSec carries the time over to the next one.
+        if (this.waitingCount > 1)
+            return;
+        this.run(() => this.server.onTick(this.state, tickDurationSec, this.api), "onTick", true);
+    }
+    /**
+     * Players who caught up: their latest-only messages go now, and in a turn-based room, players state sync
+     * skipped get a full copy. Ticking rooms check each tick and at each probe answer; your own server's
+     * runner also every 50 ms while isCatchingUp.
+     */
+    catchUp() {
+        if (this.ended)
+            return;
+        for (const id of [...this.latestSlots.keys()]) {
+            if (!this.isViewer(id) || this.isLost(id))
+                this.latestSlots.delete(id);
+            else if (!this.isBackedUp(id))
+                this.sendLatest(id);
+        }
+        let hasCaughtUp = false;
+        for (const id of [...this.stateSkippedPlayerIds]) {
+            if (this.isViewer(id) && !this.isLost(id) && this.isBackedUp(id))
+                continue;
+            this.stateSkippedPlayerIds.delete(id);
+            hasCaughtUp ||= this.isViewer(id);
+        }
+        if (hasCaughtUp)
+            this.syncSoon();
+    }
+    /** Whether anything waits for a player to catch up: latest-only messages, or a turn-based room's state. */
+    get isCatchingUp() {
+        return this.latestSlots.size > 0 || this.stateSkippedPlayerIds.size > 0;
+    }
+    /**
+     * Whether a player's connection is backed up: the transport says (the socket's bufferedAmount on your
+     * own server), or, in Zaisma rooms, a probe of theirs is ROOM_TUNING.backedUpDelayMs later than their
+     * ping with ROOM_TUNING.backedUpSizeBytes or more sent since the last probe they answered.
+     */
+    isBackedUp(playerId) {
+        if (!this.isViewer(playerId) || this.isLost(playerId))
+            return false;
+        if (this.transport.isBackedUp)
+            return this.transport.isBackedUp(playerId);
+        const presence = this.presence.get(playerId);
+        const oldest = presence?.unansweredProbes.values().next().value;
+        if (!presence || !oldest)
+            return false;
+        return this.now() - oldest.sentAtMs > (presence.pingDurationMs ?? 0) + ROOM_TUNING.backedUpDelayMs && presence.sentByteCount - presence.answeredSentByteCount >= ROOM_TUNING.backedUpSizeBytes;
+    }
+    /** The players who see the state: everyone in the match with a connection, and the spectators. */
+    stateViewerIds() {
+        return this.everyone().filter((id) => !this.isLost(id));
+    }
+    /** Which viewers are backed up this round; a turn-based room remembers them, to send a full copy once they catch up. */
+    backedUpViewers(viewerIds) {
+        const backedUpPlayerIds = new Set(viewerIds.filter((id) => this.isBackedUp(id)));
+        if (!this.ticking)
+            for (const id of backedUpPlayerIds)
+                this.stateSkippedPlayerIds.add(id);
+        return backedUpPlayerIds;
+    }
+    /** A round of state sync (stateSyncEnabled): each player's view, in full or what changed since their last. */
+    syncState() {
+        const tracker = this.stateTracker;
+        if (!tracker || this.ended)
+            return;
+        const viewerIds = this.stateViewerIds();
+        const stateView = this.server.stateView;
+        const state = this.state;
+        const round = tracker.round(state, viewerIds, stateView ? (viewerId) => stateView(state, (this.players.get(viewerId) ?? this.spectators.get(viewerId)), this.stateViewRoom) : null, this.backedUpViewers(viewerIds));
+        for (const problem of round.problems)
+            console.error(`Game server error: ${problem}`);
+        for (const { playerIds, frame } of round.frames)
+            this.sendState(playerIds, frame);
+    }
+    /** A round of state sync once the handler running now is done, for a room with no handler about to run. */
+    syncSoon() {
+        if (!this.server.stateSyncEnabled || this.ended)
+            return;
+        const syncs = this.server[SYNCS_STATE];
+        if (syncs)
+            return this.run(() => syncs(this.state, this.api), "stateSync");
+        if (this.queue)
+            this.queue = this.queue.then(() => this.syncState());
+        else
+            this.soon(() => this.syncState());
+    }
+    /** For a game server that runs state sync itself: who's backed up this round, and who needs a full copy (said once). */
+    stateViewers() {
+        const fullCopyPlayerIds = [...this.fullCopyPlayerIds].filter((id) => this.isViewer(id));
+        this.fullCopyPlayerIds.clear();
+        return { backedUpPlayerIds: [...this.backedUpViewers(this.stateViewerIds())], fullCopyPlayerIds };
+    }
+    /** A frame from a game server that runs state sync itself, checked like anything a game hands the room. */
+    sendStateFrom(playerIds, frame) {
+        if (!Array.isArray(playerIds) || !frame || typeof frame !== "object")
+            return;
+        const keys = Object.keys(frame);
+        if (keys.length !== 1 || (keys[0] !== "full" && !(keys[0] === "changes" && Array.isArray(frame.changes))))
+            return;
+        this.sendState(playerIds.filter((id) => typeof id === "string" && this.isViewer(id)), frame);
+    }
+    /** Send a state frame to players in the match, with the room's clock, counted as state sync's traffic. */
+    sendState(playerIds, frame) {
+        if (!playerIds.length)
+            return;
+        this.sendEach(playerIds, JSON.stringify({ type: "state", serverTimeMs: this.now(), ...frame }), STATE_MESSAGE_TYPE);
+    }
+    /**
+     * A game's message or bytes for some players. Reliable ones go to all of them, counting those that went to
+     * a backed-up player; latest-only ones wait in a slot for each backed-up player, replacing an older one there.
+     */
+    deliver(playerIds, outgoing, delivery) {
+        const ids = playerIds.filter((id) => !this.isLost(id));
+        if (!delivery.isLatestOnly)
+            return this.sendOut(ids, outgoing, ids.filter((id) => this.isBackedUp(id)).length);
+        const ready = [];
+        for (const id of ids) {
+            if (!this.isBackedUp(id)) {
+                // Anything still waiting for them goes first, so the newest arrives last.
+                if (this.latestSlots.has(id))
+                    this.sendLatest(id);
+                ready.push(id);
+                continue;
+            }
+            let slots = this.latestSlots.get(id);
+            if (!slots)
+                this.latestSlots.set(id, (slots = new Map()));
+            const slotKey = `${"frame" in outgoing ? "bytes" : "message"}:${delivery.latestKey}`;
+            slots.delete(slotKey);
+            slots.set(slotKey, outgoing);
+            if (slots.size > ROOM_LIMITS.maximumLatestOnlySlotCount)
+                slots.delete(slots.keys().next().value);
+        }
+        this.sendOut(ready, outgoing, 0);
+    }
+    /** A player's waiting latest-only messages, least recently replaced first. */
+    sendLatest(playerId) {
+        const slots = this.latestSlots.get(playerId);
+        this.latestSlots.delete(playerId);
+        for (const outgoing of slots?.values() ?? [])
+            this.sendOut([playerId], outgoing, 0);
+    }
+    sendOut(playerIds, outgoing, backedUpMessageCount) {
+        if ("frame" in outgoing)
+            this.sendFrame(playerIds, outgoing.frame, backedUpMessageCount);
+        else
+            this.sendEach(playerIds, outgoing.text, outgoing.messageType, backedUpMessageCount);
+    }
+    /**
+     * The match moves to a version published "now": every player hears it's coming at appliesAt, and when
+     * isHeld (a game server with onVersionUpdate) the game server hears it too and may switch sooner.
+     */
+    startVersionUpdate(versionUpdate, isHeld) {
+        if (this.ended || this.versionUpdate?.versionId === versionUpdate.versionId)
+            return;
+        this.versionUpdate = versionUpdate;
+        this.sendEach(this.everyone(), JSON.stringify({ type: "version_update", step: "coming", ...versionUpdate }));
+        if (isHeld && this.server.onVersionUpdate)
+            this.run(() => this.server.onVersionUpdate(this.state, { ...versionUpdate }, this.api), "onVersionUpdate");
+    }
+    /** The switch is happening: every player hears it just before the room closes their connections. */
+    tellVersionUpdateNow() {
+        if (!this.versionUpdate)
+            return;
+        this.sendEach(this.everyone(), JSON.stringify({ type: "version_update", step: "now", ...this.versionUpdate }));
+    }
+    /**
+     * Zaisma will end this match at endsAt (an ISO time): every player hears it and onEnding runs, once.
+     * Only Zaisma rooms call it, when the game's hosting pauses.
+     */
+    startEnding(endsAt) {
+        if (this.ended || this.endsAt !== null)
+            return;
+        this.endsAt = endsAt;
+        this.dirty = true;
+        this.sendEach(this.everyone(), JSON.stringify({ type: "ending", endsAt }));
+        if (this.server.onEnding)
+            this.run(() => this.server.onEnding(this.state, this.api), "onEnding");
+    }
+    /** End the match: everyone hears message and why (endReason), and their connections close. */
+    end(message, endReason) {
+        if (this.ended)
+            return;
+        this.ended = true;
+        this.listingChanged = true;
+        const text = JSON.stringify({ type: "ended", message, endReason });
+        for (const id of [...this.players.keys(), ...this.held.keys(), ...this.spectators.keys()]) {
+            if (this.isLost(id))
+                continue;
+            this.sendText(id, text);
+            this.transport.close(id, ENDED_CLOSE_CODE, "Match ended");
+        }
+        this.players.clear();
+        this.spectators.clear();
+        this.held.clear();
+        this.kept.clear();
+        this.reconnectUntilMs.clear();
+        this.presence.clear();
+        this.latestSlots.clear();
+        this.stateSkippedPlayerIds.clear();
+    }
+    /** The players as every player's game lists them, with why each isn't playing. */
+    list() {
+        return [...this.players.values()].map((player) => ({ ...shownPlayer(player), awayReason: this.kept.get(player.id) ?? null }));
+    }
+    /** Send a binary frame to some players, counting it like text: toward each one's backlog, and the room's traffic. */
+    sendFrame(given, frame, backedUpMessageCount = 0) {
+        if (!this.transport.sendBytes)
+            throw new Error("Sending bytes isn't available here");
+        const playerIds = given.filter((id) => !this.isLost(id));
+        this.countTraffic("outbound", BYTES_MESSAGE_TYPE, playerIds.length, frame.length, backedUpMessageCount);
+        this.depth++;
+        try {
+            for (const id of playerIds) {
+                this.transport.sendBytes(id, frame);
+                this.sent(id, frame.length);
+            }
+        }
+        finally {
+            this.depth--;
+            this.flush();
+        }
+    }
+    broadcastPlayers() {
+        this.sendEach(this.everyone(), JSON.stringify({ type: "players", players: this.list(), hostPlayerId: this.hostPlayerId }));
+    }
+    /**
+     * Send one text to several players, counting its bytes once. A player it drops for falling behind
+     * leaves once everyone has it, so nobody hears of the leave before the rest of this text.
+     */
+    sendEach(playerIds, text, messageType = ZAISMA_MESSAGE_TYPE, backedUpMessageCount = 0) {
+        const byteCount = utf8ByteCount(text);
+        const ids = [...playerIds].filter((id) => !this.isLost(id));
+        this.countTraffic("outbound", messageType, ids.length, byteCount, backedUpMessageCount);
+        this.depth++;
+        try {
+            for (const id of ids)
+                this.sendText(id, text, byteCount, null);
+        }
+        finally {
+            this.depth--;
+            this.flush();
+        }
+    }
+    /**
+     * Send a player a text, counting the bytes that went out to them: past
+     * ROOM_TUNING.maximumUnansweredSentSizeBytes since the last probe they answered, they're dropped;
+     * every ROOM_TUNING.probeSentSizeBytes, they're probed, so a backed-up connection shows as a late answer.
+     * A player whose connection dropped gets nothing: nothing is sent, counted or probed until they're back.
+     */
+    sendText(playerId, text, byteCount = utf8ByteCount(text), messageType = ZAISMA_MESSAGE_TYPE) {
+        if (this.isLost(playerId))
+            return;
+        this.transport.send(playerId, text);
+        // sendEach counts its text once for everyone (messageType null).
+        if (messageType !== null)
+            this.countTraffic("outbound", messageType, 1, byteCount);
+        this.sent(playerId, byteCount);
+    }
+    /** Bytes that went out to a player, for the probes and the backlog. */
+    sent(playerId, byteCount) {
+        const presence = this.presence.get(playerId);
+        if (!presence)
+            return;
+        presence.sentByteCount += byteCount;
+        if (presence.sentByteCount - presence.answeredSentByteCount > ROOM_TUNING.maximumUnansweredSentSizeBytes)
+            this.dropBehind(playerId);
+        else if (presence.sentByteCount - presence.lastProbeSentByteCount >= ROOM_TUNING.probeSentSizeBytes)
+            this.probe(playerId);
+    }
+    /** Probe a player for their ping and a clock sample. Probes aren't counted as bytes sent, so a probe never sets off another. */
+    probe(playerId) {
+        const presence = this.presence.get(playerId);
+        if (!presence)
+            return;
+        const probeNumber = ++this.probeCount;
+        const nowMs = this.now();
+        presence.unansweredProbes.set(probeNumber, { sentAtMs: nowMs, sentByteCount: presence.sentByteCount });
+        if (presence.unansweredProbes.size > ROOM_TUNING.maximumUnansweredProbeCount)
+            presence.unansweredProbes.delete(presence.unansweredProbes.keys().next().value);
+        presence.lastProbeAtMs = nowMs;
+        presence.lastProbeSentByteCount = presence.sentByteCount;
+        const text = JSON.stringify({ type: "probe", probeNumber, serverTimeMs: nowMs, pingDurationMs: presence.pingDurationMs });
+        this.transport.send(playerId, text);
+        this.countTraffic("outbound", ZAISMA_MESSAGE_TYPE, 1, text.length);
+    }
+    /** A ticking room probes each player in the match, and each spectator, every ROOM_TUNING.probeIntervalSec, and drops those who stopped answering. */
+    probeDue() {
+        const nowMs = this.now();
+        for (const id of this.everyone()) {
+            const presence = this.presence.get(id);
+            if (presence && !this.kept.has(id) && nowMs - presence.lastProbeAtMs >= ROOM_TUNING.probeIntervalSec * 1000)
+                this.probe(id);
+        }
+        for (const id of [...this.presence.keys()])
+            this.checkAnswers(id);
+    }
+    /** A player whose oldest unanswered probe is ROOM_TUNING.probeAnswerTimeoutSec old is dropped. */
+    checkAnswers(playerId) {
+        if (this.isLost(playerId))
+            return;
+        const oldest = this.presence.get(playerId)?.unansweredProbes.values().next().value;
+        if (oldest && this.now() - oldest.sentAtMs >= ROOM_TUNING.probeAnswerTimeoutSec * 1000)
+            this.dropBehind(playerId);
+    }
+    /** A probe answer: the player's ping moves a quarter of the way to this sample. False if it answers no probe of theirs. */
+    answer(playerId, probeNumber) {
+        const presence = this.presence.get(playerId);
+        const probe = typeof probeNumber === "number" ? presence?.unansweredProbes.get(probeNumber) : undefined;
+        if (!presence || !probe)
+            return false;
+        const sampleMs = this.now() - probe.sentAtMs;
+        const previousMs = presence.pingDurationMs;
+        presence.pingDurationMs = Math.round(previousMs === null ? sampleMs : previousMs * 0.75 + sampleMs * 0.25);
+        presence.answeredSentByteCount = probe.sentByteCount;
+        for (const number of [...presence.unansweredProbes.keys()])
+            if (number <= probeNumber)
+                presence.unansweredProbes.delete(number);
+        // The first measurement: probe again at once, so the player's game hears its ping too, even in a room that doesn't tick.
+        if (previousMs === null)
+            this.probe(playerId);
+        // An answer is when a backed-up connection shows it caught up.
+        this.soon(() => this.catchUp());
+        return true;
+    }
+    /**
+     * A player whose connection can't keep up: closed at once, so the room holds no growing backlog for
+     * them, and out of the match like any lost connection, once the handler running now is done. Their
+     * game reconnects by itself. The runtime's close event comes later and finds them gone.
+     */
+    dropBehind(playerId) {
+        if (!this.presence.delete(playerId))
+            return;
+        this.transport.close(playerId, NO_ANSWER_CLOSE_CODE, "Connection too far behind");
+        this.soon(() => this.leave(playerId, "lost"));
+    }
+    /** Token bucket per player: a short burst is fine, a flood is dropped. */
+    take(playerId) {
+        const nowMs = this.now();
+        const bucket = this.buckets.get(playerId) ?? { tokenCount: ROOM_LIMITS.maximumGameMessageBurstCount, filledAtMs: nowMs };
+        bucket.tokenCount = Math.min(ROOM_LIMITS.maximumGameMessageBurstCount, bucket.tokenCount + ((nowMs - bucket.filledAtMs) / 1000) * ROOM_LIMITS.maximumGameMessagesPerSec);
+        bucket.filledAtMs = nowMs;
+        this.buckets.set(playerId, bucket);
+        if (bucket.tokenCount < 1)
+            return false;
+        bucket.tokenCount -= 1;
+        return true;
+    }
+    /** A handler's answer becomes the state if it is one (a plain object or an array); nothing keeps the state, and anything else is a mistake that leaves it. */
+    keepAnswer(handlerName, answer) {
+        // A sandboxed game server hands back its state after every call; one that is not an object or an array and did not change is not an answer.
+        if (answer === undefined || answer === this.state)
+            return;
+        if (handlerName === "setup" || isStateAnswer(answer))
+            this.state = answer;
+        else
+            console.error("Game server error:", badHandlerAnswer(handlerName, answer));
+    }
+    /**
+     * Run a game server handler. A crash in game code is logged and never takes the room down. State sync's
+     * round follows a turn-based room's handlers and a real-time room's tick (isTick).
+     */
+    run(handler, handlerName, isTick = false) {
+        const isSyncing = this.stateTracker !== null && (isTick || !this.ticking);
+        if (!this.queue) {
+            let next;
+            this.depth++;
+            try {
+                next = handler();
+            }
+            catch (error) {
+                console.error("Game server error:", error);
+                this.depth--;
+                this.flush();
+                return;
+            }
+            this.depth--;
+            if (!isPromise(next)) {
+                this.keepAnswer(handlerName, next);
+                this.dirty = true;
+                if (isSyncing)
+                    this.syncState();
+                this.flush();
+                return;
+            }
+            this.queue = Promise.resolve();
+            const started = next;
+            handler = () => started;
+        }
+        this.waitingCount++;
+        this.queue = this.queue.then(async () => {
+            this.depth++;
+            try {
+                const next = await handler();
+                this.keepAnswer(handlerName, next);
+                this.dirty = true;
+                if (isSyncing)
+                    this.syncState();
+            }
+            catch (error) {
+                console.error("Game server error:", error);
+            }
+            finally {
+                this.waitingCount--;
+                this.depth--;
+                this.flush();
+            }
+        });
+    }
+}
+/** The calls that change the room or send from it: not for canJoin or stateView, which only decide and answer. */
+const CHANGING_CALLS = ["broadcast", "send", "broadcastBytes", "sendBytes", "end", "setListed", "setOpen", "setFriendJoinsEnabled", "setKept", "setInfo", "reserve", "kick", "moveTo", "applyVersionUpdate"];
+/** A room that reads like the room but throws room_call_unavailable for every call that changes it, for the handler named. */
+function readOnlyRoom(room, handlerName) {
+    const view = Object.create(room);
+    for (const call of CHANGING_CALLS) {
+        Object.defineProperty(view, call, {
+            value: () => {
+                throw new GameServerError("room_call_unavailable", `room.${call}`, `${handlerName} can't change the room.`, `Only read from room in ${handlerName}; change the room in the handlers that run after it, like onJoin or onMessage.`);
+            },
+        });
+    }
+    return view;
+}
+/** Whether a handler's answer can be the state: a plain object (prototype Object.prototype or null) or an array. */
+export function isStateAnswer(given) {
+    if (Array.isArray(given))
+        return true;
+    if (typeof given !== "object" || given === null)
+        return false;
+    const prototype = Object.getPrototypeOf(given);
+    return prototype === Object.prototype || prototype === null;
+}
+/** The mistake of a handler answering something that isn't a state; the state stays as it was. */
+export function badHandlerAnswer(handlerName, answer) {
+    const given = typeof answer === "string" ? `the text ${JSON.stringify(answer.slice(0, 60))}` : answer === null ? "null" : typeof answer === "object" ? `a ${answer.constructor?.name ?? "non-plain"} object` : String(answer).slice(0, 60);
+    return new GameServerError("bad_handler_answer", handlerName, `${handlerName} answered ${given}, so the state stayed as it was.`, "Answer the new state as a plain object or an array, or answer nothing to keep the state.");
+}
+function isPromise(given) {
+    return typeof given?.then === "function";
+}
+/** A player's presence as they come in: nothing sent and nothing measured yet. A room waking from sleep starts its probes afresh. */
+function newPresence(seenAtMs, clientIdle) {
+    return { seenAtMs, clientIdle, sentByteCount: 0, answeredSentByteCount: 0, lastProbeSentByteCount: 0, lastProbeAtMs: 0, unansweredProbes: new Map(), pingDurationMs: null };
+}
+/** How many bytes a text takes on the wire. */
+function utf8ByteCount(text) {
+    return new TextEncoder().encode(text).length;
+}
+/** The idle check a player's game asked for, from its hello or back message: a timeout within the limits, and whether to check at all. */
+export function clientIdle(given) {
+    const asked = (given && typeof given === "object" ? given : {});
+    const out = {};
+    if (typeof asked.idleTimeoutSec === "number" && Number.isFinite(asked.idleTimeoutSec)) {
+        out.idleTimeoutSec = Math.min(ROOM_LIMITS.maximumIdleTimeoutSec, Math.max(ROOM_LIMITS.minimumIdleTimeoutSec, Math.round(asked.idleTimeoutSec)));
+    }
+    if (typeof asked.idleCheckEnabled === "boolean")
+        out.idleCheckEnabled = asked.idleCheckEnabled;
+    return out;
+}
+/** A name and labels within the limits, with hidden characters dropped. Fields left out stay out. */
+export function tidyRoomInfo(nameAndLabels) {
+    return checks.tidyRoomInfo(nameAndLabels);
+}