@pylonsync/realtime 0.14.0

package/src/connection.ts

@@ -0,0 +1,356 @@
+/**
+ * A shard connection with no framework: one WebSocket, reconnected with
+ * backoff, that decodes frames, applies replication frames to an
+ * `EntityTable`, and sends inputs. `useShard` in `@pylonsync/react` and
+ * `connectShardGame` build on it.
+ */
+
+import { ShardClock } from "./clock";
+import { EntityTable, type ReplicationSummary } from "./replication";
+import {
+  SHARD_PROTOCOL_VERSION,
+  ShardFrameKind,
+  decodeShardPayload,
+  decodeShardRejection,
+  encodeShardInput,
+  parseShardFrame,
+  type ShardInputRejection,
+  type ShardPayloadDecoder,
+} from "./wire";
+
+export interface ShardConnectOptions {
+  /** Subscriber ID (usually the logged-in user ID). Required for multiplayer. */
+  subscriberId: string;
+  /**
+   * Auth token. Sent as a `bearer.<token>` WebSocket subprotocol, which
+   * keeps it out of URLs (proxy logs, devtools, and error telemetry record
+   * URLs, not subprotocols).
+   */
+  token?: string;
+  /**
+   * Shard ticket from a server function (`ctx.shards.ticket(...)`). Sent as
+   * a `ticket.<ticket>` WebSocket subprotocol. The shard checks it names
+   * this shard and `subscriberId`, and passes its claims to the game's
+   * authorization hooks.
+   *
+   * Tickets expire. Pass a function to get a new one for each connection
+   * attempt, so a reconnect after the expiry still gets in.
+   */
+  ticket?: string | (() => string | Promise<string>);
+  /** Host (and port) of the Pylon server. Defaults to `window.location.host`. */
+  baseUrl?: string;
+  /**
+   * Connect to the dedicated shard port instead of `/shard` on the main
+   * port (the dedicated port is the HTTP port + 3, e.g. 4324).
+   */
+  wsPort?: number;
+  /** Explicit WebSocket URL. Overrides baseUrl/wsPort. */
+  wsUrl?: string;
+  /** Reconnect on unexpected close (default: true). */
+  autoReconnect?: boolean;
+  /** First reconnect delay in ms (default 500; doubles to at most 10 000). */
+  reconnectBackoffMs?: number;
+  /**
+   * Decoder for a payload codec the client does not know: bincode (`2`) or
+   * a game's own codec (`3`). JSON and MessagePack are built in.
+   */
+  decode?: ShardPayloadDecoder;
+  /** The shard's tick rate, when known; otherwise the clock measures it. */
+  tickRate?: number;
+  /** Monotonic time in ms. Default `performance.now()`. */
+  now?: () => number;
+}
+
+export interface ShardClient<TSnapshot = unknown, TInput = unknown> {
+  /** `ack` is the highest `send()` sequence number the shard has processed. */
+  onSnapshot: (fn: (snapshot: TSnapshot, tick: number, ack: number) => void) => void;
+  /** Called when the shard refuses an input (see `ShardInputRejection.code`). */
+  onInputRejected: (fn: (rejection: ShardInputRejection) => void) => void;
+  /**
+   * For a shard that replicates entities: called after each frame is
+   * applied to `entities`, with what it changed.
+   */
+  onReplication: (
+    fn: (entities: EntityTable, summary: ReplicationSummary, tick: number, ack: number) => void,
+  ) => void;
+  /**
+   * The entities a replicating shard has sent this client. Read it each
+   * frame (a render loop); it changes in place as frames arrive.
+   */
+  readonly entities: EntityTable;
+  /** The shard's current tick, estimated from frame arrivals. */
+  readonly clock: ShardClock;
+  /** The tick of the last frame, or -1. */
+  readonly tick: number;
+  /** The ack of the last frame. */
+  readonly ack: number;
+  /**
+   * Smoothed time from sending an input to the first frame that
+   * acknowledges it (ms), or null before one has. It includes the wait for
+   * the shard's next tick.
+   */
+  readonly rttMs: number | null;
+  onError: (fn: (err: Error) => void) => void;
+  onOpen: (fn: () => void) => void;
+  onClose: (fn: () => void) => void;
+  /**
+   * Send an input. Returns its sequence number, which later frames
+   * acknowledge, or 0 when the connection is not open (the input is not
+   * sent, and `onError` hears why).
+   */
+  send: (input: TInput) => number;
+  close: () => void;
+  readonly connected: boolean;
+}
+
+/** Input send times kept for the round-trip estimate. */
+const MAX_TIMED = 256;
+
+/**
+ * Connect to a shard without React. Returns a client you can wire into any
+ * framework or render loop.
+ */
+export function connectShard<TSnapshot = unknown, TInput = unknown>(
+  shardId: string,
+  options: ShardConnectOptions,
+): ShardClient<TSnapshot, TInput> {
+  const now = options.now ?? (() => performance.now());
+  let ws: WebSocket | null = null;
+  let clientSeq = 0;
+  let closed = false;
+  let connected = false;
+  let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  let backoff = options.reconnectBackoffMs ?? 500;
+  // The shard's codec, learned from the first frame. Until then inputs go
+  // as JSON text, which every shard accepts.
+  let codec: number | null = null;
+  let lastTick = -1;
+  let lastAck = 0;
+  let rttMs: number | null = null;
+  // Send time per unacknowledged sequence number, oldest first.
+  const sentAt = new Map<number, number>();
+  const clock = new ShardClock({ tickRate: options.tickRate });
+
+  const snapshotHandlers: Array<(s: TSnapshot, t: number, ack: number) => void> = [];
+  const rejectionHandlers: Array<(r: ShardInputRejection) => void> = [];
+  const replicationHandlers: Array<
+    (entities: EntityTable, summary: ReplicationSummary, tick: number, ack: number) => void
+  > = [];
+  const entities = new EntityTable();
+  const errorHandlers: Array<(e: Error) => void> = [];
+  const openHandlers: Array<() => void> = [];
+  const closeHandlers: Array<() => void> = [];
+
+  const dispatchError = (err: Error) => {
+    for (const h of errorHandlers) h(err);
+  };
+
+  const buildWsUrl = (): string => {
+    if (options.wsUrl) return options.wsUrl;
+    const proto =
+      typeof window !== "undefined" && window.location.protocol === "https:" ? "wss" : "ws";
+    // Only shard id + subscriber id land in the URL: routing metadata, not
+    // credentials.
+    const params = new URLSearchParams({
+      shard: shardId,
+      sid: options.subscriberId,
+      v: String(SHARD_PROTOCOL_VERSION),
+    });
+    if (options.wsPort !== undefined) {
+      const hostname = (
+        options.baseUrl ?? (typeof window !== "undefined" ? window.location.hostname : "localhost")
+      ).replace(/:\d+$/, "");
+      return `${proto}://${hostname}:${options.wsPort}/?${params.toString()}`;
+    }
+    // Default: `/shard` on the page's own origin, which any proxy that
+    // forwards WebSocket upgrades on 443 already reaches.
+    const host =
+      options.baseUrl || (typeof window !== "undefined" ? window.location.host : "localhost:4321");
+    return `${proto}://${host}/shard?${params.toString()}`;
+  };
+
+  /** Round-trip samples for every input `ack` covers. */
+  const timeAcks = (ack: number, at: number) => {
+    for (const [seq, t] of sentAt) {
+      if (seq > ack) break;
+      const sample = at - t;
+      rttMs = rttMs === null ? sample : rttMs + (sample - rttMs) / 8;
+      sentAt.delete(seq);
+    }
+  };
+
+  const scheduleReconnect = () => {
+    if (closed || options.autoReconnect === false) return;
+    reconnectTimer = setTimeout(connect, backoff);
+    backoff = Math.min(backoff * 2, 10_000);
+  };
+
+  const connect = () => {
+    if (closed) return;
+    const source = options.ticket;
+    if (typeof source !== "function") {
+      open(source);
+      return;
+    }
+    let ticket: string | Promise<string>;
+    try {
+      ticket = source();
+    } catch (e) {
+      dispatchError(e instanceof Error ? e : new Error(String(e)));
+      scheduleReconnect();
+      return;
+    }
+    if (typeof ticket === "string") {
+      open(ticket);
+      return;
+    }
+    ticket.then(
+      (t) => {
+        if (!closed) open(t);
+      },
+      (e) => {
+        dispatchError(e instanceof Error ? e : new Error(String(e)));
+        scheduleReconnect();
+      },
+    );
+  };
+
+  const open = (ticket: string | undefined) => {
+    const url = buildWsUrl();
+    try {
+      // Subprotocol values must be RFC 6455 tokens; encode them so spaces
+      // and punctuation do not break the handshake.
+      const protocols: string[] = [];
+      if (options.token) protocols.push(`bearer.${encodeURIComponent(options.token)}`);
+      if (ticket) protocols.push(`ticket.${encodeURIComponent(ticket)}`);
+      ws = protocols.length ? new WebSocket(url, protocols) : new WebSocket(url);
+    } catch (e) {
+      dispatchError(e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    ws.binaryType = "arraybuffer";
+
+    ws.onopen = () => {
+      connected = true;
+      // Inputs sent on the old connection are never acknowledged on this
+      // one (acks restart with the connection).
+      sentAt.clear();
+      for (const h of openHandlers) h();
+    };
+
+    ws.onmessage = (event) => {
+      if (!(event.data instanceof ArrayBuffer)) return;
+      const at = now();
+      try {
+        const frame = parseShardFrame(event.data);
+        if (frame.kind === ShardFrameKind.Replication || frame.kind === ShardFrameKind.Snapshot) {
+          // Only the per-tick frames: a rejection can go out before its
+          // tick's frame is built, and would make the clock run early.
+          clock.observe(frame.tick, at);
+          lastTick = frame.tick;
+          lastAck = frame.ack;
+          timeAcks(frame.ack, at);
+        }
+        if (frame.kind === ShardFrameKind.Replication) {
+          let summary: ReplicationSummary;
+          try {
+            summary = entities.apply(frame.payload);
+          } catch (e) {
+            // Out of sync with the server. Reconnecting gets a full baseline.
+            dispatchError(e instanceof Error ? e : new Error(String(e)));
+            entities.clear();
+            ws?.close();
+            return;
+          }
+          // A frame applied: the connection works, so the next reconnect
+          // starts from the short delay again. (Resetting on open would
+          // retry a frame that always fails every 500 ms forever.)
+          backoff = options.reconnectBackoffMs ?? 500;
+          for (const h of replicationHandlers) h(entities, summary, frame.tick, frame.ack);
+          return;
+        }
+        // The replication codec byte names the frame format, not the
+        // shard's input codec, so only other frames set it.
+        codec = frame.codec;
+        if (frame.kind === ShardFrameKind.Snapshot) {
+          const snapshot = decodeShardPayload(frame.codec, frame.payload, options.decode) as TSnapshot;
+          backoff = options.reconnectBackoffMs ?? 500;
+          for (const h of snapshotHandlers) h(snapshot, frame.tick, frame.ack);
+        } else if (frame.kind === ShardFrameKind.InputRejected) {
+          const rejection = decodeShardRejection(frame.codec, frame.payload, options.decode);
+          if (rejection.clientSeq !== null) sentAt.delete(rejection.clientSeq);
+          for (const h of rejectionHandlers) h(rejection);
+        }
+      } catch (e) {
+        dispatchError(e instanceof Error ? e : new Error("Failed to decode shard frame"));
+      }
+    };
+
+    ws.onerror = () => {
+      dispatchError(new Error(`WebSocket error connecting to shard ${shardId}`));
+    };
+
+    ws.onclose = () => {
+      connected = false;
+      for (const h of closeHandlers) h();
+      scheduleReconnect();
+    };
+  };
+
+  connect();
+
+  return {
+    get connected() {
+      return connected;
+    },
+    get entities() {
+      return entities;
+    },
+    get clock() {
+      return clock;
+    },
+    get tick() {
+      return lastTick;
+    },
+    get ack() {
+      return lastAck;
+    },
+    get rttMs() {
+      return rttMs;
+    },
+    onSnapshot(fn) {
+      snapshotHandlers.push(fn);
+    },
+    onInputRejected(fn) {
+      rejectionHandlers.push(fn);
+    },
+    onReplication(fn) {
+      replicationHandlers.push(fn);
+    },
+    onError(fn) {
+      errorHandlers.push(fn);
+    },
+    onOpen(fn) {
+      openHandlers.push(fn);
+    },
+    onClose(fn) {
+      closeHandlers.push(fn);
+    },
+    send(input: TInput): number {
+      if (!ws || ws.readyState !== WebSocket.OPEN) {
+        dispatchError(new Error("Cannot send: shard connection is not open"));
+        return 0;
+      }
+      clientSeq += 1;
+      ws.send(encodeShardInput(codec, input, clientSeq));
+      sentAt.set(clientSeq, now());
+      if (sentAt.size > MAX_TIMED) sentAt.delete(sentAt.keys().next().value as number);
+      return clientSeq;
+    },
+    close() {
+      closed = true;
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (ws) ws.close();
+    },
+  };
+}

package/src/game.test.ts

@@ -0,0 +1,137 @@
+import { afterAll, beforeAll, expect, test } from "bun:test";
+
+import { replicationFrame, shardFrame } from "../test/frames";
+import { connectShardGame } from "./game";
+import { ShardCodec, ShardFrameKind } from "./wire";
+
+const sockets: FakeWebSocket[] = [];
+class FakeWebSocket {
+  static OPEN = 1;
+  readyState = 0;
+  binaryType = "blob";
+  sent: string[] = [];
+  onopen: (() => void) | null = null;
+  onmessage: ((e: { data: ArrayBuffer }) => void) | null = null;
+  onerror: (() => void) | null = null;
+  onclose: (() => void) | null = null;
+  constructor(readonly url: string) {
+    sockets.push(this);
+  }
+  open() {
+    this.readyState = 1;
+    this.onopen?.();
+  }
+  deliver(frame: ArrayBuffer) {
+    this.onmessage?.({ data: frame });
+  }
+  close() {
+    this.readyState = 3;
+    this.onclose?.();
+  }
+  send(data: string) {
+    this.sent.push(data);
+  }
+}
+
+const realWebSocket = globalThis.WebSocket;
+const realSetTimeout = globalThis.setTimeout;
+beforeAll(() => {
+  globalThis.WebSocket = FakeWebSocket as unknown as typeof WebSocket;
+  globalThis.setTimeout = ((fn: () => void) => {
+    queueMicrotask(fn);
+    return 0;
+  }) as unknown as typeof setTimeout;
+});
+afterAll(() => {
+  globalThis.WebSocket = realWebSocket;
+  globalThis.setTimeout = realSetTimeout;
+});
+
+function rejection(tick: number, ack: number, clientSeq: number): ArrayBuffer {
+  const body = new TextEncoder().encode(
+    JSON.stringify({ client_seq: clientSeq, code: "invalid", message: "no" }),
+  );
+  return shardFrame(ShardFrameKind.InputRejected, ShardCodec.Json, tick, ack, body);
+}
+
+test("a render loop draws entities between frames, and prediction follows acks", async () => {
+  let time = 0;
+  const game = connectShardGame<{ dx: number }>("zone", {
+    subscriberId: "p1",
+    baseUrl: "h",
+    tickRate: 20,
+    interpolationDelayMs: 100,
+    now: () => time,
+  });
+  const me = game.predict<number>((x, input) => x + input.dx);
+  let predicted = 0;
+  game.onReplication((table, _summary, _tick, ack) => {
+    const mine = table.get(1);
+    if (mine) predicted = me.reconcile(mine.x, ack);
+  });
+
+  expect(game.frame(0)).toBe(-1);
+  expect(game.send({ dx: 1 })).toBe(0); // not open yet
+
+  const ws = sockets[0];
+  expect(ws.url).toContain("v=2");
+  ws.open();
+
+  // Tick t is built at t * 50 ms and arrives 20 ms later. Entity 2 walks
+  // 1 unit per tick.
+  const deliver = (tick: number, ack: number, frame: Parameters<typeof replicationFrame>[2]) => {
+    time = tick * 50 + 20;
+    ws.deliver(replicationFrame(tick, ack, frame));
+  };
+  deliver(1, 0, { full: true, spawn: [{ id: 1, pos: [0, 0, 0] }, { id: 2, pos: [1, 0, 0] }] });
+  for (let tick = 2; tick <= 10; tick++) {
+    deliver(tick, 0, { update: [{ id: 2, from: [tick - 1, 0, 0], pos: [tick, 0, 0] }] });
+  }
+
+  // 100 ms (2 ticks) behind the newest tick, halfway between frames.
+  const renderTick = game.frame(10 * 50 + 20 + 25);
+  expect(renderTick).toBeCloseTo(8.5, 1);
+  expect(game.entities.get(2)?.x).toBeCloseTo(8.5, 1);
+  expect(game.entities.get(1)?.x).toBeCloseTo(0);
+  expect(game.latest.get(2)?.x).toBeCloseTo(10);
+
+  // Three inputs; the shard applies the first two, clamping the second.
+  const s1 = game.send({ dx: 1 });
+  const s2 = game.send({ dx: 1 });
+  const s3 = game.send({ dx: 1 });
+  expect([s1, s2, s3]).toEqual([1, 2, 3]);
+  expect(JSON.parse(ws.sent[0])).toEqual({ input: { dx: 1 }, client_seq: 1 });
+  deliver(11, 2, { update: [{ id: 1, from: [0, 0, 0], pos: [1.5, 0, 0] }] });
+  expect(predicted).toBeCloseTo(2.5);
+  expect(game.ack).toBe(2);
+  // Sent at 520 ms, acknowledged by the frame at 570 ms.
+  expect(game.rttMs).toBeCloseTo(50);
+
+  // The shard refuses input 3: it drops out of the prediction. A rejection
+  // frame moves neither the ack nor the clock.
+  const tickBefore = game.clock.serverTick(time);
+  ws.deliver(rejection(12, 0, 3));
+  expect(game.ack).toBe(2);
+  expect(game.tick).toBe(11);
+  expect(game.clock.serverTick(time)).toBeCloseTo(tickBefore);
+  deliver(12, 3, {});
+  expect(predicted).toBeCloseTo(1.5);
+  expect(game.ack).toBe(3);
+
+  // A reconnect drops inputs sent on the old connection.
+  game.send({ dx: 5 });
+  ws.close();
+  await new Promise((r) => realSetTimeout(r, 0));
+  const ws2 = sockets[1];
+  ws2.open();
+  time = 13 * 50 + 20;
+  ws2.deliver(replicationFrame(13, 0, { full: true, spawn: [{ id: 1, pos: [1.5, 0, 0] }] }));
+  expect(predicted).toBeCloseTo(1.5);
+  expect(me.size).toBe(0);
+
+  // Entity 2 was not in the full frame: it leaves at tick 13.
+  game.frame(13 * 50 + 20 + 100);
+  expect(game.entities.has(2)).toBe(false);
+  expect(game.left).toEqual([2]);
+  game.close();
+});

package/src/game.ts

@@ -0,0 +1,161 @@
+/**
+ * A shard client for a game's render loop: the connection, the clock,
+ * interpolated entities, and prediction, with no framework and no
+ * re-render per frame.
+ *
+ * ```ts
+ * const game = connectShardGame("zone-1", { subscriberId, ticket, tickRate: 20 });
+ * const me = game.predict<Vec3>((p, input) => move(p, input));
+ *
+ * function frame(now: number) {
+ *   game.frame(now); // places game.entities at the render tick
+ *   for (const e of game.entities.values()) draw(e.id, e.x, e.y, e.z);
+ *   requestAnimationFrame(frame);
+ * }
+ * requestAnimationFrame(frame);
+ *
+ * game.onReplication((table, _summary, _tick, ack) => {
+ *   const mine = table.get(myEntityId);
+ *   if (mine) local = me.reconcile({ x: mine.x, y: mine.y, z: mine.z }, ack);
+ * });
+ * onKey((input) => {
+ *   // 0: not sent (the connection is down), so do not predict it.
+ *   if (game.send(input)) local = move(local, input);
+ * });
+ * ```
+ */
+
+import type { ShardClock } from "./clock";
+import { connectShard, type ShardClient, type ShardConnectOptions } from "./connection";
+import {
+  EntityInterpolator,
+  type InterpolatedEntity,
+  type InterpolationOptions,
+} from "./interpolation";
+import { Predictor, type PredictorOptions } from "./prediction";
+import type { EntityTable, ReplicationSummary } from "./replication";
+import type { ShardInputRejection } from "./wire";
+
+export interface ShardGameOptions extends ShardConnectOptions {
+  /**
+   * How far behind the shard's estimated current tick entities are drawn,
+   * in ms. It must cover the time between frames plus network jitter.
+   * Default 100.
+   */
+  interpolationDelayMs?: number;
+  interpolation?: InterpolationOptions;
+}
+
+export interface ShardGame<TInput = unknown> {
+  /** The underlying connection. */
+  readonly connection: ShardClient<unknown, TInput>;
+  readonly clock: ShardClock;
+  /** Entities placed at the render tick by the last `frame` call. */
+  readonly entities: ReadonlyMap<number, InterpolatedEntity>;
+  /** Ids the last `frame` added to and removed from `entities`. */
+  readonly entered: readonly number[];
+  readonly left: readonly number[];
+  /** The newest state the shard sent, not interpolated. */
+  readonly latest: EntityTable;
+  readonly tick: number;
+  readonly ack: number;
+  readonly rttMs: number | null;
+  readonly connected: boolean;
+  /**
+   * Place `entities` for a render frame at `now` (ms, default
+   * `performance.now()`). Returns the render tick, or -1 before the first
+   * frame.
+   */
+  frame(now?: number): number;
+  /** Send an input; every predictor made by `predict` records it. Returns
+   *  its sequence number, or 0 when it was not sent. */
+  send(input: TInput): number;
+  /**
+   * A predictor that records every input `send` sends, forgets inputs the
+   * shard refuses, and resets when the connection reopens. Call
+   * `reconcile` with the local entity's server state after each frame.
+   */
+  predict<S>(step: (state: S, input: TInput) => S, options?: PredictorOptions): Predictor<S, TInput>;
+  onReplication(
+    fn: (entities: EntityTable, summary: ReplicationSummary, tick: number, ack: number) => void,
+  ): void;
+  onInputRejected(fn: (rejection: ShardInputRejection) => void): void;
+  onOpen(fn: () => void): void;
+  onClose(fn: () => void): void;
+  onError(fn: (err: Error) => void): void;
+  close(): void;
+}
+
+/** Connect to a replicating shard for a render loop. */
+export function connectShardGame<TInput = unknown>(
+  shardId: string,
+  options: ShardGameOptions,
+): ShardGame<TInput> {
+  const now = options.now ?? (() => performance.now());
+  const connection = connectShard<unknown, TInput>(shardId, { ...options, now });
+  const interpolator = new EntityInterpolator(options.interpolation);
+  const delayMs = options.interpolationDelayMs ?? 100;
+  const predictors: Array<Predictor<unknown, TInput>> = [];
+
+  connection.onReplication((table, summary, tick) => interpolator.record(table, summary, tick));
+  connection.onInputRejected((r) => {
+    for (const p of predictors) p.reject(r.clientSeq);
+  });
+  connection.onOpen(() => {
+    for (const p of predictors) p.reset();
+  });
+
+  return {
+    connection,
+    get clock() {
+      return connection.clock;
+    },
+    get entities() {
+      return interpolator.entities;
+    },
+    get entered() {
+      return interpolator.entered;
+    },
+    get left() {
+      return interpolator.left;
+    },
+    get latest() {
+      return connection.entities;
+    },
+    get tick() {
+      return connection.tick;
+    },
+    get ack() {
+      return connection.ack;
+    },
+    get rttMs() {
+      return connection.rttMs;
+    },
+    get connected() {
+      return connection.connected;
+    },
+    frame(at = now()) {
+      const clock = connection.clock;
+      if (!clock.ready) return -1;
+      const renderTick = clock.serverTick(at) - delayMs / clock.tickMs;
+      interpolator.update(renderTick);
+      return renderTick;
+    },
+    send(input) {
+      const seq = connection.send(input);
+      for (const p of predictors) p.push(seq, input);
+      return seq;
+    },
+    predict<S>(step: (state: S, input: TInput) => S, predictorOptions?: PredictorOptions) {
+      const p = new Predictor<S, TInput>(step, predictorOptions);
+      predictors.push(p as unknown as Predictor<unknown, TInput>);
+      return p;
+    },
+    onReplication: (fn) => connection.onReplication(fn),
+    onInputRejected: (fn) => connection.onInputRejected(fn),
+    onOpen: (fn) => connection.onOpen(fn),
+    onClose: (fn) => connection.onClose(fn),
+    onError: (fn) => connection.onError(fn),
+    close: () => connection.close(),
+  };
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from "./wire";
+export * from "./replication";
+export * from "./clock";
+export * from "./interpolation";
+export * from "./prediction";
+export * from "./connection";
+export * from "./game";