@genex-ai/multiplayer 0.16.1 → 0.17.0

package/dist/chunk-CTDU4IJ5.js

@@ -0,0 +1,2191 @@
+import {
+  ClientMessage,
+  ClientReconnection,
+  ClockSync,
+  CloseCode,
+  Interpolation,
+  JoinError,
+  Limits,
+  POSE_KEYS,
+  PROTOCOL_VERSION,
+  RESERVED_SHARED_PREFIX,
+  RoomType,
+  SEND_TIME_KEY,
+  ServerMessage,
+  isReservedEventType
+} from "./chunk-C52XFIB6.js";
+
+// src/index.ts
+import { Client, getStateCallbacks } from "@colyseus/sdk";
+
+// src/ice-request.ts
+function createIceRequester(send, timeoutMs) {
+  let inFlight = null;
+  let settle = null;
+  return {
+    request() {
+      if (inFlight) return inFlight;
+      inFlight = new Promise((resolve) => {
+        let timer;
+        const done = (cfg) => {
+          if (!settle) return;
+          settle = null;
+          inFlight = null;
+          if (timer) clearTimeout(timer);
+          resolve(cfg);
+        };
+        settle = done;
+        timer = setTimeout(() => done(null), timeoutMs);
+        send();
+      });
+      return inFlight;
+    },
+    deliver(cfg) {
+      settle?.(cfg);
+    },
+    get pending() {
+      return inFlight !== null;
+    }
+  };
+}
+
+// src/pose.ts
+var NUMERIC_POSE_KEYS = ["x", "y", "z", "yaw", "vx", "vy", "vz"];
+var AXES = [
+  ["x", "vx"],
+  ["y", "vy"],
+  ["z", "vz"]
+];
+var TWO_PI = Math.PI * 2;
+var isPoseKey = (k) => POSE_KEYS.includes(k);
+function wrapAngle(a) {
+  if (!Number.isFinite(a)) return 0;
+  let r = a % TWO_PI;
+  if (r <= -Math.PI) r += TWO_PI;
+  else if (r > Math.PI) r -= TWO_PI;
+  return r;
+}
+var validPoseNumber = (v) => typeof v === "number" && Number.isFinite(v) && Math.abs(v) <= Limits.MAX_POSE_ABS;
+function splitPose(state) {
+  const pose = {};
+  const data = {};
+  const invalid = [];
+  for (const k of Object.keys(state)) {
+    const v = state[k];
+    if (!isPoseKey(k)) {
+      data[k] = v;
+      continue;
+    }
+    if (v === void 0) continue;
+    if (k === "anim") {
+      if (typeof v === "string" && v.length <= Limits.MAX_ANIM_CHARS) pose.anim = v;
+      else invalid.push(k);
+    } else if (validPoseNumber(v)) {
+      pose[k] = v;
+    } else {
+      invalid.push(k);
+    }
+  }
+  return { pose, data, invalid };
+}
+function hasPose(p) {
+  for (const k in p) if (p[k] !== void 0) return true;
+  return false;
+}
+function deriveVelocity(pose, t, prev) {
+  const out = { ...pose };
+  const memory = { t };
+  const dt = prev ? t - prev.t : 0;
+  const usable = prev !== void 0 && dt > Interpolation.MIN_GAP_MS && dt < Interpolation.MAX_GAP_MS;
+  for (const [axis, vel] of AXES) {
+    const p = pose[axis];
+    if (p === void 0) continue;
+    memory[axis] = p;
+    if (pose[vel] !== void 0) continue;
+    const before = prev?.[axis];
+    const v = usable && before !== void 0 ? (p - before) / dt * 1e3 : 0;
+    out[vel] = validPoseNumber(v) ? v : 0;
+  }
+  return { pose: out, memory };
+}
+function readPose(p) {
+  const n = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+  return {
+    x: n(p.x),
+    y: n(p.y),
+    z: n(p.z),
+    yaw: n(p.yaw),
+    vx: n(p.vx),
+    vy: n(p.vy),
+    vz: n(p.vz),
+    anim: typeof p.anim === "string" ? p.anim : ""
+  };
+}
+var num = (o, k) => {
+  const v = o[k];
+  return typeof v === "number" && Number.isFinite(v) ? v : 0;
+};
+function samplePose(buf, r) {
+  const n = buf.length;
+  if (n === 0) return void 0;
+  let j = 0;
+  while (j < n && buf[j].t <= r) j++;
+  if (j === 0) return buf[0].state;
+  if (j >= n) {
+    const b2 = buf[n - 1];
+    const out2 = { ...b2.state };
+    const ahead = Math.min(Math.max(0, r - b2.t), Interpolation.MAX_EXTRAP_MS) / 1e3;
+    for (const [axis, vel] of AXES) out2[axis] = num(b2.state, axis) + num(b2.state, vel) * ahead;
+    if (n >= 2) {
+      const a2 = buf[n - 2];
+      const span2 = b2.t - a2.t;
+      if (span2 > 0) {
+        const k2 = Math.min(Math.max(0, r - b2.t), Interpolation.ROT_EXTRAP_MS) / span2;
+        const yb = num(b2.state, "yaw");
+        out2.yaw = yb + wrapAngle(yb - num(a2.state, "yaw")) * k2;
+      }
+    }
+    return out2;
+  }
+  const a = buf[j - 1];
+  const b = buf[j];
+  const span = b.t - a.t;
+  const k = span > 0 ? (r - a.t) / span : 1;
+  const out = { ...a.state };
+  for (const key of NUMERIC_POSE_KEYS) {
+    const va = num(a.state, key);
+    const vb = num(b.state, key);
+    out[key] = key === "yaw" ? va + wrapAngle(vb - va) * k : va + (vb - va) * k;
+  }
+  return out;
+}
+function easePose(prev, target, aPos, aRot) {
+  const out = { ...target };
+  for (const key of NUMERIC_POSE_KEYS) {
+    const pv = prev[key];
+    const tv = target[key];
+    if (typeof pv !== "number" || typeof tv !== "number" || !Number.isFinite(pv) || !Number.isFinite(tv)) continue;
+    out[key] = key === "yaw" ? pv + wrapAngle(tv - pv) * aRot : pv + (tv - pv) * aPos;
+  }
+  return out;
+}
+var SnappedData = class _SnappedData {
+  pending = [];
+  current;
+  /** More than this many queued changes means the render clock stalled: apply the oldest at once. */
+  static MAX_PENDING = 64;
+  push(t, state) {
+    this.pending.push({ t, state });
+    while (this.pending.length > _SnappedData.MAX_PENDING) this.current = this.pending.shift()?.state;
+  }
+  /** The data to show at render time `r` (`undefined` = no render clock yet: apply everything). */
+  at(r) {
+    while (this.pending.length > 0) {
+      const head = this.pending[0];
+      if (this.current !== void 0 && r !== void 0 && head.t !== void 0 && head.t > r) break;
+      this.current = head.state;
+      this.pending.shift();
+    }
+    return this.current;
+  }
+  flush() {
+    this.at(void 0);
+  }
+};
+
+// src/server-clock.ts
+function heartbeatHandleOf(room) {
+  try {
+    const handle = room.input();
+    return handle && typeof handle.send === "function" ? handle : null;
+  } catch {
+    return null;
+  }
+}
+function startHeartbeat(handle, live, hz = ClockSync.HEARTBEAT_HZ, random = Math.random) {
+  const rate = Math.min(ClockSync.MAX_HEARTBEAT_HZ, Math.max(ClockSync.MIN_HEARTBEAT_HZ, hz));
+  const base = 1e3 / rate;
+  const minMs = 1e3 / ClockSync.MAX_HEARTBEAT_HZ;
+  const maxMs = 1e3 / ClockSync.MIN_HEARTBEAT_HZ;
+  let synced = false;
+  let stopped = false;
+  let timer;
+  const beat = () => {
+    if (stopped) return;
+    if (live()) {
+      try {
+        handle.send();
+      } catch {
+      }
+      if (!synced && handle.lastProcessed >= ClockSync.WARMUP_ACKS) synced = true;
+    }
+    const next = base * (1 + (random() * 2 - 1) * ClockSync.HEARTBEAT_DITHER);
+    timer = setTimeout(beat, Math.min(maxMs, Math.max(minMs, next)));
+  };
+  beat();
+  return {
+    get synced() {
+      if (!synced && handle.lastProcessed >= ClockSync.WARMUP_ACKS) synced = true;
+      return synced;
+    },
+    stop() {
+      stopped = true;
+      if (timer) clearTimeout(timer);
+    }
+  };
+}
+function msUntil(epochMs, clock) {
+  if (clock.synced && clock.clockOrigin > 0 && clock.serverNow !== void 0 && Number.isFinite(clock.serverNow)) {
+    return epochMs - clock.clockOrigin - clock.serverNow;
+  }
+  return epochMs - clock.wallNow;
+}
+
+// src/room-lifecycle.ts
+function useSdkReconnection(room) {
+  const r = room.reconnection;
+  r.enabled = ClientReconnection.enabled;
+  r.minUptime = ClientReconnection.minUptime;
+  r.delay = ClientReconnection.delay;
+  r.minDelay = ClientReconnection.minDelay;
+  r.maxDelay = ClientReconnection.maxDelay;
+  r.maxRetries = ClientReconnection.maxRetries;
+  r.maxEnqueuedMessages = ClientReconnection.maxEnqueuedMessages;
+  r.enqueuedMessages.length = 0;
+  return room;
+}
+function withoutReconnection(room) {
+  room.reconnection.enabled = false;
+  return room;
+}
+function waitForFirstState(room, timeoutMs) {
+  return new Promise((resolve) => {
+    const onState = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    const timer = setTimeout(() => {
+      room.onStateChange.remove(onState);
+      resolve(false);
+    }, timeoutMs);
+    room.onStateChange.once(onState);
+  });
+}
+function seedsInterpolation(id, selfId, sendTime) {
+  return id !== selfId && sendTime != null;
+}
+
+// src/voice.ts
+var NOT_DELEGATED = "The microphone was refused by the page that frames this game, not by the player: the frame was not given it, so the browser never asked. On its Genex page a build is given the microphone only when it declares it. An up-to-date genex CLI declares it at `genex preview` and `genex publish` when the game's own source calls voice.join(); to declare it by hand, add \"microphone\" to genex.capabilities in the game's package.json. Then preview or publish again.";
+var VoiceNotDelegatedError = class extends Error {
+  constructor(cause) {
+    super(NOT_DELEGATED, { cause });
+    this.name = "VoiceNotDelegatedError";
+  }
+};
+var DEFAULT_ICE = [{ urls: "stun:stun.l.google.com:19302" }];
+var SPEAKING_POLL_MS = 120;
+var DEFAULT_SPEAKING_THRESHOLD = 0.02;
+var SPEAKING_RELEASE_RATIO = 0.6;
+var VoiceMesh = class {
+  transport;
+  peers = /* @__PURE__ */ new Map();
+  listeners = /* @__PURE__ */ new Set();
+  roster = [];
+  local = null;
+  audio = null;
+  localAnalyser = null;
+  levelTimer = null;
+  iceServers = DEFAULT_ICE;
+  spatial = false;
+  threshold = DEFAULT_SPEAKING_THRESHOLD;
+  micOn = true;
+  selfSpeaking = false;
+  running = false;
+  // Peering is HELD between acquiring the mic and announcing the join, because both things
+  // that happen in that window must land first: the relay's TURN credentials (a peer built
+  // without them is stuck on STUN for its whole life), and our own `__voice:join` (the relay
+  // drops a signal from a session that is not yet in the roster, and a dropped offer is never
+  // retried). Without the hold, another player joining voice in that window patches the roster
+  // and builds us a peer that can neither relay nor negotiate.
+  peeringHeld = false;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  get active() {
+    return this.running;
+  }
+  get micEnabled() {
+    return this.micOn;
+  }
+  get speaking() {
+    return this.selfSpeaking;
+  }
+  get participants() {
+    return [...this.peers.values()].map((p) => ({
+      id: p.id,
+      name: this.transport.nameOf(p.id),
+      stream: p.stream,
+      speaking: p.speaking,
+      muted: p.muted,
+      volume: p.volume,
+      connection: p.connection
+    }));
+  }
+  onChange(cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  /** Acquire the microphone. Throws if the user denies it or no device exists — the caller
+   *  surfaces that; it is a normal outcome, not a bug. The one refusal that IS a bug throws a
+   *  VoiceNotDelegatedError instead: the page framing the game withheld the microphone, because
+   *  the build never declared it. Must be called from a user gesture: browsers gate both the
+   *  permission prompt and audio playback on one. */
+  async start(options = {}, holdPeering = false) {
+    if (this.running) return;
+    this.peeringHeld = holdPeering;
+    this.iceServers = options.iceServers?.length ? options.iceServers : DEFAULT_ICE;
+    this.spatial = options.spatial === true;
+    this.threshold = options.speakingThreshold ?? DEFAULT_SPEAKING_THRESHOLD;
+    this.micOn = options.startMuted !== true;
+    try {
+      this.local = await navigator.mediaDevices.getUserMedia({
+        audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
+        video: false
+      });
+    } catch (err) {
+      throw micRefusal(err);
+    }
+    for (const t of this.local.getAudioTracks()) t.enabled = this.micOn;
+    this.audio = new AudioContext();
+    this.localAnalyser = this.makeAnalyser(this.local);
+    this.running = true;
+    this.levelTimer = setInterval(() => this.pollLevels(), SPEAKING_POLL_MS);
+  }
+  /** Tear everything down. Safe to call when not running. */
+  stop() {
+    this.running = false;
+    this.peeringHeld = false;
+    if (this.levelTimer) {
+      clearInterval(this.levelTimer);
+      this.levelTimer = null;
+    }
+    for (const id of [...this.peers.keys()]) this.destroyPeer(id);
+    for (const t of this.local?.getTracks() ?? []) t.stop();
+    this.local = null;
+    this.localAnalyser = null;
+    void this.audio?.close().catch(() => {
+    });
+    this.audio = null;
+    this.roster = [];
+    this.selfSpeaking = false;
+    this.emit();
+  }
+  /**
+   * Swap in ICE servers obtained after `start()` — in practice the relay's short-lived TURN
+   * credentials, which are fetched between acquiring the mic and announcing the join so the
+   * network round trip never spends the user gesture `getUserMedia` needs.
+   *
+   * Peers built from here on use them. Live ones are updated too, but `setConfiguration`
+   * governs FUTURE gathering only: an allocation already relaying media keeps the credential
+   * it was created with. That is why the credential's TTL is sized to outlast a session
+   * rather than to reach the next refresh.
+   */
+  setIceServers(servers) {
+    if (!servers.length) return;
+    this.iceServers = servers;
+    for (const peer of this.peers.values()) {
+      try {
+        peer.pc.setConfiguration({ iceServers: servers });
+      } catch {
+      }
+    }
+  }
+  /**
+   * Release the hold taken by `start(…, true)` and reconcile whatever roster arrived while it
+   * was up. The caller MUST reach this on every path, including the one where no credentials
+   * came back: a mesh that never peers is worse than one peering without TURN.
+   */
+  releasePeering() {
+    if (!this.peeringHeld) return;
+    this.peeringHeld = false;
+    this.setRoster(this.roster);
+  }
+  /** The relay's authoritative roster changed: open connections to newcomers, drop leavers. */
+  setRoster(ids) {
+    this.roster = ids;
+    if (!this.running) return;
+    if (this.peeringHeld) return;
+    const self = this.transport.selfId();
+    const wanted = new Set(ids.filter((id) => id !== self));
+    for (const id of wanted) if (!this.peers.has(id)) this.createPeer(id);
+    for (const id of [...this.peers.keys()]) if (!wanted.has(id)) this.destroyPeer(id);
+    this.emit();
+  }
+  /** Push-to-talk. Gates the track rather than renegotiating — instant, and it keeps the
+   *  peer connections warm so the first syllable after a key press is not clipped. */
+  setMicEnabled(on) {
+    this.micOn = on;
+    for (const t of this.local?.getAudioTracks() ?? []) t.enabled = on;
+    if (!on && this.selfSpeaking) {
+      this.selfSpeaking = false;
+      this.emit();
+    }
+  }
+  mute(id) {
+    this.setMuted(id, true);
+  }
+  unmute(id) {
+    this.setMuted(id, false);
+  }
+  setVolume(id, volume) {
+    const p = this.peers.get(id);
+    if (!p) return;
+    p.volume = Math.max(0, Math.min(1, volume));
+    if (p.el) p.el.volume = p.volume;
+    this.emit();
+  }
+  /** A signal arrived from `from` (the relay stamped it — it cannot be spoofed). */
+  async handleSignal(from, raw) {
+    if (!this.running) return;
+    const signal = raw;
+    if (!signal || typeof signal !== "object" || typeof signal.t !== "string") return;
+    const peer = this.peers.get(from) ?? (this.roster.includes(from) ? this.createPeer(from) : void 0);
+    if (!peer) return;
+    try {
+      if (signal.t === "offer") {
+        await peer.pc.setRemoteDescription(signal.sdp);
+        await this.flushIce(peer);
+        const answer = await peer.pc.createAnswer();
+        await peer.pc.setLocalDescription(answer);
+        this.transport.sendSignal(from, { t: "answer", sdp: answer });
+      } else if (signal.t === "answer") {
+        if (peer.pc.signalingState !== "have-local-offer") return;
+        await peer.pc.setRemoteDescription(signal.sdp);
+        await this.flushIce(peer);
+      } else if (signal.t === "ice") {
+        if (peer.pc.remoteDescription) await peer.pc.addIceCandidate(signal.c);
+        else peer.pendingIce.push(signal.c);
+      }
+    } catch (err) {
+      console.warn(`[multiplayer] voice signaling failed with ${from}`, err);
+    }
+  }
+  // ---- internals ----
+  setMuted(id, muted) {
+    const p = this.peers.get(id);
+    if (!p || p.muted === muted) return;
+    p.muted = muted;
+    if (p.el) p.el.muted = muted || this.spatial;
+    if (muted && p.speaking) p.speaking = false;
+    this.emit();
+  }
+  createPeer(id) {
+    const pc = new RTCPeerConnection({ iceServers: this.iceServers });
+    const peer = {
+      id,
+      pc,
+      el: null,
+      stream: null,
+      analyser: null,
+      pendingIce: [],
+      speaking: false,
+      muted: false,
+      volume: 1,
+      connection: "connecting"
+    };
+    this.peers.set(id, peer);
+    for (const track of this.local?.getAudioTracks() ?? []) {
+      if (this.local) pc.addTrack(track, this.local);
+    }
+    pc.onicecandidate = (e) => {
+      if (e.candidate) this.transport.sendSignal(id, { t: "ice", c: e.candidate.toJSON() });
+    };
+    pc.ontrack = (e) => {
+      const stream = e.streams[0] ?? new MediaStream([e.track]);
+      peer.stream = stream;
+      peer.el = this.attachSink(stream, peer);
+      peer.analyser = this.makeAnalyser(stream);
+      this.emit();
+    };
+    pc.onconnectionstatechange = () => {
+      const s = pc.connectionState;
+      const next = s === "connected" ? "connected" : s === "failed" || s === "closed" ? "failed" : "connecting";
+      if (next !== peer.connection) {
+        peer.connection = next;
+        if (next === "failed") {
+          const relayed = this.iceServers.some((s2) => hasTurnUrl(s2));
+          console.warn(
+            `[multiplayer] voice connection to ${id} failed` + (relayed ? "" : " \u2014 no TURN in the ICE list (relay offered none?)")
+          );
+        }
+        this.emit();
+      }
+    };
+    if (this.transport.selfId() < id) void this.offer(peer);
+    return peer;
+  }
+  async offer(peer) {
+    try {
+      const offer = await peer.pc.createOffer();
+      await peer.pc.setLocalDescription(offer);
+      this.transport.sendSignal(peer.id, { t: "offer", sdp: offer });
+    } catch (err) {
+      console.warn(`[multiplayer] voice offer to ${peer.id} failed`, err);
+    }
+  }
+  async flushIce(peer) {
+    const queued = peer.pendingIce.splice(0);
+    for (const c of queued) {
+      try {
+        await peer.pc.addIceCandidate(c);
+      } catch {
+      }
+    }
+  }
+  destroyPeer(id) {
+    const peer = this.peers.get(id);
+    if (!peer) return;
+    this.peers.delete(id);
+    peer.pc.onicecandidate = null;
+    peer.pc.ontrack = null;
+    peer.pc.onconnectionstatechange = null;
+    try {
+      peer.pc.close();
+    } catch {
+    }
+    if (peer.el) {
+      peer.el.srcObject = null;
+      peer.el.remove();
+    }
+  }
+  /** Attach the stream to an element. Required even in spatial mode (see VoiceJoinOptions). */
+  attachSink(stream, peer) {
+    const el = document.createElement("audio");
+    el.autoplay = true;
+    el.srcObject = stream;
+    el.muted = this.spatial || peer.muted;
+    el.volume = peer.volume;
+    el.style.display = "none";
+    document.body.appendChild(el);
+    void el.play().catch((err) => {
+      console.warn("[multiplayer] voice playback was blocked \u2014 join voice from a click/tap", err);
+    });
+    return el;
+  }
+  makeAnalyser(stream) {
+    if (!this.audio) return null;
+    try {
+      const src = this.audio.createMediaStreamSource(stream);
+      const analyser = this.audio.createAnalyser();
+      analyser.fftSize = 512;
+      src.connect(analyser);
+      return analyser;
+    } catch {
+      return null;
+    }
+  }
+  pollLevels() {
+    let changed = false;
+    const localLevel = this.micOn ? rms(this.localAnalyser) : 0;
+    const nextSelf = this.crossed(localLevel, this.selfSpeaking);
+    if (nextSelf !== this.selfSpeaking) {
+      this.selfSpeaking = nextSelf;
+      changed = true;
+    }
+    for (const peer of this.peers.values()) {
+      const next = peer.muted ? false : this.crossed(rms(peer.analyser), peer.speaking);
+      if (next !== peer.speaking) {
+        peer.speaking = next;
+        changed = true;
+      }
+    }
+    if (changed) this.emit();
+  }
+  /** Threshold with hysteresis so a name tag does not strobe between syllables. */
+  crossed(level, was) {
+    return level >= (was ? this.threshold * SPEAKING_RELEASE_RATIO : this.threshold);
+  }
+  emit() {
+    for (const cb of [...this.listeners]) {
+      try {
+        cb();
+      } catch (err) {
+        console.error("[multiplayer] a voice listener threw", err);
+      }
+    }
+  }
+};
+function isFramed() {
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+function micRefusal(err) {
+  if (err?.name !== "NotAllowedError") return err;
+  try {
+    if (!isFramed()) return err;
+    const policy = document.featurePolicy;
+    if (policy?.allowsFeature?.("microphone") !== false) return err;
+  } catch {
+    return err;
+  }
+  return new VoiceNotDelegatedError(err);
+}
+function hasTurnUrl(server) {
+  const urls = Array.isArray(server.urls) ? server.urls : [server.urls];
+  return urls.some((u) => typeof u === "string" && u.startsWith("turn"));
+}
+function rms(analyser) {
+  if (!analyser) return 0;
+  const buf = new Uint8Array(analyser.fftSize);
+  analyser.getByteTimeDomainData(buf);
+  let sum = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const v = ((buf[i] ?? 128) - 128) / 128;
+    sum += v * v;
+  }
+  return Math.sqrt(sum / buf.length);
+}
+
+// src/room-ref.ts
+var ROOM_REF = /* @__PURE__ */ Symbol("genex.roomRef");
+var roomOf = (s) => s[ROOM_REF]();
+
+// src/index.ts
+var INTERP_RATIO = Interpolation.RATIO;
+var INTERP_MIN_MS = Interpolation.MIN_MS;
+var INTERP_MAX_MS = Interpolation.MAX_MS;
+var INTERP_DEFAULT_MS = Interpolation.DEFAULT_MS;
+var JITTER_SAFETY = Interpolation.JITTER_SAFETY;
+var POISON_GUARD_MS = Interpolation.POISON_GUARD_MS;
+var INTERP_EASE = Interpolation.EASE;
+var MAX_EXTRAP_MS = Interpolation.MAX_EXTRAP_MS;
+var ROT_EXTRAP_MS = Interpolation.ROT_EXTRAP_MS;
+var CLOCK_WIN = Interpolation.CLOCK_WINDOW;
+var CLOCK_WIN_MS = Interpolation.CLOCK_WINDOW_MS;
+var CLOCK_WIN_MAX = Interpolation.CLOCK_WINDOW_MAX;
+var INTERVAL_WIN = Interpolation.INTERVAL_WINDOW;
+var MIN_GAP_MS = Interpolation.MIN_GAP_MS;
+var MAX_GAP_MS = Interpolation.MAX_GAP_MS;
+var HISTORY_MS = Interpolation.HISTORY_MS;
+var SMOOTH_TAU_POS = Interpolation.SMOOTH_TAU_POS_MS;
+var SMOOTH_TAU_ROT = Interpolation.SMOOTH_TAU_ROT_MS;
+var MAX_DT_MS = Interpolation.MAX_HOST_TICK_DT_MS;
+var REBASE_AFTER_GAP_MS = Interpolation.REBASE_AFTER_GAP_MS;
+var OBJ_STREAM = "obj:";
+var ICE_REQUEST_TIMEOUT_MS = 3e3;
+var CONTROL_TIMEOUT_MS = 5e3;
+var CONTROL_TIMEOUT_MAX_MS = 6e4;
+var POSE_DATA_KEEPALIVE_MS = 2e3;
+async function relayClient(opts) {
+  if (opts.url) return new Client(opts.url);
+  if (opts.urls.length > 1) return Client.selectByLatency(opts.urls);
+  const url = opts.urls[0];
+  if (!url) throw new Error("genex multiplayer: `urls` must contain at least one relay URL");
+  return new Client(url);
+}
+var resolveAuth = (auth) => typeof auth === "function" ? auth() : auth;
+function predictSmoothing(opt) {
+  if (opt === "predict") return { mode: "lerp" };
+  if (opt && typeof opt === "object" && opt.engine === "predict") {
+    return { mode: opt.mode === "damped" ? "damped" : "lerp", delay: opt.delay, smoothMs: opt.smoothMs };
+  }
+  return void 0;
+}
+var loadPredict = async (opt) => predictSmoothing(opt) ? import("@colyseus/sdk/predict") : void 0;
+function parseData(s) {
+  if (!s) return { state: {} };
+  try {
+    const v = JSON.parse(s);
+    if (!v || typeof v !== "object") return { state: {} };
+    const o = v;
+    const t = o[SEND_TIME_KEY];
+    if (typeof t === "number" && Number.isFinite(t)) {
+      const state = { ...o };
+      delete state[SEND_TIME_KEY];
+      return { state, sendTime: t };
+    }
+    return { state: o };
+  } catch {
+    return { state: {} };
+  }
+}
+function parseValue(s) {
+  if (s == null) return void 0;
+  try {
+    return JSON.parse(s);
+  } catch {
+    return void 0;
+  }
+}
+var finiteReplacer = (_k, v) => {
+  if (typeof v === "number") return Number.isFinite(v) ? v : 0;
+  if (typeof v === "bigint") return Number(v);
+  return v;
+};
+function sanitizeFinite(obj) {
+  return JSON.parse(JSON.stringify(obj, finiteReplacer));
+}
+var nowMs = () => typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+function slerp(a, b, t) {
+  let [bx, by, bz, bw] = b;
+  const [ax, ay, az, aw] = a;
+  let dot = ax * bx + ay * by + az * bz + aw * bw;
+  if (dot < 0) {
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+    dot = -dot;
+  }
+  if (dot > 0.9995) {
+    const x = ax + (bx - ax) * t, y = ay + (by - ay) * t, z = az + (bz - az) * t, w = aw + (bw - aw) * t;
+    const l = Math.hypot(x, y, z, w) || 1;
+    return [x / l, y / l, z / l, w / l];
+  }
+  const theta0 = Math.acos(dot);
+  const sin0 = Math.sin(theta0);
+  const s0 = Math.sin(theta0 - theta0 * t) / sin0;
+  const s1 = Math.sin(theta0 * t) / sin0;
+  return [ax * s0 + bx * s1, ay * s0 + by * s1, az * s0 + bz * s1, aw * s0 + bw * s1];
+}
+function isQuat(v) {
+  return Array.isArray(v) && v.length === 4 && v.every((n) => typeof n === "number" && Number.isFinite(n));
+}
+function blend(a, b, tNum, tQuat) {
+  const out = {};
+  const interpolating = tNum < 1;
+  for (const k in b) {
+    const av = a[k];
+    const bv = b[k];
+    if (typeof av === "number" && typeof bv === "number" && Number.isFinite(av) && Number.isFinite(bv)) {
+      out[k] = av + (bv - av) * tNum;
+    } else if (isQuat(av) && isQuat(bv)) {
+      out[k] = slerp(av, bv, tQuat);
+    } else {
+      out[k] = interpolating && k in a ? av : bv;
+    }
+  }
+  return out;
+}
+function easeState(prev, target, aNum, aQuat) {
+  const out = {};
+  for (const k in target) {
+    const tv = target[k];
+    const pv = prev[k];
+    if (typeof pv === "number" && typeof tv === "number" && Number.isFinite(pv) && Number.isFinite(tv)) {
+      out[k] = pv + (tv - pv) * aNum;
+    } else if (isQuat(pv) && isQuat(tv)) {
+      out[k] = slerp(pv, tv, aQuat);
+    } else {
+      out[k] = tv;
+    }
+  }
+  return out;
+}
+function sampleBuffer(buf, renderTime) {
+  const n = buf.length;
+  if (n === 0) return void 0;
+  if (n === 1) return buf[0].state;
+  let j = 0;
+  while (j < n && buf[j].t <= renderTime) j++;
+  if (j === 0) return buf[0].state;
+  if (j >= n) {
+    const a2 = buf[n - 2];
+    const b2 = buf[n - 1];
+    const span2 = b2.t - a2.t;
+    if (span2 <= 0) return b2.state;
+    const tPos = (Math.min(renderTime, b2.t + MAX_EXTRAP_MS) - a2.t) / span2;
+    const tRot = (Math.min(renderTime, b2.t + ROT_EXTRAP_MS) - a2.t) / span2;
+    return blend(a2.state, b2.state, tPos, tRot);
+  }
+  const a = buf[j - 1];
+  const b = buf[j];
+  const span = b.t - a.t;
+  const t = span > 0 ? (renderTime - a.t) / span : 1;
+  return blend(a.state, b.state, t, t);
+}
+function median(xs) {
+  if (xs.length === 0) return 66;
+  const s = [...xs].sort((a, b) => a - b);
+  return s[s.length >> 1];
+}
+function quantile(xs, q) {
+  if (xs.length === 0) return 0;
+  const s = [...xs].sort((a, b) => a - b);
+  const i = Math.min(s.length - 1, Math.max(0, Math.round(q * (s.length - 1))));
+  return s[i];
+}
+async function connect(opts) {
+  const client = await relayClient(opts);
+  const predict = await loadPredict(opts.smoothing);
+  const room = useSdkReconnection(
+    await client.joinOrCreate(RoomType.PLAY, {
+      ...joinOptions(opts.room, opts.name, opts.auth),
+      ...opts.options,
+      // Last, so no extra option can misreport it (PROTOCOL.md §2: missing or wrong = 426).
+      protocol: PROTOCOL_VERSION
+    }).catch(explainJoinRefusal)
+  );
+  return attachSession(room, { pose: opts.pose, smoothing: opts.smoothing, predict });
+}
+function joinOptions(gameId, name, auth) {
+  return {
+    gameId,
+    name,
+    embedToken: resolveAuth(auth)?.embedToken,
+    protocol: PROTOCOL_VERSION
+  };
+}
+var isProtocolRefusal = (err) => !!err && typeof err === "object" && err.code === JoinError.PROTOCOL_UNSUPPORTED;
+var warnProtocolRefusal = () => console.error(
+  `[multiplayer] the relay refused protocol ${PROTOCOL_VERSION} (code 426) \u2014 this game was built with a @genex-ai/multiplayer that this relay no longer serves. Update the package and republish.`
+);
+var explainJoinRefusal = (err) => {
+  if (isProtocolRefusal(err)) warnProtocolRefusal();
+  throw err;
+};
+var isSendableEventType = (type) => typeof type === "string" && type.length > 0 && type.length <= Limits.MAX_EVENT_TYPE_CHARS && !isReservedEventType(type);
+var LOCAL_EVENTS = /* @__PURE__ */ new Set([
+  "join",
+  "leave",
+  "change",
+  "shared",
+  "object",
+  "host",
+  "reconnecting",
+  "reconnected",
+  "disconnect",
+  "room:open",
+  "voice",
+  "voice:rejected"
+]);
+var SDK_CHANNELS = /* @__PURE__ */ new Set([
+  ServerMessage.OBJECT_RESULT,
+  ServerMessage.INPUT,
+  ServerMessage.ROOM_OPEN,
+  ServerMessage.CHAT,
+  ServerMessage.CHAT_HISTORY,
+  ServerMessage.VOICE_ICE,
+  ServerMessage.VOICE_SIGNAL,
+  ServerMessage.VOICE_REJECTED,
+  ServerMessage.RATE_DROP,
+  ...Object.values(ClientMessage)
+]);
+var QUEUE_RESEARCH_DELAYS_MS = [500, 1e3, 2e3, 4e3, 8e3];
+function attachSession(room, options = {}) {
+  const buffers = /* @__PURE__ */ new Map();
+  const lastStamp = /* @__PURE__ */ new Map();
+  const clockOffsets = /* @__PURE__ */ new Map();
+  const senderClocks = /* @__PURE__ */ new Map();
+  const jitterWin = /* @__PURE__ */ new Map();
+  const streamSender = /* @__PURE__ */ new Map();
+  const posedStreams = /* @__PURE__ */ new Set();
+  const smoothed = /* @__PURE__ */ new Map();
+  const smoothedAt = /* @__PURE__ */ new Map();
+  const intervalsById = /* @__PURE__ */ new Map();
+  const autoDelayById = /* @__PURE__ */ new Map();
+  let localState;
+  const objOwners = /* @__PURE__ */ new Map();
+  const objConfirmedOwners = /* @__PURE__ */ new Map();
+  const objEpochs = /* @__PURE__ */ new Map();
+  const objSeqs = /* @__PURE__ */ new Map();
+  const objStamps = /* @__PURE__ */ new Map();
+  const objText = /* @__PURE__ */ new Map();
+  const objRaw = /* @__PURE__ */ new Map();
+  const localObjState = /* @__PURE__ */ new Map();
+  const warnedUnownedWrites = /* @__PURE__ */ new Set();
+  const pendingBridge = /* @__PURE__ */ new Map();
+  let hostId;
+  let requestCounter = 0;
+  const pendingControls = /* @__PURE__ */ new Map();
+  const hasPendingControl = (id) => {
+    for (const pending of pendingControls.values()) if (pending.id === id) return true;
+    return false;
+  };
+  const testSkew = typeof globalThis !== "undefined" && globalThis.__GENEX_MP_TEST_SKEW__ || 0;
+  const now = testSkew ? () => nowMs() + testSkew : nowMs;
+  const rejectUnownedWrite = (operation, id) => {
+    if (objOwners.get(id) === room.sessionId) return false;
+    const warningKey = `${operation}:${id}`;
+    if (!warnedUnownedWrites.has(warningKey)) {
+      warnedUnownedWrites.add(warningKey);
+      console.warn(
+        `[multiplayer] objects.${operation}('${id}') ignored because this session does not own the object \u2014 await objects.claimConfirmed('${id}') and check accepted before publishing`
+      );
+    }
+    return true;
+  };
+  const pushSnap = (id, state, sendTime, sender) => {
+    const arrival = now();
+    const t = sendTime;
+    const sample = arrival - sendTime;
+    let sc = senderClocks.get(sender);
+    if (!sc) senderClocks.set(sender, sc = { samples: [], mins: [], n: 0 });
+    const n = ++sc.n;
+    sc.samples.push({ at: arrival, n });
+    while (sc.mins.length > 0 && sc.mins[sc.mins.length - 1].v >= sample) sc.mins.pop();
+    sc.mins.push({ v: sample, n });
+    while (sc.samples.length > CLOCK_WIN_MAX || sc.samples.length > CLOCK_WIN && sc.samples[0].at < arrival - CLOCK_WIN_MS) {
+      sc.samples.shift();
+    }
+    const firstKept = sc.samples[0].n;
+    while (sc.mins[0].n < firstKept) sc.mins.shift();
+    clockOffsets.set(sender, sc.mins[0].v);
+    let jw = jitterWin.get(id);
+    if (!jw) jitterWin.set(id, jw = []);
+    jw.push(sample);
+    if (jw.length > CLOCK_WIN) jw.shift();
+    streamSender.set(id, sender);
+    const prev = lastStamp.get(id);
+    lastStamp.set(id, t);
+    if (prev != null) {
+      const gap = t - prev;
+      if (gap > MIN_GAP_MS && gap < MAX_GAP_MS) {
+        let iv = intervalsById.get(id);
+        if (!iv) intervalsById.set(id, iv = []);
+        iv.push(gap);
+        if (iv.length > INTERVAL_WIN) iv.shift();
+        const jitter = jw.length >= 8 ? Math.max(0, quantile(jw, 0.9) - sc.mins[0].v) : 0;
+        const target = Math.min(
+          INTERP_MAX_MS,
+          Math.max(INTERP_MIN_MS, INTERP_RATIO * median(iv), JITTER_SAFETY * jitter)
+        );
+        const cur = autoDelayById.get(id) ?? INTERP_DEFAULT_MS;
+        autoDelayById.set(id, cur + (target - cur) * INTERP_EASE);
+      }
+    }
+    let buf = buffers.get(id);
+    if (!buf) buffers.set(id, buf = []);
+    const bridge = pendingBridge.get(id);
+    if (bridge && buf.length === 0) {
+      const delay = autoDelayById.get(id) ?? INTERP_DEFAULT_MS;
+      buf.push({ t: t - Math.max(1, delay), state: bridge });
+    }
+    pendingBridge.delete(id);
+    buf.push({ t, state });
+    const cutoff = t - HISTORY_MS;
+    while (buf.length > 2 && buf[0].t < cutoff) buf.shift();
+    while (buf.length > 1 && buf[0].t > buf[buf.length - 1].t + POISON_GUARD_MS) buf.shift();
+  };
+  const renderTimeOf = (streamKey, localNow) => {
+    const sender = streamSender.get(streamKey);
+    const offset = sender === void 0 ? void 0 : clockOffsets.get(sender);
+    if (offset === void 0) return void 0;
+    return localNow - offset - (autoDelayById.get(streamKey) ?? INTERP_DEFAULT_MS);
+  };
+  const sampleSmoothed = (streamKey, localNow) => {
+    const buf = buffers.get(streamKey);
+    const renderTime = renderTimeOf(streamKey, localNow) ?? localNow - INTERP_DEFAULT_MS;
+    const posed = posedStreams.has(streamKey);
+    const sampled = buf && (posed ? samplePose(buf, renderTime) : sampleBuffer(buf, renderTime));
+    if (!sampled) return smoothed.get(streamKey);
+    const prev = smoothed.get(streamKey);
+    let out;
+    if (prev) {
+      const dt = Math.min(MAX_DT_MS, Math.max(0, localNow - (smoothedAt.get(streamKey) ?? localNow)));
+      const aPos = 1 - Math.exp(-dt / SMOOTH_TAU_POS);
+      const aRot = 1 - Math.exp(-dt / SMOOTH_TAU_ROT);
+      out = posed ? easePose(prev, sampled, aPos, aRot) : easeState(prev, sampled, aPos, aRot);
+    } else {
+      out = sampled;
+    }
+    smoothed.set(streamKey, out);
+    smoothedAt.set(streamKey, localNow);
+    return out;
+  };
+  const clearStream = (streamKey) => {
+    buffers.delete(streamKey);
+    lastStamp.delete(streamKey);
+    streamSender.delete(streamKey);
+    smoothed.delete(streamKey);
+    smoothedAt.delete(streamKey);
+    intervalsById.delete(streamKey);
+    autoDelayById.delete(streamKey);
+    jitterWin.delete(streamKey);
+    pendingBridge.delete(streamKey);
+  };
+  const clearStreamClock = (streamKey) => {
+    buffers.delete(streamKey);
+    lastStamp.delete(streamKey);
+    streamSender.delete(streamKey);
+    intervalsById.delete(streamKey);
+    autoDelayById.delete(streamKey);
+    jitterWin.delete(streamKey);
+  };
+  const clearSenderClock = (sender) => {
+    clockOffsets.delete(sender);
+    senderClocks.delete(sender);
+  };
+  const emitters = /* @__PURE__ */ new Map();
+  const bridged = /* @__PURE__ */ new Set();
+  const emit = (event, ...args) => emitters.get(event)?.forEach((cb) => {
+    try {
+      cb(...args);
+    } catch (err) {
+      console.error(`[multiplayer] a '${event}' listener threw:`, err);
+    }
+  });
+  const lastShared = /* @__PURE__ */ new Map();
+  const handleShared = (value, key) => {
+    if (lastShared.get(key) === value) return;
+    lastShared.set(key, value);
+    emit("shared", key, parseValue(value));
+  };
+  const applyHost = (wire) => {
+    const next = wire || void 0;
+    if (next === hostId) return;
+    hostId = next;
+    emit("host", hostId);
+  };
+  let lastRoster = "";
+  const applyVoiceRoster = () => {
+    const ids = room.state?.voice ? [...room.state.voice.keys()].sort() : [];
+    const key = ids.join("\n");
+    if (key === lastRoster) return;
+    lastRoster = key;
+    voice.setRoster(ids);
+    emit("voice", voice.participants);
+  };
+  const applyObject = (id, o) => {
+    const key = OBJ_STREAM + id;
+    const me = room.sessionId;
+    const known = objSeqs.has(id);
+    const owner = o.owner || void 0;
+    const seq = Number.isFinite(o.seq) ? o.seq : 0;
+    const epoch = Number.isFinite(o.epoch) ? o.epoch : 0;
+    const t = Number.isFinite(o.t) ? o.t : 0;
+    const text = typeof o.d === "string" ? o.d : "";
+    const ownerChanged = owner !== objConfirmedOwners.get(id);
+    const handoff = ownerChanged || known && seq !== objSeqs.get(id);
+    const epochChanged = objEpochs.has(id) && epoch !== objEpochs.get(id);
+    const stampChanged = t !== objStamps.get(id);
+    objSeqs.set(id, seq);
+    objEpochs.set(id, epoch);
+    objStamps.set(id, t);
+    if (text !== objText.get(id)) {
+      objText.set(id, text);
+      const parsed = text ? parseValue(text) : void 0;
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) objRaw.set(id, parsed);
+    }
+    if (owner) objConfirmedOwners.set(id, owner);
+    else objConfirmedOwners.delete(id);
+    if (handoff || objOwners.get(id) !== owner && !hasPendingControl(id)) {
+      if (owner) objOwners.set(id, owner);
+      else objOwners.delete(id);
+    }
+    if (epochChanged) clearStream(key);
+    if (handoff && owner !== me) {
+      localObjState.delete(id);
+      if (!epochChanged) clearStreamClock(key);
+    }
+    const d = objRaw.get(id);
+    if (d && owner !== me) {
+      const sample = t !== 0 && stampChanged && owner !== void 0;
+      if (epochChanged) {
+        smoothed.set(key, d);
+        smoothedAt.set(key, now());
+        if (sample) pushSnap(key, d, t, owner);
+      } else {
+        if (handoff) {
+          pendingBridge.set(key, smoothed.get(key) ?? d);
+        }
+        if (sample) pushSnap(key, d, t, owner);
+      }
+    }
+    if (!known || handoff) emit("object", id);
+  };
+  const dropObject = (id) => {
+    const known = objSeqs.has(id) || objOwners.has(id) || objRaw.has(id) || localObjState.has(id);
+    clearStream(OBJ_STREAM + id);
+    objRaw.delete(id);
+    objOwners.delete(id);
+    objConfirmedOwners.delete(id);
+    objEpochs.delete(id);
+    objSeqs.delete(id);
+    objStamps.delete(id);
+    objText.delete(id);
+    localObjState.delete(id);
+    if (known) emit("object", id);
+  };
+  const parseCache = /* @__PURE__ */ new Map();
+  const playerEpochs = /* @__PURE__ */ new Map();
+  const playerData = /* @__PURE__ */ new Map();
+  const cachedParse = (id, raw) => {
+    if (!raw) return {};
+    const hit = parseCache.get(id);
+    if (hit && hit.raw === raw) return hit.state;
+    const { state } = parseData(raw);
+    parseCache.set(id, { raw, state });
+    return state;
+  };
+  const posedData = /* @__PURE__ */ new Map();
+  const playerPoseT = /* @__PURE__ */ new Map();
+  const predictCfg = options.predict ? predictSmoothing(options.smoothing) : void 0;
+  let predict;
+  const predictAttached = /* @__PURE__ */ new Map();
+  const attachPredict = (id, player) => {
+    if (!predictCfg || !options.predict) return;
+    predict ??= options.predict.Predict.get(room);
+    const lin = { mode: predictCfg.mode, delay: predictCfg.delay, smoothMs: predictCfg.smoothMs };
+    predict.attach(player, { x: lin, y: lin, z: lin, vx: lin, vy: lin, vz: lin });
+    predict.attach(player, { yaw: { ...lin, angle: true } });
+    predictAttached.set(id, player);
+  };
+  const detachPredict = (id) => {
+    const player = predictAttached.get(id);
+    if (player && predict) predict.detach(player);
+    predictAttached.delete(id);
+  };
+  const predictedPose = (player) => {
+    const p = predict;
+    return {
+      x: p.value(player, "x"),
+      y: p.value(player, "y"),
+      z: p.value(player, "z"),
+      yaw: p.value(player, "yaw"),
+      vx: p.value(player, "vx"),
+      vy: p.value(player, "vy"),
+      vz: p.value(player, "vz"),
+      anim: player.anim ?? ""
+      // Predict smooths numbers only: anim is the latest, not held (§15 A/B)
+    };
+  };
+  let intentionalLeave = false;
+  let dead = false;
+  let connected = true;
+  let reconnecting = false;
+  let reconnectAttempt = 0;
+  let reconnectStartedAt = 0;
+  let dropGeneration = 0;
+  const hostTickSyncs = /* @__PURE__ */ new Set();
+  const syncHostTicks = () => hostTickSyncs.forEach((sync) => sync());
+  const settleControl = (pending, result) => {
+    pendingControls.delete(pending.requestId);
+    if (pending.timeout) clearTimeout(pending.timeout);
+    pending.abort?.();
+    if (pending.operation === "claim" && pending.optimistic && !result.accepted) {
+      const owner = result.owner ?? objConfirmedOwners.get(pending.id);
+      if (owner) objOwners.set(pending.id, owner);
+      else objOwners.delete(pending.id);
+      if (owner !== room.sessionId) localObjState.delete(pending.id);
+    }
+    if (pending.operation === "claim" && result.accepted) {
+      objOwners.set(pending.id, room.sessionId);
+      clearStreamClock(OBJ_STREAM + pending.id);
+    }
+    if (pending.operation === "release" && result.accepted) {
+      localObjState.delete(pending.id);
+      if (objOwners.get(pending.id) === room.sessionId) objOwners.delete(pending.id);
+      clearStreamClock(OBJ_STREAM + pending.id);
+    }
+    if (pending.operation === "remove" && result.accepted) {
+      localObjState.delete(pending.id);
+      objRaw.delete(pending.id);
+      objOwners.delete(pending.id);
+      clearStream(OBJ_STREAM + pending.id);
+    }
+    pending.resolve(result);
+  };
+  const localResult = (pending, reason) => {
+    const o = room.state?.objects?.get(pending.id);
+    return {
+      requestId: pending.requestId,
+      operation: pending.operation,
+      id: pending.id,
+      accepted: false,
+      owner: o?.owner || void 0,
+      sequence: o && Number.isFinite(o.seq) ? o.seq : 0,
+      reason
+    };
+  };
+  const settleAllControls = (reason) => {
+    for (const pending of [...pendingControls.values()]) settleControl(pending, localResult(pending, reason));
+  };
+  const sendPendingControl = (pending, force = false) => {
+    if (!force && !connected) return;
+    const type = pending.operation === "claim" ? ClientMessage.CLAIM : pending.operation === "release" ? ClientMessage.RELEASE : ClientMessage.DESTROY;
+    send0(type, pending.payload);
+  };
+  const confirmedControl = (operation, id, options2 = {}) => {
+    const key = String(id);
+    const requestId = `${room.sessionId.slice(0, 12)}:${Date.now().toString(36)}:${(++requestCounter).toString(36)}`;
+    const timeoutMs = Math.max(250, Math.min(options2.timeoutMs ?? CONTROL_TIMEOUT_MS, CONTROL_TIMEOUT_MAX_MS));
+    return new Promise((resolve) => {
+      const pending = {
+        operation,
+        id: key,
+        requestId,
+        payload: {
+          id: key,
+          requestId,
+          ...options2.authority === "host" ? { authority: "host" } : {}
+        },
+        optimistic: operation === "claim" && options2.optimistic === true,
+        resolve,
+        timeout: null,
+        abort: void 0
+      };
+      if (intentionalLeave || dead) {
+        resolve(localResult(pending, intentionalLeave ? "aborted" : "disconnected"));
+        return;
+      }
+      if (pending.optimistic) objOwners.set(key, room.sessionId);
+      pending.timeout = setTimeout(() => settleControl(pending, localResult(pending, "timeout")), timeoutMs);
+      if (options2.signal) {
+        const onAbort = () => settleControl(pending, localResult(pending, "aborted"));
+        options2.signal.addEventListener("abort", onAbort, { once: true });
+        pending.abort = () => options2.signal?.removeEventListener("abort", onAbort);
+      }
+      pendingControls.set(requestId, pending);
+      if (options2.signal?.aborted) {
+        settleControl(pending, localResult(pending, "aborted"));
+        return;
+      }
+      sendPendingControl(pending);
+    });
+  };
+  let droppedWhileOffline = 0;
+  const send0 = (type, payload, countIfDropped = false) => {
+    if (room.connection?.isOpen) {
+      try {
+        room.send(type, payload);
+        return true;
+      } catch {
+      }
+    }
+    if (countIfDropped) droppedWhileOffline++;
+    return false;
+  };
+  let lastDataText;
+  let lastDataSentAt = 0;
+  let velocity;
+  const warnedPoseKeys = /* @__PURE__ */ new Set();
+  const publishPosed = (clean, snap) => {
+    const { pose, data, invalid } = splitPose(clean);
+    for (const k of invalid) {
+      if (warnedPoseKeys.has(k)) continue;
+      warnedPoseKeys.add(k);
+      console.warn(
+        `[multiplayer] me.set: '${k}' is a typed pose key (pose: true) and its value is not a ` + (k === "anim" ? `string of \u2264${Limits.MAX_ANIM_CHARS} chars` : "finite number") + " \u2014 it is not sent."
+      );
+    }
+    if (!hasPose(pose)) return false;
+    const t = now();
+    const derived = deriveVelocity(pose, t, snap ? void 0 : velocity);
+    velocity = derived.memory;
+    const text = JSON.stringify(data);
+    const dataDue = snap || text !== lastDataText || t - lastDataSentAt >= POSE_DATA_KEEPALIVE_MS;
+    if (dataDue && send0(ClientMessage.STATE, JSON.stringify({ ...data, [SEND_TIME_KEY]: t }))) {
+      lastDataText = text;
+      lastDataSentAt = t;
+    } else if (dataDue) {
+      lastDataText = void 0;
+    }
+    if (!send0(snap ? ClientMessage.POSE_SNAP : ClientMessage.POSE, { ...derived.pose, t })) lastDataText = void 0;
+    return true;
+  };
+  const voice = new VoiceMesh({
+    selfId: () => room.sessionId,
+    nameOf: (id) => room.state?.players?.get(id)?.name ?? "",
+    sendSignal: (to, data) => send0(ClientMessage.VOICE_SIGNAL, { to, data }, true)
+  });
+  voice.onChange(() => emit("voice", voice.participants));
+  let iceRefreshTimer = null;
+  const ice = createIceRequester(() => send0(ClientMessage.VOICE_ICE_REQUEST, {}, true), ICE_REQUEST_TIMEOUT_MS);
+  const clearIceRefresh = () => {
+    if (iceRefreshTimer) clearTimeout(iceRefreshTimer);
+    iceRefreshTimer = null;
+  };
+  const scheduleIceRefresh = (ttl) => {
+    clearIceRefresh();
+    if (typeof ttl !== "number" || !Number.isFinite(ttl) || ttl <= 0) return;
+    iceRefreshTimer = setTimeout(() => {
+      if (!voice.active) return;
+      void ice.request().then((cfg) => {
+        if (!voice.active || !cfg?.iceServers?.length) return;
+        voice.setIceServers(cfg.iceServers);
+        scheduleIceRefresh(cfg.ttl);
+      });
+    }, Math.max(6e4, Math.floor(ttl * 800)));
+  };
+  const chatHistory = [];
+  const chatSeen = /* @__PURE__ */ new Set();
+  const chatListeners = /* @__PURE__ */ new Set();
+  const chatMuted = /* @__PURE__ */ new Set();
+  const isChatMessage = (m) => !!m && typeof m === "object" && typeof m.id === "number" && typeof m.from === "string" && typeof m.name === "string" && typeof m.text === "string";
+  const acceptChat = (message) => {
+    if (!isChatMessage(message)) return;
+    if (chatSeen.has(message.id)) return;
+    if (chatMuted.has(message.from)) return;
+    chatSeen.add(message.id);
+    const last = chatHistory[chatHistory.length - 1];
+    if (!last || message.id > last.id) chatHistory.push(message);
+    else {
+      let i = chatHistory.length;
+      while (i > 0 && (chatHistory[i - 1]?.id ?? 0) > message.id) i--;
+      chatHistory.splice(i, 0, message);
+    }
+    for (const cb of [...chatListeners]) {
+      try {
+        cb(message);
+      } catch (err) {
+        console.error("[multiplayer] a chat listener threw", err);
+      }
+    }
+  };
+  const $ = getStateCallbacks(room);
+  if (!$) throw new Error("genex multiplayer: the relay room has no schema state");
+  const applyPlayer = (id, player, joining) => {
+    const self = id === room.sessionId;
+    const { state: data, sendTime } = parseData(player.data);
+    const epoch = Number.isFinite(player.epoch) ? player.epoch : 0;
+    const epochChanged = playerEpochs.has(id) && epoch !== playerEpochs.get(id);
+    playerEpochs.set(id, epoch);
+    const dataChanged = joining || player.data !== playerData.get(id);
+    playerData.set(id, player.data);
+    const poseT = Number.isFinite(player.poseT) ? player.poseT : 0;
+    const poseChanged = poseT !== (playerPoseT.get(id) ?? 0);
+    playerPoseT.set(id, poseT);
+    const posed = player.posed === true;
+    if (!self && posed && !posedStreams.has(id)) {
+      clearStream(id);
+      posedStreams.add(id);
+      posedData.set(id, new SnappedData());
+    }
+    if (!self && epochChanged) {
+      clearStream(id);
+      if (predictAttached.has(id)) detachPredict(id);
+    }
+    emit(joining ? "join" : "change", id, posed ? { ...data, ...readPose(player) } : data);
+    if (self) return;
+    if (posed) {
+      const snapped = posedData.get(id);
+      if (dataChanged || epochChanged) {
+        snapped.push(sendTime, data);
+        if (epochChanged || predictCfg) snapped.flush();
+      }
+      if (predictCfg) {
+        if (!predictAttached.has(id)) attachPredict(id, player);
+      } else if (poseT !== 0 && (poseChanged || epochChanged)) {
+        pushSnap(id, readPose(player), poseT, id);
+      }
+      return;
+    }
+    if ((dataChanged || epochChanged) && seedsInterpolation(id, room.sessionId, sendTime)) {
+      pushSnap(id, data, sendTime, id);
+    }
+  };
+  $(room.state).players.onAdd((player, id) => {
+    applyPlayer(id, player, true);
+    $(player).onChange(() => applyPlayer(id, player, false));
+  });
+  const dropPlayer = (id) => {
+    emit("leave", id);
+    clearStream(id);
+    clearSenderClock(id);
+    detachPredict(id);
+    parseCache.delete(id);
+    playerEpochs.delete(id);
+    playerData.delete(id);
+    playerPoseT.delete(id);
+    posedStreams.delete(id);
+    posedData.delete(id);
+  };
+  $(room.state).players.onRemove((_player, id) => dropPlayer(id));
+  $(room.state).shared.onAdd(handleShared);
+  $(room.state).shared.onChange(handleShared);
+  $(room.state).objects.onAdd((obj, id) => {
+    applyObject(id, obj);
+    $(obj).onChange(() => applyObject(id, obj));
+  });
+  $(room.state).objects.onRemove((_obj, id) => dropObject(id));
+  $(room.state).listen("host", (value) => applyHost(value));
+  $(room.state).voice.onAdd(applyVoiceRoster);
+  $(room.state).voice.onRemove(applyVoiceRoster);
+  const reconcileWithState = () => {
+    const state = room.state;
+    if (!state) return;
+    for (const id of /* @__PURE__ */ new Set([...objOwners.keys(), ...objRaw.keys(), ...objSeqs.keys()])) {
+      if (!state.objects?.has(id)) dropObject(id);
+    }
+    for (const id of [...playerEpochs.keys()]) {
+      if (!state.players?.has(id)) dropPlayer(id);
+    }
+    applyHost(state.host);
+    applyVoiceRoster();
+  };
+  room.onMessage(ServerMessage.VOICE_SIGNAL, (msg) => {
+    if (msg && typeof msg.from === "string") void voice.handleSignal(msg.from, msg.data);
+  });
+  room.onMessage(ServerMessage.VOICE_REJECTED, (msg) => {
+    clearIceRefresh();
+    voice.stop();
+    emit("voice:rejected", msg ?? { reason: "full" });
+  });
+  room.onMessage(ServerMessage.VOICE_ICE, (msg) => {
+    ice.deliver(msg ?? null);
+  });
+  room.onMessage(ServerMessage.CHAT, (msg) => acceptChat(msg));
+  room.onMessage(ServerMessage.CHAT_HISTORY, (msg) => {
+    if (!Array.isArray(msg?.messages)) return;
+    for (const m of msg.messages) acceptChat(m);
+  });
+  room.onMessage(ServerMessage.OBJECT_RESULT, (msg) => {
+    if (!msg || typeof msg.requestId !== "string") return;
+    const pending = pendingControls.get(msg.requestId);
+    if (!pending || msg.operation !== pending.operation || msg.id !== pending.id) return;
+    settleControl(pending, msg);
+  });
+  room.onMessage(ServerMessage.INPUT, (msg) => {
+    if (msg && typeof msg.from === "string") emit(ServerMessage.INPUT, msg.from, msg.d);
+  });
+  room.onMessage(ServerMessage.ROOM_OPEN, (msg) => {
+    if (typeof msg?.open === "boolean") emit("room:open", { open: msg.open });
+  });
+  room.onMessage(ServerMessage.RATE_DROP, (msg) => {
+    console.warn(
+      `[multiplayer] the relay dropped ${msg?.dropped ?? "some"} of your messages in the last second \u2014 you are publishing over budget. Publish idle/unchanged objects at \u22642Hz keepalive, not every tick (see the multiplayer skill's "message budget" section).`
+    );
+  });
+  room.onMessage(ServerMessage.SERVER_RESTART, () => {
+  });
+  send0(ClientMessage.CHAT_HISTORY_REQUEST, {});
+  const heartbeatHandle = heartbeatHandleOf(room);
+  const heartbeat = heartbeatHandle ? startHeartbeat(heartbeatHandle, () => !dead && !intentionalLeave) : void 0;
+  const serverNow = () => heartbeat ? room.clock.serverNow() : void 0;
+  const timeUntil = (epochMs) => msUntil(epochMs, {
+    synced: heartbeat?.synced === true,
+    clockOrigin: Number.isFinite(room.state?.clockOrigin) ? room.state?.clockOrigin : 0,
+    serverNow: serverNow(),
+    wallNow: Date.now()
+  });
+  const stopTimers = () => {
+    heartbeat?.stop();
+    predict?.dispose();
+    predict = void 0;
+    predictAttached.clear();
+  };
+  room.onDrop((code) => {
+    if (intentionalLeave || dead) return;
+    dropGeneration++;
+    if (!reconnecting) {
+      reconnecting = true;
+      reconnectAttempt = 0;
+      reconnectStartedAt = nowMs();
+    }
+    connected = false;
+    syncHostTicks();
+    const { isReconnecting, retryCount, maxRetries } = room.reconnection;
+    if (isReconnecting && retryCount >= maxRetries) return;
+    emit("reconnecting", { attempt: ++reconnectAttempt, code });
+  });
+  room.onReconnect(() => {
+    if (dead) return;
+    if (intentionalLeave) {
+      void room.leave().catch(() => {
+      });
+      return;
+    }
+    const generation = dropGeneration;
+    const gap = reconnectStartedAt ? nowMs() - reconnectStartedAt : 0;
+    if (gap > REBASE_AFTER_GAP_MS) {
+      for (const streamKey of [...buffers.keys()]) clearStream(streamKey);
+      for (const sender of [...senderClocks.keys()]) clearSenderClock(sender);
+    }
+    void (async () => {
+      await waitForFirstState(room, ClientReconnection.firstStateTimeoutMs);
+      if (generation !== dropGeneration || dead || intentionalLeave) return;
+      reconcileWithState();
+      for (const pending of [...pendingControls.values()]) sendPendingControl(pending, true);
+      send0(ClientMessage.CHAT_HISTORY_REQUEST, {});
+      reconnecting = false;
+      reconnectStartedAt = 0;
+      connected = true;
+      syncHostTicks();
+      emit("reconnected");
+      if (droppedWhileOffline > 0) {
+        console.warn(
+          `[multiplayer] ${droppedWhileOffline} fire-and-forget event(s)/input(s) were dropped while reconnecting \u2014 they are not buffered; player/object state re-synced automatically.`
+        );
+        droppedWhileOffline = 0;
+      }
+    })();
+  });
+  room.onLeave((code) => {
+    if (dead) return;
+    dead = true;
+    connected = false;
+    reconnecting = false;
+    stopTimers();
+    syncHostTicks();
+    if (intentionalLeave) return;
+    settleAllControls("disconnected");
+    emit("disconnect", code ?? 1006);
+  });
+  room.onError(() => {
+  });
+  const on = ((event, cb) => {
+    let set = emitters.get(event);
+    if (!set) emitters.set(event, set = /* @__PURE__ */ new Set());
+    set.add(cb);
+    if (!LOCAL_EVENTS.has(event) && !SDK_CHANNELS.has(event) && !bridged.has(event)) {
+      bridged.add(event);
+      room.onMessage(event, (msg) => emit(event, msg));
+    }
+    return () => {
+      set?.delete(cb);
+    };
+  });
+  const session = {
+    id: room.sessionId,
+    get players() {
+      const out = /* @__PURE__ */ new Map();
+      const localNow = now();
+      if (predict && predictAttached.size > 0) predict.tick(nowMs());
+      room.state?.players?.forEach((p, id) => {
+        const latest = cachedParse(id, p.data);
+        let state = latest;
+        let raw = latest;
+        const snapped = posedData.get(id);
+        if (id !== room.sessionId && snapped) {
+          const rawPose = readPose(p);
+          raw = { ...latest, ...rawPose };
+          if (predictAttached.has(id)) {
+            state = { ...snapped.at(void 0) ?? latest, ...predictedPose(p) };
+          } else {
+            const pose = sampleSmoothed(id, localNow) ?? rawPose;
+            state = { ...snapped.at(renderTimeOf(id, localNow)) ?? latest, ...pose };
+          }
+        } else if (id === room.sessionId) {
+          if (localState) {
+            state = localState;
+            raw = localState;
+          }
+        } else {
+          state = sampleSmoothed(id, localNow) ?? latest;
+        }
+        out.set(id, {
+          id,
+          name: p.name ?? "",
+          avatarUrl: p.avatarUrl ?? "",
+          connected: p.connected !== false,
+          uid: p.uid ?? "",
+          team: Number.isFinite(p.team) ? p.team : -1,
+          state,
+          stateRaw: raw
+        });
+      });
+      return out;
+    },
+    get activePlayers() {
+      return new Map([...session.players].filter(([, player]) => player.connected));
+    },
+    me: {
+      set(state) {
+        if (SEND_TIME_KEY in state) {
+          console.warn(`[multiplayer] '${SEND_TIME_KEY}' is a reserved field name and will be overwritten by the send timestamp \u2014 rename it.`);
+        }
+        const clean = sanitizeFinite(state);
+        localState = clean;
+        if (options.pose && publishPosed(clean, false)) return;
+        send0(ClientMessage.STATE, JSON.stringify({ ...clean, [SEND_TIME_KEY]: now() }));
+      },
+      snap(state) {
+        if (SEND_TIME_KEY in state) {
+          console.warn(`[multiplayer] '${SEND_TIME_KEY}' is a reserved field name and will be overwritten by the send timestamp \u2014 rename it.`);
+        }
+        const clean = sanitizeFinite(state);
+        localState = clean;
+        if (options.pose && publishPosed(clean, true)) return;
+        send0(ClientMessage.STATE_SNAP, JSON.stringify({ ...clean, [SEND_TIME_KEY]: now() }));
+      }
+    },
+    shared: {
+      get(key) {
+        return parseValue(room.state?.shared?.get(key));
+      },
+      set(key, value) {
+        if (key.startsWith(RESERVED_SHARED_PREFIX)) return;
+        send0(ClientMessage.SHARED, { key, value: JSON.stringify(sanitizeFinite(value)) });
+      },
+      keys() {
+        return room.state?.shared ? Array.from(room.state.shared.keys()) : [];
+      }
+    },
+    objects: {
+      claim(id) {
+        void confirmedControl("claim", id, { optimistic: true });
+      },
+      claimConfirmed(id, options2) {
+        return confirmedControl("claim", id, options2);
+      },
+      release(id) {
+        const key = String(id);
+        localObjState.delete(key);
+        if (objOwners.get(key) === room.sessionId) objOwners.delete(key);
+        clearStreamClock(OBJ_STREAM + key);
+        void confirmedControl("release", key);
+      },
+      releaseConfirmed(id, options2) {
+        return confirmedControl("release", id, options2);
+      },
+      remove(id) {
+        const key = String(id);
+        if (objOwners.get(key) === room.sessionId) {
+          localObjState.delete(key);
+          objRaw.delete(key);
+          objOwners.delete(key);
+          clearStream(OBJ_STREAM + key);
+        }
+        void confirmedControl("remove", key);
+      },
+      removeConfirmed(id, options2) {
+        return confirmedControl("remove", id, options2);
+      },
+      set(id, state) {
+        const key = String(id);
+        if (rejectUnownedWrite("set", key)) return;
+        const clean = sanitizeFinite(state);
+        if (objOwners.get(key) === room.sessionId) localObjState.set(key, clean);
+        send0(ClientMessage.OBJECT, { id: key, d: clean, t: now() });
+      },
+      snap(id, state) {
+        const key = String(id);
+        if (rejectUnownedWrite("snap", key)) return;
+        const clean = sanitizeFinite(state);
+        if (objOwners.get(key) === room.sessionId) localObjState.set(key, clean);
+        send0(ClientMessage.OBJECT_SNAP, { id: key, d: clean, t: now() });
+      },
+      get(id) {
+        const key = String(id);
+        const owner = objOwners.get(key);
+        const mine = localObjState.get(key);
+        if (owner === void 0 && !objRaw.has(key) && !mine) return void 0;
+        const isMine = owner !== void 0 && owner === room.sessionId;
+        let state;
+        let raw;
+        if (isMine && mine) {
+          state = mine;
+          raw = mine;
+          smoothed.set(OBJ_STREAM + key, mine);
+          smoothedAt.set(OBJ_STREAM + key, now());
+        } else {
+          raw = objRaw.get(key) ?? {};
+          state = sampleSmoothed(OBJ_STREAM + key, now()) ?? raw;
+        }
+        return {
+          id: key,
+          epoch: objEpochs.get(key) ?? 0,
+          owner,
+          isMine,
+          state,
+          stateRaw: raw
+        };
+      },
+      ids() {
+        return [.../* @__PURE__ */ new Set([...objOwners.keys(), ...objRaw.keys(), ...localObjState.keys()])];
+      }
+    },
+    // Gated like onHostTick (PROTOCOL.md §6.3): between a reconnect's socket opening and its first
+    // snapshot, `hostId` still holds the pre-drop value, so a failed-over ex-host would otherwise
+    // read true for a round trip and write stale host facts into `shared`.
+    get isHost() {
+      return connected && !intentionalLeave && !dead && hostId !== void 0 && hostId === room.sessionId;
+    },
+    get host() {
+      return hostId;
+    },
+    inputs: {
+      send(payload) {
+        send0(ClientMessage.INPUT, sanitizeFinite(payload), true);
+      },
+      on(cb) {
+        let set = emitters.get(ServerMessage.INPUT);
+        if (!set) emitters.set(ServerMessage.INPUT, set = /* @__PURE__ */ new Set());
+        const listener = (from, payload) => cb(from, payload);
+        set.add(listener);
+        return () => void set?.delete(listener);
+      }
+    },
+    onHostTick(hz, cb) {
+      let timer = null;
+      let last = 0;
+      const safeHz = Number.isFinite(hz) && hz > 0 ? Math.min(hz, 100) : 20;
+      const intervalMs = Math.max(10, Math.round(1e3 / safeHz));
+      const sync = () => {
+        const shouldRun = connected && !intentionalLeave && !dead && hostId !== void 0 && hostId === room.sessionId;
+        if (shouldRun && !timer) {
+          last = nowMs();
+          timer = setInterval(() => {
+            const t = nowMs();
+            cb(Math.min(t - last, MAX_DT_MS));
+            last = t;
+          }, intervalMs);
+        } else if (!shouldRun && timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+      };
+      const off = on("host", sync);
+      hostTickSyncs.add(sync);
+      sync();
+      return () => {
+        off();
+        hostTickSyncs.delete(sync);
+        if (timer) clearInterval(timer);
+        timer = null;
+      };
+    },
+    on,
+    send(type, payload) {
+      if (!isSendableEventType(type)) {
+        console.warn(`[multiplayer] send('${type}') collides with a relay-internal channel \u2014 use a different event name`);
+        return;
+      }
+      send0(type, payload, true);
+    },
+    chat: {
+      send(text) {
+        if (typeof text !== "string") return;
+        if (!text.trim()) return;
+        send0(ClientMessage.CHAT, { text }, true);
+      },
+      on(cb) {
+        chatListeners.add(cb);
+        return () => chatListeners.delete(cb);
+      },
+      get history() {
+        return [...chatHistory];
+      },
+      mute(playerId) {
+        if (typeof playerId === "string" && playerId) chatMuted.add(playerId);
+      },
+      unmute(playerId) {
+        chatMuted.delete(playerId);
+      },
+      get muted() {
+        return [...chatMuted];
+      }
+    },
+    voice: {
+      async join(options2) {
+        await voice.start(options2, true);
+        if (!options2?.iceServers?.length) {
+          const cfg = await ice.request();
+          if (voice.active && cfg?.iceServers?.length) {
+            voice.setIceServers(cfg.iceServers);
+            scheduleIceRefresh(cfg.ttl);
+          }
+        }
+        if (!voice.active) return;
+        send0(ClientMessage.VOICE_JOIN, {}, true);
+        voice.releasePeering();
+      },
+      leave() {
+        clearIceRefresh();
+        send0(ClientMessage.VOICE_LEAVE, {}, true);
+        voice.stop();
+      },
+      get active() {
+        return voice.active;
+      },
+      get participants() {
+        return voice.participants;
+      },
+      setMicEnabled(on2) {
+        voice.setMicEnabled(on2 === true);
+      },
+      get micEnabled() {
+        return voice.micEnabled;
+      },
+      get speaking() {
+        return voice.speaking;
+      },
+      mute(playerId) {
+        voice.mute(playerId);
+      },
+      unmute(playerId) {
+        voice.unmute(playerId);
+      },
+      setVolume(playerId, volume) {
+        voice.setVolume(playerId, volume);
+      },
+      get muted() {
+        return voice.participants.filter((p) => p.muted).map((p) => p.id);
+      }
+    },
+    setRoomOpen(open) {
+      send0(ClientMessage.ROOM_OPEN, { open: open === true });
+    },
+    leave() {
+      intentionalLeave = true;
+      stopTimers();
+      voice.stop();
+      clearIceRefresh();
+      connected = false;
+      syncHostTicks();
+      settleAllControls("aborted");
+      room.reconnection.enabled = false;
+      void room.leave().catch(() => {
+      });
+    },
+    serverNow,
+    get rtt() {
+      if (!heartbeat) return void 0;
+      const rtt = room.clock.smoothedRtt();
+      return rtt > 0 ? rtt : void 0;
+    },
+    get clockSynced() {
+      return heartbeat?.synced === true;
+    },
+    timeUntil
+  };
+  Object.defineProperty(session, ROOM_REF, { value: () => room, enumerable: false });
+  Object.defineProperty(session, /* @__PURE__ */ Symbol.for("genex.multiplayer.internals"), {
+    enumerable: false,
+    value: {
+      senderOf: (streamKey) => streamSender.get(streamKey),
+      offsetOf: (streamKey) => {
+        const sender = streamSender.get(streamKey);
+        return sender === void 0 ? void 0 : clockOffsets.get(sender);
+      },
+      offsetSamples: (sender) => senderClocks.get(sender)?.samples.length ?? 0,
+      bufferLength: (streamKey) => buffers.get(streamKey)?.length ?? 0
+    }
+  });
+  return session;
+}
+var SEARCH_BACKOFF_MS = [1e3, 2e3, 4e3];
+var matchJoinOptions = (opts) => joinOptions(opts.room, opts.name, opts.auth);
+function buildView(matchRoom, queueInfo, timeUntil = (epochMs) => epochMs - Date.now()) {
+  const raw = matchRoom?.state?.match;
+  const parsed = raw ? parseValue(raw) : null;
+  const m = parsed && typeof parsed === "object" ? parsed : null;
+  if (!m) {
+    return {
+      status: matchRoom ? "waiting" : "searching",
+      role: "player",
+      queue: queueInfo,
+      players: [],
+      connectedPlayers: [],
+      opponents: [],
+      teams: {},
+      myTeam: null,
+      scores: {},
+      config: {},
+      winCondition: "lastStanding",
+      championId: null,
+      challengerId: null,
+      roundId: 0,
+      winnerId: null,
+      message: matchRoom ? "Waiting for players\u2026" : "Finding a match\u2026",
+      startsAt: null,
+      endsBy: null,
+      startsInMs: null,
+      endsInMs: null
+    };
+  }
+  const myId = matchRoom?.sessionId;
+  const championId = m.championId ?? null;
+  const challengerId = m.challengerId ?? null;
+  const teams = m.teams ?? {};
+  const players = Array.isArray(m.players) ? m.players : [];
+  const connectedPlayers = m.connectedPlayers ?? players;
+  const isPlayer = myId != null && players.includes(myId);
+  const status = isPlayer ? m.phase : "spectating";
+  const opponents = players.filter((id) => id !== myId);
+  const myTeam = myId ? Object.keys(teams).find((t) => teams[t]?.includes(myId)) ?? null : null;
+  const { winCondition: wc, ...numericCfg } = m.cfg ?? {};
+  const deadline = (v) => typeof v === "number" && Number.isFinite(v) && v > 0 ? v : null;
+  const startsAt = deadline(m.startsAt);
+  const endsBy = deadline(m.endsBy);
+  const remaining = (at) => at === null ? null : Math.max(0, timeUntil(at));
+  return {
+    status,
+    role: isPlayer ? "player" : "spectator",
+    queue: { position: 0, size: 0 },
+    players,
+    connectedPlayers,
+    opponents,
+    teams,
+    myTeam,
+    scores: m.scores ?? {},
+    config: numericCfg,
+    winCondition: wc?.type ?? "lastStanding",
+    championId,
+    challengerId,
+    roundId: m.roundId ?? 0,
+    winnerId: m.winnerId ?? null,
+    message: m.message ?? "",
+    startsAt,
+    endsBy,
+    startsInMs: remaining(startsAt),
+    endsInMs: remaining(endsBy)
+  };
+}
+function matchSend(room, type, payload) {
+  if (!room?.connection?.isOpen) return;
+  try {
+    room.send(type, payload);
+  } catch {
+  }
+}
+async function matchmake(opts) {
+  const client = await relayClient(opts);
+  const predict = await loadPredict(opts.smoothing);
+  const emitters = /* @__PURE__ */ new Map();
+  const emit = (event, ...args) => emitters.get(event)?.forEach((cb) => cb(...args));
+  const on = ((event, cb) => {
+    let set = emitters.get(event);
+    if (!set) emitters.set(event, set = /* @__PURE__ */ new Set());
+    set.add(cb);
+    return () => void set?.delete(cb);
+  });
+  let session = null;
+  let matchRoom = null;
+  let queueRoom = null;
+  let queueInfo = { position: 0, size: 0 };
+  let cancelled = false;
+  let searching = false;
+  let lifecycleEpoch = 0;
+  let seating = false;
+  let requeueing = false;
+  const search = async () => {
+    if (cancelled || searching) return;
+    searching = true;
+    const epoch = ++lifecycleEpoch;
+    try {
+      session = null;
+      matchRoom = null;
+      for (let attempt = 0; ; attempt++) {
+        if (queueRoom) {
+          void queueRoom.leave();
+          queueRoom = null;
+        }
+        queueInfo = { position: 0, size: 0 };
+        let q;
+        try {
+          q = withoutReconnection(await client.joinOrCreate(RoomType.QUEUE, matchJoinOptions(opts)));
+        } catch (err) {
+          if (cancelled) return;
+          const refused = isProtocolRefusal(err);
+          if (refused) warnProtocolRefusal();
+          const delay = refused ? void 0 : SEARCH_BACKOFF_MS[attempt];
+          if (delay == null) {
+            if (attempt === 0) await new Promise((r) => setTimeout(r, 0));
+            if (cancelled) return;
+            emit("error", err);
+            return;
+          }
+          await new Promise((r) => setTimeout(r, delay));
+          if (cancelled) return;
+          continue;
+        }
+        if (cancelled || epoch !== lifecycleEpoch) {
+          void q.leave();
+          return;
+        }
+        queueRoom = q;
+        q.onMessage(ServerMessage.QUEUE, (msg) => {
+          queueInfo = { position: msg.position, size: msg.size };
+          emit("queue", msg);
+        });
+        q.onMessage(ServerMessage.SEAT, (msg) => {
+          if (cancelled || epoch !== lifecycleEpoch || queueRoom !== q || seating) return;
+          seating = true;
+          queueRoom = null;
+          void q.leave();
+          void consumeSeat(msg.reservation, msg.role, epoch);
+        });
+        q.onLeave(() => {
+          if (cancelled || queueRoom !== q) return;
+          queueRoom = null;
+          void (async () => {
+            for (const delayMs of QUEUE_RESEARCH_DELAYS_MS) {
+              await new Promise((r) => setTimeout(r, delayMs));
+              if (cancelled || queueRoom || session) return;
+              await search();
+              if (queueRoom || session) return;
+            }
+          })();
+        });
+        emit("searching");
+        return;
+      }
+    } finally {
+      searching = false;
+    }
+  };
+  const consumeSeat = async (reservation, role, epoch) => {
+    try {
+      const mr = useSdkReconnection(await client.consumeSeatReservation(reservation));
+      if (cancelled || epoch !== lifecycleEpoch) {
+        void mr.leave();
+        return;
+      }
+      matchRoom = mr;
+      const s = attachSession(mr, { pose: opts.pose, smoothing: opts.smoothing, predict });
+      session = s;
+      s.on(ServerMessage.MATCH_START, (m) => emit("matchStart", m));
+      s.on(ServerMessage.MATCH_ENDED, (m) => emit("matchEnded", m));
+      s.on(ServerMessage.MATCH_REQUEUE, () => {
+        if (session === s) void requeue();
+      });
+      s.on("disconnect", (code) => {
+        if (cancelled || session !== s) return;
+        if (code === CloseCode.SUPERSEDED || code === CloseCode.REVOKED) {
+          lifecycleEpoch++;
+          seating = false;
+          matchRoom = null;
+          session = null;
+          emit("disconnect", code);
+          return;
+        }
+        void requeue();
+      });
+      if (queueRoom) {
+        void queueRoom.leave();
+        queueRoom = null;
+      }
+      emit("matched");
+      if (role === "spectator") emit("spectate");
+    } catch {
+      if (!cancelled && epoch === lifecycleEpoch) {
+        seating = false;
+        void search();
+      }
+    } finally {
+      if (epoch === lifecycleEpoch) seating = false;
+    }
+  };
+  const requeue = async () => {
+    if (cancelled || requeueing) return;
+    requeueing = true;
+    try {
+      lifecycleEpoch++;
+      seating = false;
+      session?.leave();
+      matchRoom = null;
+      session = null;
+      await search();
+    } finally {
+      requeueing = false;
+    }
+  };
+  void search();
+  const liveRoom = () => session ? roomOf(session) : null;
+  let viewSession = null;
+  let lastHydratedView = null;
+  const stableView = () => {
+    if (session !== viewSession) {
+      viewSession = session;
+      lastHydratedView = null;
+    }
+    const live = liveRoom();
+    const hydrated = !!live?.state?.match;
+    if (!hydrated && session && lastHydratedView) return lastHydratedView;
+    const next = buildView(live, queueInfo, session ? session.timeUntil : void 0);
+    if (hydrated) lastHydratedView = next;
+    return next;
+  };
+  return {
+    get session() {
+      return session;
+    },
+    get matchmaking() {
+      return stableView();
+    },
+    on,
+    eliminated() {
+      matchSend(liveRoom(), ClientMessage.MATCH_ELIMINATED, {});
+    },
+    score(delta = 1) {
+      matchSend(liveRoom(), ClientMessage.MATCH_SCORE, { delta });
+    },
+    finish() {
+      matchSend(liveRoom(), ClientMessage.MATCH_FINISH, {});
+    },
+    retry() {
+      if (cancelled || searching || queueRoom || matchRoom) return;
+      void search();
+    },
+    cancel() {
+      cancelled = true;
+      lifecycleEpoch++;
+      seating = false;
+      session?.leave();
+      if (!session && matchRoom) void matchRoom.leave();
+      if (queueRoom) void queueRoom.leave();
+      matchRoom = null;
+      queueRoom = null;
+      session = null;
+    }
+  };
+}
+function wirePrivate(room, options) {
+  const emitters = /* @__PURE__ */ new Map();
+  const emit = (event, ...args) => emitters.get(event)?.forEach((cb) => cb(...args));
+  const on = ((event, cb) => {
+    let set = emitters.get(event);
+    if (!set) emitters.set(event, set = /* @__PURE__ */ new Set());
+    set.add(cb);
+    return () => void set?.delete(cb);
+  });
+  let live = true;
+  const session = attachSession(room, options);
+  session.on(ServerMessage.MATCH_START, (m) => emit("matchStart", m));
+  session.on(ServerMessage.MATCH_ENDED, (m) => emit("matchEnded", m));
+  session.on(ServerMessage.MATCH_REQUEUE, () => void (live = false));
+  session.on("disconnect", () => void (live = false));
+  const liveRoom = () => live ? roomOf(session) : null;
+  return {
+    get session() {
+      return live ? session : null;
+    },
+    get matchmaking() {
+      return buildView(liveRoom(), { position: 0, size: 0 }, session.timeUntil);
+    },
+    on,
+    eliminated() {
+      matchSend(liveRoom(), ClientMessage.MATCH_ELIMINATED, {});
+    },
+    score(delta = 1) {
+      matchSend(liveRoom(), ClientMessage.MATCH_SCORE, { delta });
+    },
+    finish() {
+      matchSend(liveRoom(), ClientMessage.MATCH_FINISH, {});
+    },
+    retry() {
+    },
+    cancel() {
+      session.leave();
+      live = false;
+    }
+  };
+}
+async function createPrivate(opts) {
+  const client = await relayClient(opts);
+  const predict = await loadPredict(opts.smoothing);
+  const room = useSdkReconnection(await client.create(RoomType.MATCH, matchJoinOptions(opts)));
+  const handle = wirePrivate(room, { pose: opts.pose, smoothing: opts.smoothing, predict });
+  Object.defineProperty(handle, "code", { value: room.roomId, enumerable: true });
+  return handle;
+}
+async function joinPrivate(code, opts) {
+  const client = await relayClient(opts);
+  const predict = await loadPredict(opts.smoothing);
+  const room = useSdkReconnection(await client.joinById(code, matchJoinOptions(opts)));
+  return wirePrivate(room, { pose: opts.pose, smoothing: opts.smoothing, predict });
+}
+
+export {
+  roomOf,
+  connect,
+  matchmake,
+  createPrivate,
+  joinPrivate
+};