@genex-ai/multiplayer 0.16.1 → 0.17.0

package/dist/protocol.d.ts

@@ -0,0 +1,419 @@
+/** The protocol this SDK speaks, sent as the `protocol` join option. Bumped on any change a
+ *  client of the previous version would misread — a schema field inserted/retyped, a message
+ *  reshaped, a semantic change. Appending a schema field or adding a message is not a bump. */
+declare const PROTOCOL_VERSION = 3;
+/** The oldest protocol the relay still seats. A join below it (or without one) is refused with
+ *  {@link JoinError.PROTOCOL_UNSUPPORTED}. Protocol 3 is a hard cut: 2 (`__v`) is not served. */
+declare const MIN_PROTOCOL_VERSION = 3;
+/** Colyseus room types. Every game shares them; games are isolated by the `gameId` filter. */
+declare const RoomType: {
+    /** The plain relay room: joinOrCreate, fullest-first placement. */
+    readonly PLAY: "play";
+    /** The matchmaking search pool. No game session — it only hands out seat reservations. */
+    readonly QUEUE: "queue";
+    /** A capped match arena: seat reservation (matchmade), create (private lobby) or joinById (invite). */
+    readonly MATCH: "match";
+};
+/** Join option keys (every room type). Anything else is ignored, except the server-owned names in
+ *  {@link SERVER_OWNED_JOIN_OPTIONS}, which refuse the join. */
+declare const JoinOption: {
+    /** The game's slug. Must equal the embed token's `slug` claim. */
+    readonly GAME_ID: "gameId";
+    /** A fresh `embed:play` JWT. Required — there is no anonymous join. */
+    readonly EMBED_TOKEN: "embedToken";
+    /** Display-name fallback when the token carries none. */
+    readonly NAME: "name";
+    /** {@link PROTOCOL_VERSION}. Required. */
+    readonly PROTOCOL: "protocol";
+};
+/** Join options only the relay itself may set; a client sending any of them is refused (400). */
+declare const SERVER_OWNED_JOIN_OPTIONS: readonly ["clients", "preset", "winCondition", "config", "matchmade"];
+/** Join refusal codes (the matchmaking error's `code`; the message names the reason). */
+declare const JoinError: {
+    /** A server-owned option was sent. */
+    readonly BAD_OPTION: 400;
+    /** No token, an invalid/expired token, or a revoked session. */
+    readonly AUTH_REQUIRED: 401;
+    /** Token for another game ('wrong game'), or the room's guest cap is full. */
+    readonly FORBIDDEN: 403;
+    /** `protocol` missing or outside [MIN_PROTOCOL_VERSION, PROTOCOL_VERSION]. Update the client. */
+    readonly PROTOCOL_UNSUPPORTED: 426;
+};
+/** A preview (staging) build's rooms: the relay keys them `preview--<slug>`, apart from the live
+ *  game's rooms, so testers on a preview link play together and never meet real players. The
+ *  client always sends the plain slug as `gameId`; the relay picks the room from the token's
+ *  channel (PROTOCOL.md §3.4). No game can be named into this form: slugs never hold `--`. */
+declare const STAGING_ROOM_PREFIX = "preview--";
+/** The room key the relay files a join under, from the token's slug and channel. */
+declare const roomKeyFor: (slug: string, channel: "production" | "staging") => string;
+/** The game slug behind a room key (the key itself for a live room). */
+declare const slugOfRoomKey: (key: string) => string;
+/** Client → relay message types. Each row's payload and lane are in PROTOCOL.md §5. */
+declare const ClientMessage: {
+    readonly STATE: "state";
+    readonly STATE_SNAP: "__state:snap";
+    readonly SHARED: "shared";
+    readonly CLAIM: "claim";
+    readonly RELEASE: "release";
+    readonly DESTROY: "destroy";
+    readonly OBJECT: "obj";
+    readonly OBJECT_SNAP: "__object:snap";
+    readonly INPUT: "__input";
+    readonly ROOM_OPEN: "__room:open";
+    readonly CHAT: "__chat";
+    readonly CHAT_HISTORY_REQUEST: "__chat:history:request";
+    readonly VOICE_ICE_REQUEST: "__voice:ice:request";
+    readonly VOICE_JOIN: "__voice:join";
+    readonly VOICE_LEAVE: "__voice:leave";
+    readonly VOICE_SIGNAL: "__voice:signal";
+    readonly MATCH_ELIMINATED: "match:eliminated";
+    readonly MATCH_SCORE: "match:score";
+    readonly MATCH_FINISH: "match:finish";
+    readonly POSE: "__pose";
+    readonly POSE_SNAP: "__pose:snap";
+};
+/** Relay → client message types. */
+declare const ServerMessage: {
+    readonly OBJECT_RESULT: "__object:result";
+    readonly INPUT: "__input";
+    readonly ROOM_OPEN: "__room:open";
+    readonly CHAT: "__chat";
+    readonly CHAT_HISTORY: "__chat:history";
+    readonly VOICE_ICE: "__voice:ice";
+    readonly VOICE_SIGNAL: "__voice:signal";
+    readonly VOICE_REJECTED: "__voice:rejected";
+    readonly RATE_DROP: "rate:drop";
+    readonly SERVER_RESTART: "server:restart";
+    readonly MATCH_START: "match:start";
+    readonly MATCH_ENDED: "match:ended";
+    readonly MATCH_REQUEUE: "match:requeue";
+    readonly QUEUE: "queue";
+    readonly SEAT: "seat";
+};
+type ClientMessageType = (typeof ClientMessage)[keyof typeof ClientMessage];
+type ServerMessageType = (typeof ServerMessage)[keyof typeof ServerMessage];
+/** Prefixes a game event may not use. The relay drops (and counts) a client message with one of
+ *  these that it has no handler for — it is never relayed to peers. */
+declare const RESERVED_EVENT_PREFIXES: readonly ["__", "match:", "server:", "rate:"];
+/** Exact names a game event may not use: the relay's own unprefixed verbs. */
+declare const RESERVED_EVENT_TYPES: readonly ["state", "shared", "claim", "release", "destroy", "obj", "queue", "seat"];
+/** Whether `type` belongs to the relay rather than the game. A game event (any other string of
+ *  1..MAX_EVENT_TYPE_CHARS) is relayed verbatim to every other client in the room. */
+declare function isReservedEventType(type: string): boolean;
+/** Shared-map keys with this prefix are refused from clients (kept free for the relay). */
+declare const RESERVED_SHARED_PREFIX = "__";
+/** The key a sender stamps into its own `PlayerState.data` JSON: its send clock in ms (§10). */
+declare const SEND_TIME_KEY = "__t";
+/** Every inbound message spends a token from one lane. An empty lane drops the message (never a
+ *  kick) and earns a `rate:drop` notice, at most one per second. `bulk` and `input` additionally
+ *  share {@link GLOBAL_RATE}; the others are reserved capacity outside it. `bulk` also drops
+ *  probabilistically below `softZone` tokens, so overload loss spreads across streams. */
+declare const RATE_LANES: {
+    readonly state: {
+        readonly rate: 30;
+        readonly burst: 60;
+        readonly softZone: 0;
+    };
+    readonly control: {
+        readonly rate: 40;
+        readonly burst: 80;
+        readonly softZone: 0;
+    };
+    readonly input: {
+        readonly rate: 60;
+        readonly burst: 120;
+        readonly softZone: 0;
+    };
+    readonly bulk: {
+        readonly rate: 120;
+        readonly burst: 240;
+        readonly softZone: 60;
+    };
+    readonly chat: {
+        readonly rate: 2;
+        readonly burst: 5;
+        readonly softZone: 0;
+    };
+    readonly voice: {
+        readonly rate: 25;
+        readonly burst: 60;
+        readonly softZone: 0;
+    };
+    /** `__pose` / `__pose:snap` (§6.6). Its own reserved lane, outside the global bucket like
+     *  `state`: a posed player publishes pose AND (low-rate) `data`, and neither may starve the other. */
+    readonly pose: {
+        readonly rate: 30;
+        readonly burst: 60;
+        readonly softZone: 0;
+    };
+};
+type RateLane = keyof typeof RATE_LANES;
+declare const GLOBAL_RATE: {
+    readonly rate: 180;
+    readonly burst: 360;
+};
+/** Colyseus's own per-socket ceiling. Unlike the lanes this CLOSES the socket (4002); it exists
+ *  only to stop a raw socket hammering far past anything the lanes accept. */
+declare const MAX_MESSAGES_PER_SECOND = 1200;
+/** The lane each relay-handled client message spends. Game events and anything unhandled: bulk. */
+declare const MESSAGE_LANE: Readonly<Record<ClientMessageType, RateLane>>;
+/** WebSocket close codes a client can observe. Terminal = the seat is gone; do not reconnect. */
+declare const CloseCode: {
+    readonly GOING_AWAY: 1001;
+    readonly NO_STATUS: 1005;
+    readonly ABNORMAL: 1006;
+    /** Colyseus: the server is going down, come back. The one ≥4000 code that is not terminal. */
+    readonly MAY_TRY_RECONNECT: 4010;
+    readonly NORMAL: 1000;
+    /** A deliberate leave (Colyseus CONSENTED) — and the code a match room boots a requeued player
+     *  with when it ignored `match:requeue` (Genex MATCH_BOOT). Same number, same meaning: seat gone. */
+    readonly CONSENTED: 4000;
+    readonly MATCH_BOOT: 4000;
+    readonly SERVER_SHUTDOWN: 4001;
+    /** Colyseus: protocol error, or the socket exceeded MAX_MESSAGES_PER_SECOND. */
+    readonly WITH_ERROR: 4002;
+    /** Colyseus SDK: every reconnection attempt failed (the grace expired). */
+    readonly FAILED_TO_RECONNECT: 4003;
+    /** The player's session was revoked (signed out from the dashboard). Do not rejoin with it. */
+    readonly REVOKED: 4401;
+    /** A newer session of the same player took the seat (second tab, or the page reloaded). */
+    readonly SUPERSEDED: 4409;
+};
+declare const Limits: {
+    readonly ROOM_MAX_CLIENTS: 64;
+    readonly MAX_NAME_CHARS: 64;
+    readonly MAX_AVATAR_URL_CHARS: 512;
+    readonly MAX_UID_CHARS: 64;
+    /** `state` / `__state:snap` payload (the JSON text). */
+    readonly MAX_STATE_BYTES: number;
+    readonly MAX_SHARED_KEY_CHARS: 256;
+    readonly MAX_SHARED_VALUE_BYTES: number;
+    /** Distinct game keys a room's `shared` map may ever hold (keys are never deleted). */
+    readonly MAX_SHARED_KEYS: 256;
+    readonly MAX_OBJECT_ID_CHARS: 128;
+    /** An object's `d` as stored (JSON text). */
+    readonly MAX_OBJECT_STATE_BYTES: number;
+    /** Live objects per room (an id counts from its first accepted claim until `destroy`). */
+    readonly MAX_OBJECTS: 128;
+    readonly MAX_REQUEST_ID_CHARS: 96;
+    /** Game events and `__input`: the payload's JSON encoding. */
+    readonly MAX_EVENT_BYTES: number;
+    readonly MAX_EVENT_TYPE_CHARS: 128;
+    /** JSON payload shape bounds: nesting depth and total node count. */
+    readonly MAX_JSON_DEPTH: 32;
+    readonly MAX_JSON_NODES: 4096;
+    /** Code points per chat line after normalization. */
+    readonly MAX_CHAT_CHARS: 500;
+    readonly CHAT_HISTORY_MAX: 50;
+    readonly CHAT_HISTORY_MAX_BYTES: number;
+    readonly MAX_VOICE_PARTICIPANTS: 6;
+    readonly MAX_VOICE_SIGNAL_BYTES: number;
+    /** `match:score` delta is clamped to ±this. */
+    readonly MAX_SCORE_DELTA: 1000;
+    /** Results kept per session for request-id replay, and how long. */
+    readonly CONTROL_RESULTS_PER_SESSION: 128;
+    readonly CONTROL_RESULT_TTL_MS: 60000;
+    /** Open preset `teams` knob range (0 = no teams). */
+    readonly MAX_TEAMS: 8;
+    /** `__pose` `anim` string (§6.6). */
+    readonly MAX_ANIM_CHARS: 64;
+    /** Every `__pose` number must be finite with |v| ≤ this (float32 holds it without overflowing to
+     *  Infinity; past ~1e7 a float32 position is coarser than a metre anyway). */
+    readonly MAX_POSE_ABS: 1000000000;
+};
+declare const RelayTiming: {
+    /** State patch cadence: every accumulated change goes out on this tick. */
+    readonly PATCH_INTERVAL_MS: number;
+    /** Seat grace after an abnormal drop (1006 etc.). */
+    readonly RECONNECT_GRACE_S: 30;
+    /** Seat grace after a 1001 close (reload/navigate) — long enough to rejoin and supersede. */
+    readonly GOING_AWAY_GRACE_S: 5;
+    /** A dropped host keeps host for this long before the relay fails over. */
+    readonly HOST_FAILOVER_GRACE_MS: 1500;
+    /** A freshly changed owner cannot be displaced by an ordinary claim for this long. */
+    readonly MIN_OWNERSHIP_HOLD_MS: 300;
+    /** After `server:restart`, clients are dropped this much later. */
+    readonly SHUTDOWN_DRAIN_MS: 3000;
+    /** A requeued match player that has not left is booted (MATCH_BOOT) after this. */
+    readonly REQUEUE_GRACE_MS: 5000;
+    /** A seat reservation must be consumed within this. */
+    readonly SEAT_RESERVATION_S: 15;
+    /** The queue room's matchmaking pass. */
+    readonly QUEUE_TICK_MS: 1000;
+    /** Embed tokens are re-checked for revocation on this cadence (REVOKED close on hit). */
+    readonly REVOCATION_SWEEP_MS: 30000;
+};
+/** One owner of reconnection: the Colyseus SDK's in-place auto-reconnect, on from the first
+ *  millisecond (`minUptime: 0`), sized so the last attempt (~23.75s of backoff) lands inside the
+ *  30s seat grace, and with no send queue — a stale queued pose or event must never replay. */
+declare const ClientReconnection: {
+    readonly enabled: true;
+    readonly minUptime: 0;
+    readonly delay: 125;
+    readonly minDelay: 100;
+    readonly maxDelay: 4000;
+    readonly maxRetries: 9;
+    readonly maxEnqueuedMessages: 0;
+    /** After the SDK reports reconnected, wait at most this for the first state decode (§8). */
+    readonly firstStateTimeoutMs: 2000;
+};
+type ObjectControlOperation = 'claim' | 'release' | 'remove';
+type ObjectControlReason = 'accepted' | 'already-owner' | 'held' | 'rate-limited' | 'not-owner' | 'capacity' | 'invalid' | 'missing' | 'host-authority' | 'not-host';
+/** `claim` / `release` / `destroy` payload. `authority: 'host'` is claim-only and host-only. */
+type ObjectControlRequest = {
+    id: string;
+    requestId: string;
+    authority?: 'host';
+};
+/** `__object:result` payload — exactly one per request id (rate-limited answers are not cached). */
+type ObjectControlResult = {
+    requestId: string;
+    operation: ObjectControlOperation;
+    id: string;
+    accepted: boolean;
+    /** Owner after the operation, when there is one. */
+    owner?: string;
+    /** `ObjectState.seq` after the operation (0 when the object does not exist). */
+    sequence: number;
+    reason: ObjectControlReason;
+    /** On `held` / `rate-limited`: earliest sensible retry. */
+    retryAfterMs?: number;
+};
+/** `obj` / `__object:snap`: `d` is a JSON object, `t` the sender's clock in ms. */
+type ObjectPublish = {
+    id: string;
+    d: Record<string, unknown>;
+    t: number;
+};
+/** `shared`: `value` is JSON text. */
+type SharedWrite = {
+    key: string;
+    value: string;
+};
+/** `__input` as delivered to the host. */
+type InputEnvelope = {
+    from: string;
+    d: unknown;
+};
+/** `__chat` as broadcast (the client sends only `{ text }`). */
+type ChatMessage = {
+    id: number;
+    from: string;
+    name: string;
+    text: string;
+    at: number;
+};
+type VoiceSignal = {
+    to: string;
+    data: unknown;
+};
+type VoiceSignalEnvelope = {
+    from: string;
+    data: unknown;
+};
+type IceServer = {
+    urls: string | string[];
+    username?: string;
+    credential?: string;
+};
+type IceConfig = {
+    iceServers: IceServer[];
+    ttl: number;
+};
+type MatchEnded = {
+    winnerId: string | null;
+    losers: string[];
+    draw: boolean;
+    scores: Record<string, number>;
+};
+/** The `PlayerState` pose keys, in schema order. An SDK that offers pose routes exactly these keys of
+ *  a game's player state into `__pose` and everything else into `data`; a posed player's `data` never
+ *  carries them (§6.6). `anim` is discrete; the rest interpolate (`yaw` along the shortest arc). */
+declare const POSE_KEYS: readonly ["x", "y", "z", "yaw", "vx", "vy", "vz", "anim"];
+type PoseKey = (typeof POSE_KEYS)[number];
+/** `__pose` / `__pose:snap` payload. Every key but `t` is optional; an absent key keeps the stored
+ *  value (so a 2D game may never send `z`). Numbers: finite, |v| ≤ {@link Limits.MAX_POSE_ABS};
+ *  `t`: the sender's clock in ms (same clock as `__t`), finite and nonzero. Unknown keys are ignored;
+ *  a known key of the wrong type drops the whole message. */
+type PosePublish = {
+    x?: number;
+    y?: number;
+    z?: number;
+    /** Radians, any finite value. */
+    yaw?: number;
+    /** World units per second. */
+    vx?: number;
+    vy?: number;
+    vz?: number;
+    /** ≤ {@link Limits.MAX_ANIM_CHARS}. */
+    anim?: string;
+    t: number;
+};
+declare const Interpolation: {
+    /** Render delay target = RATIO × median publish interval of that sender… */
+    readonly RATIO: 1.5;
+    /** …but at least JITTER_SAFETY × (p90 − min) of that sender's (arrival − sendTime)… */
+    readonly JITTER_SAFETY: 1.25;
+    /** …clamped to [MIN_MS, MAX_MS], and DEFAULT_MS before anything is measured. */
+    readonly MIN_MS: 90;
+    readonly MAX_MS: 300;
+    readonly DEFAULT_MS: 100;
+    /** Per-sample fraction the delay moves toward its target (no pops). */
+    readonly EASE: 0.1;
+    /**
+     * The min-filtered clock-offset window, kept PER SENDER: it holds at least the last CLOCK_WINDOW
+     * samples AND at least CLOCK_WINDOW_MS of them, whichever reaches further back, so a sender that
+     * owns many streams never shrinks the time the window covers. The jitter term reads each stream's
+     * own last CLOCK_WINDOW samples.
+     */
+    readonly CLOCK_WINDOW: 80;
+    readonly CLOCK_WINDOW_MS: 5000;
+    /** Hard cap on one sender's window (memory bound for a sender publishing very many streams). */
+    readonly CLOCK_WINDOW_MAX: 4096;
+    /** Publish-gap history for the median; gaps outside (MIN_GAP_MS, MAX_GAP_MS) are ignored. */
+    readonly INTERVAL_WINDOW: 30;
+    readonly MIN_GAP_MS: 5;
+    readonly MAX_GAP_MS: 2000;
+    /** Snapshot history kept per stream (never fewer than 2). */
+    readonly HISTORY_MS: 1500;
+    /** Past the newest snapshot: dead-reckon position at most this far, rotation this far. */
+    readonly MAX_EXTRAP_MS: 250;
+    readonly ROT_EXTRAP_MS: 150;
+    /** Output smoothing time constants (alpha = 1 − e^(−dt/τ), dt clamped to 250 ms). */
+    readonly SMOOTH_TAU_POS_MS: 30;
+    readonly SMOOTH_TAU_ROT_MS: 70;
+    /** A head snapshot this far in the future of the newest is a foreign-clock poison: drop it. */
+    readonly POISON_GUARD_MS: 2000;
+    /** A reconnect gap longer than this discards every stream's history (one deliberate rebase). */
+    readonly REBASE_AFTER_GAP_MS: 1000;
+    /** Host tick dt is clamped to this (a backgrounded tab must not tunnel the simulation). */
+    readonly MAX_HOST_TICK_DT_MS: 250;
+};
+/** The relay's clock heartbeat (§16). The relay declares `HeartbeatInput` (schema.ts) with
+ *  `defineInput` purely so every state frame carries the TIMED `[u32 sNow][u32 ackSeq]` prefix; it
+ *  consumes every buffered heartbeat right before each patch, so `ackSeq` advances one patch after
+ *  arrival and each client measures RTT on its own heartbeats. No fixed timestep, no simulation, no
+ *  rewind stamps, nothing forwarded. Present only when the join handshake carries the input sections. */
+declare const ClockSync: {
+    /** The heartbeat rate a client SHOULD send at, from a wall-clock timer (never the render loop). */
+    readonly HEARTBEAT_HZ: 10;
+    /** A client that sends heartbeats MUST stay within [MIN_HEARTBEAT_HZ, MAX_HEARTBEAT_HZ] while its
+     *  page is foregrounded. Below MIN the offset and RTT refresh too slowly; above MAX buys nothing,
+     *  and the relay's small buffer (RELAY_BUFFER) folds the excess away. */
+    readonly MIN_HEARTBEAT_HZ: 5;
+    readonly MAX_HEARTBEAT_HZ: 20;
+    /** Each interval is the nominal one × (1 ± up to this), clamped to the band above. A fixed interval
+     *  that divides the patch interval phase-locks to the patch tick (every RTT sample then carries the
+     *  same hold); the dither walks the phase so near-zero holds keep turning up. */
+    readonly HEARTBEAT_DITHER: 0.15;
+    /** Relay `defineInput({ bufferMaxSize })`. Overflow counts as consumed, so a burst still acks. */
+    readonly RELAY_BUFFER: 4;
+    /** Acked heartbeats (RTT-valid samples) before a client treats `serverNow` as synced and uses it
+     *  for deadlines (≈3 s at 10 Hz). The room clock seeds its offset from the first TIMED frame, which
+     *  is biased by the one-way latency, and then moves by an EMA (α = 0.1) per RTT sample, so after k
+     *  samples 0.9^k of that bias remains: ≈35% at 10, ≈4% at 30 (≈6 ms at 150 ms one way). 30 is also
+     *  where the room clock's RTT gate stops being bypassed (its warmup). */
+    readonly WARMUP_ACKS: 30;
+};
+
+export { type ChatMessage, ClientMessage, type ClientMessageType, ClientReconnection, ClockSync, CloseCode, GLOBAL_RATE, type IceConfig, type IceServer, type InputEnvelope, Interpolation, JoinError, JoinOption, Limits, MAX_MESSAGES_PER_SECOND, MESSAGE_LANE, MIN_PROTOCOL_VERSION, type MatchEnded, type ObjectControlOperation, type ObjectControlReason, type ObjectControlRequest, type ObjectControlResult, type ObjectPublish, POSE_KEYS, PROTOCOL_VERSION, type PoseKey, type PosePublish, RATE_LANES, RESERVED_EVENT_PREFIXES, RESERVED_EVENT_TYPES, RESERVED_SHARED_PREFIX, type RateLane, RelayTiming, RoomType, SEND_TIME_KEY, SERVER_OWNED_JOIN_OPTIONS, STAGING_ROOM_PREFIX, ServerMessage, type ServerMessageType, type SharedWrite, type VoiceSignal, type VoiceSignalEnvelope, isReservedEventType, roomKeyFor, slugOfRoomKey };

package/dist/protocol.js

@@ -0,0 +1,58 @@
+import {
+  ClientMessage,
+  ClientReconnection,
+  ClockSync,
+  CloseCode,
+  GLOBAL_RATE,
+  Interpolation,
+  JoinError,
+  JoinOption,
+  Limits,
+  MAX_MESSAGES_PER_SECOND,
+  MESSAGE_LANE,
+  MIN_PROTOCOL_VERSION,
+  POSE_KEYS,
+  PROTOCOL_VERSION,
+  RATE_LANES,
+  RESERVED_EVENT_PREFIXES,
+  RESERVED_EVENT_TYPES,
+  RESERVED_SHARED_PREFIX,
+  RelayTiming,
+  RoomType,
+  SEND_TIME_KEY,
+  SERVER_OWNED_JOIN_OPTIONS,
+  STAGING_ROOM_PREFIX,
+  ServerMessage,
+  isReservedEventType,
+  roomKeyFor,
+  slugOfRoomKey
+} from "./chunk-C52XFIB6.js";
+export {
+  ClientMessage,
+  ClientReconnection,
+  ClockSync,
+  CloseCode,
+  GLOBAL_RATE,
+  Interpolation,
+  JoinError,
+  JoinOption,
+  Limits,
+  MAX_MESSAGES_PER_SECOND,
+  MESSAGE_LANE,
+  MIN_PROTOCOL_VERSION,
+  POSE_KEYS,
+  PROTOCOL_VERSION,
+  RATE_LANES,
+  RESERVED_EVENT_PREFIXES,
+  RESERVED_EVENT_TYPES,
+  RESERVED_SHARED_PREFIX,
+  RelayTiming,
+  RoomType,
+  SEND_TIME_KEY,
+  SERVER_OWNED_JOIN_OPTIONS,
+  STAGING_ROOM_PREFIX,
+  ServerMessage,
+  isReservedEventType,
+  roomKeyFor,
+  slugOfRoomKey
+};