@genex-ai/multiplayer 0.17.1 → 0.17.6

package/dist/{chunk-C52XFIB6.js → chunk-ZSWF4VCN.js}

@@ -1,13 +1,26 @@
 // src/protocol.ts
 var PROTOCOL_VERSION = 3;
 var MIN_PROTOCOL_VERSION = 3;
+var AUTHORITY_PROTOCOL_VERSION = 4;
+var AUTHORITY_MIN_PROTOCOL_VERSION = 4;
+var RELAY_WINDOW = Object.freeze({ min: MIN_PROTOCOL_VERSION, max: PROTOCOL_VERSION });
+var AUTHORITY_WINDOW = Object.freeze({
+  min: AUTHORITY_MIN_PROTOCOL_VERSION,
+  max: AUTHORITY_PROTOCOL_VERSION
+});
+function inProtocolWindow(sent, window) {
+  return typeof sent === "number" && Number.isInteger(sent) && sent >= window.min && sent <= window.max;
+}
 var RoomType = {
   /** The plain relay room: joinOrCreate, fullest-first placement. */
   PLAY: "play",
   /** The matchmaking search pool. No game session — it only hands out seat reservations. */
   QUEUE: "queue",
   /** A capped match arena: seat reservation (matchmade), create (private lobby) or joinById (invite). */
-  MATCH: "match"
+  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. */
+  AUTHORITY: "authority"
 };
 var JoinOption = {
   /** The game's slug. Must equal the embed token's `slug` claim. */
@@ -19,7 +32,77 @@ var JoinOption = {
   /** {@link PROTOCOL_VERSION}. Required. */
   PROTOCOL: "protocol"
 };
+var 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. */
+  CAPS: "caps"
+};
+var 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*). */
+  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*). */
+  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`. */
+  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`. */
+  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. */
+  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. */
+  FAST: "fast@1",
+  MAX_CAPS: 16,
+  MAX_CAP_CHARS: 32
+};
+function capsOf(value) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.length > AuthorityCaps.MAX_CAPS) return null;
+  const ok = value.every((cap) => typeof cap === "string" && cap.length <= AuthorityCaps.MAX_CAP_CHARS);
+  return ok ? [...value] : null;
+}
+var AUTHORITY_PHYSICS_UNITS = 6;
+var SIXTIETHS_PER_SECOND = 60;
+var AUTHORITY_PHYSICS_TICK_WEIGHT = { 20: 1, 30: 1, 60: 1, 120: 2 };
+function authorityRoomUnits(physics, tickHz) {
+  return physics ? AUTHORITY_PHYSICS_UNITS * AUTHORITY_PHYSICS_TICK_WEIGHT[tickHz] : 1;
+}
+function authorityPhysicsBudgetSixtieths(tickHz) {
+  return SIXTIETHS_PER_SECOND / tickHz * AUTHORITY_PHYSICS_TICK_WEIGHT[tickHz];
+}
+var MS_PER_SECOND = 1e3;
+function authorityTickBudgetMs(tickHz) {
+  return authorityPhysicsBudgetSixtieths(tickHz) * MS_PER_SECOND / SIXTIETHS_PER_SECOND;
+}
+var AUTHORITY_ENCODER_BUFFER_BYTES = 1048576;
 var SERVER_OWNED_JOIN_OPTIONS = ["clients", "preset", "winCondition", "config", "matchmade"];
+var AUTHORITY_SERVER_OWNED_JOIN_OPTIONS = [
+  ...SERVER_OWNED_JOIN_OPTIONS,
+  "moduleSha",
+  "tickHz",
+  "maxPlayers",
+  "lagComp",
+  "seed",
+  "units",
+  "leaseId",
+  "region"
+];
 var JoinError = {
   /** A server-owned option was sent. */
   BAD_OPTION: 400,
@@ -27,8 +110,18 @@ var JoinError = {
   AUTH_REQUIRED: 401,
   /** Token for another game ('wrong game'), or the room's guest cap is full. */
   FORBIDDEN: 403,
-  /** `protocol` missing or outside [MIN_PROTOCOL_VERSION, PROTOCOL_VERSION]. Update the client. */
-  PROTOCOL_UNSUPPORTED: 426
+  /** `protocol` missing or outside the room type's window ({@link RELAY_WINDOW},
+   *  {@link AUTHORITY_WINDOW}). Update the client. */
+  PROTOCOL_UNSUPPORTED: 426,
+  // ---- authority rooms only (§17.2); a relay room never answers these ----
+  /** The game's owner is not entitled to server-authoritative rooms. Terminal: do not retry. */
+  NOT_ENTITLED: 402,
+  /** The owner's room quota, concurrency cap or credits refused a NEW room. Live rooms never close for it. */
+  ROOM_QUOTA: 429,
+  /** The game has no published room module on this channel, or it could not be loaded. */
+  MODULE_UNAVAILABLE: 424,
+  /** No authority server can take the room right now, or admission could not be checked. Retry later. */
+  AUTHORITY_CAPACITY: 503
 };
 var STAGING_ROOM_PREFIX = "preview--";
 var roomKeyFor = (slug, channel) => channel === "staging" ? `${STAGING_ROOM_PREFIX}${slug}` : slug;
@@ -141,7 +234,12 @@ var CloseCode = {
   /** The player's session was revoked (signed out from the dashboard). Do not rejoin with it. */
   REVOKED: 4401,
   /** A newer session of the same player took the seat (second tab, or the page reloaded). */
-  SUPERSEDED: 4409
+  SUPERSEDED: 4409,
+  // ---- authority rooms only (§17.6), terminal ----
+  /** The operator or the platform halted the room (kill switch, takedown, disabled game). */
+  MODULE_HALTED: 4500,
+  /** The game's room module broke its limits or threw; the room is gone. */
+  MODULE_FAULT: 4501
 };
 var Limits = {
   ROOM_MAX_CLIENTS: 64,
@@ -207,6 +305,29 @@ var RelayTiming = {
   /** Embed tokens are re-checked for revocation on this cadence (REVOKED close on hit). */
   REVOCATION_SWEEP_MS: 3e4
 };
+var AuthorityTiming = {
+  /** Fixed simulation step rate when the module does not choose one. */
+  TICK_HZ: 30,
+  /** How far behind the server clock clients render other entities (the interpolation buffer). */
+  RENDER_DELAY_MS: 100,
+  /** The furthest back lag compensation rewinds for one input's `seen` snapshot. */
+  MAX_REWIND_MS: 500,
+  /** Inputs buffered per seat before the oldest are folded away. */
+  INPUT_BUFFER: 32,
+  /** State patch cadence. The spike measured its feel gates at 50 ms; 33 is an owner call. */
+  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). */
+  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. */
+  INPUT_REPEAT_RUN_MS: 33
+};
 var ClientReconnection = {
   enabled: true,
   minUptime: 0,
@@ -284,9 +405,24 @@ var ClockSync = {
 export {
   PROTOCOL_VERSION,
   MIN_PROTOCOL_VERSION,
+  AUTHORITY_PROTOCOL_VERSION,
+  AUTHORITY_MIN_PROTOCOL_VERSION,
+  RELAY_WINDOW,
+  AUTHORITY_WINDOW,
+  inProtocolWindow,
   RoomType,
   JoinOption,
+  AuthorityJoinOption,
+  AuthorityCaps,
+  capsOf,
+  AUTHORITY_PHYSICS_UNITS,
+  AUTHORITY_PHYSICS_TICK_WEIGHT,
+  authorityRoomUnits,
+  authorityPhysicsBudgetSixtieths,
+  authorityTickBudgetMs,
+  AUTHORITY_ENCODER_BUFFER_BYTES,
   SERVER_OWNED_JOIN_OPTIONS,
+  AUTHORITY_SERVER_OWNED_JOIN_OPTIONS,
   JoinError,
   STAGING_ROOM_PREFIX,
   roomKeyFor,
@@ -305,6 +441,7 @@ export {
   CloseCode,
   Limits,
   RelayTiming,
+  AuthorityTiming,
   ClientReconnection,
   POSE_KEYS,
   Interpolation,

package/dist/fast-client-CZ41v-oB.d.ts

@@ -0,0 +1,465 @@
+import { I as InputData } from './module-DqtFb5wA.js';
+
+/** The datagram format's version, the first byte of every datagram. */
+declare const FAST_VERSION = 1;
+/** No datagram is longer: the IPv6 minimum MTU (1280) less IP, UDP and QUIC headers. */
+declare const FAST_MAX_DATAGRAM_BYTES = 1200;
+/** The binding key's length: 8 random bytes per socket, sent on the reliable channel at join. */
+declare const FAST_KEY_BYTES = 8;
+/** The redundant window as time: the longest delay episode measured on `real-mac-wifi` (70–170 ms). */
+declare const INPUT_REDUNDANCY_MS = 170;
+/** The window's least inputs: two datagrams lost in a row are recovered at any tick rate. */
+declare const INPUT_REDUNDANCY_MIN = 3;
+/** The window's most inputs, and the most a datagram may carry: 32 full slots and
+ *  {@link FAST_MAX_ACTIONS} actions still fit {@link FAST_MAX_DATAGRAM_BYTES}. */
+declare const INPUT_REDUNDANCY_MAX = 32;
+/** Presses past the window awaiting the server's ack that one datagram carries (the oldest). */
+declare const FAST_MAX_ACTIONS = 8;
+/** The longest gap the server fills with the last input held; a longer one is skipped. */
+declare const FAST_GAP_FILL_MS = 250;
+/** A datagram whose newest seq is more than this far (as ticks) past the last accepted is dropped. */
+declare const FAST_SEQ_AHEAD_MS = 5000;
+/** Snapshots each side holds as bases: 533 ms at 60 Hz, over a 409 ms p99 round trip plus an episode. */
+declare const FAST_SNAPSHOT_HISTORY = 32;
+/** The most fragments one snapshot may have (about 37 KB); a larger body is not sent on this channel. */
+declare const FAST_MAX_FRAGMENTS = 32;
+/** Incomplete snapshots a client gathers at once; the oldest gives way. */
+declare const FAST_REASSEMBLY_SLOTS = 4;
+/** One record's most bytes. */
+declare const FAST_MAX_RECORD_BYTES = 1024;
+/** A client with no snapshot this long after its first datagram falls back to the WebSocket. */
+declare const FAST_HANDSHAKE_MS = 1000;
+/** A client with no snapshot for this long falls back to the WebSocket. */
+declare const FAST_STALL_FALLBACK_MS = 2000;
+/** The reliable messages of the fast channel (§17.12): the server's binding at join and the client's
+ *  fallback. Reserved names (`__`), so no game event can be mistaken for one. */
+declare const FastMessage: {
+    /** Server → client: `{ sid, key, url }`, the seat's binding. */
+    readonly Bind: "__fast";
+    /** Client → server: `{ last }`, the last seq the client sent by datagram; its inputs go by
+     *  `room.input()` from now on. */
+    readonly Off: "__fast:off";
+};
+type FastMessage = (typeof FastMessage)[keyof typeof FastMessage];
+/** Where a browser reaches the seat's channel (§17.12 *WebTransport*): a relay's WebTransport session
+ *  `url` (`https://host:port/w/<worker>`) and the SHA-256 hashes (64 lowercase hex digits each) of the
+ *  certificates it may serve, for `serverCertificateHashes`. The relay forwards the seat's datagrams,
+ *  byte for byte, to the endpoint `url` names; the binding (`sid`, `key`) is the same. */
+interface FastWebTransport {
+    url: string;
+    hashes: string[];
+}
+/** The `__fast` message's payload. `wt`, sent when the room's worker has a WebTransport relay, is read
+ *  only by a browser; every other client ignores it. */
+interface FastBindMessage {
+    sid: number;
+    key: string;
+    url: string;
+    wt?: FastWebTransport;
+}
+/** The `__fast:off` message's payload. */
+interface FastOffMessage {
+    last: number;
+}
+/** The datagram kinds, the second byte. */
+declare const FastKind: {
+    readonly Uplink: 1;
+    readonly Snapshot: 2;
+};
+type FastKind = (typeof FastKind)[keyof typeof FastKind];
+/** Why a datagram or a value was refused. */
+declare const FastFault: {
+    readonly Oversized: "oversized";
+    readonly Truncated: "truncated";
+    readonly Trailing: "trailing";
+    readonly Version: "version";
+    readonly Kind: "kind";
+    readonly Session: "session";
+    readonly Key: "key";
+    readonly Count: "count";
+    readonly Fresh: "fresh";
+    readonly Actions: "actions";
+    readonly Flags: "flags";
+    readonly Order: "order";
+    readonly Field: "field";
+    readonly Ahead: "ahead";
+    readonly Fragment: "fragment";
+    readonly Mismatch: "mismatch";
+    readonly Duplicate: "duplicate";
+    readonly Keyframe: "keyframe";
+    readonly Body: "body";
+    readonly Base: "base";
+    readonly Stale: "stale";
+};
+type FastFault = (typeof FastFault)[keyof typeof FastFault];
+/** How the server came by an accepted input. */
+declare const AcceptKind: {
+    /** First sent in the datagram that brought it. */
+    readonly Fresh: "fresh";
+    /** Sent first in an earlier datagram that was lost; carried again by redundancy or as an action. */
+    readonly Recovered: "recovered";
+    /** No datagram the server got carried it: the last input held stands in for it. */
+    readonly Fill: "fill";
+};
+type AcceptKind = (typeof AcceptKind)[keyof typeof AcceptKind];
+type FastResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    fault: FastFault;
+};
+/** One input on the wire: its client sequence, its `tick@1` field, its render time and its payload. */
+interface FastInput {
+    seq: number;
+    tick: number;
+    /** The render time its sender drew the world at when it sent it (§17.5): the room clock, whole ms,
+     *  as its WebSocket input frame's stamp would carry it; 0: not stamped (no synced clock). */
+    render: number;
+    input: InputData;
+}
+/** An uplink datagram's content. `window` is contiguous, oldest first; `actions` ascend below it. */
+interface Uplink {
+    sid: number;
+    key: string;
+    ackSnap: number;
+    fresh: number;
+    actions: FastInput[];
+    window: FastInput[];
+}
+/** A seat's fast-channel binding, from the reliable `fast` message. */
+interface FastBinding {
+    sid: number;
+    key: string;
+}
+/** The redundant window at `tickHz`: {@link INPUT_REDUNDANCY_MS} of inputs, within its bounds. */
+declare function inputRedundancyTicks(tickHz: number): number;
+/** The longest uplink a seat at `tickHz` sends: the header, {@link FAST_MAX_ACTIONS} actions and a full
+ *  window of slots, each at its largest (a socket that cannot carry it cannot carry the channel). */
+declare function uplinkMaxBytes(tickHz: number): number;
+/** The longest gap filled at `tickHz` ({@link FAST_GAP_FILL_MS} of ticks). */
+declare const gapFillMax: (tickHz: number) => number;
+/** The farthest a datagram's newest seq may be past the last accepted at `tickHz`. */
+declare const seqAheadMax: (tickHz: number) => number;
+/** Lowercase hex of `bytes`. */
+declare function toHex(bytes: Uint8Array): string;
+/** The bytes of hex text `hex` (an even count of hex digits; anything else reads as no bytes). */
+declare function fromHex(hex: string): Uint8Array;
+/** An input whose buttons gain a bit over `previous`'s. */
+declare const isPress: (previous: InputData | null, input: InputData) => boolean;
+/** Encodes uplink `u` (§17.12 *Uplink datagram*); refuses (`field`) what the wire cannot carry. */
+declare function encodeUplink(u: Uplink): FastResult<Uint8Array>;
+/** Decodes an uplink datagram for the seat bound by `binding`: checked whole, the session and key
+ *  first; any fault drops it. Payloads are as sent (the server sanitizes as it accepts). */
+declare function decodeUplink(bytes: Uint8Array, binding: FastBinding): FastResult<Uplink>;
+/** The render time a fast input carries (§17.12 *Render-time stamp*), the stamp its WebSocket input
+ *  frame would carry: `round(serverNow) − round(renderDelay + rtt/2)` whole ms, the delay clamped to
+ *  [0, 65535], 0 when that is not above 0 or the clock has not synced (`serverNow` null). */
+declare function renderStamp(serverNow: number | null, renderDelay: number, rtt: number): number;
+/** What {@link uplinkFor} needs beside the inputs. */
+interface UplinkOptions {
+    sid: number;
+    key: string;
+    /** The newest snapshot the client applied. */
+    ackSnap: number;
+    /** The server's last accepted input seq, from the newest applied snapshot's `inputAck`. */
+    inputAck: number;
+    /** How many of the newest inputs this datagram sends first. */
+    fresh: number;
+    tickHz: number;
+}
+/** The client's next uplink (§17.12 *Redundancy and one-shot inputs*): `sent` is every input it still
+ *  holds, ascending and contiguous, back past `inputAck`; the window is the newest
+ *  {@link inputRedundancyTicks}, and the oldest {@link FAST_MAX_ACTIONS} presses before it that the
+ *  server has not acked ride as actions. */
+declare function uplinkFor(sent: readonly FastInput[], o: UplinkOptions): Uplink;
+/** A seat's receive state: the last accepted seq (from `seqBase` at bind), the last accepted input
+ *  (null before the first) and the newest snapshot the seat acknowledged. */
+interface SeatRx {
+    last: number;
+    input: InputData | null;
+    ackSnap: number;
+}
+/** One input the server accepted, sanitized, in seq order, with the render time lag compensation
+ *  judges it at (0: unstamped; a filled input takes the one of the input after its gap). */
+interface AcceptedInput {
+    seq: number;
+    tick: number;
+    render: number;
+    input: InputData;
+    kind: AcceptKind;
+}
+interface AcceptOptions {
+    tickHz: number;
+    /** The newest snapshot id the server sent this seat (an `ackSnap` past it is ignored). */
+    snapSent: number;
+}
+interface AcceptResult {
+    seat: SeatRx;
+    accepted: AcceptedInput[];
+    /** Seqs consumed without a step: a gap longer than {@link gapFillMax}. */
+    skipped: number;
+    /** Set when the whole datagram was dropped; `seat` is then the very one given. */
+    fault?: FastFault;
+}
+/** The server's take of decoded uplink `u` for seat `seat` (§17.12 *Server dedup*): every held input
+ *  and slot ascending through `accept(seq)` (a seq at or below the last accepted is dropped), a gap
+ *  filled with the last input held or, past {@link gapFillMax}, skipped; `ackSnap` forward only. A
+ *  datagram whose newest seq is past {@link seqAheadMax} is dropped whole. Nothing new: the very same
+ *  seat. */
+declare function acceptUplink(seat: SeatRx, u: Uplink, o: AcceptOptions): AcceptResult;
+/** A snapshot's motion records, ascending by key; each record's bytes are the record codec's. */
+type Records = readonly {
+    key: number;
+    bytes: Uint8Array;
+}[];
+/** A snapshot body: the keys removed since the base, then the records new or changed. */
+interface SnapshotBody {
+    removed: number[];
+    records: Records;
+}
+/** The snapshot header the server writes. `base` 0 is a keyframe. */
+interface SnapshotHead {
+    sid: number;
+    snap: number;
+    base: number;
+    tick: number;
+    inputAck: number;
+    /** The room clock (ms since room start, §16.1 `sNow`, truncated to a uint32) when the server wrote
+     *  the snapshot: the value a WebSocket patch's TIMED prefix carries, so a fast seat's clock samples
+     *  exactly what a WebSocket seat's does (the tick's nominal instant is up to a step earlier). */
+    sent: number;
+}
+/** The body that turns `base` into `next` (null `base`: a keyframe, every record). */
+declare function diffSnapshot(base: Records | null, next: Records): SnapshotBody;
+/** The base the server deltas against: the seat's `ackSnap` while it still holds that snapshot
+ *  (`held`, its last {@link FAST_SNAPSHOT_HISTORY} sent ids), else 0 (a keyframe). */
+declare const deltaBase: (held: readonly number[], ackSnap: number) => number;
+/** The fragments of snapshot `head` with body `body` (§17.12 *Downlink snapshot*): `oversized` past
+ *  {@link FAST_MAX_FRAGMENTS}, `field` for a value the wire cannot carry. */
+declare function encodeSnapshot(head: SnapshotHead, body: SnapshotBody): FastResult<Uint8Array[]>;
+/** One decoded snapshot fragment. */
+interface Fragment {
+    snap: number;
+    base: number;
+    tick: number;
+    inputAck: number;
+    sent: number;
+    keyframe: boolean;
+    frag: number;
+    frags: number;
+    chunk: Uint8Array;
+}
+/** Decodes a snapshot fragment for seat `sid`; any fault drops it. */
+declare function decodeFragment(bytes: Uint8Array, sid: number): FastResult<Fragment>;
+/** Parses a reassembled body to the byte (keys ascending and unique, lengths in bounds, nothing left). */
+declare function parseBody(bytes: Uint8Array): FastResult<SnapshotBody>;
+/** `base`'s records less `body.removed`, with `body.records` written over them. */
+declare function applyBody(base: Records, body: SnapshotBody): Records;
+/** An applied snapshot the client holds as a base. */
+interface HeldSnapshot {
+    snap: number;
+    tick: number;
+    inputAck: number;
+    sent: number;
+    records: Records;
+}
+/** A snapshot being gathered: its first fragment's header and the chunks so far. */
+interface PartialSnapshot {
+    snap: number;
+    base: number;
+    tick: number;
+    inputAck: number;
+    sent: number;
+    keyframe: boolean;
+    frags: number;
+    chunks: readonly (Uint8Array | null)[];
+}
+/** The client's receive state: sets being gathered (ascending), applied snapshots held as bases
+ *  (oldest first, at most {@link FAST_SNAPSHOT_HISTORY}) and the newest applied id (0: none). */
+interface ClientRx {
+    partials: readonly PartialSnapshot[];
+    history: readonly HeldSnapshot[];
+    newest: number;
+}
+declare const emptyClientRx: () => ClientRx;
+interface ReceiveResult {
+    rx: ClientRx;
+    /** The snapshot this fragment completed and applied, else null. */
+    applied: number | null;
+    fault?: FastFault;
+}
+/** The client's take of one snapshot datagram (§17.12 *Applying a snapshot*). A fault drops the
+ *  fragment; while nothing was gathered for it, the answer is the very `rx` given. */
+declare function receiveFragment(rx: ClientRx, bytes: Uint8Array, sid: number): ReceiveResult;
+
+/** What a record describes, the first byte. */
+declare const MotionRecordKind: {
+    readonly Entity: 1;
+    readonly Seat: 2;
+};
+type MotionRecordKind = (typeof MotionRecordKind)[keyof typeof MotionRecordKind];
+/** An entity's motion fields (AuthorityEntity, §17.3, §17.7, §17.10), each at its default when absent. */
+interface EntityMotion {
+    x: number;
+    y: number;
+    z: number;
+    vx: number;
+    vy: number;
+    vz: number;
+    yaw: number;
+    pitch: number;
+    duck: number;
+    spin: number;
+    fuel: number;
+    epoch: number;
+    mstate: number;
+    qx: number;
+    qy: number;
+    qz: number;
+    qw: number;
+    lvx: number;
+    lvy: number;
+    lvz: number;
+    avx: number;
+    avy: number;
+    avz: number;
+    sleep: boolean;
+    rest: number;
+}
+/** A seat's input echo and pacing counters (AuthorityPlayer `in*`, §17.11), each 0 when absent. */
+interface SeatEcho {
+    inMoveX: number;
+    inMoveY: number;
+    inMoveZ: number;
+    inYaw: number;
+    inPitch: number;
+    inButtons: number;
+    inRep: number;
+    inStarve: number;
+    inBuf: number;
+    /** The receiving seat's own record only: its last input the server consumed (stepped or skipped)
+     *  as of this snapshot, the ack its reconciler replays from (0 in every other seat's record). */
+    inAck: number;
+}
+/** One motion record: an entity's or a seat's, by its id. */
+type MotionRecord = {
+    kind: typeof MotionRecordKind.Entity;
+    id: string;
+    motion: EntityMotion;
+} | {
+    kind: typeof MotionRecordKind.Seat;
+    id: string;
+    motion: SeatEcho;
+};
+/** The longest id a record carries, in characters (AuthorityLimits MAX_ENTITY_ID_CHARS and seat ids). */
+declare const RECORD_ID_MAX_CHARS = 64;
+/** Every entity motion field at its default. */
+declare const blankEntityMotion: () => EntityMotion;
+/** Every seat motion field at its default. */
+declare const blankSeatEcho: () => SeatEcho;
+/** The schema's quantize on a symmetric clamped range of half-width `half`: the uint16 code. */
+declare function quantizeCode(half: number, value: number): number;
+/** The schema's dequantize: the float a decoder reads for `code`. */
+declare const dequantizeCode: (half: number, code: number) => number;
+/** The record's bytes (§17.12 *Motion records*); refuses (`field`) what it cannot carry. */
+declare function encodeRecord(r: MotionRecord): FastResult<Uint8Array>;
+/** Reads one record to the byte; any fault drops it (the whole snapshot it came in). Every field
+ *  left out reads as its default. */
+declare function decodeRecord(bytes: Uint8Array): FastResult<MotionRecord>;
+
+/** A datagram socket to the room's fast endpoint. `send` never throws; a lost datagram is the
+ *  channel's normal case. */
+interface FastDatagramSocket {
+    send(bytes: Uint8Array): void;
+    close(): void;
+    /** True once the socket knows it can never carry the channel (a session that opens asynchronously
+     *  and was refused): the seat falls back at once instead of waiting out a deadline. */
+    failed?(): boolean;
+    /** The longest datagram the socket can send now, where it knows one (WebTransport's
+     *  `maxDatagramSize`): below the seat's largest uplink ({@link uplinkMaxBytes}), the seat falls back
+     *  at once. */
+    maxDatagramBytes?(): number | undefined;
+}
+/** Opens a socket to a `__fast` `url`, handing each datagram that arrives to `receive`; null when this
+ *  client cannot reach that kind of url (the seat then falls back at once). `bind` is the whole
+ *  binding (the client always passes it), for an opener that reaches the channel another way
+ *  (`bind.wt`, WebTransport). */
+type FastSocketOpener = (url: string, receive: (bytes: Uint8Array) => void, bind?: FastBindMessage) => FastDatagramSocket | null;
+/** Why a fast seat went back to the WebSocket. */
+declare const FastFallbackReason: {
+    /** The `__fast` binding was malformed, this client cannot open its url, or its socket failed. */
+    readonly Unreachable: "unreachable";
+    /** No snapshot within {@link FAST_HANDSHAKE_MS} of the first datagram. */
+    readonly Handshake: "handshake";
+    /** No snapshot for {@link FAST_STALL_FALLBACK_MS} after the last one. */
+    readonly Stall: "stall";
+    /** The server asked for it (`__fast:off` from the server). */
+    readonly Server: "server";
+};
+type FastFallbackReason = (typeof FastFallbackReason)[keyof typeof FastFallbackReason];
+/** One applied snapshot as the session uses it: its header and the motion records that differ from the
+ *  previous applied snapshot's (a record that does not decode is left out: its id stays as it was). */
+interface FastSnapshot {
+    snap: number;
+    tick: number;
+    /** The last input seq the server accepted (the header's `inputAck`). */
+    inputAck: number;
+    /** The room clock the server wrote it at (the header's `sent`, a WebSocket patch's TIMED `sNow`). */
+    sent: number;
+    changed: readonly MotionRecord[];
+}
+/** What one received datagram did. */
+interface FastReceipt {
+    applied: FastSnapshot | null;
+    fault?: FastFault;
+}
+interface FastClientOptions {
+    bind: FastBindMessage;
+    tickHz: number;
+    open: FastSocketOpener;
+    /** The clock the deadlines run on (ms). */
+    now: () => number;
+    /** Each applied snapshot, after the receive state took it. */
+    onSnapshot?: (s: FastSnapshot) => void;
+}
+/** One seat's fast channel on one socket. */
+interface FastClient {
+    readonly bind: FastBindMessage;
+    /** The snapshot receive state (reassembly, held bases, newest applied). */
+    readonly rx: ClientRx;
+    /** The newest input seq queued (0: none). */
+    readonly lastQueued: number;
+    /** True once closed: nothing is sent or received again. */
+    readonly closed: boolean;
+    /** An input sent this frame: seqs ascend by one from the first queued. */
+    queue(input: FastInput): void;
+    /** One datagram carrying the inputs queued since the last flush and the redundant window (one more for
+     *  each further window's worth of new inputs); nothing when none was queued. */
+    flush(): void;
+    /** The input of seq `seq` while it is still held. */
+    inputAt(seq: number): FastInput | undefined;
+    /** When the input of seq `seq` was first sent (by `now`), for each of the newest {@link seqAheadMax}
+     *  inputs: the server consumes an input well after it received it (its buffer, the next keyframe), and
+     *  the round trip is timed from the send of the input a snapshot acks as consumed. */
+    sentAt(seq: number): number | undefined;
+    /** The latest decoded record of `id` of `kind` (from the newest applied snapshot), else undefined. */
+    motionOf(kind: MotionRecordKind, id: string): MotionRecord | undefined;
+    /** Whether a deadline has passed (§17.12 *Fallback*), by the injected clock. */
+    due(): FastFallbackReason | null;
+    /** One datagram from the socket. A fault, a stale or duplicate fragment or a datagram for another
+     *  seat changes nothing. */
+    receive(bytes: Uint8Array): FastReceipt;
+    close(): void;
+}
+/** A `__fast` payload this client can use: sid a uint32, key {@link FAST_KEY_BYTES} bytes of lowercase
+ *  hex, url a string. */
+declare function isFastBind(m: unknown): m is FastBindMessage;
+/** The inputs `uplinkFor` still needs once the server accepted through `inputAck`: the window's newest
+ *  inputs, every input after the ack, and the one before the oldest of those (a press is a bit its
+ *  previous input lacked). At most {@link seqAheadMax} of them. */
+declare function heldInputs(sent: readonly FastInput[], inputAck: number, tickHz: number): FastInput[];
+/** Opens a seat's fast channel on `o.bind`; null when the opener cannot reach its url. */
+declare function openFastClient(o: FastClientOptions): FastClient | null;
+
+export { blankEntityMotion as $, AcceptKind as A, type FastReceipt as B, type ClientRx as C, type FastResult as D, type EntityMotion as E, type FastSocketOpener as F, type FastSnapshot as G, type FastWebTransport as H, type Fragment as I, type HeldSnapshot as J, INPUT_REDUNDANCY_MAX as K, INPUT_REDUNDANCY_MIN as L, INPUT_REDUNDANCY_MS as M, type MotionRecord as N, MotionRecordKind as O, type PartialSnapshot as P, type ReceiveResult as Q, RECORD_ID_MAX_CHARS as R, type Records as S, type SeatEcho as T, type SeatRx as U, type SnapshotBody as V, type SnapshotHead as W, type Uplink as X, type UplinkOptions as Y, acceptUplink as Z, applyBody as _, type FastBindMessage as a, blankSeatEcho as a0, decodeFragment as a1, decodeRecord as a2, decodeUplink as a3, deltaBase as a4, dequantizeCode as a5, diffSnapshot as a6, emptyClientRx as a7, encodeRecord as a8, encodeSnapshot as a9, encodeUplink as aa, fromHex as ab, gapFillMax as ac, heldInputs as ad, inputRedundancyTicks as ae, isFastBind as af, isPress as ag, openFastClient as ah, parseBody as ai, quantizeCode as aj, receiveFragment as ak, renderStamp as al, seqAheadMax as am, toHex as an, uplinkFor as ao, uplinkMaxBytes as ap, FastFallbackReason as b, type AcceptOptions as c, type AcceptResult as d, type AcceptedInput as e, FAST_GAP_FILL_MS as f, FAST_HANDSHAKE_MS as g, FAST_KEY_BYTES as h, FAST_MAX_ACTIONS as i, FAST_MAX_DATAGRAM_BYTES as j, FAST_MAX_FRAGMENTS as k, FAST_MAX_RECORD_BYTES as l, FAST_REASSEMBLY_SLOTS as m, FAST_SEQ_AHEAD_MS as n, FAST_SNAPSHOT_HISTORY as o, FAST_STALL_FALLBACK_MS as p, FAST_VERSION as q, type FastBinding as r, type FastClient as s, type FastClientOptions as t, type FastDatagramSocket as u, FastFault as v, type FastInput as w, FastKind as x, FastMessage as y, type FastOffMessage as z };