@zaisma/game-server 1.12.0 → 1.14.0

package/src/outside-players.js

@@ -0,0 +1,162 @@
+/**
+ * Players from outside Zaisma, for a game server on your own server: a game played anywhere but its Zaisma
+ * page (exported, on another site, wrapped for a store) has no Zaisma pass, so its game sends a playerToken
+ * instead (Zaisma.setUpOffZaisma) and your server says who that is with startServer's identifyPlayer. Such a
+ * player joins with kind "outside_zaisma", in the same rooms as players from the Zaisma page.
+ *
+ * signInWithZaismaPlayers makes an identifyPlayer for players signed in with Zaisma (Sign in with Zaisma's ID
+ * tokens): the same player ID and name as on Zaisma. guestPlayer is who a player with no token is, when
+ * startServer's outsideGuestsEnabled lets them in: a temporary ID and a generated name, like Zaisma's guests.
+ */
+import { guestName } from "./names.js";
+import { fromBase64Url } from "./pass.js";
+import { GameServerError, ROOM_LIMITS, tidyRoomInfo } from "./room.js";
+export const OUTSIDE_PLAYER_LIMITS = {
+    maximumIdCharacterCount: 100,
+    maximumSignInAppCount: 20,
+    /** How far an ID token's exp may be past, for clocks that differ a little. */
+    clockLeewaySec: 60,
+    /** How long the keys and profiles are kept before they're fetched again. */
+    keysKeptMs: 3600_000,
+    profileKeptMs: 300_000,
+    /** A refresh for a key ID it doesn't know waits this long after the last fetch, so made-up key IDs can't make it fetch on every token. */
+    minimumRefreshIntervalMs: 30_000,
+    maximumProfileCount: 10_000,
+};
+const RS256 = { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" };
+const SIGN_IN_APP_ID = /^sign_in_app_[a-z0-9]+$/;
+const decoder = new TextDecoder();
+const encoder = new TextEncoder();
+/** The ID token keys at <siteUrl>/.well-known/jwks.json, kept an hour; a fetch that fails keeps the keys already held. */
+function keysAt(jwksUrl) {
+    let kept = null;
+    let fetchedAtMs = 0;
+    return async (isRefreshing) => {
+        const nowMs = Date.now();
+        if (kept && !isRefreshing && nowMs - kept.fetchedAtMs < OUTSIDE_PLAYER_LIMITS.keysKeptMs)
+            return kept.keys;
+        if (kept && isRefreshing && nowMs - fetchedAtMs < OUTSIDE_PLAYER_LIMITS.minimumRefreshIntervalMs)
+            return kept.keys;
+        fetchedAtMs = nowMs;
+        try {
+            const response = await fetch(jwksUrl);
+            if (!response.ok)
+                throw new Error(`Couldn't load Zaisma's sign-in keys from ${jwksUrl}`);
+            kept = { keys: (await response.json()).keys, fetchedAtMs: nowMs };
+        }
+        catch (error) {
+            if (kept)
+                return kept.keys;
+            throw error;
+        }
+        return kept.keys;
+    };
+}
+/** Accounts' public profiles at Zaisma (https://rooms.zaisma.com/v1/players/<id>), each kept 5 minutes; null when no account has that ID. */
+function profilesAt(profilesUrl) {
+    const kept = new Map();
+    return async (playerId) => {
+        const found = kept.get(playerId);
+        if (found && Date.now() - found.fetchedAtMs < OUTSIDE_PLAYER_LIMITS.profileKeptMs)
+            return found.profile;
+        const response = await fetch(`${profilesUrl}/${encodeURIComponent(playerId)}`);
+        if (response.status !== 200 && response.status !== 404)
+            throw new Error(`Couldn't look up player ${playerId} at ${profilesUrl}`);
+        const profile = response.status === 200 ? (await response.json()).player : null;
+        if (kept.size > OUTSIDE_PLAYER_LIMITS.maximumProfileCount)
+            kept.clear();
+        kept.set(playerId, { profile, fetchedAtMs: Date.now() });
+        return profile;
+    };
+}
+/** A token's header and claims, unchecked, or null when it isn't a JWT. */
+function tokenParts(token) {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+        return null;
+    try {
+        const header = JSON.parse(decoder.decode(fromBase64Url(parts[0])));
+        const claims = JSON.parse(decoder.decode(fromBase64Url(parts[1])));
+        if (!header || typeof header !== "object" || !claims || typeof claims !== "object" || Array.isArray(claims))
+            return null;
+        return { header, claims, signature: fromBase64Url(parts[2]) };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * An identifyPlayer for players signed in with Zaisma: the game signs them in with Sign in with Zaisma and
+ * sends the ID token as its playerToken. The token is checked like any OpenID Connect ID token: RS256 only,
+ * signed by Zaisma's published key, its iss the siteUrl, its aud one of signInAppIds, not expired. The player
+ * is { id, name }: the account's Zaisma player ID, the same as on Zaisma, and its name from the token (or its
+ * public profile when the token has none). Answers null for any token that doesn't check out, and for an
+ * account deleted since; throws only when Zaisma's keys or profiles can't be reached (the runner answers busy).
+ *
+ *   startServer({ gameServer, gameSlug, identifyPlayer: signInWithZaismaPlayers({ signInAppIds: ["sign_in_app_8f3k2m"] }) });
+ */
+export function signInWithZaismaPlayers(options) {
+    const fields = ["signInAppIds", "siteUrl", "loadKeys", "loadProfile"];
+    if (!options || typeof options !== "object")
+        throw new GameServerError("bad_option", "options", "signInWithZaismaPlayers takes one object of options.", 'Call signInWithZaismaPlayers({ signInAppIds: ["sign_in_app_…"] }).');
+    for (const field of Object.keys(options)) {
+        if (!fields.includes(field))
+            throw new GameServerError("unknown_option", field, `${field} isn't a signInWithZaismaPlayers option.`, `signInWithZaismaPlayers takes: ${fields.join(", ")}.`);
+    }
+    const { signInAppIds, siteUrl = "https://zaisma.com" } = options;
+    if (!Array.isArray(signInAppIds) || signInAppIds.length < 1 || signInAppIds.length > OUTSIDE_PLAYER_LIMITS.maximumSignInAppCount || !signInAppIds.every((id) => typeof id === "string" && SIGN_IN_APP_ID.test(id))) {
+        throw new GameServerError("bad_option", "signInAppIds", "signInAppIds isn't a list of sign-in app IDs.", `Give 1 to ${OUTSIDE_PLAYER_LIMITS.maximumSignInAppCount} of your sign-in apps' IDs, like ["sign_in_app_8f3k2m"] (list_sign_in_apps shows them).`);
+    }
+    if (typeof siteUrl !== "string" || !URL.canParse(siteUrl))
+        throw new GameServerError("bad_option", "siteUrl", "siteUrl isn't a URL.", 'Give where Sign in with Zaisma runs, like "https://zaisma.com".');
+    for (const field of ["loadKeys", "loadProfile"]) {
+        if (options[field] !== undefined && typeof options[field] !== "function")
+            throw new GameServerError("bad_option", field, `${field} isn't a function.`, field === "loadKeys" ? "Give async (isRefreshing) => the keys, as a list." : "Give async (playerId) => { name } or null.");
+    }
+    const loadKeys = options.loadKeys ?? keysAt(`${siteUrl}/.well-known/jwks.json`);
+    const loadProfile = options.loadProfile ?? profilesAt("https://rooms.zaisma.com/v1/players");
+    return async (playerToken) => {
+        const parts = typeof playerToken === "string" ? tokenParts(playerToken) : null;
+        // An ID token, never an access token (at+jwt) or a token signed any other way.
+        if (!parts || parts.header.alg !== "RS256" || parts.header.typ !== "JWT" || typeof parts.header.kid !== "string")
+            return null;
+        const { header, claims } = parts;
+        const nowSec = Math.floor(Date.now() / 1000);
+        if (claims.iss !== siteUrl || typeof claims.aud !== "string" || !signInAppIds.includes(claims.aud))
+            return null;
+        if (typeof claims.exp !== "number" || claims.exp + OUTSIDE_PLAYER_LIMITS.clockLeewaySec <= nowSec)
+            return null;
+        if (typeof claims.sub !== "string" || !claims.sub || claims.sub.length > OUTSIDE_PLAYER_LIMITS.maximumIdCharacterCount)
+            return null;
+        // A key published since the keys were fetched: fetched again once.
+        let jwk = (await loadKeys(false)).find((key) => key.kid === header.kid);
+        if (!jwk)
+            jwk = (await loadKeys(true)).find((key) => key.kid === header.kid);
+        if (!jwk || jwk.kty !== "RSA" || !jwk.n || !jwk.e)
+            return null;
+        const key = await crypto.subtle.importKey("jwk", { kty: "RSA", n: jwk.n, e: jwk.e }, RS256, false, ["verify"]);
+        const [signedHeader, signedClaims] = playerToken.split(".");
+        if (!(await crypto.subtle.verify(RS256, key, parts.signature, encoder.encode(`${signedHeader}.${signedClaims}`))))
+            return null;
+        // A token without the profile scope carries no name: the account's public one. A deleted account has none, and plays no more.
+        const name = typeof claims.name === "string" && claims.name ? claims.name : ((await loadProfile(claims.sub))?.name ?? null);
+        return name ? { id: claims.sub, name } : null;
+    };
+}
+/** A player with no token, when startServer's outsideGuestsEnabled lets them in: a temporary player ID and a generated name, as Zaisma's guests have. */
+export function guestPlayer() {
+    const randomPart = Array.from(crypto.getRandomValues(new Uint8Array(12)), (byte) => byte.toString(36).padStart(2, "0")).join("").slice(0, 20);
+    return { id: `player_${randomPart}`, name: guestName() };
+}
+/** What identifyPlayer answered, checked for the runner: the player, with their name tidied, or what was wrong with it. */
+export function checkedOutsidePlayer(given) {
+    if (!given || typeof given !== "object" || Array.isArray(given))
+        return { mistake: "identifyPlayer answered something other than { id, name } or null." };
+    const { id, name } = given;
+    if (typeof id !== "string" || !id || id.length > OUTSIDE_PLAYER_LIMITS.maximumIdCharacterCount)
+        return { mistake: `identifyPlayer's id isn't text of 1 to ${OUTSIDE_PLAYER_LIMITS.maximumIdCharacterCount} characters.` };
+    const tidied = typeof name === "string" ? tidyRoomInfo({ name }).name : null;
+    if (typeof name !== "string" || !tidied || name.trim().length > ROOM_LIMITS.maximumNameCharacterCount)
+        return { mistake: `identifyPlayer's name isn't text of 1 to ${ROOM_LIMITS.maximumNameCharacterCount} characters.` };
+    return { player: { id, name: tidied } };
+}

package/src/pass.d.ts

@@ -62,8 +62,12 @@ export interface PassClaims {
     iat: number;
     exp: number;
 }
-/** A signed-in Zaisma account, or a guest. */
-export type PlayerKind = "guest" | "account";
+/**
+ * A signed-in Zaisma account, a guest, or a player from outside Zaisma (outside_zaisma): one your own server let
+ * in without a Zaisma pass, by its identifyPlayer (signed in with Zaisma, or your game's own accounts) or as a
+ * guest from elsewhere (outsideGuestsEnabled). Zaisma's rooms and passes never give outside_zaisma.
+ */
+export type PlayerKind = "guest" | "account" | "outside_zaisma";
 /** No chat, friends only, or anyone in the same chat group: the player's "Who can chat with you" setting (docs/DECISIONS.md, "Social settings, with the social modes as presets"). */
 export type WhoCanChat = "nobody" | "friends" | "anyone";
 /** A pass's JWS header typ (RFC 8725 explicit typing): verifyPass refuses any other token (wrong_kind). */
@@ -117,6 +121,7 @@ export declare const RECEIPT_TOKEN_TYPE = "receipt+jwt";
 export declare const RECEIPT_ISSUER_URL = "https://rooms.zaisma.com/receipts";
 /** The receipt contract this copy reads: verifyReceipt refuses any other receipt_version_number (wrong_version). */
 export declare const RECEIPT_VERSION_NUMBER = 1;
+export declare function fromBase64Url(text: string): Uint8Array<ArrayBuffer>;
 /** Make a new signing key, as a JWK string for a signing secret (the rooms Worker's PASS_SIGNING_KEY and RECEIPT_SIGNING_KEY). */
 export declare function generateSigningKey(): Promise<string>;
 export interface SigningKey {

package/src/pass.js

@@ -96,7 +96,7 @@ function toBase64Url(bytes) {
         binary += String.fromCharCode(byte);
     return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
-function fromBase64Url(text) {
+export function fromBase64Url(text) {
     const binary = atob(text.replace(/-/g, "+").replace(/_/g, "/"));
     return Uint8Array.from(binary, (character) => character.charCodeAt(0));
 }

package/src/requests.d.ts

@@ -11,10 +11,11 @@
  */
 import type { GameDatabase } from "./database.ts";
 import type { ReceiptClaims } from "./pass.ts";
-import type { Player } from "./room.ts";
+import type { KickOptions, LiveRoom, Player, RoomPlayer, RoomSelection } from "./room.ts";
 /**
  * What onRequest, onSchedule and onWebhook reach besides what they're given: the game's own database, the
- * same one its rooms use, its secrets, and receipt checks.
+ * same one its rooms use, its secrets, receipt checks, and the game's live rooms. Room messages sent from here
+ * reach rooms with senderKind "server"; on your own server they reach the Node runner's own rooms.
  */
 export interface Server {
     database: GameDatabase;
@@ -25,6 +26,31 @@ export interface Server {
     secrets: Readonly<Record<string, string>>;
     /** Check a purchase's receipt, as room.verifyReceipt does: the runtime fills in Zaisma's keys and this game. */
     verifyReceipt(receipt: string): Promise<ReceiptClaims>;
+    /** Send a message to one of the game's live rooms by its code, as room.sendToRoom does. isDelivered is false when no such room is running or it's busy. */
+    sendToRoom(roomCode: string, message: unknown): Promise<{
+        isDelivered: boolean;
+    }>;
+    /** Send a message to every live room of the game with someone in it, or those holding every label given, as room.sendToEveryRoom does. */
+    sendToEveryRoom(message: unknown, roomSelection?: RoomSelection): Promise<{
+        roomCount: number;
+    }>;
+    /** The game's live rooms, or those holding every label given, newest first, up to 500. */
+    listRooms(roomSelection?: RoomSelection): Promise<{
+        rooms: LiveRoom[];
+    }>;
+    /** One live room and who's in it, players then spectators, or null when no such room is running. */
+    getRoom(roomCode: string): Promise<{
+        room: LiveRoom;
+        players: RoomPlayer[];
+    } | null>;
+    /** Remove a player from a live room, as room.kick does there: its onLeave hears reason "kicked". isDone is false when the room or the player isn't there. */
+    kickFromRoom(roomCode: string, playerId: string, kickOptions?: KickOptions): Promise<{
+        isDone: boolean;
+    }>;
+    /** End a live room's match, as room.end does there: its players hear message. isDone is false when no such room is running. */
+    endRoom(roomCode: string, message?: string): Promise<{
+        isDone: boolean;
+    }>;
 }
 export declare const REQUEST_LIMITS: {
     /** A request, as JSON. */
@@ -34,12 +60,14 @@ export declare const REQUEST_LIMITS: {
      * items with 40-character names, 200 friends and 100 blocks) is about 70 KB, with room to spare.
      */
     readonly maximumPassSizeBytes: number;
+    /** A game played off Zaisma sends a playerToken in place of a pass (Zaisma.setUpOffZaisma), to a game server on your own server. */
+    readonly maximumPlayerTokenSizeBytes: number;
     /** What onRequest answers, as JSON. */
     readonly maximumAnswerSizeBytes: number;
     /** How long onRequest may take, awaiting the database included, before the request fails. */
     readonly answerTimeoutSec: 10;
 };
-export type RequestErrorCode = "bad_request" | "too_big" | "bad_pass" | "account_needed" | "game_not_open_to_player" | "game_unavailable" | "no_request_handler" | "game_server_error" | "hosting_paused" | "slow_down" | "bad_origin" | "busy";
+export type RequestErrorCode = "bad_request" | "too_big" | "bad_pass" | "bad_player_token" | "account_needed" | "game_not_open_to_player" | "game_unavailable" | "no_request_handler" | "game_server_error" | "hosting_paused" | "slow_down" | "bad_origin" | "busy";
 export declare const REQUEST_ERROR_TEXT: Record<RequestErrorCode, string>;
 /** The HTTP status each request error answers with. */
 export declare const REQUEST_ERROR_HTTP_STATUS: Record<RequestErrorCode, number>;
@@ -52,7 +80,9 @@ export declare function requestError(code: RequestErrorCode, message?: string):
 };
 /**
  * Read what a game sent: its pass and its request, plain JSON within REQUEST_LIMITS.maximumRequestSizeBytes
- * (nothing is null). The pass's own size doesn't count.
+ * (nothing is null). The pass's own size doesn't count. A game server on its developer's own server
+ * (isPlayerTokenTaken) also takes { playerToken, request } from a game played off Zaisma: its token as text,
+ * or null for a guest. Zaisma's rooms never do.
  */
 export declare function readRequestBody(text: string): {
     pass: string;
@@ -60,6 +90,17 @@ export declare function readRequestBody(text: string): {
 } | {
     code: "bad_request" | "too_big";
 };
+export declare function readRequestBody(text: string, isPlayerTokenTaken: boolean): {
+    pass: string;
+    request: unknown;
+} | {
+    playerToken: string | null;
+    request: unknown;
+} | {
+    code: "bad_request" | "too_big";
+};
+/** A playerToken as a game off Zaisma sends it: text up to REQUEST_LIMITS.maximumPlayerTokenSizeBytes, or null for a guest. */
+export declare function isPlayerToken(given: unknown): given is string | null;
 /**
  * What onRequest answered, as the game gets it: plain JSON (nothing is null), within
  * REQUEST_LIMITS.maximumAnswerSizeBytes, or a mistake for the game server's errors.

package/src/requests.js

@@ -17,6 +17,8 @@ export const REQUEST_LIMITS = {
      * items with 40-character names, 200 friends and 100 blocks) is about 70 KB, with room to spare.
      */
     maximumPassSizeBytes: 96 * 1024,
+    /** A game played off Zaisma sends a playerToken in place of a pass (Zaisma.setUpOffZaisma), to a game server on your own server. */
+    maximumPlayerTokenSizeBytes: 8 * 1024,
     /** What onRequest answers, as JSON. */
     maximumAnswerSizeBytes: 1024 * 1024,
     /** How long onRequest may take, awaiting the database included, before the request fails. */
@@ -26,6 +28,7 @@ export const REQUEST_ERROR_TEXT = {
     bad_request: "Requests are JSON with the player's pass and the game's request: { pass, request }.",
     too_big: `Requests are up to ${REQUEST_LIMITS.maximumRequestSizeBytes / 1024} KB.`,
     bad_pass: "Your player pass isn't valid for this game.",
+    bad_player_token: "This server doesn't know this player. Sign in again.",
     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.",
     game_unavailable: "This game isn't available right now.",
@@ -41,6 +44,7 @@ export const REQUEST_ERROR_HTTP_STATUS = {
     bad_request: 400,
     too_big: 413,
     bad_pass: 401,
+    bad_player_token: 401,
     account_needed: 403,
     game_not_open_to_player: 403,
     game_unavailable: 404,
@@ -55,11 +59,7 @@ export const REQUEST_ERROR_HTTP_STATUS = {
 export function requestError(code, message) {
     return { error: { code, message: message || REQUEST_ERROR_TEXT[code] } };
 }
-/**
- * Read what a game sent: its pass and its request, plain JSON within REQUEST_LIMITS.maximumRequestSizeBytes
- * (nothing is null). The pass's own size doesn't count.
- */
-export function readRequestBody(text) {
+export function readRequestBody(text, isPlayerTokenTaken = false) {
     let body;
     try {
         body = JSON.parse(text);
@@ -69,13 +69,20 @@ export function readRequestBody(text) {
     }
     if (!body || typeof body !== "object" || Array.isArray(body))
         return { code: "bad_request" };
-    const { pass, request } = body;
-    if (typeof pass !== "string" || pass.length > REQUEST_LIMITS.maximumPassSizeBytes)
+    const { pass, playerToken, request } = body;
+    const isOutside = isPlayerTokenTaken && pass === undefined && isPlayerToken(playerToken);
+    if (!isOutside && (typeof pass !== "string" || pass.length > REQUEST_LIMITS.maximumPassSizeBytes))
         return { code: "bad_request" };
     const requestText = request === undefined ? "null" : JSON.stringify(request);
     if (new TextEncoder().encode(requestText).length > REQUEST_LIMITS.maximumRequestSizeBytes)
         return { code: "too_big" };
-    return { pass, request: request === undefined ? null : request };
+    if (isOutside)
+        return { playerToken: playerToken, request: request === undefined ? null : request };
+    return { pass: pass, request: request === undefined ? null : request };
+}
+/** A playerToken as a game off Zaisma sends it: text up to REQUEST_LIMITS.maximumPlayerTokenSizeBytes, or null for a guest. */
+export function isPlayerToken(given) {
+    return given === null || (typeof given === "string" && given.length > 0 && new TextEncoder().encode(given).length <= REQUEST_LIMITS.maximumPlayerTokenSizeBytes);
 }
 /**
  * What onRequest answered, as the game gets it: plain JSON (nothing is null), within

package/src/room-calls.d.ts

@@ -8,6 +8,8 @@ export interface RoomCallLimits {
     maximumLabelNameCharacterCount: number;
     maximumLabelValueCharacterCount: number;
     maximumLabelCount: number;
+    /** A room message (room.sendToRoom, room.sendToEveryRoom) as JSON: ROOM_MESSAGE_LIMITS has it. */
+    maximumRoomMessageSizeBytes: number;
 }
 /** The error a mistake in a room call throws: GameServerError, or the sandbox's copy of it. */
 export type RoomCallErrorClass = new (code: "bad_room_call" | "room_call_unavailable", field: string, message: string, fix: string) => Error;
@@ -65,6 +67,20 @@ export interface RoomCallChecks {
         labels?: Record<string, string>;
     };
     checkEnd(message: unknown): string | undefined;
+    /** room.sendToRoom: another room's code (never this room's) and the message as plain JSON within the size, copied. */
+    checkSendToRoom(toRoomCode: unknown, message: unknown, ownRoomCode: string | null, call: string): {
+        toRoomCode: string;
+        message: unknown;
+    };
+    /** room.sendToEveryRoom: the message as plain JSON within the size, copied, and which rooms (checkRoomSelection). */
+    checkSendToEveryRoom(message: unknown, roomSelection: unknown, call: string): {
+        message: unknown;
+        labels: Record<string, string> | null;
+    };
+    /** Which rooms a call means: those holding every label given (tidied as room.setInfo tidies them), or null for every room. */
+    checkRoomSelection(roomSelection: unknown, call: string): {
+        labels: Record<string, string> | null;
+    };
     /** Text with hidden characters dropped, spaces collapsed, cut to the length. */
     tidy(given: unknown, maximumCharacterCount: number): string;
     /** A name and labels within the limits, with hidden characters dropped. Fields left out stay out. */

package/src/room-calls.js

@@ -177,7 +177,37 @@ function roomCallChecksParts() {
                 throw mistake("room.end", "room.end's message must be text.", "Give the text players see, or leave it out.");
             return message.slice(0, limits.maximumKickMessageCharacterCount);
         };
-        return { checkBroadcast, checkSend, checkBroadcastBytes, checkSendBytes, checkKick, checkReserve, checkMoveTo, checkSetInfo, checkEnd, tidy, tidyRoomInfo, checkRoomData };
+        const readRoomMessage = (message, call) => {
+            if (message === undefined || message === null)
+                throw mistake(call, `${call} needs a message.`, "Give the message as plain JSON, like { kind: \"blood_moon\" }.");
+            const checked = checkRoomData(message, limits.maximumRoomMessageSizeBytes);
+            if (!checked.isValid)
+                throw mistake(call, `${call}'s message isn't plain JSON up to ${limits.maximumRoomMessageSizeBytes / 1024} KB.`, "Give numbers, text, true or false, lists and plain objects, and keep it small.");
+            return checked.checkedData;
+        };
+        const checkRoomSelection = (roomSelection, call) => {
+            const given = closed(roomSelection, ["labels"], call);
+            if (given.labels === undefined || given.labels === null)
+                return { labels: null };
+            if (typeof given.labels !== "object" || Array.isArray(given.labels) || Object.keys(given.labels).length > limits.maximumLabelCount) {
+                throw mistake(call, `${call}'s labels must be an object of up to ${limits.maximumLabelCount} labels.`, 'Give the labels the rooms hold, like { Map: "Docks" }, or leave labels out for every room.');
+            }
+            for (const labelValue of Object.values(given.labels)) {
+                if (typeof labelValue !== "string")
+                    throw mistake(call, `${call}'s labels must each be text.`, 'Give each label as text, like { Map: "Docks" }.');
+            }
+            const labels = tidyRoomInfo({ labels: given.labels }).labels ?? {};
+            return { labels: Object.keys(labels).length ? labels : null };
+        };
+        const checkSendToRoom = (toRoomCode, message, ownRoomCode, call) => {
+            if (typeof toRoomCode !== "string" || !ROOM_CODE.test(toRoomCode))
+                throw mistake(call, `${call} needs a room code.`, "Give the code of a live room of this game, like one listRooms answered.");
+            if (toRoomCode === ownRoomCode)
+                throw mistake(call, `${call} was given this room's own code.`, "Handle the message here, in this room's own handler; send to other rooms by their codes.");
+            return { toRoomCode, message: readRoomMessage(message, call) };
+        };
+        const checkSendToEveryRoom = (message, roomSelection, call) => ({ message: readRoomMessage(message, call), ...checkRoomSelection(roomSelection, call) });
+        return { checkBroadcast, checkSend, checkBroadcastBytes, checkSendBytes, checkKick, checkReserve, checkMoveTo, checkSetInfo, checkEnd, checkSendToRoom, checkSendToEveryRoom, checkRoomSelection, tidy, tidyRoomInfo, checkRoomData };
     }
     return { checksFor };
 }