@zaisma/game-server 0.0.1 → 1.0.0

package/src/room.d.ts

@@ -0,0 +1,1462 @@
+/**
+ * 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 { type GameDatabase } from "./database.ts";
+import type { PlayerKind, ReceiptClaims } from "./pass.ts";
+import type { Server } from "./requests.ts";
+import { type Schedule, type ScheduledRun } from "./schedules.ts";
+import { type StateChange } from "./state-sync.ts";
+import type { WebhookEvent } from "./webhooks.ts";
+export interface Player {
+    /** An account's player ID is the same in every game; a guest's lasts only for their pass. */
+    id: string;
+    /** The account's name, or a guest's generated one like "Swift Fox 42". */
+    name: string;
+    /** A signed-in Zaisma account, or a guest. */
+    kind: PlayerKind;
+    /**
+     * The permanent items the account owns in this game, by item_name, from the pass it joined with (its
+     * owned_item_names): check one with player.ownedItemNames?.includes("skin_red-dragon"). Absent for guests
+     * and when the player owns nothing here. Only the game server sees it; other players' games never do.
+     */
+    ownedItemNames?: string[];
+}
+export interface Room {
+    /**
+     * This room's code, like K7Q2MX: the code players join it by. Use it to treat rooms differently, like
+     * keeping only your one shared world (setKept in "WRLD22", canJoin refusing elsewhere).
+     */
+    readonly roomCode: string;
+    /** Players in the room right now, in join order. */
+    readonly players: readonly Player[];
+    /**
+     * Spectators watching the room (maximumSpectatorCount), in join order: they get what the room sends
+     * everyone, send nothing and don't count as playing. Never in players.
+     */
+    readonly spectators: readonly Player[];
+    /**
+     * Send a message to every player and spectator (audience), or everyone but one (exceptPlayerId).
+     * delivery "latest_only" lets a player whose connection is backed up skip it for a newer one (SendOptions).
+     */
+    broadcast(message: unknown, broadcastOptions?: BroadcastOptions): void;
+    /** Send a message to one player or spectator. */
+    send(playerId: string, message: unknown, sendOptions?: SendOptions): void;
+    /**
+     * Send bytes to every player, or everyone but one (exceptPlayerId), like a compact snapshot of the
+     * world. Each player's game gets them as the "bytes" event, with fromPlayerId or null.
+     */
+    broadcastBytes(bytes: Uint8Array, broadcastOptions?: BroadcastOptions): void;
+    /** Send bytes to one player or spectator. */
+    sendBytes(playerId: string, bytes: Uint8Array, sendOptions?: SendOptions): void;
+    /** End the match: everyone is told why (message, with endReason "game") and disconnected, and the room closes. */
+    end(message?: string): void;
+    /**
+     * When Zaisma will end this match, an ISO time, or null. Set once the game's hosting on Zaisma rooms
+     * pauses for the month (its free allowance, or its developer's budget or credit, is used), an hour after
+     * the pause, so your game can save and tell its players (onEnding runs then); never set on your own server.
+     */
+    readonly endsAt: string | null;
+    /** Shown in room lists (the game page and Zaisma.rooms.list). A hidden room still works by code and link. */
+    readonly isListed: boolean;
+    setListed(isListed: boolean): void;
+    /** Taking new players. A closed room lets back only players who were already in it. */
+    readonly isOpen: boolean;
+    setOpen(isOpen: boolean): void;
+    /**
+     * Whether Zaisma's Join offers this room: a player's friends on zaisma.com, and Zaisma.friends. Off
+     * shows their Join grayed as "Private room". It isn't a lock: a code or link still reaches the room,
+     * so close it (setOpen) or answer false from canJoin to keep players out.
+     */
+    readonly friendJoinsEnabled: boolean;
+    setFriendJoinsEnabled(isEnabled: boolean): void;
+    /**
+     * A kept room doesn't end when everyone leaves: it sleeps with its state saved and wakes when someone
+     * joins, for worlds that last. Its saved state counts against the game's storage. room.end() ends it
+     * for good. setKept(false) makes it an ordinary room again, whose state goes a day after it empties.
+     */
+    readonly isKept: boolean;
+    setKept(isKept: boolean): void;
+    /** The room's name, like "Ana's castle", or null. Up to 40 characters. */
+    readonly name: string | null;
+    /** Up to 4 labels players can filter by, like { Mode: "Classic", Map: "Docks" }. */
+    readonly labels: Readonly<Record<string, string>>;
+    /**
+     * Name and label the room, from the game or from what a player typed. Names and labels a player
+     * typed show on zaisma.com only if they pass Zaisma's text filter; your game is responsible for
+     * them inside the game. Leave a field out to keep it; null clears it.
+     */
+    setInfo(nameAndLabels: RoomInfo): void;
+    /**
+     * Make a new room for some of this room's players, like a lobby starting a match, and move them
+     * there. The new room runs this same game server: its setup(setupData) gets your setupData, only
+     * the players named can join it (a closed room, until it opens), and it's hidden from room lists
+     * unless you list it. Each player gets a "move" event in the game and joins when the game says so.
+     * Returns the new room's code. setupData is plain JSON, up to 4 KB; players can read it but not change it.
+     */
+    reserve(reserveOptions: ReserveOptions): string;
+    /**
+     * Remove a player from the room, telling them why (message, up to 200 characters; your game's
+     * words, so keep them within the content rules). keepOut keeps them out of this room for the rest
+     * of the match, and out of any room it reserves after. onLeave runs once the current handler is done.
+     */
+    kick(playerId: string, kickOptions?: KickOptions): void;
+    /**
+     * Send some of this room's players to another room of this game that already exists, like back to
+     * their party's match or into the next area of an open world. The other room's canJoin decides with
+     * your joinData (plain JSON, up to 4 KB) and holds a seat for each player it takes for a minute,
+     * even if it's closed to new players; its onJoin gets the same joinData. Each player taken gets a
+     * "move" event in the game, which follows by default. onMoved then says who was taken and who was
+     * turned away; they stay here.
+     */
+    moveTo(roomCode: string, moveOptions: MoveOptions): void;
+    /**
+     * The game's own SQLite database, shared by all its rooms and kept between matches: for what the
+     * game server owns or must trust, like inventories, leaderboards and bans. Plain SQL, awaited in
+     * any handler (which then runs as async). In Zaisma rooms it's part of the game's hosting; on your
+     * own server the Node runner keeps it in a local file (--database), so the same code runs in both.
+     */
+    readonly database: GameDatabase;
+    /**
+     * The game's secrets, by name, like room.secrets.STRIPE_SECRET_KEY: set per game on Zaisma
+     * (set_secret) and never shown again, or the environment variables on your own server. Calls to
+     * other servers are plain fetch(); on Zaisma they reach the hosts the game lists in
+     * game_server_allowed_hosts, and anything else throws an OutsideCallError.
+     */
+    readonly secrets: Readonly<Record<string, string>>;
+    /**
+     * Check a purchase's receipt, as the game sent it, before delivering: its claims, or an error named
+     * ReceiptError with a code (wrong_game, bad_signature, ...); check error.name, not instanceof, since in
+     * Zaisma rooms it isn't your copy's class. The runtime fills in Zaisma's published keys and this game, in
+     * Zaisma rooms and on your own server alike. Any other error means the check couldn't run just now (keys
+     * that didn't load, a time-out): try again later, never treat the receipt as refused. Deliver once per purchase_id, and only when purchase_status
+     * is completed.
+     */
+    verifyReceipt(receipt: string): Promise<ReceiptClaims>;
+    /**
+     * Whether two players in the room have a block between them, either way (never which one made it):
+     * from their Zaisma accounts, or a block a player just made in the game. A block is a wall both ways,
+     * so don't deliver chat, voice or emotes from one to the other, and keep them apart in your own
+     * matchmaking when you can, but never keep either one out: who plays is your call. Each player's game
+     * hides the other's emotes and phrases by itself (room.isMuted).
+     */
+    hasBlockBetween(firstPlayerId: string, secondPlayerId: string): boolean;
+    /**
+     * Whether two players in the room are Zaisma friends: both accounts, as their friendship was when the
+     * later of them joined. Use it for friends-only chat, teams or a "friend" mark; guests are never
+     * anyone's friend. It never says who else a player's friends are.
+     */
+    areFriends(firstPlayerId: string, secondPlayerId: string): boolean;
+    /**
+     * A player's round trip to the room in milliseconds, smoothed, or null for a player who isn't in the
+     * room or hasn't been measured yet (the room probes each player right after they join). The player's
+     * game reads the same number as room.pingDurationMs. The room measures it itself, so a player can only
+     * make theirs look worse by answering late, never better: cap any lag compensation that uses it.
+     */
+    pingDurationMs(playerId: string): number | null;
+    /**
+     * The room's clock now, in epoch milliseconds, like Date.now(). Players' games estimate the same
+     * clock with room.serverTimeMs(), so a time the game server sends, like when a race starts, means
+     * the same moment for everyone.
+     */
+    serverTimeMs(): number;
+    /**
+     * Why a player in the room isn't playing, or null while they play: "idle" or "hidden" (your onAway
+     * kept them), or "lost" (their connection dropped and they have reconnectTimeoutSec to come back).
+     * Every player's game sees the same in its player list (awayReason).
+     */
+    awayReason(playerId: string): AwayReason | null;
+    /**
+     * Switch to the new version now, with onVersionUpdate: at a good moment, like the end of a round. The
+     * room saves, every player's game reconnects (reloading at the new version when its files changed) and
+     * the new version's onRestored carries on from the state. Does nothing when no update is coming, and on
+     * your own server.
+     */
+    applyVersionUpdate(): void;
+}
+/** Who a broadcast reaches: players and spectators (everyone), only the players, or only the spectators. */
+export type Audience = "everyone" | "players" | "spectators";
+/**
+ * How a message goes: "reliable" (the default) reaches every player in order. "latest_only" may be
+ * dropped: a player whose connection is backed up skips older ones and gets the newest once they catch
+ * up, like positions sent every tick. In Zaisma rooms it rides the WebSocket today, and moves to real
+ * datagrams the day Cloudflare carries them, with no change to your game.
+ */
+export type Delivery = "reliable" | "latest_only";
+export interface SendOptions {
+    delivery?: Delivery;
+    /**
+     * For "latest_only", and needed there: which messages replace each other while a player is backed
+     * up, up to 40 characters, like "positions".
+     */
+    latestKey?: string;
+    /**
+     * The player this message or these bytes are from, when you pass one player's on; each player's game
+     * hears it with the message (or bytes), and null when it's left out: from the game server. The game
+     * server vouches for it.
+     */
+    fromPlayerId?: string;
+}
+export interface BroadcastOptions extends SendOptions {
+    /** A player who doesn't get it, like the one whose move this is. */
+    exceptPlayerId?: string;
+    /** Who gets it: "everyone" (the default: players and spectators), "players" or "spectators". */
+    audience?: Audience;
+}
+export interface MoveOptions {
+    playerIds: string[];
+    joinData?: unknown;
+}
+/** A player another room turned away (room.moveTo), with why: an error code and its message. */
+export interface Refusal {
+    player: Player;
+    code: RoomErrorCode;
+    message: string;
+}
+/** Who another room took (room.moveTo) and who it turned away. */
+export interface MoveResult {
+    roomCode: string;
+    movedPlayers: Player[];
+    refusals: Refusal[];
+}
+/**
+ * How a player came in: fromRoomCode, the code of the room that sent them (room.moveTo), or null.
+ * isReturning: they're coming back to the seat the room held for them, after walking away or losing their connection.
+ * isSpectator: they come to watch (joinRoom({ isSpectator: true })), not to play.
+ */
+export interface JoinInfo {
+    fromRoomCode: string | null;
+    isReturning: boolean;
+    isSpectator: boolean;
+}
+/**
+ * Why a player isn't playing: no input (idle), the game hidden in a real-time room, or lost: their
+ * connection dropped, and the room keeps them for reconnectTimeoutSec.
+ */
+export type AwayReason = "idle" | "hidden" | "lost";
+/** A player as players' games see them: who they are, never what they own (that's the game server's, from the pass). */
+export type ShownPlayer = Omit<Player, "ownedItemNames">;
+/** A player as the room lists them to every player's game: awayReason says why they aren't playing, or null while they play. */
+export interface ListedPlayer extends ShownPlayer {
+    awayReason: AwayReason | null;
+}
+/**
+ * Why a player left: left (closed the game or left the room), lost (their connection dropped and they
+ * weren't back within reconnectTimeoutSec, and the room holds their seat), idle or hidden (they walked
+ * away, and the room holds their seat), kicked.
+ */
+export type LeaveReason = "left" | AwayReason | "kicked";
+export interface LeaveInfo {
+    reason: LeaveReason;
+}
+/** What onAway hears: why the player isn't playing. */
+export interface AwayInfo {
+    reason: AwayReason;
+}
+/** What one room asks another when moving players there; fromRoomCode is the asking room's, added by the transport. */
+export interface MoveAsk {
+    fromRoomCode: string;
+    players: Player[];
+    joinData: unknown;
+}
+/** The other room's answer to a MoveAsk: who it took, and who it turned away and why. */
+export interface MoveAnswer {
+    movedPlayerIds: string[];
+    refusals: {
+        playerId: string;
+        code: RoomErrorCode;
+        message: string;
+    }[];
+}
+export interface KickOptions {
+    message?: string;
+    keepOut?: boolean;
+}
+/** A room made for some players: who, the data its game server starts with, and how it shows. */
+export interface ReserveOptions extends RoomInfo {
+    playerIds: string[];
+    setupData?: unknown;
+    isListed?: boolean;
+    /** false: friends can't Join the new room from Zaisma ("Private room"). */
+    friendJoinsEnabled?: boolean;
+    /** true: the new room is kept (room.setKept). */
+    isKept?: boolean;
+}
+/** How a reserved room starts, as the room that made it sends it on. */
+export interface RoomStart extends Pick<RoomSettings, "isListed" | "name" | "labels">, Partial<Pick<RoomSettings, "friendJoinsEnabled">> {
+    playerIds: string[];
+    setupData: unknown;
+    /** Players kept out of the room that made this one, and why: they stay out of this one too. */
+    keptOut?: Record<string, string>;
+    /** The code of the room that made this one, where awayMode "lobby" sends players. Added by the transport. */
+    lobbyRoomCode?: string;
+    /** Kept (room.setKept) from the start. */
+    isKept?: boolean;
+}
+/** A room's name and labels, as a game sets them. */
+export interface RoomInfo {
+    name?: string | null;
+    labels?: Record<string, string | number> | null;
+}
+/** Who checks for players who give no input: the room (server), each player's game (client), or nobody (off). */
+export type IdleCheck = "server" | "client" | "off";
+/** What happens to a player who walks away: their seat is held (hold), or they're sent to the room that made this one (lobby). */
+export type AwayMode = "hold" | "lobby";
+/**
+ * A handler answers the new state (a plain object or an array), or nothing to keep it; an async handler
+ * (one that awaits room.database) answers it later. Any other answer, like a number or null, is a mistake:
+ * the state stays and the game's logs say bad_handler_answer.
+ */
+export type HandlerResult<S> = void | S | Promise<void | S>;
+export interface GameServer<S = any> {
+    /** Up to 100. Defaults to 8. */
+    maximumPlayerCount?: number;
+    /**
+     * Spectators a room takes, up to 100: they watch a match without playing (joinRoom({ isSpectator: true })),
+     * get what the room sends everyone, send nothing, don't count as playing or toward maximumPlayerCount,
+     * and are free (off the player-hour meter). Leave it out, or 0, and nobody can watch.
+     */
+    maximumSpectatorCount?: number;
+    /** Ticks a second, up to 60. Leave out for turn-based games so the room can sleep between moves. */
+    ticksPerSec?: number;
+    /**
+     * The room's first player is its host: they may hide, show, open, close and name the room, and
+     * kick players, from the game. When the host leaves, the next player takes over. The relay has this on.
+     */
+    hostControlsEnabled?: boolean;
+    /**
+     * Who checks for players who give no input. "server" (the default): after idleTimeoutSec, the
+     * player's game asks "Still there?", and 30 seconds later they walk away. "client": each player's
+     * game decides (joinRoom({ idleTimeoutSec, idleCheckEnabled })), as the relay does. "off": nobody.
+     */
+    idleCheck?: IdleCheck;
+    /** Seconds without input before "Still there?", 30 to 86400. Defaults to 600 (10 minutes). */
+    idleTimeoutSec?: number;
+    /**
+     * What happens when a player walks away (idle, or the game hidden for 2 minutes in a real-time
+     * room). "hold" (the default) takes them out of the match (onLeave) and holds their seat for
+     * seatHoldDurationSec, so they come straight back to it. "lobby" sends them to the room that made
+     * this one (room.reserve), holding their seat if there isn't one or it won't take them. Give onAway
+     * to handle it yourself instead.
+     */
+    awayMode?: AwayMode;
+    /**
+     * How long the room holds a seat for a player who walked away or lost their connection, in
+     * seconds: up to 1800, 0 for none. Defaults to 300. Held seats count toward maximumPlayerCount.
+     */
+    seatHoldDurationSec?: number;
+    /**
+     * How long a player whose connection dropped stays in the match as away (reason "lost") before they
+     * leave it, in seconds: 0 to 300, 0 to take them out at once. Defaults to 30. Your onAway and onBack
+     * run, so you can freeze their character; held seats come after (seatHoldDurationSec).
+     */
+    reconnectTimeoutSec?: number;
+    /**
+     * Send each player the state, then only what changes: a full copy when they join (and after their
+     * connection was backed up), then the changes after each tick, or after each handler in a turn-based
+     * game. Their game reads it as room.state, or room.smoothedState() to move evenly between updates.
+     * Off by default. The state goes as JSON, so keep it plain; cut what each player sees with stateView.
+     */
+    stateSyncEnabled?: boolean;
+    /**
+     * How often a real-time room saves its state, in seconds: 1 to 60, default 5. A restarted room comes
+     * back with the last saved state (onRestored). Turn-based rooms save after every change and ignore it.
+     */
+    stateSaveIntervalSec?: number;
+    /**
+     * The starting state. It must be plain JSON so a sleeping room can be saved and woken. setupData
+     * is what room.reserve() passed when another room made this one, and null otherwise. Rooms need it;
+     * a game server that only answers requests (onRequest) or runs on schedules can leave it out.
+     */
+    setup?(setupData: unknown): S;
+    /**
+     * A request from the player's game outside any room (Zaisma.server.request(request)), like a
+     * leaderboard, a shop or a daily reward in a single-player game. Answer what the game gets back:
+     * plain JSON, up to 1 MB, within 10 seconds. request is plain JSON from the player's browser, up
+     * to 16 KB, so check it like any message; player is who sent it, from their player pass. There's no
+     * room and no state: keep what lasts in server.database; server.secrets has the game's secrets. If it throws, the game gets
+     * error.code "game_server_error" and you see the error with the game server's others.
+     */
+    onRequest?(player: Player, request: unknown, server: Server): unknown;
+    /**
+     * When the game server runs by itself, outside rooms and requests: daily resets, a weekly
+     * leaderboard, a persistent world's turns. Up to 10, each a name and a cron in UTC (minute hour
+     * day-of-month month day-of-week), so at most once a minute: [{ name: "daily-reset", cron: "0 0 * * *" }].
+     */
+    schedules?: Schedule[];
+    /**
+     * A schedule is due: run.name says which, run.scheduledAt the minute it was due (an ISO time, UTC).
+     * There's no room, no player and no state: keep what lasts in server.database; server.secrets has the game's secrets. It has 30 seconds.
+     * A run can rarely come twice or a little late (after a restart), so make it safe to repeat, like
+     * a reset that checks run.scheduledAt against the last one it did. If it throws, you see the
+     * error with the game server's others.
+     */
+    onSchedule?(run: ScheduledRun, server: Server): unknown;
+    /**
+     * An event from one of the developer's webhooks: a webhook whose destination is this game's game
+     * server (create_webhook with destination_kind "game_server"), or, on your own server, one whose
+     * endpoint_url is this server's /v1/webhooks. event is what any webhook is sent: event.kind, and
+     * event.game, event.version and event.bug_report as the developer API answers them
+     * (event.account_deletion for account_deleted: Zaisma erases the player's rows itself unless the game
+     * turned that off). Turn it into a
+     * Discord post or a GitHub issue with fetch() and the tokens in server.secrets. There's no room, no
+     * player and no state. Finishing without an error counts as delivered; throwing (or taking over 10
+     * seconds) tries it again later, up to 6 times, so make it safe to repeat: event.id is the same on
+     * every try. Each event counts as one of the game's requests.
+     */
+    onWebhook?(event: WebhookEvent, server: Server): unknown;
+    /**
+     * joinData is what the player's game passed to joinRoom({ joinData }), like the character they
+     * picked, or null. It comes from the player's browser, so check it like any message. For a player
+     * another room sent (room.moveTo), joinData is what that room's game server passed, and
+     * joinInfo.fromRoomCode is its code.
+     */
+    onJoin?(state: S, player: Player, room: Room, joinData: unknown, joinInfo: JoinInfo): HandlerResult<S>;
+    /**
+     * Say who may come in, before they join: answer true to let them in, false to turn them
+     * away, or { refusalMessage } to turn them away with a message they see (up to 200 characters), like
+     * a wrong room password in joinData or a full team. Answering nothing, or anything else, is a mistake
+     * and turns them away too, logged as a game server error (bad_handler_answer). Players coming back after a dropped connection don't ask
+     * again. Only decide here; change the state in onJoin. If it throws, the player is turned away.
+     * Players another room sends are asked when it sends them, with its joinData and
+     * joinInfo.fromRoomCode, and not again when they arrive.
+     */
+    canJoin?(state: S, player: Player, room: Room, joinData: unknown, joinInfo: JoinInfo): JoinAnswer | Promise<JoinAnswer>;
+    /** After room.moveTo: who the other room took, and who it turned away and why. */
+    onMoved?(state: S, moveResult: MoveResult, room: Room): HandlerResult<S>;
+    /**
+     * leaveInfo.reason says why they left; a player who lost their connection or walked away gets their
+     * seat held. A dropped connection ("lost") first comes to onAway, and only here if they aren't back
+     * within reconnectTimeoutSec.
+     */
+    onLeave?(state: S, player: Player, room: Room, leaveInfo: LeaveInfo): HandlerResult<S>;
+    /** A spectator came to watch: send them what they need to follow the match, like the whole state once. */
+    onSpectatorJoin?(state: S, spectator: Player, room: Room): HandlerResult<S>;
+    /** A spectator stopped watching (left, lost their connection or was kicked). No seat is held. */
+    onSpectatorLeave?(state: S, spectator: Player, room: Room): HandlerResult<S>;
+    /**
+     * A player walked away (idle, hidden) or their connection dropped (lost). For idle and hidden, with
+     * onAway they stay in the room and your game decides what happens: kick them, move them
+     * (room.moveTo) or keep them. For lost, every game hears it, and the room decides when time's up:
+     * they stay for reconnectTimeoutSec, then leave (onLeave, reason "lost"); freeze their character
+     * meanwhile. They don't count as playing while away, and a room where everyone is away stops
+     * ticking. onBack runs when they return: send them what they missed.
+     */
+    onAway?(state: S, player: Player, room: Room, awayInfo: AwayInfo): HandlerResult<S>;
+    onBack?(state: S, player: Player, room: Room): HandlerResult<S>;
+    onMessage?(state: S, player: Player, room: Room, message: unknown): HandlerResult<S>;
+    /**
+     * Bytes a player's game sent (room.sendBytes), like a compact input, under the same limits as
+     * messages: up to 16 KB each, 30 a second. Read them with a DataView; they're a copy, yours to keep.
+     */
+    onBytes?(state: S, player: Player, room: Room, bytes: Uint8Array): HandlerResult<S>;
+    /** tickDurationSec: seconds since the last tick, about 1 / ticksPerSec (more when a tick was skipped). */
+    onTick?(state: S, tickDurationSec: number, room: Room): HandlerResult<S>;
+    /**
+     * Zaisma will end this match at room.endsAt, because the game's hosting paused for the month: save
+     * what should outlive it and tell your players. Runs once; each player's game also gets
+     * the "ending" event. Never runs on your own server.
+     */
+    onEnding?(state: S, room: Room): HandlerResult<S>;
+    /**
+     * The room restarted (Zaisma restarts its rooms on every update, and your own server may restart) and
+     * came back with the state it last saved: restoreInfo.savedAt says when, and restoreInfo.lostDurationSec
+     * how many seconds of play since then are lost, so you can resync clocks or tell your players. Runs
+     * once, instead of setup. The players who were in the match come back as away (reason "lost"): onAway
+     * runs for each after this, and onBack as each reconnects, or onLeave if they aren't back within
+     * reconnectTimeoutSec.
+     */
+    onRestored?(state: S, restoreInfo: RestoreInfo, room: Room): HandlerResult<S>;
+    /**
+     * With stateSyncEnabled: what this player sees of the state, like only what's near them in a big
+     * world, or without the other team's hidden cards. Leave it out and everyone sees all of it. Answer
+     * plain JSON, a new object or parts of the state; don't change the state here. Keep it cheap: it runs
+     * for every player on every tick. viewer is the player it's for.
+     */
+    stateView?(state: S, viewer: Player, room: Room): unknown;
+    /**
+     * The developer published a version with match_update_mode "now", and this match moves to it. With
+     * this handler the room waits for you: call room.applyVersionUpdate() at a good moment, like the end of
+     * a round, or it switches at versionUpdate.appliesAt, 5 minutes on. Without it, it switches 10 seconds
+     * after the notice. Each player's game hears it too (the room's "versionUpdate" event), to show a
+     * countdown or save. Never runs on your own server.
+     */
+    onVersionUpdate?(state: S, versionUpdate: VersionUpdate, room: Room): HandlerResult<S>;
+}
+/**
+ * What onVersionUpdate hears, as players' games do: the version the match moves to, when it switches at
+ * the latest (an ISO time), and whether the game's files changed, so players' games reload.
+ */
+export interface VersionUpdate {
+    versionId: string;
+    appliesAt: string;
+    isReloading: boolean;
+}
+/**
+ * What onRestored hears: when the state it came back with was saved (an ISO time), how many seconds of
+ * play since then are lost, and the version of the game that saved it (null on your own server), which
+ * differs from the one running after an update, so the game can bring an older state up to date.
+ */
+export interface RestoreInfo {
+    savedAt: string;
+    lostDurationSec: number;
+    savedVersionId: string | null;
+}
+/**
+ * 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 declare function restoreInfoOf(savedAtMs: number, nowMs?: number, savedVersionId?: string | null, isSavedEmpty?: boolean): RestoreInfo;
+/**
+ * What canJoin answers: true lets the player in; false turns them away; { refusalMessage } turns them
+ * away with that message. Answering nothing turns them away too, and is logged as a mistake.
+ */
+export type JoinAnswer = boolean | {
+    refusalMessage: string;
+};
+/**
+ * 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 declare function readJoinAnswer(answer: unknown): {
+    isAllowed: true;
+} | {
+    isAllowed: false;
+    refusalMessage: string | null;
+} | {
+    mistake: GameServerError;
+};
+/** Everything a game server object may have, in the order the docs give them. Anything else is refused. */
+export declare const GAME_SERVER_OPTIONS: readonly ["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 declare const ROOM_LIMITS: {
+    /** Players in one room: what one room carries at 60 ticks a second (test/load/room-load.test.ts). */
+    readonly maximumPlayerCount: 100;
+    readonly 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. */
+    readonly maximumSpectatorCount: 100;
+    readonly maximumTicksPerSec: 60;
+    /** A room's name, its labels, and each label's name and value. */
+    readonly maximumNameCharacterCount: 40;
+    readonly maximumLabelCount: 4;
+    readonly maximumLabelNameCharacterCount: 16;
+    readonly maximumLabelValueCharacterCount: 24;
+    /** Join data a player brings to a room, and setup data a reserved room starts with, as JSON. */
+    readonly maximumJoinDataSizeBytes: number;
+    readonly maximumSetupDataSizeBytes: number;
+    /** 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. */
+    readonly maximumReservesPerMin: 20;
+    /** A kick's message, and a refusal's (canJoin's refusalMessage). */
+    readonly maximumKickMessageCharacterCount: 200;
+    readonly maximumRefusalMessageCharacterCount: 200;
+    /** Largest game message (or bytes) a client may send. */
+    readonly maximumGameMessageSizeBytes: number;
+    /**
+     * 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.
+     */
+    readonly maximumGameMessagesPerSec: 30;
+    readonly maximumGameMessageBurstCount: 60;
+    /** The idle check's default and range (idleTimeoutSec, joinRoom({ idleTimeoutSec })). */
+    readonly defaultIdleTimeoutSec: 600;
+    readonly minimumIdleTimeoutSec: 30;
+    readonly maximumIdleTimeoutSec: number;
+    /** How long a game hidden in a real-time room counts before its player is away. */
+    readonly hiddenTimeoutSec: 120;
+    /** How long a seat is held by default, and at most (seatHoldDurationSec). */
+    readonly defaultSeatHoldDurationSec: 300;
+    readonly maximumSeatHoldDurationSec: 1800;
+    /** How long a player whose connection dropped stays in the match by default, and at most (reconnectTimeoutSec). */
+    readonly defaultReconnectTimeoutSec: 30;
+    readonly maximumReconnectTimeoutSec: 300;
+    /** How often a real-time room saves its state by default, and the range (stateSaveIntervalSec). */
+    readonly defaultStateSaveIntervalSec: 5;
+    readonly minimumStateSaveIntervalSec: 1;
+    readonly maximumStateSaveIntervalSec: 60;
+    /** A match moving to a version published "now": its notice without onVersionUpdate, and the longest onVersionUpdate can hold it. */
+    readonly defaultVersionUpdateDelaySec: 10;
+    readonly maximumVersionUpdateDelaySec: 300;
+    /** A real-time room's state bigger than this as JSON isn't saved, and a restart starts it fresh. */
+    readonly maximumSavedStateSizeBytes: number;
+    /** A player's view of the state as JSON (stateSyncEnabled): bigger views aren't sent, and the game's errors say so once. */
+    readonly maximumStateViewSizeBytes: number;
+    /** A latest-only message's latestKey. */
+    readonly maximumLatestKeyCharacterCount: 40;
+    /** Latest-only messages waiting for a backed-up player, one per latestKey; past it, the oldest is dropped. */
+    readonly 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 declare const ROOM_TUNING: {
+    /** How often a ticking room probes each player, for their ping and the room's clock. */
+    readonly probeIntervalSec: 2;
+    /** A probe left unanswered this long drops the player: their connection stopped or fell too far behind. */
+    readonly probeAnswerTimeoutSec: 8;
+    /** A player is also probed each time this much has gone out to them since their last probe. */
+    readonly probeSentSizeBytes: number;
+    /** Bytes sent to a player since the last probe they answered; past it, they're dropped. */
+    readonly maximumUnansweredSentSizeBytes: number;
+    /** Unanswered probes the room remembers per player; the oldest is forgotten past it. */
+    readonly 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.
+     */
+    readonly backedUpSizeBytes: number;
+    readonly backedUpDelayMs: 250;
+};
+/** The room protocol's version: hello and welcome say it, so either side can tell what the other speaks. */
+export declare const PROTOCOL_VERSION_NUMBER = 1;
+/**
+ * What a GameServerError's code says: unknown_option and bad_option (a game server object that breaks
+ * the rules), bad_room_call (a room call's arguments are wrong), room_call_limit (too many reserves a
+ * minute, or room calls in one go), room_call_unavailable (that call can't run here or now) and
+ * bad_handler_answer (a handler answered something that isn't a state, or canJoin answered nothing).
+ */
+export type GameServerErrorCode = "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 declare class GameServerError extends Error {
+    readonly code: GameServerErrorCode;
+    readonly field: string;
+    readonly fix: string;
+    constructor(code: GameServerErrorCode, field: string, message: string, fix: string);
+    /** 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: unknown): boolean;
+}
+/** The error for an option a game server doesn't take, naming the ones it does. */
+export declare function unknownOptionError(field: string): GameServerError;
+/** The error for a room whose game server has no setup(): it only answers requests, runs on schedules or takes webhooks. */
+export declare function noSetupError(): GameServerError;
+/** A game server's schedules, checked (readSchedules), or GameServerError for the field schedules. */
+export declare function checkSchedules(schedules: unknown, hasOnSchedule: boolean): Schedule[];
+/** Check a game server's options once, when it's defined: unknown options and values out of range throw. */
+export declare function defineGameServer<S>(server: GameServer<S>): GameServer<S>;
+/** Whether a room shows in room lists, takes new players and is offered by Zaisma's Join, and its name and labels. */
+export interface RoomSettings {
+    isListed: boolean;
+    isOpen: boolean;
+    friendJoinsEnabled: boolean;
+    name: string | null;
+    labels: Record<string, string>;
+}
+/**
+ * Messages from the room to a client. Every message says its type; a game's own messages carry
+ * theirs in data (docs/NAMING.md).
+ *
+ * Clients send {type: "hello", protocolVersionNumber, pass, joinData?, room?: {isListed?, friendJoinsEnabled?, name?, labels?}, idleTimeoutSec?,
+ * idleCheckEnabled?} first (ClientMessage; joinData is for canJoin and onJoin; the room's settings only count from
+ * the player who makes it, and a room is listed only when its first player's hello says isListed: true;
+ * the idle fields only where the game server's idleCheck is "client"), then {type: "message", data}.
+ * With hostControlsEnabled, the host may also send {type: "room", room: {isListed?, isOpen?,
+ * friendJoinsEnabled?, name?, labels?}} and {type: "kick", playerId, keepOut?}. hostPlayerId is null without host controls.
+ *
+ * Versions: welcome says the room's protocolVersionNumber (PROTOCOL_VERSION_NUMBER). A message with a type
+ * the room doesn't know is counted and ignored, never refused, so a newer SDK still talks to an older room.
+ * A game's messages reach players as {type: "message", data, fromPlayerId}: the player the game server
+ * says it's from (SendOptions.fromPlayerId), or null.
+ *
+ * Blocks (docs/DECISIONS.md, "How blocks work"): a player's game sends {type: "block", playerId} for a
+ * player in the room it blocked (a guest's, or one just made) and {type: "unblock", playerId} when it
+ * takes one back; blocks between accounts the room finds itself. Each player gets {type: "blocks",
+ * playerIds}, the players in the room they have a block with, either way, whenever that changes. A
+ * hello from Zaisma.rooms.quickJoin may say avoidBlockedPlayers: true, and a Zaisma room then turns the
+ * player away with blocked_player_here when someone they blocked is in it, so quickJoin tries another.
+ * Every hello from quickJoin says isQuickJoin: true, so Zaisma knows the game joins players by itself.
+ *
+ * Players who walk away (docs/DECISIONS.md): clients send the text "ping" every 30 seconds or so (the
+ * room answers "pong"; a connection with no ping or message for about a minute is dropped), and
+ * {type: "here"} now and then while the player gives input but the game sends nothing. They send
+ * {type: "idle"} when the player didn't answer "Still there?", {type: "hidden"} and {type: "shown"} as
+ * the game is hidden and shown (where welcome's awayChecks.hiddenTimeoutSec says it counts), and
+ * {type: "back", joinData?, idleTimeoutSec?, idleCheckEnabled?} when the player returns. A player out
+ * of the match with their seat held gets {type: "away"}, and once the seat is no longer held, their
+ * connection closes with SEAT_GONE_CLOSE_CODE.
+ *
+ * Ping and the room's clock (docs/DECISIONS.md, "Rooms under lag"): the room sends {type: "probe",
+ * probeNumber, serverTimeMs, pingDurationMs} right after welcome and again once it's answered (so the
+ * client hears its first ping), every welcome.probeIntervalSec while
+ * the room ticks (null when it doesn't), and each time ROOM_TUNING.probeSentSizeBytes has gone out to
+ * the player. The client answers at once with {type: "probe_answer", probeNumber}. Answers aren't game
+ * messages: they don't count toward the 30 a second or the idle check. A probe left unanswered for
+ * ROOM_TUNING.probeAnswerTimeoutSec, or ROOM_TUNING.maximumUnansweredSentSizeBytes sent since the last
+ * answered one, closes the connection with NO_ANSWER_CLOSE_CODE.
+ *
+ * Bytes: after hello, a client may also send binary frames (room.sendBytes), each up to
+ * ROOM_LIMITS.maximumGameMessageSizeBytes and counted with its messages, for the game server's onBytes.
+ * Every binary frame the room sends starts with one byte, the length in UTF-8 bytes of the player ID
+ * they came from (0 for the game server), then that ID, then the bytes (bytesFrame).
+ *
+ * State sync (stateSyncEnabled): {type: "state", serverTimeMs, full} with the player's whole view, the
+ * first time and after their connection was backed up, then {type: "state", serverTimeMs, changes} with
+ * what changed since (StateChange, state-sync.ts). serverTimeMs is the room's clock as it was sent.
+ *
+ * Spectators (maximumSpectatorCount): a hello with isSpectator: true watches. A spectator's welcome says
+ * isSpectator: true, and they get the players, the state and every message sent to everyone, but they send
+ * nothing: only probe answers, and anything else gets spectator_cannot_send. welcome and every "room"
+ * message carry spectatorCount, and a "room" message goes out whenever it changes.
+ */
+export type ServerMessage = {
+    type: "welcome";
+    me: ShownPlayer;
+    isSpectator: boolean;
+    players: ListedPlayer[];
+    room: RoomSettings;
+    spectatorCount: number;
+    hostPlayerId: string | null;
+    awayChecks: AwayChecks;
+    endsAt: string | null;
+    probeIntervalSec: number | null;
+    protocolVersionNumber: number;
+} | {
+    type: "probe";
+    probeNumber: number;
+    serverTimeMs: number;
+    pingDurationMs: number | null;
+} | {
+    type: "ending";
+    endsAt: string;
+} | {
+    type: "version_update";
+    step: "coming" | "now";
+    versionId: string;
+    appliesAt: string;
+    isReloading: boolean;
+} | {
+    type: "players";
+    players: ListedPlayer[];
+    hostPlayerId: string | null;
+} | {
+    type: "away";
+    awayReason: Exclude<AwayReason, "lost">;
+    seatHoldDurationSec: number;
+} | {
+    type: "kicked";
+    message: string;
+    isKeptOut: boolean;
+} | {
+    type: "room";
+    room: RoomSettings;
+    spectatorCount: number;
+} | {
+    type: "move";
+    roomCode: string;
+} | {
+    type: "message";
+    data: unknown;
+    fromPlayerId: string | null;
+} | {
+    type: "state";
+    serverTimeMs: number;
+    full: unknown;
+} | {
+    type: "state";
+    serverTimeMs: number;
+    changes: StateChange[];
+} | {
+    type: "blocks";
+    playerIds: string[];
+} | {
+    type: "error";
+    code: RoomErrorCode;
+    message: string;
+    versionId?: string;
+} | {
+    type: "ended";
+    message: string;
+    endReason: EndReason;
+};
+/**
+ * Messages from a client to the room. A room ignores a type it doesn't know (it counts it, like any
+ * message), so a client may send newer ones.
+ */
+export type ClientMessage = {
+    type: "hello";
+    protocolVersionNumber: number;
+    pass: string;
+    joinData?: unknown;
+    room?: Partial<Pick<RoomSettings, "isListed" | "friendJoinsEnabled">> & RoomInfo;
+    idleTimeoutSec?: number;
+    idleCheckEnabled?: boolean;
+    isSpectator?: boolean;
+    isQuickJoin?: boolean;
+    avoidBlockedPlayers?: boolean;
+} | {
+    type: "message";
+    data: unknown;
+} | {
+    type: "room";
+    room: Partial<RoomSettings>;
+} | {
+    type: "kick";
+    playerId: string;
+    keepOut?: boolean;
+} | {
+    type: "block";
+    playerId: string;
+} | {
+    type: "unblock";
+    playerId: string;
+} | {
+    type: "probe_answer";
+    probeNumber: number;
+} | {
+    type: "here";
+} | {
+    type: "idle";
+} | {
+    type: "hidden";
+} | {
+    type: "shown";
+} | {
+    type: "back";
+    joinData?: unknown;
+    idleTimeoutSec?: number;
+    idleCheckEnabled?: boolean;
+};
+/**
+ * Why a match ended: the game ended it (room.end), its hosting paused, its game server stopped working,
+ * the game became unavailable, its kept room was deleted, or no players were left for its spectators.
+ */
+export type EndReason = "game" | "hosting_paused" | "game_server_stopped" | "game_unavailable" | "kept_room_deleted" | "no_players";
+export type RoomErrorCode = "room_full" | "room_closed" | "ended" | "too_big" | "too_fast" | "bad_message" | "bad_pass" | "no_hello" | "not_allowed" | "game_unavailable" | "busy" | "kept_out" | "refused" | "room_not_running" | "hosting_paused" | "account_needed" | "game_not_open_to_player" | "blocked_player_here" | "other_version" | "spectators_full" | "spectator_cannot_send" | "already_playing" | "bad_origin" | "send_queue_full";
+export declare const ERROR_TEXT: Record<RoomErrorCode, string>;
+/** What players are told when Zaisma ends a match at room.endsAt. */
+export declare 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.";
+/**
+ * isListed, isOpen, the players who have been in the room, the players kept out of it and a reserved
+ * room's setup data, saved with a sleeping room's state.
+ */
+export interface SavedRoom extends RoomSettings {
+    knownPlayerIds: string[];
+    setupData?: unknown;
+    keptOut?: Record<string, string>;
+    expected?: Record<string, Expected>;
+    held?: Record<string, Held>;
+    kept?: Record<string, AwayReason>;
+    /** Players whose connection dropped, with when their time to come back runs out (reconnectTimeoutSec). */
+    reconnecting?: Record<string, Reconnecting>;
+    lobbyRoomCode?: string;
+    /** Blocks between the room's players from their accounts, as pairs of player IDs. */
+    accountBlocks?: [string, string][];
+    /** Blocks players' games said they made, each the blocker's player ID and then the blocked one's. */
+    sessionBlocks?: [string, string][];
+    /** Friendships between the room's players, as pairs of player IDs. */
+    friendships?: [string, string][];
+    /** When Zaisma will end the match (room.endsAt), once it's set. */
+    endsAt?: string;
+    /** Kept (room.setKept): it sleeps with its state when everyone leaves, instead of going a day later. */
+    isKept?: boolean;
+}
+/** A seat held for a player out of the match: who, why they're out, and until when. */
+export interface Held {
+    player: Player;
+    reason: AwayReason;
+    untilMs: number;
+}
+/**
+ * A player whose connection dropped, still in the match: who, and when their time to come back runs out.
+ * Saved with the room, so a room that sleeps and wakes, which finds its players by their connections, keeps them.
+ */
+export interface Reconnecting {
+    player: Player;
+    untilMs: number;
+}
+/** When a room counts its players as away, or null when it doesn't: no input (idle), and the game hidden. */
+export interface AwayChecks {
+    idleTimeoutSec: number | null;
+    hiddenTimeoutSec: number | null;
+}
+/** A player another room is sending here: the join data it sent, where from, and until when their seat is held. */
+export interface Expected {
+    joinData: unknown;
+    fromRoomCode: string;
+    untilMs: number;
+}
+/** The idle check a player's game asked for, for idleCheck "client": its timeout, or none at all. */
+export interface ClientIdle {
+    idleTimeoutSec?: number;
+    idleCheckEnabled?: boolean;
+}
+/** How the room reaches players: a Durable Object's sockets, or a Node server's. */
+export interface Transport {
+    send(playerId: string, text: string): void;
+    /** A binary frame (bytesFrame). Without it, rooms can't send bytes. */
+    sendBytes?(playerId: string, frame: Uint8Array): void;
+    close(playerId: string, closeCode: number, reason: string): void;
+    /** Set up a reserved room, then send each of its players a "move" message. Without it, rooms can't reserve. */
+    reserve?(roomCode: string, start: RoomStart): void;
+    /**
+     * Ask another room of the game to take some players (its expect()), send each player it takes a
+     * "move" message, then hand the answer to this room's moved(). Without it, rooms can't move players.
+     */
+    moveTo?(roomCode: string, ask: Omit<MoveAsk, "fromRoomCode">): void;
+    /** This room's code, as room.roomCode. */
+    roomCode: string;
+    /** The game's database, as room.database. Without it, its calls fail with database_unavailable. */
+    database?: GameDatabase;
+    /** The game's secrets, as room.secrets. Without them, there are none. */
+    secrets?: Readonly<Record<string, string>>;
+    /** room.verifyReceipt, with Zaisma's keys and this game filled in. Without it, it throws, saying so. */
+    verifyReceipt?(receipt: string): Promise<ReceiptClaims>;
+    /** room.applyVersionUpdate(): switch to the version coming now. Without it (your own server), it does nothing. */
+    applyVersionUpdate?(): void;
+    /** Whether a player's connection holds ROOM_TUNING.backedUpSizeBytes or more not yet sent. Without it, the room judges by its probes. */
+    isBackedUp?(playerId: string): boolean;
+}
+/** room.secrets and server.secrets where a game has none. */
+export declare const NO_SECRETS: Readonly<Record<string, string>>;
+/** room.verifyReceipt and server.verifyReceipt where the runtime has no receipt keys. */
+export declare const NO_RECEIPT_CHECK: () => Promise<ReceiptClaims>;
+/**
+ * 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 declare function checkRoomData(given: unknown, maximumSizeBytes: number): {
+    isValid: true;
+    checkedData: unknown;
+} | {
+    isValid: false;
+};
+/**
+ * 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 declare function errorMessage(code: RoomErrorCode, message?: string, details?: {
+    versionId: string;
+}): string;
+/** Whether a player may come in, and if not, why. */
+export type Admission = {
+    isAllowed: true;
+} | {
+    isAllowed: false;
+    code: RoomErrorCode;
+    message?: string;
+};
+/** WebSocket close code for a match that ended normally. */
+export declare const ENDED_CLOSE_CODE = 4000;
+/** Close code for a player refused or removed by the room: the SDK doesn't reconnect. */
+export declare 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 declare const SEAT_GONE_CLOSE_CODE = 4002;
+/** Close code for a connection that stopped answering or fell too far behind; the SDK reconnects. */
+export declare 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 declare 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 declare 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 declare function bytesFrame(bytes: Uint8Array, fromPlayerId: string | null): Uint8Array;
+/**
+ * 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 declare const QUEUES_INPUT: unique symbol;
+/**
+ * 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 declare const PAIR_CHANGE_COUNT: unique symbol;
+/** 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 declare const RESERVE_WITH_ROOM_CODE: unique symbol;
+/**
+ * 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 declare const SYNCS_STATE: unique symbol;
+/**
+ * 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 declare const STATE_SYNC: unique symbol;
+/** What STATE_SYNC hands a game server that runs state sync itself. */
+export interface StateSyncHooks {
+    viewers(): {
+        backedUpPlayerIds: string[];
+        fullCopyPlayerIds: string[];
+    };
+    send(playerIds: unknown, frame: unknown): void;
+}
+/** Messages a room's traffic counts by type: their data.type, like "move", or one of these. */
+export declare const NO_MESSAGE_TYPE = "(none)";
+export declare const BYTES_MESSAGE_TYPE = "(bytes)";
+export declare const ZAISMA_MESSAGE_TYPE = "(zaisma)";
+export declare const OTHER_MESSAGE_TYPE = "(other)";
+/** State sync's updates (stateSyncEnabled). */
+export declare const STATE_MESSAGE_TYPE = "(state)";
+export type TrafficDirection = "inbound" | "outbound";
+/**
+ * One message type's traffic in one direction: how many, their bytes and the largest, and how many of
+ * those sent reliably went to a player whose connection was backed up (for the latest_only hint).
+ */
+export interface MessageTypeTraffic {
+    messageType: string;
+    direction: TrafficDirection;
+    messageCount: number;
+    sizeBytes: number;
+    largestSizeBytes: number;
+    backedUpMessageCount: number;
+}
+/**
+ * A room's traffic since it was last taken (takeTraffic): bytes in, messages and bytes out (each
+ * frame once per player it went to), and per message type. Messages in are RoomCore.messageCount.
+ */
+export interface RoomTraffic {
+    inboundSizeBytes: number;
+    outboundMessageCount: number;
+    outboundSizeBytes: number;
+    messageTypes: MessageTypeTraffic[];
+}
+/** No traffic yet. */
+export declare function noTraffic(): RoomTraffic;
+/** Two rooms' (or two hours') traffic added up, message types matched by type and direction. */
+export declare function addTraffic(first: RoomTraffic, second: RoomTraffic): RoomTraffic;
+export declare class RoomCore<S = any> {
+    state: S;
+    readonly players: Map<string, Player>;
+    /** Spectators watching (maximumSpectatorCount): never in players, never counted as playing. */
+    readonly spectators: Map<string, Player>;
+    ended: boolean;
+    /** When Zaisma will end this match (room.endsAt), or null. */
+    endsAt: string | null;
+    /** Messages received from clients, for usage counts. */
+    messageCount: number;
+    /** The rest of the room's traffic since takeTraffic, by "<direction> <type>". */
+    private traffic;
+    /** Goes up whenever a block or friendship between players may have changed (PAIR_CHANGE_COUNT). */
+    private pairChangeCount;
+    /** Set when the state changed and a sleeping room should save it. */
+    dirty: boolean;
+    /** A version published "now" this match is moving to, once the transport started it (startVersionUpdate). */
+    versionUpdate: {
+        versionId: string;
+        appliesAt: string;
+        isReloading: boolean;
+    } | null;
+    /** When a real-time room's state was last saved, set by the transport after each save; null until it has been. */
+    savedAtMs: number | null;
+    /** Hidden from room lists until its first player's hello asks for it (joinRoom's isListed, quickJoin), or a reserve does. */
+    isListed: boolean;
+    isOpen: boolean;
+    friendJoinsEnabled: boolean;
+    name: string | null;
+    labels: Record<string, string>;
+    /** Kept (room.setKept): the transport keeps its state when it empties. */
+    isKept: boolean;
+    /**
+     * 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: boolean;
+    /** Players who have been in this room, newest last: they may come back after it closes. */
+    readonly known: Set<string>;
+    /** Players kicked and kept out for the rest of the match, with the message they were given. */
+    readonly keptOut: Map<string, string>;
+    /** Players other rooms are sending here (room.moveTo), with a seat each until they arrive. */
+    readonly expected: Map<string, Expected>;
+    /** Seats held for players out of the match (walked away, or lost their connection) until they come back or it runs out. */
+    readonly held: Map<string, Held>;
+    /** Players who walked away that onAway kept in the room, and players whose connection dropped (lost), and why. */
+    readonly kept: Map<string, AwayReason>;
+    /** Players whose connection dropped (kept as "lost"): when their time to reconnect runs out. */
+    readonly reconnectUntilMs: Map<string, number>;
+    /** The room that made this one, where awayMode "lobby" sends players who walk away. */
+    lobbyRoomCode: string | null;
+    /** Blocks between players from their accounts (Zaisma's own record, or passes on your own server), either way: pairKey(first, second). */
+    private readonly accountBlocks;
+    /** Blocks players' games said they made, a guest's or one just made: blockKey(blocker, blocked). */
+    private readonly sessionBlocks;
+    /** Friendships between players from their accounts (Zaisma's own record, or passes on your own server): pairKey(first, second). */
+    private readonly friendships;
+    /** The blocks each player was last told of, so they're told again only when theirs change. */
+    private readonly toldBlocks;
+    /** When each player in the match was last heard from, when their game was hidden, and the idle check their game asked for. */
+    private presence;
+    /** Players this room is sending to its lobby for walking away, so onMoved doesn't hear of it. */
+    private sentAway;
+    /** What a reserved room started with, kept so a room that starts over starts the same way. */
+    private setupData;
+    /** When this room last reserved rooms, for the limit. */
+    private reservedAtMs;
+    private buckets;
+    /** Probes this room has sent, to every player: each probe's number. */
+    private probeCount;
+    /** What each player was last sent of the state (stateSyncEnabled), unless the game server runs state sync itself (SYNCS_STATE). */
+    private readonly stateTracker;
+    /** For a game server that runs state sync itself: players with a new connection, who need a full copy. */
+    private readonly fullCopyPlayerIds;
+    /** A turn-based room's players state sync skipped as backed up, who get a full copy once they catch up. */
+    private readonly stateSkippedPlayerIds;
+    /** Latest-only messages waiting for each backed-up player, by "<kind>:<latestKey>", least recently replaced first. */
+    private readonly latestSlots;
+    private readonly now;
+    readonly maximumPlayerCount: number;
+    readonly maximumSpectatorCount: number;
+    private readonly api;
+    /** The room as canJoin and stateView see it: reading works, and any call that changes or sends throws room_call_unavailable. */
+    private readonly canJoinRoom;
+    private readonly stateViewRoom;
+    readonly server: GameServer<S>;
+    private readonly 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.
+     */
+    private queue;
+    /** Handlers waiting in the queue, so ticks don't pile up behind a slow game server. */
+    private waitingCount;
+    /** Handlers running right now, and what waits for them to finish (a kicked player's onLeave). */
+    private depth;
+    private 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: GameServer<S>, transport: Transport, startOptions?: {
+        state?: S;
+        players?: Player[];
+        spectators?: Player[];
+        room?: SavedRoom;
+        start?: RoomStart;
+        presence?: Record<string, {
+            seenAtMs?: number;
+            clientIdle?: ClientIdle;
+        }>;
+        restoreInfo?: RestoreInfo;
+        lostPlayers?: Player[];
+        now?: () => number;
+    });
+    /**
+     * 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.
+     */
+    private restored;
+    /** What a sleeping room saves besides the game's state. */
+    get saved(): SavedRoom;
+    /** The blocks worth keeping while the room sleeps: those between players it still remembers. */
+    private savedBlocks;
+    /** Whether two players are friends, from their accounts as the later of them joined. */
+    areFriends(firstPlayerId: string, secondPlayerId: string): boolean;
+    /**
+     * 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: string, friendPlayerIds: readonly string[]): void;
+    /** Whether two players have a block between them, either way: from their accounts, or one a player's game said it made. */
+    hasBlockBetween(firstPlayerId: string, secondPlayerId: string): boolean;
+    /**
+     * 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: string, blockPlayerIds: readonly string[]): void;
+    /** The players in the room this one has a block with, either way. */
+    private blockedWith;
+    /** Tell each player the players in the room they have a block with, when that changed. */
+    private tellBlocks;
+    /** A player's game blocked a player in the room (a guest's block, or one just made), or took one back. */
+    private sessionBlock;
+    /** Players in the match who haven't walked away: what room lists and "playing now" count. */
+    get playingCount(): number;
+    /** Seats the room holds for players on their way (room.moveTo) or out of the match for now. */
+    get heldSeatCount(): number;
+    /** Resolves once every handler started so far has finished (at once for game servers that answer at once). */
+    settled(): Promise<void>;
+    get ticking(): boolean;
+    /** How many are watching. */
+    get spectatorCount(): number;
+    /**
+     * 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).
+     */
+    admit(player: Player, joinData?: unknown, admitOptions?: {
+        isSpectator?: boolean;
+    }): Promise<Admission>;
+    /** The game server's canJoin, then the room's rules again, since things may change while it decides. */
+    private ask;
+    /**
+     * 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).
+     */
+    private door;
+    /**
+     * 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.
+     */
+    private spectatorDoor;
+    /** 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: string): boolean;
+    /** The seat held for a player out of the match, if it hasn't run out. */
+    private holding;
+    /** The seat held for a player another room is sending, if it hasn't run out. */
+    private seat;
+    /** Seats held for players other rooms are sending and players out of the match, dropping those that ran out. */
+    private countHeldSeats;
+    /**
+     * 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.
+     */
+    expect(ask: MoveAsk): Promise<MoveAnswer>;
+    /**
+     * 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: Player, joinOptions?: {
+        isListed?: boolean;
+        friendJoinsEnabled?: boolean;
+        joinData?: unknown;
+        clientIdle?: ClientIdle;
+        isSpectator?: boolean;
+    } & RoomInfo): {
+        isAllowed: true;
+        isRejoin: boolean;
+    } | {
+        isAllowed: false;
+        code: RoomErrorCode;
+        message?: string;
+    };
+    /**
+     * 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.
+     */
+    private watch;
+    /** A spectator stops watching: gone at once, and the game hears it (onSpectatorLeave) once the handler running now is done. */
+    private stopWatching;
+    /**
+     * 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: string, reason?: "left" | "lost"): void;
+    /** Take a player out of the match, forgetting what the room knew about them while they were in. */
+    private out;
+    /** Hold a seat for a player out of the match, for the game's seatHoldDurationSec. */
+    private hold;
+    /** When this room counts a player as away (welcome's awayChecks), by the game's settings and what their game asked for. */
+    private checks;
+    /** Seconds without input before a player counts as idle, or null if nobody checks for them. */
+    private idleTimeoutSecFor;
+    /**
+     * 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.
+     */
+    private walkAway;
+    /** A player who walked away is back: kept in the room by onAway, or coming back to their held seat. */
+    private back;
+    /** A player kept away is playing again: the game hears it (onBack), and every player's list shows them playing. */
+    private cameBack;
+    /** Players whose time to reconnect ran out leave the match, with their seat held (onLeave, reason "lost"). */
+    private expireReconnects;
+    /** When the first player whose connection dropped runs out of time to reconnect, or null if nobody is reconnecting. */
+    nextReconnectDeadlineMs(): number | null;
+    /** Whether a player is in the match without a connection: dropped, and still within reconnectTimeoutSec. */
+    private isLost;
+    /**
+     * 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(): void;
+    /** A raw text message from a client. Returns an error code if it was refused. */
+    receive(playerId: string, text: string): RoomErrorCode | null;
+    /** Bytes from a client (a binary frame). Returns an error code if they were refused. */
+    receiveBytes(playerId: string, bytes: Uint8Array): RoomErrorCode | 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.
+     */
+    private receiveFromSpectator;
+    /**
+     * 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).
+     */
+    private input;
+    /** 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. */
+    private countTraffic;
+    /** The room's traffic since the last time it was taken, and start counting afresh. */
+    takeTraffic(): RoomTraffic;
+    /**
+     * 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(): string | 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.
+     */
+    private hostKick;
+    /** The host hides, shows, opens, closes, turns friends' Join on or off, names or labels the room, when the game server allows it. */
+    private hostChange;
+    private settings;
+    /** Change isListed, isOpen, friendJoinsEnabled, the name or labels, and tell everyone in the room. */
+    private settle;
+    /** Tell every player and spectator the room's settings and how many are watching. */
+    private tellRoom;
+    /** The players and the spectators: everyone the room tells what happens in it. */
+    private everyone;
+    /** Whether the room sends to this player: they're in the match, or watching. */
+    private isViewer;
+    /** Who a broadcast reaches (BroadcastOptions.audience, already checked). */
+    private audienceOf;
+    /**
+     * 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: boolean): void;
+    /** 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. */
+    private reserve;
+    /** Send players to another room of the game (room.moveTo). Mistakes in the game's call throw. */
+    private moveTo;
+    /** A call that needs the transport to offer it and the room to be going: otherwise it throws room_call_unavailable. */
+    private requireCall;
+    /**
+     * 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: string, answer: MoveAnswer, sent: Player[]): void;
+    /** Reserving rooms and moving players share one limit a minute. */
+    private limit;
+    /** Remove a player (room.kick). Their onLeave runs once the handler that kicked them is done. */
+    kick(playerId: string, kickOptions?: KickOptions): void;
+    /** Keep players out, newest last, up to as many as the room remembers. */
+    private keepOut;
+    /** Run now, or once the handler running now is done, so a handler never runs inside another. */
+    private soon;
+    private flush;
+    private remember;
+    tick(tickDurationSec: number): void;
+    /**
+     * 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(): void;
+    /** Whether anything waits for a player to catch up: latest-only messages, or a turn-based room's state. */
+    get isCatchingUp(): boolean;
+    /**
+     * 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: string): boolean;
+    /** The players who see the state: everyone in the match with a connection, and the spectators. */
+    private stateViewerIds;
+    /** Which viewers are backed up this round; a turn-based room remembers them, to send a full copy once they catch up. */
+    private backedUpViewers;
+    /** A round of state sync (stateSyncEnabled): each player's view, in full or what changed since their last. */
+    private syncState;
+    /** A round of state sync once the handler running now is done, for a room with no handler about to run. */
+    private syncSoon;
+    /** For a game server that runs state sync itself: who's backed up this round, and who needs a full copy (said once). */
+    private stateViewers;
+    /** A frame from a game server that runs state sync itself, checked like anything a game hands the room. */
+    private sendStateFrom;
+    /** Send a state frame to players in the match, with the room's clock, counted as state sync's traffic. */
+    private sendState;
+    /**
+     * 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.
+     */
+    private deliver;
+    /** A player's waiting latest-only messages, least recently replaced first. */
+    private sendLatest;
+    private sendOut;
+    /**
+     * 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: {
+        versionId: string;
+        appliesAt: string;
+        isReloading: boolean;
+    }, isHeld: boolean): void;
+    /** The switch is happening: every player hears it just before the room closes their connections. */
+    tellVersionUpdateNow(): void;
+    /**
+     * 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: string): void;
+    /** End the match: everyone hears message and why (endReason), and their connections close. */
+    end(message: string, endReason: EndReason): void;
+    /** The players as every player's game lists them, with why each isn't playing. */
+    private list;
+    /** Send a binary frame to some players, counting it like text: toward each one's backlog, and the room's traffic. */
+    private sendFrame;
+    private broadcastPlayers;
+    /**
+     * 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.
+     */
+    private sendEach;
+    /**
+     * 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.
+     */
+    private sendText;
+    /** Bytes that went out to a player, for the probes and the backlog. */
+    private sent;
+    /** Probe a player for their ping and a clock sample. Probes aren't counted as bytes sent, so a probe never sets off another. */
+    private probe;
+    /** A ticking room probes each player in the match, and each spectator, every ROOM_TUNING.probeIntervalSec, and drops those who stopped answering. */
+    private probeDue;
+    /** A player whose oldest unanswered probe is ROOM_TUNING.probeAnswerTimeoutSec old is dropped. */
+    private checkAnswers;
+    /** A probe answer: the player's ping moves a quarter of the way to this sample. False if it answers no probe of theirs. */
+    private answer;
+    /**
+     * 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.
+     */
+    private dropBehind;
+    /** Token bucket per player: a short burst is fine, a flood is dropped. */
+    private take;
+    /** 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. */
+    private keepAnswer;
+    /**
+     * 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).
+     */
+    private run;
+}
+/** Whether a handler's answer can be the state: a plain object (prototype Object.prototype or null) or an array. */
+export declare function isStateAnswer(given: unknown): boolean;
+/** The mistake of a handler answering something that isn't a state; the state stays as it was. */
+export declare function badHandlerAnswer(handlerName: string, answer: unknown): GameServerError;
+/** 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 declare function clientIdle(given: unknown): ClientIdle;
+/** A name and labels within the limits, with hidden characters dropped. Fields left out stay out. */
+export declare function tidyRoomInfo(nameAndLabels: RoomInfo): Partial<Pick<RoomSettings, "name" | "labels">>;