castle-web-sdk 0.4.35 → 0.4.37

package/README.md

@@ -25,6 +25,7 @@ import { setup, initCard, Store, Leaderboard } from "castle-web-sdk";
 - [Snapshot](#snapshot)
 - [Portal](#portal)
 - [Decks](#decks)
+- [Clipboard](#clipboard)
 - [Haptics](#haptics)
 - [Agent](#agent)
 - [Lifecycle](#lifecycle)
@@ -251,11 +252,30 @@ guide.
 
 ### Limits
 
-The platform caps key length, value size, how many keys one call may
-touch, page size, and how much a deck may store in total, and it limits
-how fast a player may read and write. Going over any of them rejects
-with a `CastleError` whose `code` says which, so a deck can tell a
-player it is saving too fast apart from a deck that is out of space.
+The platform caps key length, value size, how many keys one read may
+name, and how much a deck may store in total, and it limits how fast a
+player may read and write. Going over one of these rejects with a
+`CastleError` whose `code` says which, so a deck can tell a player it is
+saving too fast apart from a deck that is out of space:
+
+| limit | value |
+|---|---|
+| key | 128 bytes |
+| value | 256 KB |
+| keys in one `get` | 32 |
+| whole deck | 50 MB, 500,000 keys |
+| one player's calls | 20 a second, 512 KB a second |
+| every player of a deck together | 500 calls a second, 8 MB a second |
+
+These do not reject. `set` and `remove` with more than 32 keys are split
+into several calls by the SDK (each still counts against the rate above).
+A `list` page holds at most 1,000 entries (a larger `limit` is lowered to
+it) and ends early once it reaches 1 MB; take the next page with its
+`cursor`.
+
+A value is JSON, so binary data such as a picture or a video clip costs
+about a third more once encoded, and a clip of more than a few seconds
+does not fit in one. Ship media with the deck instead.
 
 ## Storage
 
@@ -267,6 +287,10 @@ player it is saving too fast apart from a deck that is out of space.
 
 `Storage` saves data for the current player. Nobody else can read it.
 
+A player's whole `Storage` document is at most 2 MB. A write that takes
+it past that never saves, and nothing tells the deck: `set` has already
+returned.
+
 - **`Storage.get<T>(key): Promise<T | null>`** — the value at `key`, or
   `null` if it is not set.
 - **`Storage.set(key, value)`** — sets `key`. `value` must be something
@@ -295,7 +319,9 @@ await Store.private.set({ level: 7 });
 > and adds counters, listing, and leaderboards.
 
 `SharedStorage` saves data that other players can read. Values must be
-something that converts to JSON, same as `Storage`.
+something that converts to JSON, same as `Storage`. Each bucket holds at
+most 2 MB, and a write past that is dropped without an error, as with
+`Storage`.
 
 Scopes: `'deck'` is one bucket for the whole deck, readable and writable
 by any player. `'user'` is a per-player bucket that anyone can read and
@@ -522,6 +548,9 @@ when the player collects or closes it. `options`:
 
 Collecting works only in the Castle mobile app; the website shows "collect in
 the app" and the dev server a short notice, and both resolve `unavailable`.
+`offer` was added to the app on 2026-09-22; an app build from before then
+rejects it with `UNKNOWN_COMMAND` (see [CastleError](#castleerror)), so catch
+it where a deck has to keep going without the card.
 `SnapshotOfferResult` has a `status`:
 
 - `'collected'` — the player collected it.
@@ -536,6 +565,11 @@ const { status } = await Snapshot.offer({
 });
 ```
 
+A snapshot is not the deck's cover, and no SDK call sets the cover. A cover
+the creator chose by hand is kept; otherwise `save-deck` photographs the deck
+as it opens, falling back to a `preview.png` the deck folder holds when that
+capture does not produce one.
+
 ### `Snapshot.onTaken(handler): () => void`
 
 Registers a function called just before an offer's capture, the twin of the
@@ -606,7 +640,9 @@ label as the fallback. `PortalInfoResult` has a `status`:
   `null`), and `coverUrl`, a `data:` url of the deck's cover or `null`.
 - `'broken'` — the portal wouldn't work for this player: the deck doesn't
   exist, has portals turned off, or isn't visible to them.
-- `'unavailable'` — the host couldn't look it up.
+- `'unavailable'` — the host couldn't look it up. This includes a Castle
+  app built before `portal.info` was added (2026-09-22): `info` never
+  throws `UNKNOWN_COMMAND`.
 
 ```js
 const info = await Portal.info(doorway.deckId);
@@ -650,6 +686,13 @@ for (const deck of decks) {
 }
 ```
 
+## Clipboard
+
+The SDK has no clipboard command, and neither Castle host adds one: the
+Castle app has no clipboard bridge, and castle.xyz's player does not grant
+its frame `clipboard-write`. `navigator.clipboard` is best-effort — catch
+its failure and show the text so the player can copy it by hand.
+
 ## Haptics
 
 `Haptics` plays a short device vibration ("buzz") for tactile feedback —
@@ -1030,5 +1073,25 @@ Common codes:
 - `CASTLE_HOST_UNAVAILABLE` — the Castle host (the app or website running
   the deck) didn't handle the request — e.g. it timed out or wasn't
   reachable. Usually transient; retry or surface a gentle error.
+- `UNKNOWN_COMMAND` ("Unknown Castle command.") — the Castle app running
+  the deck is a build older than the command. Each app build knows only the
+  commands it shipped with, and only an app update adds one, so keep the
+  deck working without it. The app's last version bump, iOS v1.149, came
+  before every command below, so v1.149 and earlier builds lack all of
+  them. Each date is the commit that added the command to the app's code,
+  not when a build carrying it reached the stores; an app built from code
+  before that commit answers `UNKNOWN_COMMAND`:
+  - `Multiplayer.join` — 2026-08-29
+  - `Store` (every method) — 2026-09-03
+  - `Lifecycle.restoreState` — 2026-09-08 (resolves `null` instead of
+    throwing)
+  - `User.get` — 2026-09-10
+  - `Characters` — 2026-09-20
+  - `Snapshot.offer` — 2026-09-22
+  - `Portal.info` — 2026-09-22 (resolves `unavailable` instead of throwing)
+  - `Agent.chat`, `Decks.mine`, `Decks.saved` — 2026-09-23
+
+  `Leaderboard.show` resolves `unavailable` rather than throwing on an app
+  that lacks it.
 - `CAULDRON_STORAGE_STALE_GENERATION` — the handle belongs to an older reset
   generation; reopen explicitly rather than replaying work into the new one.

package/dist/castle.d.ts

@@ -14,8 +14,9 @@ export type { LeaderboardData, LeaderboardEntry, LeaderboardOptions, Leaderboard
 export { Lifecycle } from "./lifecycle";
 export type { CastleLifecycleApi } from "./lifecycle";
 export { Multiplayer } from "./multiplayer";
-export type { CastleMultiplayerApi, MultiplayerConnection, MultiplayerConnectionState, MultiplayerJoinOptions, MultiplayerRoster, MultiplayerStateMetadata, } from "./multiplayer";
-export type { MultiplayerSoloReason } from "./commands";
+export type { CastleMultiplayerApi, MultiplayerConnection, MultiplayerConnectionState, MultiplayerDestinationJoinResult, MultiplayerDestinationOptions, MultiplayerJoinOptions, MultiplayerRoster, MultiplayerStateMetadata, } from "./multiplayer";
+export type { MultiplayerVoice, VoiceJoinStatus, VoiceListener, VoiceMixEntry, VoiceSpatialOptions, VoiceState, VoiceVector, } from "./multiplayerVoice";
+export type { MultiplayerDestinationAudience, MultiplayerSoloReason } from "./commands";
 export { MAX_CLIENT_FRAME_BYTES, MAX_PLAYERS_CAP } from "./multiplayerProtocol";
 export type { ClientByeFrame, ClientHelloFrame, ClientMessageFrame, ClientPingFrame, ClientPongFrame, ClientReplacedFrame, ClientRosterFrame, ClientToPlatformFrame, ClientToPlatformMessageFrame, MultiplayerPlayer, PlayerIdentity, PlatformToClientFrame, SessionPlayer, SessionType, } from "./multiplayerProtocol";
 export { registerParams } from "./paramsRegistry";

package/dist/commands.d.ts

@@ -103,6 +103,51 @@ export interface MultiplayerGetSessionResult {
     /** Internal local-serve scope for restoring this Play panel after a reload. */
     devReconnectScope?: string;
 }
+export interface MultiplayerJoinDestinationParams {
+    routeId: string;
+    slot: string;
+}
+export type MultiplayerDestinationAudience = "player" | "party" | "public";
+export type MultiplayerJoinDestinationStatus = "ok" | "cancelled" | "full" | "unavailable" | "not_found" | "forbidden" | "party_required";
+export interface MultiplayerJoinDestinationResult {
+    status: MultiplayerJoinDestinationStatus;
+    url: string | null;
+    nonce: string | null;
+    sessionId: string | null;
+    audience: MultiplayerDestinationAudience | null;
+}
+export type VoiceState = "unavailable" | "off" | "joining" | "live";
+export type VoiceJoinStatus = "joined" | "declined" | "unavailable";
+export interface VoiceMixEntry {
+    /** 0 (silent) to 1 (full). */
+    gain?: number;
+    /** -1 (left) to 1 (right). Ignored for a player with a 3D position. */
+    pan?: number;
+}
+export type VoiceVector = [number, number, number];
+export interface VoiceListener {
+    position: VoiceVector;
+    /** The direction the listener faces; need not be normalized. */
+    forward: VoiceVector;
+    /** Defaults to [0, 1, 0]. */
+    up?: VoiceVector;
+}
+export interface VoiceSpatialOptions {
+    /** How volume falls off with distance; default "inverse". */
+    distanceModel?: "linear" | "inverse" | "exponential";
+    /** Distance at which a voice is at full volume; default 1. */
+    refDistance?: number;
+    /** Beyond this, a voice gets no quieter ("linear": silent); default 100. */
+    maxDistance?: number;
+    /** How fast volume falls off; default 1. */
+    rolloff?: number;
+}
+export interface VoiceSpatialUpdate {
+    listener?: VoiceListener;
+    /** Keyed by userId. `null` returns a player to plain gain and pan. */
+    positions?: Record<string, VoiceVector | null>;
+    options?: VoiceSpatialOptions;
+}
 export interface CharacterSummary {
     id: string;
     version: string;
@@ -295,6 +340,23 @@ export interface CommandParams {
         style: HapticStyle;
     };
     "multiplayer.getSession": MultiplayerGetSessionParams;
+    "multiplayer.joinDestination": MultiplayerJoinDestinationParams;
+    "voice.getState": {
+        sessionId: string;
+    };
+    "voice.requestJoin": {
+        sessionId: string;
+    };
+    "voice.leave": {
+        sessionId: string;
+    };
+    "voice.setMix": {
+        sessionId: string;
+        mix: Record<string, VoiceMixEntry>;
+    };
+    "voice.setSpatial": {
+        sessionId: string;
+    } & VoiceSpatialUpdate;
     "characters.open": {
         characterId: string;
     };
@@ -417,6 +479,22 @@ export interface CommandResult {
     "portal.info": PortalInfoResult;
     "haptics.play": HapticsResult;
     "multiplayer.getSession": MultiplayerGetSessionResult;
+    "multiplayer.joinDestination": MultiplayerJoinDestinationResult;
+    "voice.getState": {
+        state: VoiceState;
+    };
+    "voice.requestJoin": {
+        status: VoiceJoinStatus;
+    };
+    "voice.leave": {
+        ok: true;
+    };
+    "voice.setMix": {
+        ok: true;
+    };
+    "voice.setSpatial": {
+        ok: true;
+    };
     "characters.open": CharacterAdmission;
     "characters.send": CharacterOperation;
     "characters.status": CharacterOperation;
@@ -510,3 +588,18 @@ export interface UnloadDoneEnvelope {
         state?: string;
     };
 }
+export type VoiceEvent = {
+    type: "state";
+    sessionId: string;
+    state: VoiceState;
+} | {
+    type: "speaking";
+    sessionId: string;
+    userIds: string[];
+};
+export interface VoiceEventEnvelope {
+    castleSdk: typeof CASTLE_SDK_PROTOCOL;
+    voice: VoiceEvent;
+}
+export declare function isVoiceState(value: unknown): value is VoiceState;
+export declare function voiceEventFrom(value: unknown): VoiceEvent | null;

package/dist/commands.js

@@ -44,3 +44,28 @@ export function unloadRequestId(value) {
     const unload = record.unload;
     return typeof unload?.unloadId === "string" ? unload.unloadId : null;
 }
+const VOICE_STATES = ["unavailable", "off", "joining", "live"];
+export function isVoiceState(value) {
+    return typeof value === "string" && VOICE_STATES.includes(value);
+}
+export function voiceEventFrom(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const record = value;
+    if (record.castleSdk !== CASTLE_SDK_PROTOCOL)
+        return null;
+    const event = record.voice;
+    if (typeof event !== "object" || event === null)
+        return null;
+    if (typeof event.sessionId !== "string")
+        return null;
+    if (event.type === "state" && isVoiceState(event.state)) {
+        return { type: "state", sessionId: event.sessionId, state: event.state };
+    }
+    if (event.type === "speaking" &&
+        Array.isArray(event.userIds) &&
+        event.userIds.every((userId) => typeof userId === "string")) {
+        return { type: "speaking", sessionId: event.sessionId, userIds: event.userIds.slice() };
+    }
+    return null;
+}

package/dist/multiplayer.d.ts

@@ -1,6 +1,7 @@
-import type { MultiplayerSoloReason } from "./commands";
+import type { MultiplayerDestinationAudience, MultiplayerSoloReason } from "./commands";
 import { CastleError } from "./errors";
 import { type MultiplayerPlayer } from "./multiplayerProtocol";
+import { type MultiplayerVoice } from "./multiplayerVoice";
 export type MultiplayerJoinOptions = {
     mode: "named";
     key: string;
@@ -9,6 +10,17 @@ export type MultiplayerJoinOptions = {
 } | {
     mode: "public";
 };
+export interface MultiplayerDestinationOptions {
+    routeId: string;
+    slot: string;
+}
+export type MultiplayerDestinationJoinResult = {
+    status: "joined";
+    connection: MultiplayerConnection;
+    audience: MultiplayerDestinationAudience;
+} | {
+    status: "cancelled" | "full" | "unavailable" | "not_found" | "forbidden" | "party_required";
+};
 export type MultiplayerConnectionState = "acquiring" | "connecting" | "connected" | "reconnecting" | "closed";
 export type MultiplayerStateMetadata = {
     type: "connectionLost";
@@ -43,9 +55,12 @@ export interface MultiplayerConnection {
     onMessage(callback: (data: unknown) => void): () => void;
     onRoster(callback: (roster: MultiplayerRoster) => void): () => void;
     onStateChange(callback: (state: MultiplayerConnectionState, metadata?: MultiplayerStateMetadata) => void): () => void;
+    /** Voice chat for this session, run by the host. See MultiplayerVoice. */
+    readonly voice: MultiplayerVoice;
     leave(): void;
 }
 export interface CastleMultiplayerApi {
     join(options: MultiplayerJoinOptions): Promise<MultiplayerConnection>;
+    joinDestination(options: MultiplayerDestinationOptions): Promise<MultiplayerDestinationJoinResult>;
 }
 export declare const Multiplayer: CastleMultiplayerApi;

package/dist/multiplayer.js

@@ -1,17 +1,22 @@
 import { CastleError } from "./errors";
 import { BINARY_MESSAGE_TAG, isBinaryPayload, MAX_CLIENT_FRAME_BYTES, toUint8Array, } from "./multiplayerProtocol";
 import { hostRequest } from "./transport";
+import { MultiplayerVoiceImpl } from "./multiplayerVoice";
 const KEEPALIVE_INTERVAL_MS = 25_000;
 const HELLO_TIMEOUT_MS = 10_000;
 const RECONNECT_BUDGET_MS = 30_000;
 const RECONNECT_DELAYS_MS = [500, 1_000, 2_000, 4_000, 8_000];
 const INVALID_DEV_RECONNECT_CLOSE_CODE = 4003;
 let activeConnection = null;
-export const Multiplayer = { join };
+let latestJoinAttempt = 0;
+let pendingDestinationJoin = null;
+export const Multiplayer = { join, joinDestination };
 async function join(options) {
     const params = joinParams(options);
+    latestJoinAttempt += 1;
+    cancelPendingDestinationJoin();
     activeConnection?.leave();
-    const connection = new MultiplayerConnectionImpl(params, () => {
+    const connection = new MultiplayerConnectionImpl({ command: "multiplayer.getSession", params }, () => {
         if (activeConnection === connection)
             activeConnection = null;
     });
@@ -19,9 +24,80 @@ async function join(options) {
     await connection.start();
     return connection;
 }
+async function joinDestination(options) {
+    const params = destinationParams(options);
+    const attempt = ++latestJoinAttempt;
+    cancelPendingDestinationJoin();
+    if (activeConnection?.matchesDestination(params)) {
+        return {
+            status: "joined",
+            connection: activeConnection,
+            audience: activeConnection.destinationAudience,
+        };
+    }
+    const previousConnection = activeConnection;
+    const controller = new AbortController();
+    const pending = { controller, connection: null };
+    pendingDestinationJoin = pending;
+    let acquired;
+    try {
+        acquired = await hostRequest("multiplayer.joinDestination", params, {
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        if (attempt !== latestJoinAttempt || controller.signal.aborted) {
+            return { status: "cancelled" };
+        }
+        const status = destinationStatusFromError(error);
+        if (status)
+            return { status };
+        throw error;
+    }
+    if (attempt !== latestJoinAttempt)
+        return { status: "cancelled" };
+    if (acquired.status !== "ok") {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        return { status: acquired.status };
+    }
+    if (!acquired.url || !acquired.nonce || !acquired.audience) {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        return { status: "unavailable" };
+    }
+    const connection = new MultiplayerConnectionImpl({ command: "multiplayer.joinDestination", params }, () => {
+        if (activeConnection === connection)
+            activeConnection = null;
+    }, acquired.audience);
+    pending.connection = connection;
+    try {
+        await connection.start(acquired);
+    }
+    catch (error) {
+        if (pendingDestinationJoin === pending)
+            pendingDestinationJoin = null;
+        if (attempt !== latestJoinAttempt || controller.signal.aborted) {
+            return { status: "cancelled" };
+        }
+        throw error;
+    }
+    if (pendingDestinationJoin === pending)
+        pendingDestinationJoin = null;
+    if (attempt !== latestJoinAttempt) {
+        connection.leave();
+        return { status: "cancelled" };
+    }
+    previousConnection?.leave();
+    activeConnection = connection;
+    return { status: "joined", connection, audience: acquired.audience };
+}
 class MultiplayerConnectionImpl {
-    params;
+    request;
     onClosed;
+    destinationAudience;
     currentState = "acquiring";
     currentPlayerId = "";
     currentSessionId = "";
@@ -39,9 +115,15 @@ class MultiplayerConnectionImpl {
     messages = new Set();
     rosters = new Set();
     states = new Set();
-    constructor(params, onClosed) {
-        this.params = params;
+    voiceImpl = new MultiplayerVoiceImpl({
+        sessionId: () => this.currentSessionId,
+        players: () => this.roster?.players ?? [],
+        isSolo: () => this.solo,
+    });
+    constructor(request, onClosed, destinationAudience = null) {
+        this.request = request;
         this.onClosed = onClosed;
+        this.destinationAudience = destinationAudience;
     }
     get state() {
         return this.currentState;
@@ -58,9 +140,12 @@ class MultiplayerConnectionImpl {
     get soloReason() {
         return this.currentSoloReason;
     }
-    async start() {
+    get voice() {
+        return this.voiceImpl;
+    }
+    async start(initial) {
         try {
-            await this.acquire();
+            await this.acquire(initial);
         }
         catch (error) {
             const castleError = asCastleError(error);
@@ -108,9 +193,16 @@ class MultiplayerConnectionImpl {
             return;
         this.finish({ type: "left" });
     }
-    async acquire() {
+    matchesDestination(params) {
+        return (this.currentState !== "closed" &&
+            this.request.command === "multiplayer.joinDestination" &&
+            this.request.params.routeId === params.routeId &&
+            this.request.params.slot === params.slot &&
+            this.destinationAudience !== null);
+    }
+    async acquire(initial) {
         this.transition("acquiring");
-        const result = await hostRequest("multiplayer.getSession", this.params);
+        const result = initial ?? await requestAcquisition(this.request);
         this.assertOpen();
         if (result.status === "solo") {
             this.connectSolo(result);
@@ -122,8 +214,11 @@ class MultiplayerConnectionImpl {
         this.solo = false;
         this.currentSoloReason = null;
         this.baseUrl = result.url;
-        this.devReconnectStorageKey = result.devReconnectScope
-            ? `castle-dev-mp-reconnect:${result.url}:${result.sessionId}:${result.devReconnectScope}`
+        const devReconnectScope = "devReconnectScope" in result
+            ? result.devReconnectScope
+            : undefined;
+        this.devReconnectStorageKey = devReconnectScope
+            ? `castle-dev-mp-reconnect:${result.url}:${result.sessionId}:${devReconnectScope}`
             : null;
         this.transition("connecting");
         const savedToken = this.devReconnectStorageKey
@@ -171,6 +266,7 @@ class MultiplayerConnectionImpl {
         };
         this.setRoster({ players: [you], you });
         this.transition("connected");
+        void this.voiceImpl.attach();
     }
     openSocket(credential, value) {
         const attempt = ++this.socketAttempt;
@@ -253,6 +349,7 @@ class MultiplayerConnectionImpl {
         this.reAcquisitionUsed = false;
         this.transition("connected");
         this.startKeepalive();
+        void this.voiceImpl.attach();
     }
     handleFrame(frame) {
         switch (frame.t) {
@@ -293,6 +390,7 @@ class MultiplayerConnectionImpl {
     }
     setRoster(roster) {
         this.roster = roster;
+        this.voiceImpl.rosterChanged();
         for (const callback of this.rosters)
             callListener(callback, roster);
     }
@@ -391,6 +489,7 @@ class MultiplayerConnectionImpl {
         this.socketAttempt += 1;
         closeSocket(socket, 1000, "session closed");
         this.currentState = "closed";
+        this.voiceImpl.dispose();
         for (const callback of this.states)
             callStateListener(callback, "closed", metadata);
         this.onClosed();
@@ -423,6 +522,62 @@ function joinParams(options) {
     }
     throw invalidJoinOptions();
 }
+function destinationParams(options) {
+    if (!options ||
+        typeof options !== "object" ||
+        typeof options.routeId !== "string" ||
+        !/^[A-Za-z0-9_-]{1,64}$/.test(options.routeId) ||
+        typeof options.slot !== "string" ||
+        options.slot.length === 0 ||
+        options.slot.includes("\0") ||
+        !isValidUnicode(options.slot) ||
+        new TextEncoder().encode(options.slot).byteLength > 128) {
+        throw multiplayerError("INVALID_ARGUMENT", "Multiplayer.joinDestination requires a valid routeId and a non-empty slot of at most 128 bytes.", "Multiplayer.joinDestination");
+    }
+    return { routeId: options.routeId, slot: options.slot };
+}
+function cancelPendingDestinationJoin() {
+    const pending = pendingDestinationJoin;
+    pendingDestinationJoin = null;
+    pending?.controller.abort();
+    pending?.connection?.leave();
+}
+async function requestAcquisition(request) {
+    if (request.command === "multiplayer.getSession") {
+        return hostRequest(request.command, request.params);
+    }
+    return hostRequest(request.command, request.params);
+}
+function destinationStatusFromError(error) {
+    if (!(error instanceof CastleError))
+        return null;
+    switch (error.code) {
+        case "CAULDRON_DESTINATION_NOT_FOUND":
+            return "not_found";
+        case "CAULDRON_DESTINATION_FORBIDDEN":
+            return "forbidden";
+        case "CAULDRON_DESTINATION_PARTY_REQUIRED":
+            return "party_required";
+        case "CAULDRON_DESTINATION_FULL":
+            return "full";
+        case "CAULDRON_DESTINATION_UNAVAILABLE":
+        case "CAULDRON_DESTINATION_CONFIG_CHANGED":
+            return "unavailable";
+        case "CANCELLED":
+            return "cancelled";
+        default:
+            return null;
+    }
+}
+function isValidUnicode(value) {
+    try {
+        encodeURIComponent(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function invalidJoinOptions() {
     return multiplayerError("INVALID_ARGUMENT", "Multiplayer.join requires named, party, or public options.");
 }