@genex-ai/multiplayer 0.17.1 → 0.17.8

package/dist/protocol.d.ts

@@ -5,6 +5,24 @@ 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;
+/** The protocol an authority room (§17) speaks. Authority rooms have their own window so the relay
+ *  rooms' window above never moves: a published protocol-3 game keeps joining `play`, `queue` and
+ *  `match` exactly as before, and only an authority session sends 4. */
+declare const AUTHORITY_PROTOCOL_VERSION = 4;
+/** The oldest protocol an authority room seats. */
+declare const AUTHORITY_MIN_PROTOCOL_VERSION = 4;
+/** The inclusive range of `protocol` values one room type accepts. */
+interface ProtocolWindow {
+    min: number;
+    max: number;
+}
+/** `play`, `queue` and `match`. */
+declare const RELAY_WINDOW: Readonly<ProtocolWindow>;
+/** `authority` (§17). */
+declare const AUTHORITY_WINDOW: Readonly<ProtocolWindow>;
+/** Whether a sent `protocol` join option lies inside `window`: an integer number, nothing else
+ *  (a string, a boxed number or a missing option is outside every window). */
+declare function inProtocolWindow(sent: unknown, window: Readonly<ProtocolWindow>): boolean;
 /** 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. */
@@ -13,6 +31,9 @@ declare const RoomType: {
     readonly QUEUE: "queue";
     /** A capped match arena: seat reservation (matchmade), create (private lobby) or joinById (invite). */
     readonly MATCH: "match";
+    /** A server-authoritative room (§17): the server runs the game's room module, clients send input.
+     *  Served by the authority cluster, never by a relay. */
+    readonly AUTHORITY: "authority";
 };
 /** 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. */
@@ -26,8 +47,113 @@ declare const JoinOption: {
     /** {@link PROTOCOL_VERSION}. Required. */
     readonly PROTOCOL: "protocol";
 };
+/** The authority room's own join options (§17.2, §17.10). */
+declare const AuthorityJoinOption: {
+    /** The capabilities this client implements: at most {@link AuthorityCaps.MAX_CAPS} strings of at
+     *  most {@link AuthorityCaps.MAX_CAP_CHARS} characters; absent = []. Any other value is refused
+     *  with 400 by every authority room. */
+    readonly CAPS: "caps";
+    /** The client's SDK and version, `<sdk>/<version>` (§17.1): counted so a protocol bump can see whom it would
+     *  strand. Telemetry only: anything malformed is counted as unknown, never refused. */
+    readonly SDK: "sdk";
+    /** The pool this join asks for (§17.2 *Choosing a room*): rooms are found by it beside the game and
+     *  the region. Absent or empty = the game's one pool, as a client that names no room has always had.
+     *  Malformed (authority/room-key.ts `matchKeyOf`) is refused with 400. */
+    readonly MATCH_KEY: "matchKey";
+    /** `true` on a `create` makes a private room: no matchmaking reaches it, only its code. Any other
+     *  type is refused with 400. */
+    readonly PRIVATE: "private";
+    /** The room this seat lost (§17.13 *Drain and rejoin*): a room code. Rooms are found by it too, so a
+     *  lost room's seats meet in one successor, which alone reads the room's hand-off. Absent or empty =
+     *  no successor. Malformed is refused with 400. */
+    readonly SUCCESSOR_OF: "successorOf";
+    /** `true` keeps a successor closed to the game's pool: the lost room was private. Any other type is
+     *  refused with 400. */
+    readonly SUCCESSOR_CLOSED: "successorClosed";
+};
+/** `server:restart` on an authority room (§17.13): the room closes with 4001 this long after it. */
+interface AuthorityDrainNotice {
+    drainMs: number;
+}
+/** The SDK label this TypeScript client sends. tests hold it to package.json. */
+declare const AUTHORITY_SDK_LABEL = "ts/0.17.8";
+/** Client capabilities (§17.10 *Joining*). */
+declare const AuthorityCaps: {
+    /** Decodes and draws §17.10's physics bodies. A physics room refuses a join without it (426). An
+     *  SDK sends it only once its drawing passes `physics-draw.json` and, for an engine SDK, its own
+     *  probe on the pinned core (§17.10 *Conformance*). */
+    readonly PHYSICS: "physics@1";
+    /** Also predicts a predicting room's bodies (§17.11): it builds the room's world from `physDesc`,
+     *  adopts and replays keyframes, and draws its predicted bodies. A client sends it beside
+     *  `physics@1`, never alone; a room serves the same state to both, so the cap only says what the
+     *  client does. An SDK sends it only once it passes `physics-predict.json` (§17.11 *Conformance*). */
+    readonly PHYSICS_PREDICT: "physics@2";
+    /** Reconciles a predicting room's repeated inputs (§17.11 *Input pacing*): it predicts its own
+     *  entity from the state as stepped through `ackSeq + inRep`, not `ackSeq`. A predicting room repeats
+     *  a starved seat's last input only for a client that sends it; without it a starved tick steps
+     *  nothing, as before. An SDK sends it only once it passes `input-repeat.json`. */
+    readonly INPUT_REPEAT: "repeat@1";
+    /** Collides with, rides and draws a room's declared lifts (§17.11 *Lifts*). A room that declares
+     *  lifts refuses a join without it (426, `lifts@1 required`): a client that does not pose them
+     *  would fall through them in its prediction. An SDK sends it only once it passes `lifts.json`. */
+    readonly LIFTS: "lifts@1";
+    /** Writes into each input the server tick its prediction steps it at (`AuthorityInput.tick`, modulo
+     *  2^16; §17.11 *The input's tick*): the server then judges a re-timed input (a tick that steps two of
+     *  a seat's inputs or none) at the tick it was meant for — a firstperson view on a spinning lift
+     *  carried by the lift's turn between the two, lag compensation's lift frames. Without it the field
+     *  is ignored, as before. */
+    readonly INPUT_TICK: "tick@1";
+    /** Moves the seat's inputs and motion state to the fast channel (§17.12): redundant input datagrams
+     *  and ack-delta snapshots over UDP or WebTransport, the WebSocket kept for everything else. Sent
+     *  beside `tick@1`. An SDK sends it only once it passes `fast-transport.json` and its transport
+     *  tests; a room that does not offer the channel ignores it. */
+    readonly FAST: "fast@1";
+    /** The seat can come back to the fast channel after a fallback (§17.12 *Return to the channel*): it asks
+     *  for a fresh binding, proves the path and swaps. Sent beside `fast@1`; a host that does not know it
+     *  ignores it, and a client asks only a host whose binding says `rev` 2. */
+    readonly FAST_RETURN: "fast-return@1";
+    readonly MAX_CAPS: 16;
+    readonly MAX_CAP_CHARS: 32;
+};
+/** A join's `caps` option as a list, or null when it is malformed (refused with 400). */
+declare function capsOf(value: unknown): string[] | null;
+/** Placement units a physics room weighs at up to 60 Hz (§17.10 *Admission and placement*); any
+ *  other room weighs 1. */
+declare const AUTHORITY_PHYSICS_UNITS = 6;
+/** How many times its 60 Hz weight a physics room weighs at each tick rate (§17.10 *Admission and
+ *  placement*): a 120 Hz room steps twice as often, so it places and meters as twelve rooms. */
+declare const AUTHORITY_PHYSICS_TICK_WEIGHT: {
+    readonly 20: 1;
+    readonly 30: 1;
+    readonly 60: 1;
+    readonly 120: 2;
+};
+/** A room's weight per unit the platform weighs a room by: 1 without physics, else
+ *  {@link AUTHORITY_PHYSICS_UNITS} times its tick rate's {@link AUTHORITY_PHYSICS_TICK_WEIGHT}. */
+declare function authorityRoomUnits(physics: boolean, tickHz: keyof typeof AUTHORITY_PHYSICS_TICK_WEIGHT): number;
+/** How many 1/60 s of simulated time one tick's physics budget covers at `tickHz` (§17.10 *Limits
+ *  and failures*): the 1/60 s a tick steps up to 60 Hz, so a room's budget per simulated second is the
+ *  same at 20, 30 and 60 Hz; a 60 Hz tick's at 120 Hz (the owner's per-tick rule, 2026-11-03), so a
+ *  120 Hz room gets twice the CPU per simulated second, as it weighs twice in placement. Per second it
+ *  is always {@link AUTHORITY_PHYSICS_TICK_WEIGHT} times a 60 Hz room's. */
+declare function authorityPhysicsBudgetSixtieths(tickHz: keyof typeof AUTHORITY_PHYSICS_TICK_WEIGHT): number;
+/** The simulated time one tick's budgets are written for at `tickHz`, ms: its
+ *  {@link authorityPhysicsBudgetSixtieths} (50, 33.3 and 16.7 at 20, 30 and 60 Hz, and a 60 Hz tick's
+ *  16.7 at 120 Hz). Placement's event-loop gate is a share of it (colyseus `authorityLoopP99MaxMs`). */
+declare function authorityTickBudgetMs(tickHz: keyof typeof AUTHORITY_PHYSICS_TICK_WEIGHT): number;
+/** Colyseus's `Encoder.BUFFER_SIZE` on every authority worker (§17.10 *Interest*), set before any
+ *  room is created: a physics room's full state outgrows the 16 KiB default, and a predicting room's
+ *  (§17.11: a canonical descriptor on every body, up to 32 shared shapes of 16 KiB) measured 672 KB.
+ *  A full sync past it is re-run in a grown buffer, which sent the C# and C-core decoders a view they
+ *  could not decode, so it must never be taken. 1 MiB, written as one literal: esbuild keeps an
+ *  unused `1024 * 1024` in the relay bridge build and drops a literal. */
+declare const AUTHORITY_ENCODER_BUFFER_BYTES = 1048576;
 /** 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"];
+/** The authority room's server-owned options (§17.2): the relay's plus what the authority server
+ *  stamps from the admission it got for the room and the region the join entered through (§17.1). A separate list on purpose — adding these names to
+ *  {@link SERVER_OWNED_JOIN_OPTIONS} would start refusing protocol-3 joins that send them today. */
+declare const AUTHORITY_SERVER_OWNED_JOIN_OPTIONS: readonly ["clients", "preset", "winCondition", "config", "matchmade", "moduleSha", "tickHz", "maxPlayers", "lagComp", "seed", "units", "leaseId", "region", "createdBy"];
 /** Join refusal codes (the matchmaking error's `code`; the message names the reason). */
 declare const JoinError: {
     /** A server-owned option was sent. */
@@ -36,8 +162,20 @@ declare const JoinError: {
     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. */
+    /** A join by code entered through another region than the room's (§17.2 *Choosing a room*): the
+     *  client tries its next region. */
+    readonly WRONG_REGION: 421;
+    /** `protocol` missing or outside the room type's window ({@link RELAY_WINDOW},
+     *  {@link AUTHORITY_WINDOW}). Update the client. */
     readonly PROTOCOL_UNSUPPORTED: 426;
+    /** The game's owner is not entitled to server-authoritative rooms. Terminal: do not retry. */
+    readonly NOT_ENTITLED: 402;
+    /** The owner's room quota, concurrency cap or credits refused a NEW room. Live rooms never close for it. */
+    readonly ROOM_QUOTA: 429;
+    /** The game has no published room module on this channel, or it could not be loaded. */
+    readonly MODULE_UNAVAILABLE: 424;
+    /** No authority server can take the room right now, or admission could not be checked. Retry later. */
+    readonly AUTHORITY_CAPACITY: 503;
 };
 /** 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
@@ -155,6 +293,22 @@ declare const GLOBAL_RATE: {
 /** 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 same ceiling on an authority room's socket (§17.6 *The socket ceiling*): twenty seconds of inputs
+ *  at the top tick rate, so a seat whose TCP stalled that long and then hands its whole backlog over in
+ *  a second is not closed for it. A seat costs the worker's event loop about 5 µs a frame: 1% of a core
+ *  at the ceiling, and it may not exceed it. */
+declare const AUTHORITY_MAX_MESSAGES_PER_SECOND = 2400;
+/** The largest frame an authority node reads (a bigger one closes the socket): a client sends an input
+ *  frame (under 100 bytes) and `__fast:off` and nothing else, and no room type there takes a shared value. */
+declare const AUTHORITY_MAX_FRAME_BYTES: number;
+/** Why a seat, not its room, was closed: the reason text of its close frame. */
+declare const SeatCloseReason: {
+    /** Its socket passed {@link AUTHORITY_MAX_MESSAGES_PER_SECOND} (4002). */
+    readonly MessageFlood: "message_flood";
+    /** Its input had not changed for the room's idle limit (4408). */
+    readonly SeatIdle: "seat_idle";
+};
+type SeatCloseReason = (typeof SeatCloseReason)[keyof typeof SeatCloseReason];
 /** 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. */
@@ -178,7 +332,50 @@ declare const CloseCode: {
     readonly REVOKED: 4401;
     /** A newer session of the same player took the seat (second tab, or the page reloaded). */
     readonly SUPERSEDED: 4409;
+    /** Authority rooms: the seat's input had not changed for the room's idle limit (§17.6 *Room lifetime*). */
+    readonly IDLE: 4408;
+    /** The operator or the platform halted the room (kill switch, takedown, disabled game). */
+    readonly MODULE_HALTED: 4500;
+    /** The game's room module broke its limits or threw; the room is gone. */
+    readonly MODULE_FAULT: 4501;
+};
+/** Why an authority room's module was stopped. These are abuse and defect kills, distinct from billing: a quota
+ *  never closes a live room. The host's reason for an end, and the reason text of the close frame every seat gets
+ *  (§17.6), for the game's creator to read. */
+declare const AuthorityCloseCode: {
+    /** A call ran past its hard timeout (an infinite loop, a long microtask). */
+    readonly ModuleTimeout: "module_timeout";
+    /** The module hit its memory limit, or the heap poll caught it near the limit. */
+    readonly ModuleMemory: "module_memory";
+    /** The module threw (or failed to load) too many times. */
+    readonly ModuleError: "module_error";
+    /** The module's output broke the wire limits too many times. */
+    readonly ModuleOutputInvalid: "module_output_invalid";
+    /** The module stayed under the hard timeout but over the mean CPU budget for a whole window. */
+    readonly ModuleBudget: "module_budget";
+    /** The operator or the platform stopped the room (kill switch, takedown, disabled game). */
+    readonly Halted: "halted";
+    /** isolated-vm's wall-clock backstop stopped a call while the guest's own CPU stayed under its limit: the
+     *  host stalled (contention, a GC pause, descheduled). The guest was cut off mid-call, so it is
+     *  never called again; the room ends, but the module is not at fault. */
+    readonly HostStall: "host_stall";
+    /** The room's physics passed the physics meter for the third strike (§17.10). */
+    readonly PhysicsBudget: "physics_budget";
+    /** The room reached its age limit (§17.6 *Room lifetime*), announced like a drain. Not a fault. */
+    readonly RoomAge: "room_age";
+    /** The room sent more than its ceiling for a whole window (§17.6 *The downlink budget*): its module writes
+     *  too much state or too many events for its seats. Lower what it writes; no strike comes first. */
+    readonly ModuleBandwidth: "module_bandwidth";
+    /** The physics core answered `internal` (C§11.3): every physics room on that instance ends. Never
+     *  the module's fault. */
+    readonly PhysicsInternal: "physics_internal";
 };
+type AuthorityCloseCode = (typeof AuthorityCloseCode)[keyof typeof AuthorityCloseCode];
+/** A close frame's reason text as the vocabulary, or null: it comes from the network, so anything else reads as no reason.
+ *  Nothing at the module's top level, so the relay's bridge bundle, which never closes an authority room, leaves all this out. */
+declare function authorityCloseCodeOf(reason: unknown): AuthorityCloseCode | null;
+/** What to tell a player when a room ends with a reason: the code is for the game's creator, and none of them is the player's to act on. */
+declare const AUTHORITY_ROOM_ENDED_TEXT = "This match ended because of a problem with the game. Please try again.";
 declare const Limits: {
     readonly ROOM_MAX_CLIENTS: 64;
     readonly MAX_NAME_CHARS: 64;
@@ -243,6 +440,29 @@ declare const RelayTiming: {
     /** Embed tokens are re-checked for revocation on this cadence (REVOKED close on hit). */
     readonly REVOCATION_SWEEP_MS: 30000;
 };
+declare const AuthorityTiming: {
+    /** Fixed simulation step rate when the module does not choose one. */
+    readonly TICK_HZ: 30;
+    /** How far behind the server clock clients render other entities (the interpolation buffer). */
+    readonly RENDER_DELAY_MS: 100;
+    /** The furthest back lag compensation rewinds for one input's `seen` snapshot. */
+    readonly MAX_REWIND_MS: 500;
+    /** Inputs buffered per seat before the oldest are folded away. */
+    readonly INPUT_BUFFER: 32;
+    /** State patch cadence. The spike measured its feel gates at 50 ms; 33 is an owner call. */
+    readonly PATCH_INTERVAL_MS: 50;
+    /** A predicting room repeats a starved seat's last input for at most this long of repeats not yet
+     *  paid back (§17.11 *Input pacing*), then the seat holds: a vanished player stops instead of
+     *  driving into a wall. Rocket League's client resends its last 10 frames of input in every packet
+     *  (83 ms at 120 Hz), the gap its server's repeat bridges; 100 ms is that rounded up to whole ticks
+     *  at every tick rate (12 at 120 Hz, 6 at 60, 3 at 30). */
+    readonly INPUT_REPEAT_MAX_MS: 100;
+    /** One starve run is repeated for at most this long; past it the seat holds as before (§17.11 *Input
+     *  pacing*): a stick steady before a starve is less and less likely to stay so through it, and on
+     *  car-ball (5 runs a profile) 4 repeats a run at 120 Hz kept its corrections over 20 u at the base's
+     *  under loss where 12 doubled them. 4 ticks at 120 Hz, 2 at 60, 1 at 30. */
+    readonly INPUT_REPEAT_RUN_MS: 33;
+};
 /** 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. */
@@ -416,4 +636,4 @@ declare const ClockSync: {
     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 };
+export { AUTHORITY_ENCODER_BUFFER_BYTES, AUTHORITY_MAX_FRAME_BYTES, AUTHORITY_MAX_MESSAGES_PER_SECOND, AUTHORITY_MIN_PROTOCOL_VERSION, AUTHORITY_PHYSICS_TICK_WEIGHT, AUTHORITY_PHYSICS_UNITS, AUTHORITY_PROTOCOL_VERSION, AUTHORITY_ROOM_ENDED_TEXT, AUTHORITY_SDK_LABEL, AUTHORITY_SERVER_OWNED_JOIN_OPTIONS, AUTHORITY_WINDOW, AuthorityCaps, AuthorityCloseCode, type AuthorityDrainNotice, AuthorityJoinOption, AuthorityTiming, 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, type ProtocolWindow, RATE_LANES, RELAY_WINDOW, RESERVED_EVENT_PREFIXES, RESERVED_EVENT_TYPES, RESERVED_SHARED_PREFIX, type RateLane, RelayTiming, RoomType, SEND_TIME_KEY, SERVER_OWNED_JOIN_OPTIONS, STAGING_ROOM_PREFIX, SeatCloseReason, ServerMessage, type ServerMessageType, type SharedWrite, type VoiceSignal, type VoiceSignalEnvelope, authorityCloseCodeOf, authorityPhysicsBudgetSixtieths, authorityRoomUnits, authorityTickBudgetMs, capsOf, inProtocolWindow, isReservedEventType, roomKeyFor, slugOfRoomKey };

package/dist/protocol.js

@@ -1,4 +1,19 @@
 import {
+  AUTHORITY_ENCODER_BUFFER_BYTES,
+  AUTHORITY_MAX_FRAME_BYTES,
+  AUTHORITY_MAX_MESSAGES_PER_SECOND,
+  AUTHORITY_MIN_PROTOCOL_VERSION,
+  AUTHORITY_PHYSICS_TICK_WEIGHT,
+  AUTHORITY_PHYSICS_UNITS,
+  AUTHORITY_PROTOCOL_VERSION,
+  AUTHORITY_ROOM_ENDED_TEXT,
+  AUTHORITY_SDK_LABEL,
+  AUTHORITY_SERVER_OWNED_JOIN_OPTIONS,
+  AUTHORITY_WINDOW,
+  AuthorityCaps,
+  AuthorityCloseCode,
+  AuthorityJoinOption,
+  AuthorityTiming,
   ClientMessage,
   ClientReconnection,
   ClockSync,
@@ -14,6 +29,7 @@ import {
   POSE_KEYS,
   PROTOCOL_VERSION,
   RATE_LANES,
+  RELAY_WINDOW,
   RESERVED_EVENT_PREFIXES,
   RESERVED_EVENT_TYPES,
   RESERVED_SHARED_PREFIX,
@@ -22,12 +38,34 @@ import {
   SEND_TIME_KEY,
   SERVER_OWNED_JOIN_OPTIONS,
   STAGING_ROOM_PREFIX,
+  SeatCloseReason,
   ServerMessage,
+  authorityCloseCodeOf,
+  authorityPhysicsBudgetSixtieths,
+  authorityRoomUnits,
+  authorityTickBudgetMs,
+  capsOf,
+  inProtocolWindow,
   isReservedEventType,
   roomKeyFor,
   slugOfRoomKey
-} from "./chunk-C52XFIB6.js";
+} from "./chunk-CSQEEANB.js";
 export {
+  AUTHORITY_ENCODER_BUFFER_BYTES,
+  AUTHORITY_MAX_FRAME_BYTES,
+  AUTHORITY_MAX_MESSAGES_PER_SECOND,
+  AUTHORITY_MIN_PROTOCOL_VERSION,
+  AUTHORITY_PHYSICS_TICK_WEIGHT,
+  AUTHORITY_PHYSICS_UNITS,
+  AUTHORITY_PROTOCOL_VERSION,
+  AUTHORITY_ROOM_ENDED_TEXT,
+  AUTHORITY_SDK_LABEL,
+  AUTHORITY_SERVER_OWNED_JOIN_OPTIONS,
+  AUTHORITY_WINDOW,
+  AuthorityCaps,
+  AuthorityCloseCode,
+  AuthorityJoinOption,
+  AuthorityTiming,
   ClientMessage,
   ClientReconnection,
   ClockSync,
@@ -43,6 +81,7 @@ export {
   POSE_KEYS,
   PROTOCOL_VERSION,
   RATE_LANES,
+  RELAY_WINDOW,
   RESERVED_EVENT_PREFIXES,
   RESERVED_EVENT_TYPES,
   RESERVED_SHARED_PREFIX,
@@ -51,7 +90,14 @@ export {
   SEND_TIME_KEY,
   SERVER_OWNED_JOIN_OPTIONS,
   STAGING_ROOM_PREFIX,
+  SeatCloseReason,
   ServerMessage,
+  authorityCloseCodeOf,
+  authorityPhysicsBudgetSixtieths,
+  authorityRoomUnits,
+  authorityTickBudgetMs,
+  capsOf,
+  inProtocolWindow,
   isReservedEventType,
   roomKeyFor,
   slugOfRoomKey