@usions/sdk 2.2.0 → 2.11.0

package/src/modules/leaderboard.js

@@ -0,0 +1,46 @@
+/**
+ * Usion SDK Leaderboard — scores for mini-games.
+ *
+ * Opt-in per game (the service must have `leaderboard.enabled`). Rides the
+ * unified backend channel, so it works in standalone AND embedded games.
+ *
+ *   await Usion.leaderboard.submit(1500);              // your score
+ *   const friends = await Usion.leaderboard.friends();  // people you've messaged + you
+ *   const top = await Usion.leaderboard.top();          // global top N
+ *   const me = await Usion.leaderboard.me();            // { score, rank, total }
+ *
+ * The **friends** board is scoped to users you've messaged (your conversations)
+ * plus yourself — that's the "see the scores of people I've chatted with" view.
+ * Entries: { user_id, name, avatar, score, rank, is_me, metadata }.
+ */
+export function createLeaderboardModule(Usion) {
+  function serviceId(opts) {
+    return (opts && opts.serviceId) || (Usion.config && Usion.config.serviceId);
+  }
+
+  return {
+    /** Submit a score (best score is kept, per the service's order config). */
+    submit: function (score, metadata, opts) {
+      return Usion._backendEmit('lb:submit', { service_id: serviceId(opts), score: score, metadata: metadata != null ? metadata : null });
+    },
+
+    /** Leaderboard of people you've messaged (plus you). Returns entries[]. */
+    friends: function (opts) {
+      opts = opts || {};
+      return Usion._backendEmit('lb:friends', { service_id: serviceId(opts), limit: opts.limit || 50 })
+        .then(function (r) { return (r && r.entries) || []; });
+    },
+
+    /** Global top N. Returns entries[]. */
+    top: function (opts) {
+      opts = opts || {};
+      return Usion._backendEmit('lb:top', { service_id: serviceId(opts), limit: opts.limit || 20 })
+        .then(function (r) { return (r && r.entries) || []; });
+    },
+
+    /** Your own score + global rank: { score, rank, total }. */
+    me: function (opts) {
+      return Usion._backendEmit('lb:me', { service_id: serviceId(opts) });
+    },
+  };
+}

package/src/modules/lobby.js

@@ -0,0 +1,103 @@
+/**
+ * Usion SDK Lobby — parties, ready-up, and matchmaking.
+ *
+ * The social rendezvous layer that game rooms can't provide: form a party by
+ * code, ready up together, and start as a group — plus a thin wrapper over the
+ * platform's stranger matchmaking. Rides the platform Socket.IO connection
+ * (Usion.game.socket), so connect first with Usion.game.connect().
+ *
+ *   const { code } = await Usion.lobby.create({ maxPlayers: 4 });
+ *   Usion.lobby.onUpdate(({ members }) => renderLobby(members));
+ *   await Usion.lobby.setReady(true);
+ *   // host, once everyone's ready: create a room then start the party in it
+ *   const room = await Usion.lobby.queue(serviceId);     // or your own room API
+ *   await Usion.lobby.start(room.id);
+ *   Usion.lobby.onStarted(({ room_id }) => Usion.game.join(room_id));
+ *
+ * Works in every mode: it rides the unified backend channel (Usion._backendEmit
+ * / _backendOn), which uses the SDK's own socket when standalone and relays
+ * through the parent app when embedded (iframe/WebView).
+ */
+export function createLobbyModule(Usion) {
+  const state = { code: null, host: null, status: null, members: [] };
+  const handlers = {};
+  let bound = false;
+
+  function bind() {
+    if (bound) return;
+    bound = true;
+    Usion._backendOn('lobby:update', function (d) {
+      state.code = d.code; state.host = d.host; state.status = d.status; state.members = d.members || [];
+      if (handlers.update) handlers.update(d);
+    });
+    Usion._backendOn('lobby:started', function (d) {
+      state.status = 'started';
+      if (handlers.started) handlers.started(d);
+    });
+  }
+
+  function ack(event, data) {
+    bind();
+    return Usion._backendEmit(event, data);
+  }
+
+  return {
+    get state() { return state; },
+
+    /** Register a handler for lobby membership/ready changes. */
+    onUpdate: function (cb) { handlers.update = cb; bind(); },
+    /** Register a handler for when the host starts the party. */
+    onStarted: function (cb) { handlers.started = cb; bind(); },
+
+    /** Create a party. Resolves with { code }. You become the host. */
+    create: async function (opts) {
+      opts = opts || {};
+      const r = await ack('lobby:create', { max_players: opts.maxPlayers || 8, public: !!opts.public });
+      if (r && r.code) state.code = r.code;
+      return r;
+    },
+
+    /** Join a party by code. */
+    join: async function (code) {
+      const r = await ack('lobby:join', { code: String(code || '').toUpperCase() });
+      if (r && r.code) state.code = r.code;
+      return r;
+    },
+
+    /** Leave the current party. */
+    leave: function () { state.code = null; return ack('lobby:leave', {}).catch(function () {}); },
+
+    /** Set your ready state. */
+    setReady: function (ready) { return ack('lobby:ready', { ready: ready !== false }); },
+
+    /** True when every member is ready. */
+    allReady: function () { return state.members.length > 0 && state.members.every(function (m) { return m.ready; }); },
+
+    /** Whether the current user is the party host. */
+    isHost: function () {
+      const id = Usion.user && Usion.user.getId && Usion.user.getId();
+      return !!(state.host && id && state.host === id);
+    },
+
+    /** Host: start the party in an already-created game room. */
+    start: function (roomId) { return ack('lobby:start', { room_id: roomId }); },
+
+    /**
+     * Stranger matchmaking — find or create a game room for a service via the
+     * platform's REST matchmaker. Resolves with the room.
+     */
+    queue: async function (serviceId, opts) {
+      opts = opts || {};
+      const apiUrl = (Usion.config && Usion.config.apiUrl) || '';
+      const token = Usion.user && Usion.user.getToken && Usion.user.getToken();
+      if (!apiUrl) throw new Error('No apiUrl configured');
+      const res = await fetch(apiUrl.replace(/\/$/, '') + '/games/matchmake', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + token },
+        body: JSON.stringify({ service_id: serviceId, conversation_id: opts.conversationId || ('standalone_' + serviceId) }),
+      });
+      if (!res.ok) throw new Error('Matchmake failed: HTTP ' + res.status);
+      return res.json();
+    },
+  };
+}

package/src/modules/matchmaking.js

@@ -0,0 +1,61 @@
+/**
+ * Usion SDK Matchmaking — pair up with online strangers ("quick match").
+ *
+ * Lets a mini-app connect players who don't know each other: join a queue, and
+ * when enough players are waiting the platform creates a room and matches you.
+ * Rides the unified backend channel, so it works standalone AND embedded.
+ *
+ *   const m = await Usion.matchmaking.find();    // resolves when matched
+ *   await Usion.game.connect(); await Usion.game.join(m.roomId);
+ *   // ...or cancel while waiting:
+ *   Usion.matchmaking.cancel();
+ *   Usion.matchmaking.onMatch(({ roomId, players }) => { ... });
+ */
+export function createMatchmakingModule(Usion) {
+  let pending = null;          // { resolve, reject } for an in-flight find()
+  let onMatchCb = null;
+  let bound = false;
+
+  function normalize(d) {
+    return { roomId: d && d.room_id, players: (d && d.player_ids) || [], serviceId: d && d.service_id };
+  }
+
+  function bind() {
+    if (bound) return;
+    bound = true;
+    Usion._backendOn('mm:matched', function (d) {
+      const r = normalize(d);
+      if (onMatchCb) onMatchCb(r);
+      if (pending) { const p = pending; pending = null; p.resolve(r); }
+    });
+  }
+
+  return {
+    /** Register a handler called whenever a match is found. */
+    onMatch: function (cb) { onMatchCb = cb; bind(); },
+
+    /**
+     * Join the queue for `serviceId` (defaults to the current game) and resolve
+     * when matched with { roomId, players, serviceId }. Stays pending until a
+     * match (use cancel() to stop waiting).
+     */
+    find: function (serviceId, opts) {
+      opts = opts || {};
+      const sid = serviceId || (Usion.config && Usion.config.serviceId);
+      bind();
+      const self = this;
+      return Usion._backendEmit('mm:join', { service_id: sid, size: opts.size || 2 }).then(function () {
+        return new Promise(function (resolve, reject) {
+          if (pending) pending.reject(new Error('superseded'));
+          pending = { resolve: resolve, reject: reject };
+        });
+      });
+    },
+
+    /** Leave the queue / stop waiting. */
+    cancel: function () {
+      if (pending) { pending.reject(new Error('cancelled')); pending = null; }
+      return Usion._backendEmit('mm:cancel', {});
+    },
+  };
+}

package/src/modules/netcode/binary.js

@@ -0,0 +1,113 @@
+/**
+ * Usion SDK Netcode — compact binary codec (zero-dependency).
+ *
+ * A tiny MessagePack-style serializer for JSON-like snapshot payloads. Pair it
+ * with the snapshot sender/receiver (`encode`/`decode` options) to send game
+ * state as binary over the WebRTC data channel or a binary-capable WebSocket —
+ * meaningfully smaller than JSON, especially after quantization (small ints
+ * pack into 1–2 bytes). WebRTC/Socket.IO transmit ArrayBuffers natively.
+ *
+ * NOT for the iframe/WebView proxy path (that bridge relays JSON) — use binary
+ * on direct/mesh transports.
+ *
+ * Wire tags:  0xc0 null · 0xc2 false · 0xc3 true · 0xc4 int(zigzag varint) ·
+ *             0xc5 float64 · 0xc6 string · 0xc7 array · 0xc8 object
+ */
+const NULL = 0xc0, FALSE = 0xc2, TRUE = 0xc3, INT = 0xc4, F64 = 0xc5, STR = 0xc6, ARR = 0xc7, OBJ = 0xc8;
+
+const _enc = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const _dec = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
+
+function pushVarint(out, n) {
+  // unsigned LEB128
+  n = n >>> 0;
+  while (n > 0x7f) { out.push((n & 0x7f) | 0x80); n >>>= 7; }
+  out.push(n);
+}
+function zigzag(n) { return ((n << 1) ^ (n >> 31)) >>> 0; }
+function unzigzag(u) { return (u >>> 1) ^ -(u & 1); }
+
+function encodeValue(out, v) {
+  if (v === null || v === undefined) { out.push(NULL); return; }
+  const t = typeof v;
+  if (t === 'boolean') { out.push(v ? TRUE : FALSE); return; }
+  if (t === 'number') {
+    if (Number.isInteger(v) && v >= -2147483648 && v <= 2147483647) {
+      out.push(INT); pushVarint(out, zigzag(v));
+    } else {
+      out.push(F64);
+      const b = new Uint8Array(8); new DataView(b.buffer).setFloat64(0, v, true);
+      for (let i = 0; i < 8; i++) out.push(b[i]);
+    }
+    return;
+  }
+  if (t === 'string') {
+    out.push(STR);
+    const bytes = _enc ? _enc.encode(v) : Buffer.from(v, 'utf8');
+    pushVarint(out, bytes.length);
+    for (let i = 0; i < bytes.length; i++) out.push(bytes[i]);
+    return;
+  }
+  if (Array.isArray(v)) {
+    out.push(ARR); pushVarint(out, v.length);
+    for (let i = 0; i < v.length; i++) encodeValue(out, v[i]);
+    return;
+  }
+  if (t === 'object') {
+    const keys = Object.keys(v);
+    out.push(OBJ); pushVarint(out, keys.length);
+    for (let i = 0; i < keys.length; i++) {
+      const k = keys[i];
+      const kb = _enc ? _enc.encode(k) : Buffer.from(k, 'utf8');
+      pushVarint(out, kb.length);
+      for (let j = 0; j < kb.length; j++) out.push(kb[j]);
+      encodeValue(out, v[k]);
+    }
+    return;
+  }
+  out.push(NULL);
+}
+
+/** Encode a JSON-like value to a Uint8Array. */
+export function encode(value) {
+  const out = [];
+  encodeValue(out, value);
+  return Uint8Array.from(out);
+}
+
+function reader(bytes) {
+  let off = 0;
+  const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  function varint() {
+    let shift = 0, result = 0, b;
+    do { b = bytes[off++]; result |= (b & 0x7f) << shift; shift += 7; } while (b & 0x80);
+    return result >>> 0;
+  }
+  function str() {
+    const len = varint();
+    const slice = bytes.subarray(off, off + len);
+    off += len;
+    return _dec ? _dec.decode(slice) : Buffer.from(slice).toString('utf8');
+  }
+  function value() {
+    const tag = bytes[off++];
+    switch (tag) {
+      case NULL: return null;
+      case TRUE: return true;
+      case FALSE: return false;
+      case INT: return unzigzag(varint());
+      case F64: { const v = dv.getFloat64(off, true); off += 8; return v; }
+      case STR: return str();
+      case ARR: { const n = varint(); const a = new Array(n); for (let i = 0; i < n; i++) a[i] = value(); return a; }
+      case OBJ: { const n = varint(); const o = {}; for (let i = 0; i < n; i++) { const k = str(); o[k] = value(); } return o; }
+      default: return null;
+    }
+  }
+  return value;
+}
+
+/** Decode a Uint8Array / ArrayBuffer produced by `encode`. */
+export function decode(buf) {
+  const bytes = buf instanceof Uint8Array ? buf : new Uint8Array(buf);
+  return reader(bytes)();
+}

package/src/modules/netcode/delta.js

@@ -0,0 +1,236 @@
+/**
+ * Usion SDK Netcode — Delta compression for JSON game state.
+ *
+ * Real-time games typically re-send their entire world every tick. Most of
+ * that payload is unchanged. `diff` produces a minimal patch describing only
+ * what changed since the previous state; `patch` reconstructs the new state
+ * from a base + patch. Both are plain JSON, so the patch rides on the existing
+ * realtime/action channels unchanged.
+ *
+ * Wire format:
+ *   - Objects → `{ k: <patch> }` for changed keys, `_d: [keys]` for deletions.
+ *   - **Entity arrays** (every element a plain object with a stable `id`) →
+ *     keyed diff `{ _ka:{id:patch}, _add:[entities], _del:[ids], _ord:[ids] }`.
+ *     This is O(changes), not O(index shift): inserting/removing an element no
+ *     longer rewrites every following index. (Gaffer-on-Games "state sync".)
+ *   - Other arrays → index diff `{ _a:{i:patch}, _n:length }`.
+ *   - Primitives / type changes → `{ _s: value }`.
+ *   - No change → `undefined`.
+ *
+ * `quantize` rounds numeric fields to a fixed resolution before diffing, so
+ * sub-resolution jitter doesn't produce spurious deltas and payloads shrink
+ * (the single biggest, simplest snapshot-compression win — Gaffer on Games).
+ */
+
+const SET = '_s';   // wholesale set
+const DEL = '_d';   // deleted object keys
+const ARR = '_a';   // index array patches
+const LEN = '_n';   // index array length
+const KA = '_ka';   // keyed-array: per-id patches
+const ADD = '_add'; // keyed-array: added entities (full)
+const KDEL = '_del';// keyed-array: removed ids
+const ORD = '_ord'; // keyed-array: explicit id order (only when it changes)
+
+function isPlainObject(v) {
+  return v !== null && typeof v === 'object' && !Array.isArray(v);
+}
+
+function isEntityArray(v) {
+  if (!Array.isArray(v) || v.length === 0) return false;
+  for (let i = 0; i < v.length; i++) {
+    const e = v[i];
+    if (!isPlainObject(e) || (typeof e.id !== 'string' && typeof e.id !== 'number')) return false;
+  }
+  return true;
+}
+
+function sameOrder(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+
+/**
+ * Compute a minimal patch turning `prev` into `next`.
+ * @returns the patch, or `undefined` when nothing changed.
+ */
+export function diff(prev, next) {
+  if (prev === next) return undefined;
+
+  const prevArr = Array.isArray(prev);
+  const nextArr = Array.isArray(next);
+
+  // Type changed (or one side primitive) — send the whole value.
+  if (prevArr !== nextArr || isPlainObject(prev) !== isPlainObject(next)) {
+    return { [SET]: next };
+  }
+
+  if (nextArr) {
+    // Keyed (entity) arrays: diff by id so index shifts are free.
+    if (isEntityArray(prev) && isEntityArray(next)) return diffKeyedArray(prev, next);
+    return diffIndexArray(prev, next);
+  }
+
+  if (isPlainObject(next)) return diffObject(prev, next);
+
+  // Two differing primitives.
+  return { [SET]: next };
+}
+
+function diffObject(prev, next) {
+  const out = {};
+  let changed = false;
+  for (const k in next) {
+    if (!Object.prototype.hasOwnProperty.call(next, k)) continue;
+    const d = diff(prev[k], next[k]);
+    if (d !== undefined) { out[k] = d; changed = true; }
+  }
+  const deleted = [];
+  for (const k in prev) {
+    if (!Object.prototype.hasOwnProperty.call(prev, k)) continue;
+    if (!Object.prototype.hasOwnProperty.call(next, k)) deleted.push(k);
+  }
+  if (deleted.length) { out[DEL] = deleted; changed = true; }
+  return changed ? out : undefined;
+}
+
+function diffIndexArray(prev, next) {
+  const out = { [ARR]: {} };
+  let changed = false;
+  for (let i = 0; i < next.length; i++) {
+    const d = i < prev.length ? diff(prev[i], next[i]) : { [SET]: next[i] };
+    if (d !== undefined) { out[ARR][i] = d; changed = true; }
+  }
+  if (next.length !== prev.length) { out[LEN] = next.length; changed = true; }
+  return changed ? out : undefined;
+}
+
+function diffKeyedArray(prev, next) {
+  const prevById = {};
+  const prevIds = [];
+  for (let i = 0; i < prev.length; i++) { prevById[prev[i].id] = prev[i]; prevIds.push(prev[i].id); }
+  const nextIds = [];
+  const out = {};
+  let changed = false;
+
+  for (let i = 0; i < next.length; i++) {
+    const e = next[i];
+    nextIds.push(e.id);
+    if (Object.prototype.hasOwnProperty.call(prevById, e.id)) {
+      const d = diff(prevById[e.id], e);
+      if (d !== undefined) {
+        if (!out[KA]) out[KA] = {};
+        out[KA][e.id] = d;
+        changed = true;
+      }
+    } else {
+      if (!out[ADD]) out[ADD] = [];
+      out[ADD].push(e);
+      changed = true;
+    }
+  }
+
+  const nextIdSet = {};
+  for (let i = 0; i < nextIds.length; i++) nextIdSet[nextIds[i]] = true;
+  for (let i = 0; i < prevIds.length; i++) {
+    if (!nextIdSet[prevIds[i]]) {
+      if (!out[KDEL]) out[KDEL] = [];
+      out[KDEL].push(prevIds[i]);
+      changed = true;
+    }
+  }
+
+  if (!sameOrder(prevIds, nextIds)) { out[ORD] = nextIds; changed = true; }
+  return changed ? out : undefined;
+}
+
+/**
+ * Apply a patch produced by `diff` to `base`, returning the new value.
+ * Does not mutate `base`. A nullish patch returns `base` unchanged.
+ */
+export function patch(base, p) {
+  if (p === undefined || p === null) return base;
+  if (Object.prototype.hasOwnProperty.call(p, SET)) return p[SET];
+
+  // Keyed (entity) array.
+  if (p[KA] || p[ADD] || p[KDEL] || p[ORD]) return patchKeyedArray(base, p);
+
+  // Index array.
+  if (Object.prototype.hasOwnProperty.call(p, ARR) || Object.prototype.hasOwnProperty.call(p, LEN)) {
+    const src = Array.isArray(base) ? base : [];
+    const len = Object.prototype.hasOwnProperty.call(p, LEN) ? p[LEN] : src.length;
+    const out = src.slice(0, len);
+    const patches = p[ARR] || {};
+    for (const i in patches) {
+      if (!Object.prototype.hasOwnProperty.call(patches, i)) continue;
+      out[i] = patch(out[i], patches[i]);
+    }
+    return out;
+  }
+
+  // Object patch.
+  const out = isPlainObject(base) ? Object.assign({}, base) : {};
+  const deleted = p[DEL];
+  for (const k in p) {
+    if (k === DEL) continue;
+    if (!Object.prototype.hasOwnProperty.call(p, k)) continue;
+    out[k] = patch(out[k], p[k]);
+  }
+  if (Array.isArray(deleted)) for (let i = 0; i < deleted.length; i++) delete out[deleted[i]];
+  return out;
+}
+
+function patchKeyedArray(base, p) {
+  const baseArr = Array.isArray(base) ? base : [];
+  const byId = {};
+  const baseOrder = [];
+  for (let i = 0; i < baseArr.length; i++) {
+    const e = baseArr[i];
+    if (e && (typeof e.id === 'string' || typeof e.id === 'number')) { byId[e.id] = e; baseOrder.push(e.id); }
+  }
+  // Apply per-id field patches.
+  if (p[KA]) for (const id in p[KA]) {
+    if (Object.prototype.hasOwnProperty.call(p[KA], id) && byId[id] !== undefined) byId[id] = patch(byId[id], p[KA][id]);
+  }
+  // Additions.
+  if (p[ADD]) for (let i = 0; i < p[ADD].length; i++) { const e = p[ADD][i]; byId[e.id] = e; }
+  // Removals.
+  const removed = {};
+  if (p[KDEL]) for (let i = 0; i < p[KDEL].length; i++) removed[p[KDEL][i]] = true;
+
+  if (p[ORD]) {
+    const out = [];
+    for (let i = 0; i < p[ORD].length; i++) {
+      const id = p[ORD][i];
+      if (byId[id] !== undefined) out.push(byId[id]);
+    }
+    return out;
+  }
+  // No order change: keep base order minus removals, patched in place.
+  const out = [];
+  for (let i = 0; i < baseOrder.length; i++) {
+    const id = baseOrder[i];
+    if (!removed[id]) out.push(byId[id]);
+  }
+  return out;
+}
+
+/**
+ * Round every numeric field to `precision` decimal places (default 2),
+ * returning a new value. Apply before diffing so sub-resolution jitter and
+ * float noise don't generate spurious deltas, and payloads stay small.
+ */
+export function quantize(value, precision = 2) {
+  const f = Math.pow(10, precision);
+  function q(v) {
+    if (typeof v === 'number') return Number.isFinite(v) ? Math.round(v * f) / f : v;
+    if (Array.isArray(v)) return v.map(q);
+    if (isPlainObject(v)) {
+      const o = {};
+      for (const k in v) if (Object.prototype.hasOwnProperty.call(v, k)) o[k] = q(v[k]);
+      return o;
+    }
+    return v;
+  }
+  return q(value);
+}

package/src/modules/netcode/index.js

@@ -0,0 +1,41 @@
+/**
+ * Usion SDK Netcode — public namespace.
+ *
+ * A small, zero-dependency, transport-agnostic toolkit for smooth low-latency
+ * multiplayer. Works across all Usion connection modes (platform / direct /
+ * proxy) and both platforms, computing on top of the existing realtime/action
+ * plumbing — no host or backend changes required to use it.
+ *
+ *   SnapshotInterpolation — smooth rendering; adaptive buffer + capped extrapolation
+ *   Predictor             — client prediction + reconciliation + error smoothing
+ *   Coalescer             — fixed-Hz outbound send batching
+ *   PingMeter             — RTT / jitter telemetry
+ *   MeshConnection        — WebRTC P2P (sequenced, TURN-ready, auto-reconnect)
+ *   MeshNetwork           — N-peer full mesh
+ *   diff / patch / quantize — JSON delta compression (id-keyed arrays)
+ *   encode / decode        — compact binary codec
+ */
+import { SnapshotInterpolation, Vault } from './interpolation.js';
+import { Predictor } from './prediction.js';
+import { Coalescer } from './sender.js';
+import { PingMeter } from './ping.js';
+import { MeshConnection } from './mesh.js';
+import { MeshNetwork } from './mesh-network.js';
+import { WebTransportConnection } from './webtransport.js';
+import { NetworkSim } from './netsim.js';
+import { Lockstep } from './lockstep.js';
+import { LagCompensator } from './lagcomp.js';
+import { diff, patch, quantize } from './delta.js';
+import { encode, decode } from './binary.js';
+
+export const netcode = {
+  SnapshotInterpolation, Vault, Predictor, Coalescer, PingMeter,
+  MeshConnection, MeshNetwork, WebTransportConnection, NetworkSim, Lockstep, LagCompensator,
+  diff, patch, quantize, encode, decode,
+};
+
+export {
+  SnapshotInterpolation, Vault, Predictor, Coalescer, PingMeter,
+  MeshConnection, MeshNetwork, WebTransportConnection, NetworkSim, Lockstep, LagCompensator,
+  diff, patch, quantize, encode, decode,
+};