@zaisma/game-server 1.5.0 → 1.7.0

package/bin/local-play.js

@@ -1215,6 +1215,12 @@ export async function startLocalPlay(givenOptions) {
         }
         return notLocal();
       }
+      // Zaisma's chat check, as the runner's rooms ask it for room.chat (checkChat): the bench lets every message through,
+      // nothing flagged, the way /v1/filter stands in below. Zaisma's own filter runs once the game is on Zaisma.
+      if (request.method === "POST" && path === "/v1/chat/check") {
+        await readBody();
+        return reply(200, { isAllowed: true, reason: null, message: null, hasSwearing: false, hasSlur: false });
+      }
       if (request.method === "POST" && ["/v1/pass", "/v1/rooms", "/v1/report", "/v1/filter", "/v1/friends", "/v1/friends/room", "/v1/items/unhandled", "/v1/items/handled"].includes(path)) {
         if (!isGameOrigin(origin)) return fail(403, "bad_origin", "Not allowed from here.");
         const body = await readBody();
@@ -1225,7 +1231,7 @@ export async function startLocalPlay(givenOptions) {
           return reply(200, await passFor(given.as, given.playerNumber));
         }
         if (path === "/v1/rooms") return reply(200, { roomCode: roomCode() });
-        if (path === "/v1/filter") return reply(200, { isAllowed: true, reason: null, message: null, hasSwearing: false, text: String(body.text ?? ""), is_stand_in: true });
+        if (path === "/v1/filter") return reply(200, { isAllowed: true, reason: null, message: null, hasSwearing: false, hasSlur: false, text: String(body.text ?? ""), is_stand_in: true });
         if (path === "/v1/report") {
           log(`Report (not sent anywhere): ${JSON.stringify({ roomCode: body.roomCode, playerId: body.playerId, playerName: body.playerName, reason: body.reason, details: body.details })}`);
           return reply(200, { isReported: true });

package/bin/node.js

@@ -22,7 +22,7 @@ import { createServer } from "node:http";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { resolve } from "node:path";
 import { realpathSync } from "node:fs";
-import { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, ERROR_TEXT, NO_ANSWER_CLOSE_CODE, PASS_ISSUER_URL, PassError, ReceiptError, REMOVED_CLOSE_CODE, REQUEST_ERROR_HTTP_STATUS, REQUEST_LIMITS, ROOM_LIMITS, ROOM_TUNING, WEBHOOK_LIMITS, GameServerError, RoomCore, restoreInfoOf, passesAreFriends, passesHaveBlockBetween, answerRequest, startSchedules, checkRoomData, clientIdle, defineGameServer, errorMessage, isRoomCode, readRequestBody, relay, requestError, runWebhook, tidyRoomInfo, verifyPass, verifyReceipt, verifyWebhook } from "../src/internal.js";
+import { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, ERROR_TEXT, NO_ANSWER_CLOSE_CODE, PASS_ISSUER_URL, PassError, ReceiptError, REMOVED_CLOSE_CODE, REQUEST_ERROR_HTTP_STATUS, REQUEST_LIMITS, ROOM_LIMITS, ROOM_TUNING, WEBHOOK_LIMITS, GameServerError, RoomCore, chatSettingsOf, checkChat, readChatMessage, restoreInfoOf, passesAreFriends, passesHaveBlockBetween, answerRequest, startSchedules, checkRoomData, clientIdle, defineGameServer, errorMessage, isRoomCode, readRequestBody, relay, requestError, runWebhook, tidyRoomInfo, verifyPass, verifyReceipt, verifyWebhook } from "../src/internal.js";
 import { OutsideCallError } from "../src/outside-calls.js";
 import { checkedStartServerOptions, localDatabase, localRoomStates, passKeysFrom, profilesFrom, receiptKeysFrom, secretsFromEnvironment } from "./node-parts.js";
 
@@ -290,10 +290,11 @@ export function startServer(options) {
       saved ? { state: saved.state, room: saved.savedRoom, ...(definition.ticksPerSec || saved.matchPlayers?.length ? { restoreInfo: restoreInfoOf(saved.savedAtMs, Date.now(), null, saved.isSavedEmpty), lostPlayers: saved.matchPlayers } : {}) } : { start },
     );
     if (saved) core.savedAtMs = saved.savedAtMs;
-    // passes: each player's checked pass, newest, for the blocks and friendships between them (passesHaveBlockBetween, passesAreFriends).
+    // passes: each player's checked pass, newest, for the blocks and friendships between them (passesHaveBlockBetween, passesAreFriends);
+    // passTexts: the same passes as the players sent them, for Zaisma's chat filter (checkChat).
     // savedStateKey: what the room last saved (its state and its match's players), so an unchanged one isn't written again.
     // seatedAtMs: when each player came into this room on their own, for the game's one-room rule (the oldest seat closes first).
-    room = { core, sockets, passes: new Map(), seatedAtMs: new Map(), timer: null, probeTimer: null, waiting: false, savedStateKey: saved ? stateKeyOf(saved.stateJson, saved.matchPlayers, saved.savedRoom.isKept === true) : null, hasReportedStateSize: false };
+    room = { core, sockets, passes: new Map(), passTexts: new Map(), seatedAtMs: new Map(), timer: null, probeTimer: null, waiting: false, savedStateKey: saved ? stateKeyOf(saved.stateJson, saved.matchPlayers, saved.savedRoom.isKept === true) : null, hasReportedStateSize: false };
     rooms.set(code, room);
     return room;
   }
@@ -402,6 +403,24 @@ export function startServer(options) {
     }
   }
 
+  /**
+   * A player's chat message (room.chat): the room checks it and asks the game server's onChat (startChat),
+   * Zaisma's filter looks (checkChat, with the passes of those who may read it), and it goes to them
+   * (deliverChat) or the sender hears why not (stopChat). Everyone it may reach is in the sender's chat
+   * group, so the first CHAT_CHECK_LIMITS.maximumReceiverCount of them stand for the rest.
+   */
+  async function chatIn(room, playerId, chat) {
+    const started = await room.core.startChat(playerId, chat);
+    if (!started) return;
+    let check = { isAllowed: true, reason: null, message: null, hasSwearing: false, hasSlur: false };
+    if (started.receiverPlayerIds.length) {
+      const receiverPasses = started.receiverPlayerIds.map((id) => room.passTexts.get(id)).filter((pass) => typeof pass === "string");
+      check = await checkChat({ text: started.text, senderPass: room.passTexts.get(playerId) ?? "", receiverPasses, isAdultFilterEnabled: definition.adultChatFilterEnabled === true });
+    }
+    if (check.isAllowed) room.core.deliverChat(playerId, chat.chatNumber, started.receiverPlayerIds, { text: started.text, hasSwearing: check.hasSwearing, hasSlur: check.hasSlur });
+    else room.core.stopChat(playerId, chat.chatNumber, check.reason ?? "unchecked", check.message ?? "");
+  }
+
   /** Keep a room for players on their way, even if it empties meanwhile. */
   function wait(code, room, durationMs) {
     room.waiting = true;
@@ -489,6 +508,9 @@ export function startServer(options) {
       if (text === "ping") return ws.send("pong");
       if (playerId) {
         const room = rooms.get(code);
+        // Chat goes through Zaisma's filter (checkChat) on its way, so the room takes it before the game's messages.
+        const chat = text === null ? null : readChatMessage(text);
+        if (chat && room) return chatIn(room, playerId, chat);
         // Bytes (a binary frame) go to the game server's onBytes, under the same limits as messages.
         const errorCode = text === null ? room?.core.receiveBytes(playerId, binaryBytes(received)) : room?.core.receive(playerId, text);
         if (errorCode) ws.send(errorMessage(errorCode));
@@ -537,9 +559,16 @@ export function startServer(options) {
       room.sockets.set(player.id, ws);
       // Blocks between accounts come in their passes: this player's and those of everyone the room remembers.
       // Spectators send nothing, so nothing of theirs reaches a player to block.
+      // Who the player may chat with, from their pass: the room keeps it, and the game never sees it. Spectators send nothing, chat included.
+      room.core.setChatSettings(player.id, isSpectator ? null : chatSettingsOf(claims));
       if (!isSpectator) {
         room.passes.set(player.id, claims);
-        for (const id of room.passes.keys()) if (!room.core.known.has(id) && id !== player.id) room.passes.delete(id);
+        room.passTexts.set(player.id, pass);
+        for (const id of room.passes.keys()) {
+          if (room.core.known.has(id) || id === player.id) continue;
+          room.passes.delete(id);
+          room.passTexts.delete(id);
+        }
         room.core.setAccountBlocks(player.id, [...room.passes].filter(([id, other]) => id !== player.id && passesHaveBlockBetween(claims, other)).map(([id]) => id));
         room.core.setFriends(player.id, [...room.passes].filter(([id, other]) => id !== player.id && passesAreFriends(claims, other)).map(([id]) => id));
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zaisma/game-server",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "Run your Zaisma game server: the same rooms on Zaisma or on your own server.",
   "license": "MIT",
   "homepage": "https://zaisma.com",

package/sdk/zaisma.d.ts

@@ -51,8 +51,9 @@ declare namespace Zaisma {
     /**
      * This tab's player, with their player pass: the signed-in Zaisma account, with the same player ID in
      * every game, or a guest. joinRoom gets one by itself; call this to let the player into a server of
-     * your own. Kept for the tab, so a guest who reloads stays the same guest, and renewed when it has
-     * under 10 minutes left or the player signed in or out. Fails with error.code "unchecked" when the
+     * your own. A guest's is kept for the tab, so a guest who reloads stays the same guest, and renewed when
+     * it has under 10 minutes left or the player signs in; an account gets a new one each time the game
+     * loads, for whoever is signed in then. Fails with error.code "unchecked" when the
      * game isn't played on its zaisma.com page, "not_on_zaisma" when it isn't hosted on Zaisma, and
      * "account_needed" for a guest when the game needs an account for multiplayer or the whole game
      * (its account_requirement setting): ask them to sign in with Zaisma.player.signIn().
@@ -176,10 +177,10 @@ declare namespace Zaisma {
   /**
    * Zaisma's chat check: the same check Zaisma runs on its side on every chat message to or from an
    * under-18 account. It stops contact details in any disguise, moving to another app or meeting up,
-   * personal details, slurs and sexual content, and answers with the words to show the sender. Swearing
-   * is flagged (hasSwearing) but allowed: blocking it is your game's call. Use it to show the sender why
-   * at once; Zaisma checks again when the message is delivered, so it can't be skipped. Checks the whole
-   * text, up to 2000 characters; a longer one is refused (too_long), never cut.
+   * personal details and sexual content, and answers with the words to show the sender. Swearing and
+   * slurs are flagged (hasSwearing, hasSlur) but allowed: blocking them is your game's call. For chat
+   * between players use {@link Room.chat}, which runs this check on its way; this one is for other text
+   * players type. Checks the whole text, up to 2000 characters; a longer one is refused (too_long), never cut.
    *
    * @example
    * const check = await Zaisma.checkChat(typedMessage);
@@ -997,6 +998,11 @@ declare namespace Zaisma {
     readonly name: string | null;
     /** The room's labels, like { Mode: "Classic", Map: "Docks" }. */
     readonly labels: Readonly<Record<string, string>>;
+    /**
+     * Whether this player can chat at all ({@link Room.chat}): a Zaisma account whose chat setting isn't
+     * nobody, playing (not watching). False for guests: hide your chat box, and offer preset phrases or emotes.
+     */
+    readonly canChat: boolean;
     /**
      * When Zaisma will end this match, an ISO time, or null: set once the game's hosting pauses for the
      * month, an hour after the pause (the "ending" event). Never set in a room on your own server.
@@ -1133,8 +1139,31 @@ declare namespace Zaisma {
      * player changed their mind. A block never removes anyone from the room.
      */
     block(playerId: string): Promise<boolean>;
-    /** Report a player to Zaisma, with what happened in the player's own words if they gave any (details). Nothing about the reporting player is sent. */
+    /**
+     * Report a player to Zaisma, with what happened in the player's own words if they gave any (details).
+     * The last chat lines (up to 20) they sent this player, or this player sent them, go with it from this
+     * screen; nothing else about the reporting player is sent.
+     */
     report(playerId: string, reason: ReportReason, details?: string): Promise<ReportAnswer>;
+    /**
+     * Send a chat message: through the room to the players in it (or chatOptions.toPlayerIds of them) who
+     * may chat with this player, on Zaisma's rooms or your own server's runner. It reaches only players in
+     * this player's chat group whose settings let them chat with this player, never anyone with a block
+     * between them, and never spectators. Your game server's onChat may stop it or send it to fewer
+     * players first; then Zaisma's chat filter checks it on its way (messages to and from under-18s
+     * always, between adults when your game server turns it on), and Zaisma keeps none of it. Draw the
+     * chat yourself: the "chat" event brings the others' messages; show this player's own when it resolves.
+     *
+     * Resolves { sentAt } once it went, even when nobody could read it (the sender is never told who
+     * can't). Rejects with error.code chat_stopped (error.reason says why, like contact_details or
+     * stopped_by_game, and error.message is what to show the player), chat_not_allowed (a guest, or chat
+     * set to nobody: check {@link Room.canChat} first), chat_empty, chat_too_long (over 2000 characters),
+     * chat_too_fast (over 20 in 10 seconds) or connection_closed.
+     *
+     * @example
+     * room.chat(input.value).then(({ sentAt }) => addLine(room.me.name, input.value), (error) => showError(error.message));
+     */
+    chat(text: string, chatOptions?: ChatOptions): Promise<ChatSent>;
 
     /**
      * Listen for an event. Listening is optional: without "move" and "back" listeners, the SDK follows
@@ -1241,8 +1270,53 @@ declare namespace Zaisma {
      * room.on("versionUpdate", ({ appliesAt }) => showBanner(`Updating at ${new Date(appliesAt).toLocaleTimeString()}`));
      */
     versionUpdate: (versionUpdate: VersionUpdate) => void;
+    /**
+     * Another player's chat message reached this player ({@link Room.chat}). Messages from players this
+     * player muted or blocked never come. hasSwearing and hasSlur flag what Zaisma allows: hide or blur
+     * them if your game doesn't. (Optional here only so games written for v1's events still fit.)
+     */
+    chat?: (chatMessage: ChatMessage) => void;
+  }
+
+  /** What {@link Room.chat} takes. */
+  interface ChatOptions {
+    /** Send it to only these players in the room (like a team), from room.players. All players when left out. */
+    toPlayerIds?: string[];
   }
 
+  /** {@link Room.chat}'s answer once the message went. */
+  interface ChatSent {
+    /** When the room sent it, as an ISO time. */
+    sentAt: string;
+  }
+
+  /** A chat message another player sent ({@link Room.chat}), as the "chat" event brings it. */
+  interface ChatMessage {
+    fromPlayerId: string;
+    text: string;
+    /** It swears: Zaisma allows it; hide it if your game doesn't. */
+    hasSwearing: boolean;
+    /** It has a slur: Zaisma allows it too; your game and its moderators decide. */
+    hasSlur: boolean;
+    /** When the room sent it, as an ISO time. */
+    sentAt: string;
+  }
+
+  /**
+   * The codes {@link Room.chat} rejects with: chat_stopped (the game server's onChat or Zaisma's filter
+   * stopped it: error.reason and error.message say why), chat_not_allowed, chat_empty, chat_too_long,
+   * chat_too_fast, bad_player_id, busy (try again in a moment), ended, spectator_cannot_send and
+   * connection_closed. More codes may come within v1: show the error's message.
+   */
+  type ChatErrorCode = "chat_stopped" | "chat_not_allowed" | "chat_empty" | "chat_too_long" | "chat_too_fast" | "chat_not_here" | "bad_player_id" | "busy" | "ended" | "spectator_cannot_send" | "connection_closed";
+
+  /**
+   * Why {@link Room.chat} was stopped (error.reason with chat_stopped): "stopped_by_game" (your game
+   * server's onChat), the filter's {@link ChatCheckReason}s, "chat_paused" (the sender's chat is paused
+   * for now) or "not_allowed_to_chat". More values may come.
+   */
+  type ChatStoppedReason = "stopped_by_game" | ChatCheckReason | "chat_paused" | "not_allowed_to_chat";
+
   /** What {@link Room.smoothedState} takes. */
   interface SmoothingOptions {
     /** How far behind the room's clock to draw, in milliseconds, from 0 to 1000. By default 100. */
@@ -1467,6 +1541,7 @@ declare namespace Zaisma {
    * - already_playing: a player in the room tried to watch it too.
    * - spectator_cannot_send: a spectator tried to send to the room ({@link Room.send}, {@link Room.sendBytes}).
    * - send_queue_full: the SDK's own: more than 60 reliable sends waited while the room wasn't reachable, so the oldest were dropped. Send less while connectionStatus isn't open, or use latest_only for updates that replace each other.
+   * - chat_not_allowed, chat_empty, chat_too_long, chat_too_fast: {@link Room.chat} refused (they reject its promise, not the "error" event); chat_not_here: the room's server doesn't take chat.
    *
    * More codes may come within v1: handle one you don't know like an error you can show (its message).
    */
@@ -1494,7 +1569,12 @@ declare namespace Zaisma {
     | "spectators_full"
     | "already_playing"
     | "spectator_cannot_send"
-    | "send_queue_full";
+    | "send_queue_full"
+    | "chat_not_here"
+    | "chat_not_allowed"
+    | "chat_empty"
+    | "chat_too_long"
+    | "chat_too_fast";
 
   /**
    * The codes a request's errors have ({@link Server.request}), from Zaisma or the Node runner alike:
@@ -1551,6 +1631,7 @@ declare namespace Zaisma {
    * - bad_idle_timeout: an idleTimeoutSec that isn't from 30 to 86400.
    * - request_failed: Zaisma didn't answer (no connection, or a problem on Zaisma's side); try again.
    * - no_game: {@link Items.buy} named a game that isn't open to play here.
+   * - chat_stopped, chat_not_allowed, chat_empty, chat_too_long, chat_too_fast, chat_not_here: {@link Room.chat} didn't send ({@link ChatErrorCode}).
    * - And a request's ({@link RequestErrorCode}).
    *
    * More values may come; treat an unknown one as "request_failed".
@@ -1558,6 +1639,12 @@ declare namespace Zaisma {
   type ErrorCode =
     | RoomErrorCode
     | RequestErrorCode
+    | "chat_stopped"
+    | "chat_not_allowed"
+    | "chat_empty"
+    | "chat_too_long"
+    | "chat_too_fast"
+    | "chat_not_here"
     | "unchecked"
     | "unknown_option"
     | "unknown_event"
@@ -1636,6 +1723,8 @@ declare namespace Zaisma {
     message: string | null;
     /** Whether it swears. Zaisma allows swearing; block it yourself if your game doesn't. */
     hasSwearing: boolean;
+    /** Whether it has a slur. Zaisma allows it too; your game and its moderators decide. */
+    hasSlur: boolean;
     /** The text tidied up: hidden characters and extra spaces gone, line breaks kept (empty when it's too_long). */
     text: string;
   }
@@ -1643,10 +1732,11 @@ declare namespace Zaisma {
   /**
    * Why {@link checkChat} stopped a message: "contact_details" (a link, handle, email, phone number or
    * contact app in any disguise, or moving to another app or meeting up), "personal_details" (where
-   * someone lives, their school, their full name, photos), "slur", "sexual", "unchecked" (Zaisma couldn't
-   * check it: try again in a moment) or "too_long" (over 2000 characters). The game server's
-   * ChatCheckReason has two more, "chat_paused" and "not_allowed_to_chat", which only a room can give.
-   * More values may come; treat an unknown one as a stop: show message.
+   * someone lives, their school, their full name, photos), "sexual" or "too_long" (over 2000 characters).
+   * "slur" and "unchecked" are v1's and no longer given: slurs are flagged (hasSlur), and what the AI can't
+   * look at goes after the rules. The game server's ChatCheckReason has two more, "chat_paused" and
+   * "not_allowed_to_chat", which only a room can give. More values may come; treat an unknown one as a
+   * stop: show message.
    */
   type ChatCheckReason = "contact_details" | "personal_details" | "slur" | "sexual" | "unchecked" | "too_long";
 

package/sdk/zaisma.js

@@ -29,7 +29,11 @@
   var SMOOTHING_OPTIONS = ["delayMs"];
   var DELIVERIES = ["reliable", "latest_only"];
   var ROOM_INFO_FIELDS = ["name", "labels"];
-  var ROOM_EVENTS = ["message", "bytes", "state", "players", "connectionStatus", "ended", "ending", "kicked", "settings", "move", "moved", "idle", "away", "back", "muted", "error", "versionUpdate"];
+  var ROOM_EVENTS = ["message", "bytes", "state", "players", "connectionStatus", "ended", "ending", "kicked", "settings", "move", "moved", "idle", "away", "back", "muted", "error", "versionUpdate", "chat"];
+  /** Chat (room.chat): the longest message, the lines a room keeps in memory for reports, and how many of them a report carries. */
+  var MAXIMUM_CHAT_CHARACTER_COUNT = 2000;
+  var KEPT_CHAT_LINE_COUNT = 50;
+  var REPORTED_CHAT_LINE_COUNT = 20;
   var SAVES_EVENTS = ["conflict", "developerChange"];
   var ITEMS_EVENTS = ["purchase", "refund", "sheetOpen", "sheetClose"];
   var VERSIONS_EVENTS = ["update"];
@@ -186,9 +190,11 @@
     if (!config.rooms) return Promise.reject(notOnZaisma("Player passes come from Zaisma, so they work only in games played on Zaisma."));
     if (!passPromise) {
       passPromise = roomKey().then(function (given) {
-        // The kept pass, unless the player signed in or out since it was made.
+        // A guest keeps their pass, so a reload is the same guest. An account gets a new one with each page's key: the key is for
+        // whoever is signed in now (another account than the kept pass's, maybe), and its pass brings their chat settings, friends
+        // and blocks as they are now; the account's player ID is the same either way.
         var kept = keptPass();
-        if (kept && kept.kind === given.playerKind) return kept;
+        if (kept && kept.kind === "guest" && given.playerKind === "guest") return kept;
         return post("/v1/pass", { gameSlug: config.game, roomKey: given.key }).then(function (answer) {
           var mine = { id: answer.player.id, name: answer.player.name, kind: answer.player.kind, pass: answer.pass, expiresAt: answer.expiresAt };
           try { sessionStorage.setItem(passKey, JSON.stringify(mine)); } catch (error) { /* fine */ }
@@ -457,6 +463,12 @@
     this._flushTimer = null;
     this._isQueueFullSaid = false;
     this._isWelcomed = false;
+    // Chat (room.chat): whether this player can chat at all (from welcome), the messages waiting for the
+    // room's answer by their chatNumber, and the room's last chat lines, in memory only, for reports.
+    this.canChat = false;
+    this._chatNumber = 0;
+    this._chats = new Map();
+    this._chatLines = [];
   }
   Room.prototype = Object.create(Emitter.prototype);
 
@@ -557,6 +569,7 @@
         room._checks = message.awayChecks || { idleTimeoutSec: null, hiddenTimeoutSec: null };
         room._probeIntervalSec = typeof message.probeIntervalSec === "number" ? message.probeIntervalSec : null;
         room.spectatorCount = typeof message.spectatorCount === "number" ? message.spectatorCount : 0;
+        room.canChat = message.canChat === true && !room.isSpectator;
         room._away = room._gone = room._idleSent = room._coming = room._offered = room._isReloadingForVersion = false;
         room.awayReason = null;
         room._isQueueFullSaid = false;
@@ -606,6 +619,8 @@
         room._mutedChanged();
       } else if (message.type === "message") {
         room._emit("message", message.data, typeof message.fromPlayerId === "string" ? message.fromPlayerId : null);
+      } else if (message.type === "chat" || message.type === "chat_sent" || message.type === "chat_stopped" || (message.type === "error" && typeof message.chatNumber === "number")) {
+        room._chatAnswer(message);
       } else if (message.type === "state") {
         room._takeState(message);
       } else if (message.type === "room") {
@@ -661,6 +676,7 @@
       if (room._done || event.code === 4000 || event.code === 4001) {
         room._done = true;
         room._queue = [];
+        room._failChats();
         room._setConnectionStatus("closed");
         if (room._ready) {
           room._ready.reject(codedError("connection_closed", "The connection closed before the room let the player in" + (event.reason ? ": " + event.reason : "") + "."));
@@ -1253,16 +1269,85 @@
     });
     return blockAsk;
   }
-  /** Report a player to Zaisma. reason: real_life_threat, personal_details, following_after_block or sexual (Zaisma looks), or harassment, cheating or other (passed to the game's developer). Nothing about you is sent. */
+  /**
+   * Report a player to Zaisma. reason: real_life_threat, personal_details, following_after_block or sexual (Zaisma looks), or harassment, cheating or other (passed to the game's developer).
+   * The last chat lines they sent you, or you sent them, go with it (up to 20); nothing else about you is sent.
+   */
   Room.prototype.report = function (playerId, reason, details) {
     var reported = this.players.filter(function (each) { return each.id === playerId; })[0];
-    return post("/v1/report", { gameSlug: config.game, roomCode: this.roomCode, playerId: playerId, playerName: reported ? reported.name : "", reason: reason, details: details || "" });
+    var me = this.me ? this.me.id : null;
+    var chatMessages = this._chatLines.filter(function (line) {
+      return line.fromPlayerId === playerId || (line.fromPlayerId === me && (!line.toPlayerIds || line.toPlayerIds.indexOf(playerId) !== -1));
+    }).slice(-REPORTED_CHAT_LINE_COUNT).map(function (line) { return { fromPlayerId: line.fromPlayerId, text: line.text, sentAt: line.sentAt }; });
+    return post("/v1/report", { gameSlug: config.game, roomCode: this.roomCode, playerId: playerId, playerName: reported ? reported.name : "", reason: reason, details: details || "", chatMessages: chatMessages });
+  };
+
+  /**
+   * Send a chat message (zaisma.d.ts: room.chat): through the room, to the players who may chat with this
+   * one, after the game server's onChat and Zaisma's chat filter. Resolves { sentAt } once it went, even to
+   * nobody; rejects with a coded error when it didn't.
+   */
+  Room.prototype.chat = function (text, chatOptions) {
+    var toPlayerIds = chatOptions && chatOptions.toPlayerIds;
+    if (!this.canChat) return Promise.reject(codedError("chat_not_allowed", "You can't chat here."));
+    if (typeof text !== "string" || !text.trim()) return Promise.reject(codedError("chat_empty", "Type a message first."));
+    if (text.length > MAXIMUM_CHAT_CHARACTER_COUNT) return Promise.reject(codedError("chat_too_long", "That message is too long to send."));
+    if (toPlayerIds !== undefined && !(Array.isArray(toPlayerIds) && toPlayerIds.every(function (id) { return typeof id === "string"; }))) {
+      return Promise.reject(codedError("bad_player_id", "chatOptions.toPlayerIds takes a list of player IDs from room.players."));
+    }
+    if (this._done) return Promise.reject(codedError("connection_closed", "This room is closed."));
+    var room = this;
+    var chatNumber = ++this._chatNumber;
+    var payload = { type: "chat", chatNumber: chatNumber, text: text };
+    if (toPlayerIds) payload.toPlayerIds = toPlayerIds.slice();
+    return new Promise(function (resolve, reject) {
+      room._chats.set(chatNumber, { text: text, toPlayerIds: payload.toPlayerIds || null, resolve: resolve, reject: reject });
+      // Waits in order with the other sends while the connection is back.
+      room._sendReliable(JSON.stringify(payload));
+    });
+  };
+  /** A chat line, kept in memory for reports: the last KEPT_CHAT_LINE_COUNT. */
+  Room.prototype._keepChatLine = function (line) {
+    this._chatLines.push(line);
+    if (this._chatLines.length > KEPT_CHAT_LINE_COUNT) this._chatLines.shift();
+  };
+  /** What the room said about chat: someone's message, or its answer on one of this player's. */
+  Room.prototype._chatAnswer = function (message) {
+    if (message.type === "chat") {
+      if (typeof message.fromPlayerId !== "string" || typeof message.text !== "string") return;
+      // Muted and blocked players' chat never reaches the game.
+      if (this.isMuted(message.fromPlayerId)) return;
+      var chat = { fromPlayerId: message.fromPlayerId, text: message.text, hasSwearing: message.hasSwearing === true, hasSlur: message.hasSlur === true, sentAt: typeof message.sentAt === "string" ? message.sentAt : new Date().toISOString() };
+      this._keepChatLine({ fromPlayerId: chat.fromPlayerId, text: chat.text, sentAt: chat.sentAt, toPlayerIds: null });
+      this._emit("chat", chat);
+      return;
+    }
+    var waiting = this._chats.get(message.chatNumber);
+    if (!waiting) return;
+    this._chats.delete(message.chatNumber);
+    if (message.type === "chat_sent") {
+      this._keepChatLine({ fromPlayerId: this.me ? this.me.id : null, text: waiting.text, sentAt: message.sentAt, toPlayerIds: waiting.toPlayerIds });
+      waiting.resolve({ sentAt: message.sentAt });
+    } else if (message.type === "chat_stopped") {
+      var stopped = codedError("chat_stopped", typeof message.message === "string" && message.message ? message.message : "Your message wasn't sent.");
+      stopped.reason = typeof message.reason === "string" ? message.reason : null;
+      waiting.reject(stopped);
+    } else {
+      waiting.reject(codedError(message.code, message.message));
+    }
+  };
+  /** Chat messages still waiting when the room closes don't go. */
+  Room.prototype._failChats = function () {
+    var waiting = Array.from(this._chats.values());
+    this._chats.clear();
+    waiting.forEach(function (chat) { chat.reject(codedError("connection_closed", "The room closed before the message went.")); });
   };
 
   Room.prototype.leave = function () {
     if (!this._done) left(this);
     this._done = true;
     this._queue = [];
+    this._failChats();
     if (this._ws) this._ws.close(1000, "Left");
   };
 

package/src/chat.d.ts

@@ -1,9 +1,10 @@
 /**
  * Zaisma's chat filter for your own server (docs/DECISIONS.md, "The text filter catches what matters and
  * leaves the rest alone"). Every chat message to or from an under-18 account is checked on Zaisma's side:
- * contact details in any disguise, moving to another app or meeting up, personal details, slurs and
- * sexual content are stopped. Swearing is only flagged (hasSwearing): blocking it is your call. The answer
- * is one verdict for the whole message, never per receiver, so it never says who's under 18.
+ * contact details in any disguise, moving to another app or meeting up, personal details and sexual
+ * content are stopped. Swearing and slurs are only flagged (hasSwearing, hasSlur): blocking them is your
+ * call. Between adults it only flags, unless you turn the filter on for them too (isAdultFilterEnabled).
+ * The answer is one verdict for the whole message, never per receiver, so it never says who's under 18.
  *
  * checkChat sends the players' passes (as your server received them) and the sender's last few messages to
  * Zaisma (POST <issuer>/v1/chat/check), so a phone number sent a few digits at a time is caught too.
@@ -11,14 +12,17 @@
  * It's for your own server only. In Zaisma rooms the room filters the chat it delivers itself, so a game
  * server running there never sees passes, and checkChat throws a ChatCheckError (own_server_only).
  */
-/** Why a message was stopped. The same reasons as Zaisma.checkChat, plus chat_paused and not_allowed_to_chat. */
+/**
+ * Why a message was stopped. The same reasons as Zaisma.checkChat, plus chat_paused, not_allowed_to_chat and
+ * unchecked (Zaisma couldn't be reached). slur is v1's and no longer given: slurs are flagged (hasSlur), never stopped.
+ */
 export type ChatCheckReason = "contact_details" | "personal_details" | "slur" | "sexual" | "chat_paused" | "unchecked" | "too_long" | "not_allowed_to_chat";
 export interface ChatCheck {
     /** Whether to deliver it. */
     isAllowed: boolean;
     /**
-     * Why not; null when it's allowed. chat_paused: the sender's chat is paused or removed. unchecked: Zaisma
-     * couldn't check it, so don't deliver it (try again in a moment). too_long: over 2000 characters.
+     * Why not; null when it's allowed. chat_paused: the sender's chat is paused or removed. unchecked: your
+     * server couldn't reach Zaisma, so don't deliver it (try again in a moment). too_long: over 2000 characters.
      * not_allowed_to_chat: canChat says the sender and a receiver may not chat (Zaisma checks it too).
      */
     reason: ChatCheckReason | null;
@@ -26,6 +30,8 @@ export interface ChatCheck {
     message: string | null;
     /** Whether it swears. Zaisma allows it; block it yourself if your game doesn't. */
     hasSwearing: boolean;
+    /** Whether it has a slur. Zaisma allows it too, so your game and its moderators decide. */
+    hasSlur: boolean;
 }
 export interface ChatCheckOptions {
     /** The message. */
@@ -34,7 +40,15 @@ export interface ChatCheckOptions {
     senderPass: string;
     /** The passes of everyone it would reach, up to 50. */
     receiverPasses: string[];
+    /** Check chat between adults too, as for under-18s; each message Zaisma's AI looks at counts on your hosting meter. False by default. */
+    isAdultFilterEnabled?: boolean;
 }
+/** Chat in rooms (room.chat), for both Zaisma's rooms and your own server's runner: past any human's typing, so it only stops floods. */
+export declare const CHAT_ROOM_LIMITS: {
+    /** Chat messages one player may send in any chatWindowDurationMs; past it, chat_too_fast. */
+    readonly maximumChatMessageCount: 20;
+    readonly chatWindowDurationMs: 10000;
+};
 export declare const CHAT_CHECK_LIMITS: {
     /** The longest message checked, in characters: the whole text is checked, and a longer one is refused (too_long), never cut. */
     readonly maximumMessageCharacterCount: 2000;
@@ -56,8 +70,9 @@ export declare class ChatCheckError extends Error {
 /**
  * Check one chat message with Zaisma's filter. Call it on every chat message your server delivers, after
  * canChat says the players may chat, and deliver it only when isAllowed (Zaisma applies canChat's rule
- * too, so a message to anyone who may not chat is stopped). It's free. When Zaisma can't be
- * reached it answers unchecked: don't deliver the message.
+ * too, so a message to anyone who may not chat is stopped). It's free, except the checks of chat between
+ * adults when isAdultFilterEnabled. When Zaisma can't be reached it answers unchecked: don't deliver the message.
+ * The runner (zaisma-game-server) does all this for room.chat in its rooms.
  *
  *   const check = await checkChat({ text, senderPass, receiverPasses: [receiverPass] });
  *   if (!check.isAllowed || check.hasSwearing) return reply(sender, check.message ?? "No swearing here.");

package/src/chat.js

@@ -1,9 +1,10 @@
 /**
  * Zaisma's chat filter for your own server (docs/DECISIONS.md, "The text filter catches what matters and
  * leaves the rest alone"). Every chat message to or from an under-18 account is checked on Zaisma's side:
- * contact details in any disguise, moving to another app or meeting up, personal details, slurs and
- * sexual content are stopped. Swearing is only flagged (hasSwearing): blocking it is your call. The answer
- * is one verdict for the whole message, never per receiver, so it never says who's under 18.
+ * contact details in any disguise, moving to another app or meeting up, personal details and sexual
+ * content are stopped. Swearing and slurs are only flagged (hasSwearing, hasSlur): blocking them is your
+ * call. Between adults it only flags, unless you turn the filter on for them too (isAdultFilterEnabled).
+ * The answer is one verdict for the whole message, never per receiver, so it never says who's under 18.
  *
  * checkChat sends the players' passes (as your server received them) and the sender's last few messages to
  * Zaisma (POST <issuer>/v1/chat/check), so a phone number sent a few digits at a time is caught too.
@@ -12,6 +13,12 @@
  * server running there never sees passes, and checkChat throws a ChatCheckError (own_server_only).
  */
 import { OutsideCallError } from "./outside-calls.js";
+/** Chat in rooms (room.chat), for both Zaisma's rooms and your own server's runner: past any human's typing, so it only stops floods. */
+export const CHAT_ROOM_LIMITS = {
+    /** Chat messages one player may send in any chatWindowDurationMs; past it, chat_too_fast. */
+    maximumChatMessageCount: 20,
+    chatWindowDurationMs: 10_000,
+};
 export const CHAT_CHECK_LIMITS = {
     /** The longest message checked, in characters: the whole text is checked, and a longer one is refused (too_long), never cut. */
     maximumMessageCharacterCount: 2000,
@@ -34,9 +41,9 @@ export class ChatCheckError extends Error {
         this.fix = fix;
     }
 }
-const UNCHECKED = { isAllowed: false, reason: "unchecked", message: "This message couldn't be checked. Try again in a moment.", hasSwearing: false };
-const TOO_LONG = { isAllowed: false, reason: "too_long", message: "That message is too long to send.", hasSwearing: false };
-const REASONS = ["contact_details", "personal_details", "slur", "sexual", "chat_paused", "unchecked", "too_long", "not_allowed_to_chat"];
+const UNCHECKED = { isAllowed: false, reason: "unchecked", message: "This message couldn't be checked. Try again in a moment.", hasSwearing: false, hasSlur: false };
+const TOO_LONG = { isAllowed: false, reason: "too_long", message: "That message is too long to send.", hasSwearing: false, hasSlur: false };
+const REASONS = ["contact_details", "personal_details", "sexual", "chat_paused", "unchecked", "too_long", "not_allowed_to_chat"];
 /** Each sender's last messages, by the sender's pass's player ID: only in this process's memory. */
 const recentBySender = new Map();
 /** The claims of a pass, unchecked: Zaisma checks the signature. Only to find whose it is and where it's from. */
@@ -67,13 +74,16 @@ function rememberText(senderPlayerId, text, nowMs) {
 /**
  * Check one chat message with Zaisma's filter. Call it on every chat message your server delivers, after
  * canChat says the players may chat, and deliver it only when isAllowed (Zaisma applies canChat's rule
- * too, so a message to anyone who may not chat is stopped). It's free. When Zaisma can't be
- * reached it answers unchecked: don't deliver the message.
+ * too, so a message to anyone who may not chat is stopped). It's free, except the checks of chat between
+ * adults when isAdultFilterEnabled. When Zaisma can't be reached it answers unchecked: don't deliver the message.
+ * The runner (zaisma-game-server) does all this for room.chat in its rooms.
  *
  *   const check = await checkChat({ text, senderPass, receiverPasses: [receiverPass] });
  *   if (!check.isAllowed || check.hasSwearing) return reply(sender, check.message ?? "No swearing here.");
  */
 export async function checkChat({ text, senderPass, receiverPasses }) {
+    // Read apart from the destructuring, which is v1's signature as it's locked (test/contracts).
+    const isAdultFilterEnabled = arguments[0]?.isAdultFilterEnabled === true;
     const claims = readClaims(String(senderPass ?? ""));
     if (typeof claims.sub !== "string" || !isZaismaIssuer(claims.iss) || !Array.isArray(receiverPasses))
         return UNCHECKED;
@@ -87,7 +97,7 @@ export async function checkChat({ text, senderPass, receiverPasses }) {
         const response = await fetch(`${claims.iss}/v1/chat/check`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ gameSlug: claims.aud, senderPass, receiverPasses: receiverPasses.slice(0, CHAT_CHECK_LIMITS.maximumReceiverCount), text: message, recentTexts }),
+            body: JSON.stringify({ gameSlug: claims.aud, senderPass, receiverPasses: receiverPasses.slice(0, CHAT_CHECK_LIMITS.maximumReceiverCount), text: message, recentTexts, isAdultFilterEnabled }),
             signal: AbortSignal.timeout(CHAT_CHECK_LIMITS.checkTimeoutMs),
         });
         if (!response.ok)
@@ -96,12 +106,12 @@ export async function checkChat({ text, senderPass, receiverPasses }) {
         if (typeof answer.isAllowed !== "boolean")
             return UNCHECKED;
         const reason = typeof answer.reason === "string" && REASONS.includes(answer.reason) ? answer.reason : null;
-        return { isAllowed: answer.isAllowed, reason, message: typeof answer.message === "string" ? answer.message : null, hasSwearing: answer.hasSwearing === true };
+        return { isAllowed: answer.isAllowed, reason, message: typeof answer.message === "string" ? answer.message : null, hasSwearing: answer.hasSwearing === true, hasSlur: answer.hasSlur === true };
     }
     catch (error) {
         // In Zaisma rooms the gateway refuses the call to Zaisma's own address: checkChat is for a game server on your own server.
         if (error instanceof OutsideCallError && ["unreachable_host", "not_https", "host_not_allowed"].includes(error.code)) {
-            throw new ChatCheckError("checkChat is for a game server on your own server. In Zaisma rooms the room runs Zaisma's chat filter on the chat it delivers.", "Send chat through Zaisma's chat hosting in rooms once it's out; until then, check what a player types in the game with Zaisma.checkChat, or offer preset phrases and emotes.");
+            throw new ChatCheckError("checkChat is for a game server on your own server. In Zaisma rooms the room runs Zaisma's chat filter on the chat it delivers.", "In Zaisma rooms, send chat with room.chat in the game; the room filters it.");
         }
         return UNCHECKED;
     }

package/src/index.d.ts

@@ -1,10 +1,10 @@
-export { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, GAME_SERVER_OPTIONS, GameServerError, NO_ANSWER_CLOSE_CODE, REMOVED_CLOSE_CODE, ROOM_LIMITS, SEAT_GONE_CLOSE_CODE, VERSION_UPDATE_CLOSE_CODE, defineGameServer, type Audience, type AwayInfo, type AwayMode, type AwayReason, type BroadcastOptions, type Delivery, type GameServer, type GameServerErrorCode, type HandlerResult, type IdleCheck, type JoinAnswer, type JoinInfo, type KickOptions, type LeaveInfo, type LeaveReason, type MoveOptions, type MoveResult, type Player, type Purchase, type Refusal, type ReserveOptions, type RestoreInfo, type Room, type RoomErrorCode, type RoomInfo, type SendOptions, type VersionUpdate, } from "./room.ts";
+export { BUSY_CLOSE_CODE, ENDED_CLOSE_CODE, GAME_SERVER_OPTIONS, GameServerError, NO_ANSWER_CLOSE_CODE, REMOVED_CLOSE_CODE, ROOM_LIMITS, SEAT_GONE_CLOSE_CODE, VERSION_UPDATE_CLOSE_CODE, defineGameServer, type Audience, type AwayInfo, type AwayMode, type AwayReason, type BroadcastOptions, type Delivery, type GameServer, type GameServerErrorCode, type HandlerResult, type IdleCheck, type JoinAnswer, type ChatAnswer, type ChatInfo, type JoinInfo, type KickOptions, type LeaveInfo, type LeaveReason, type MoveOptions, type MoveResult, type Player, type Purchase, type Refusal, type ReserveOptions, type RestoreInfo, type Room, type RoomErrorCode, type RoomInfo, type SendOptions, type VersionUpdate, } from "./room.ts";
 export { REQUEST_LIMITS, type RequestErrorCode, type Server } from "./requests.ts";
 export { SCHEDULE_LIMITS, type Schedule, type ScheduledRun } from "./schedules.ts";
 export { WEBHOOK_LIMITS, verifyWebhook, type WebhookError, type WebhookErrorCode, type WebhookEvent, type WebhookEventKind, type WebhookHeaders } from "./webhooks.ts";
 export { DATABASE_LIMITS, DatabaseError, type DatabaseErrorCode, type DatabaseRow, type DatabaseStatement, type DatabaseValue, type GameDatabase } from "./database.ts";
 export { OUTSIDE_CALL_LIMITS, OutsideCallError, type OutsideCallErrorCode } from "./outside-calls.ts";
 export { PASS_ISSUER_URL, PASS_TOKEN_TYPE, PASS_VERSION_NUMBER, PassError, RECEIPT_ISSUER_URL, RECEIPT_TOKEN_TYPE, RECEIPT_VERSION_NUMBER, ReceiptError, canChat, passesAreFriends, passesHaveBlockBetween, verifyPass, verifyReceipt, type PassClaims, type PassErrorCode, type PassExpectations, type PlayerKind, type PublicKey, type ReceiptClaims, type ReceiptErrorCode, type ReceiptExpectations, type WhoCanChat } from "./pass.ts";
-export { CHAT_CHECK_LIMITS, ChatCheckError, checkChat, type ChatCheck, type ChatCheckOptions, type ChatCheckReason } from "./chat.ts";
+export { CHAT_CHECK_LIMITS, CHAT_ROOM_LIMITS, ChatCheckError, checkChat, type ChatCheck, type ChatCheckOptions, type ChatCheckReason } from "./chat.ts";
 export { guestName, isRoomCode } from "./names.ts";
 export { relay } from "./relay.ts";