@genex-ai/multiplayer 0.16.2 → 0.17.0

package/dist/index.js

@@ -1,1812 +1,10 @@
-// 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/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 `__voice`
-  // 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/index.ts
-var RELAY_ROOM_TYPE = "play";
-var QUEUE_ROOM_TYPE = "queue";
-var MATCH_ROOM_TYPE = "match";
-var INTERP_RATIO = 1.5;
-var INTERP_MIN_MS = 90;
-var INTERP_MAX_MS = 300;
-var JITTER_SAFETY = 1.25;
-var POISON_GUARD_MS = 2e3;
-var INTERP_EASE = 0.1;
-var MAX_EXTRAP_MS = 250;
-var ROT_EXTRAP_MS = 150;
-var CLOCK_WIN = 80;
-var SMOOTH_TAU_POS = 30;
-var SMOOTH_TAU_ROT = 70;
-var SEND_TIME_KEY = "__t";
-var RESERVED_PREFIX = "__";
-var OBJ_PREFIX = "__obj:";
-var HOST_KEY = "__host";
-var MATCH_KEY = "__match";
-var INPUT_MSG = "__input";
-var CAPABILITIES_MSG = "__capabilities";
-var CAPABILITIES_REQUEST_MSG = "__capabilities:request";
-var CHAT_MSG = "__chat";
-var CHAT_HISTORY_MSG = "__chat:history";
-var CHAT_HISTORY_REQUEST_MSG = "__chat:history:request";
-var VOICE_KEY = "__voice";
-var VOICE_JOIN_MSG = "__voice:join";
-var VOICE_LEAVE_MSG = "__voice:leave";
-var VOICE_SIGNAL_MSG = "__voice:signal";
-var VOICE_REJECTED_MSG = "__voice:rejected";
-var VOICE_ICE_REQUEST_MSG = "__voice:ice:request";
-var VOICE_ICE_MSG = "__voice:ice";
-var ICE_REQUEST_TIMEOUT_MS = 3e3;
-var OBJECT_CONTROL_RESULT_MSG = "__object:result";
-var OBJECT_CONTROL_VERSION = 2;
-var STATE_SNAP_MSG = "__state:snap";
-var ROOM_OPEN_MSG = "__room:open";
-var OBJECT_SNAP_MSG = "__object:snap";
-var MP_PROTOCOL = 2;
-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 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 room = await client.joinOrCreate(RELAY_ROOM_TYPE, {
-    gameId: opts.room,
-    name: opts.name,
-    embedToken: resolveAuth(opts.auth)?.embedToken,
-    ...opts.options,
-    __v: MP_PROTOCOL
-    // tells the relay this client hides reserved `__` keys (see MP_PROTOCOL)
-  });
-  return attachSession(client, room);
-}
-var RESERVED_SEND_TYPES = /* @__PURE__ */ new Set([
-  "state",
-  "shared",
-  "claim",
-  "obj",
-  "release",
-  "destroy",
-  STATE_SNAP_MSG,
-  OBJECT_SNAP_MSG,
-  // Server→client control verbs a game must never ORIGINATE — they'd broadcast to peers via the
-  // relay's `*` handler: 'server:restart' would trip every peer's save-flush, 'rate:drop' a bogus
-  // over-budget warning, 'queue'/'seat' spurious matchmaking control.
-  "server:restart",
-  "rate:drop",
-  "queue",
-  "seat",
-  CAPABILITIES_MSG,
-  CAPABILITIES_REQUEST_MSG,
-  OBJECT_CONTROL_RESULT_MSG
-]);
-var isReservedSendType = (type) => RESERVED_SEND_TYPES.has(type) || type.startsWith("match:") || type.startsWith(RESERVED_PREFIX);
-var RECONNECT_DELAYS_MS = [500, 1e3, 2e3, 4e3, 8e3];
-var ROOM_REF = /* @__PURE__ */ Symbol("genex.roomRef");
-var roomOf = (s) => s[ROOM_REF]();
-function attachSession(client, initialRoom) {
-  let room = initialRoom;
-  const buffers = /* @__PURE__ */ new Map();
-  const lastStamp = /* @__PURE__ */ new Map();
-  const clockOffsets = /* @__PURE__ */ new Map();
-  const offsetWin = /* @__PURE__ */ new Map();
-  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 objEpochs = /* @__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 objectControlVersion = 0;
-  let requestCounter = 0;
-  const pendingControls = /* @__PURE__ */ new Map();
-  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) => {
-    const arrival = now();
-    const t = sendTime ?? arrival;
-    if (sendTime != null) {
-      let win = offsetWin.get(id);
-      if (!win) offsetWin.set(id, win = []);
-      win.push(arrival - sendTime);
-      if (win.length > CLOCK_WIN) win.shift();
-      clockOffsets.set(id, Math.min(...win));
-    }
-    const prev = lastStamp.get(id);
-    lastStamp.set(id, t);
-    if (prev != null) {
-      const gap = t - prev;
-      if (gap > 5 && gap < 2e3) {
-        let iv = intervalsById.get(id);
-        if (!iv) intervalsById.set(id, iv = []);
-        iv.push(gap);
-        if (iv.length > 30) iv.shift();
-        const ow = offsetWin.get(id);
-        const jitter = ow && ow.length >= 8 ? quantile(ow, 0.9) - Math.min(...ow) : 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) ?? 100;
-        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 && sendTime != null) {
-      const delay = autoDelayById.get(id) ?? INTERP_MIN_MS;
-      buf.push({ t: t - Math.max(1, delay), state: bridge });
-    }
-    pendingBridge.delete(id);
-    buf.push({ t, state });
-    const cutoff = t - 1500;
-    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 sampleSmoothed = (streamKey, localNow) => {
-    const buf = buffers.get(streamKey);
-    const autoDelay = autoDelayById.get(streamKey) ?? 100;
-    const renderTime = localNow - (clockOffsets.get(streamKey) ?? 0) - autoDelay;
-    const sampled = buf && sampleBuffer(buf, renderTime);
-    if (!sampled) return smoothed.get(streamKey);
-    const prev = smoothed.get(streamKey);
-    let out;
-    if (prev) {
-      const dt = Math.min(250, Math.max(0, localNow - (smoothedAt.get(streamKey) ?? localNow)));
-      out = easeState(prev, sampled, 1 - Math.exp(-dt / SMOOTH_TAU_POS), 1 - Math.exp(-dt / SMOOTH_TAU_ROT));
-    } else {
-      out = sampled;
-    }
-    smoothed.set(streamKey, out);
-    smoothedAt.set(streamKey, localNow);
-    return out;
-  };
-  const clearStream = (streamKey) => {
-    buffers.delete(streamKey);
-    lastStamp.delete(streamKey);
-    clockOffsets.delete(streamKey);
-    offsetWin.delete(streamKey);
-    smoothed.delete(streamKey);
-    smoothedAt.delete(streamKey);
-    intervalsById.delete(streamKey);
-    autoDelayById.delete(streamKey);
-    pendingBridge.delete(streamKey);
-  };
-  const clearStreamClock = (streamKey) => {
-    buffers.delete(streamKey);
-    lastStamp.delete(streamKey);
-    clockOffsets.delete(streamKey);
-    offsetWin.delete(streamKey);
-    intervalsById.delete(streamKey);
-    autoDelayById.delete(streamKey);
-  };
-  const emitters = /* @__PURE__ */ new Map();
-  const bridged = /* @__PURE__ */ new Set();
-  const reserved = /* @__PURE__ */ new Set([
-    "join",
-    "leave",
-    "change",
-    "shared",
-    "object",
-    "host",
-    "reconnecting",
-    "reconnected",
-    "disconnect",
-    // Locally emitted by the voice mesh — never relay message types. Without these here,
-    // room.on('voice', …) would register a stray room.onMessage('voice') as well.
-    "voice",
-    "voice:rejected",
-    INPUT_MSG,
-    // inputs.on() has its own channel — never bridged as a custom event
-    "rate:drop",
-    // relay → us only (over-budget warning); handled internally, never bridged
-    CAPABILITIES_MSG,
-    CAPABILITIES_REQUEST_MSG,
-    OBJECT_CONTROL_RESULT_MSG,
-    STATE_SNAP_MSG,
-    OBJECT_SNAP_MSG,
-    // chat.on() has its own channel. Bridging these would re-register room.onMessage for
-    // the same type and clobber the chat listener, silently killing chat for that game.
-    CHAT_MSG,
-    CHAT_HISTORY_MSG,
-    CHAT_HISTORY_REQUEST_MSG,
-    // voice.* owns these; bridging them would clobber the mesh's own listeners.
-    VOICE_SIGNAL_MSG,
-    VOICE_REJECTED_MSG,
-    VOICE_JOIN_MSG,
-    VOICE_LEAVE_MSG,
-    VOICE_ICE_REQUEST_MSG,
-    VOICE_ICE_MSG
-  ]);
-  const emit = (event, ...args) => emitters.get(event)?.forEach((cb) => cb(...args));
-  const lastShared = /* @__PURE__ */ new Map();
-  const handleShared = (value, key) => {
-    if (lastShared.get(key) === value) return;
-    lastShared.set(key, value);
-    if (key === MATCH_KEY) return;
-    if (key === HOST_KEY) {
-      const next = parseValue(value) || void 0;
-      if (next !== hostId) {
-        hostId = next;
-        emit("host", hostId);
-      }
-      return;
-    }
-    if (key === VOICE_KEY) {
-      const ids = parseValue(value);
-      voice.setRoster(Array.isArray(ids) ? ids.filter((v) => typeof v === "string") : []);
-      emit("voice", voice.participants);
-      return;
-    }
-    if (key.startsWith(OBJ_PREFIX)) {
-      const id = key.slice(OBJ_PREFIX.length);
-      const blob = parseValue(value);
-      if (!blob || typeof blob !== "object") return;
-      const owner = typeof blob.o === "string" && blob.o ? blob.o : void 0;
-      const ownerChanged = owner !== objOwners.get(id);
-      const epoch = typeof blob.e === "number" && Number.isFinite(blob.e) ? blob.e : 0;
-      const epochChanged = objEpochs.has(id) && epoch !== objEpochs.get(id);
-      objEpochs.set(id, epoch);
-      if (epochChanged) clearStream(key);
-      if (ownerChanged) {
-        if (owner) objOwners.set(id, owner);
-        else objOwners.delete(id);
-        if (owner !== room.sessionId) {
-          localObjState.delete(id);
-          if (!epochChanged) clearStreamClock(key);
-        }
-      }
-      if (blob.d && typeof blob.d === "object" && Object.keys(blob.d).length > 0) {
-        objRaw.set(id, blob.d);
-        if (owner !== room.sessionId) {
-          if (epochChanged) {
-            smoothed.set(key, blob.d);
-            smoothedAt.set(key, now());
-            pushSnap(key, blob.d, blob.t);
-          } else if (ownerChanged) {
-            pendingBridge.set(key, smoothed.get(key) ?? blob.d);
-          } else {
-            pushSnap(key, blob.d, blob.t);
-          }
-        }
-      }
-      if (ownerChanged) emit("object", id);
-      return;
-    }
-    emit("shared", key, parseValue(value));
-  };
-  const parseCache = /* @__PURE__ */ new Map();
-  const playerEpochs = /* @__PURE__ */ new Map();
-  let lastPlayersView = /* @__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;
-  };
-  let intentionalLeave = false;
-  let dead = false;
-  let connected = true;
-  let reconnectStartedAt = 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);
-    if (pending.capabilityTimer) clearTimeout(pending.capabilityTimer);
-    pending.abort?.();
-    if (pending.operation === "claim" && pending.optimistic && !result.accepted) {
-      if (result.owner) objOwners.set(pending.id, result.owner);
-      else objOwners.delete(pending.id);
-      if (result.owner !== room.sessionId) localObjState.delete(pending.id);
-      clearStreamClock(OBJ_PREFIX + pending.id);
-    }
-    if (pending.operation === "claim" && result.accepted) {
-      objOwners.set(pending.id, room.sessionId);
-      clearStreamClock(OBJ_PREFIX + 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_PREFIX + pending.id);
-    }
-    if (pending.operation === "remove" && result.accepted) {
-      localObjState.delete(pending.id);
-      objRaw.delete(pending.id);
-      objOwners.delete(pending.id);
-      clearStream(OBJ_PREFIX + pending.id);
-    }
-    pending.resolve(result);
-  };
-  const settleAllControls = (reason) => {
-    for (const pending of [...pendingControls.values()]) {
-      settleControl(pending, {
-        requestId: pending.requestId,
-        operation: pending.operation,
-        id: pending.id,
-        accepted: false,
-        owner: pending.optimistic ? pending.previousOwner : objOwners.get(pending.id),
-        sequence: 0,
-        reason
-      });
-    }
-  };
-  const sendPendingControl = (pending) => {
-    if (!connected || !room.connection?.isOpen) return;
-    send0(
-      pending.operation === "remove" ? "destroy" : pending.operation,
-      pending.payload
-    );
-  };
-  const flushCapabilityWaiters = () => {
-    if (objectControlVersion < OBJECT_CONTROL_VERSION) return;
-    for (const pending of pendingControls.values()) {
-      if (pending.capabilityTimer) {
-        clearTimeout(pending.capabilityTimer);
-        pending.capabilityTimer = null;
-      }
-      sendPendingControl(pending);
-    }
-  };
-  const confirmedControl = (operation, id, options = {}) => {
-    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(options.timeoutMs ?? 5e3, 6e4));
-    return new Promise((resolve) => {
-      const pending = {
-        operation,
-        id: key,
-        requestId,
-        payload: {
-          id: key,
-          requestId,
-          ...options.authority === "host" ? { authority: "host" } : {}
-        },
-        optimistic: operation === "claim" && options.optimistic === true,
-        previousOwner: objOwners.get(key),
-        resolve,
-        timeout: null,
-        capabilityTimer: null,
-        abort: void 0
-      };
-      if (pending.optimistic) objOwners.set(key, room.sessionId);
-      pending.timeout = setTimeout(() => {
-        settleControl(pending, {
-          requestId,
-          operation,
-          id: key,
-          accepted: false,
-          owner: pending.optimistic ? pending.previousOwner : objOwners.get(key),
-          sequence: 0,
-          reason: "timeout"
-        });
-      }, timeoutMs);
-      if (options.signal) {
-        const onAbort = () => settleControl(pending, {
-          requestId,
-          operation,
-          id: key,
-          accepted: false,
-          owner: pending.optimistic ? pending.previousOwner : objOwners.get(key),
-          sequence: 0,
-          reason: "aborted"
-        });
-        options.signal.addEventListener("abort", onAbort, { once: true });
-        pending.abort = () => options.signal?.removeEventListener("abort", onAbort);
-      }
-      pendingControls.set(requestId, pending);
-      if (options.signal?.aborted) {
-        settleControl(pending, {
-          requestId,
-          operation,
-          id: key,
-          accepted: false,
-          owner: pending.optimistic ? pending.previousOwner : objOwners.get(key),
-          sequence: 0,
-          reason: "aborted"
-        });
-        return;
-      }
-      if (objectControlVersion >= OBJECT_CONTROL_VERSION) {
-        sendPendingControl(pending);
-      } else {
-        pending.capabilityTimer = setTimeout(() => {
-          if (!pendingControls.has(requestId) || objectControlVersion >= OBJECT_CONTROL_VERSION) return;
-          settleControl(pending, {
-            requestId,
-            operation,
-            id: key,
-            accepted: false,
-            owner: pending.optimistic ? pending.previousOwner : objOwners.get(key),
-            sequence: 0,
-            reason: "unsupported"
-          });
-        }, 500);
-      }
-    });
-  };
-  let droppedWhileOffline = 0;
-  const send0 = (type, payload, countIfDropped = false) => {
-    if (room.connection?.isOpen) {
-      try {
-        room.send(type, payload);
-        return;
-      } catch {
-      }
-    }
-    if (countIfDropped) droppedWhileOffline++;
-  };
-  const voice = new VoiceMesh({
-    selfId: () => room.sessionId,
-    nameOf: (id) => room.state?.players?.get(id)?.name ?? "",
-    sendSignal: (to, data) => send0(VOICE_SIGNAL_MSG, { to, data }, true)
-  });
-  voice.onChange(() => emit("voice", voice.participants));
-  let iceRefreshTimer = null;
-  const ice = createIceRequester(() => send0(VOICE_ICE_REQUEST_MSG, {}, 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 wireRoom = (r) => {
-    let hydrated;
-    const $ = getStateCallbacks(r);
-    $(r.state).players.onAdd((player, id) => {
-      const { state, sendTime } = parseData(player.data);
-      const addEpoch = Number.isFinite(player.epoch) ? player.epoch : 0;
-      const addEpochChanged = playerEpochs.has(id) && addEpoch !== playerEpochs.get(id);
-      playerEpochs.set(id, addEpoch);
-      if (id !== room.sessionId && addEpochChanged) clearStream(id);
-      emit("join", id, state);
-      if (id !== room.sessionId && sendTime != null) pushSnap(id, state, sendTime);
-      $(player).onChange(() => {
-        const { state: st, sendTime: ts } = parseData(player.data);
-        const epoch = Number.isFinite(player.epoch) ? player.epoch : 0;
-        const epochChanged = epoch !== (playerEpochs.get(id) ?? epoch);
-        playerEpochs.set(id, epoch);
-        if (id !== room.sessionId && epochChanged) clearStream(id);
-        emit("change", id, st);
-        if (id !== room.sessionId) pushSnap(id, st, ts);
-      });
-    });
-    $(r.state).players.onRemove((_player, id) => {
-      emit("leave", id);
-      clearStream(id);
-      parseCache.delete(id);
-      playerEpochs.delete(id);
-    });
-    $(r.state).shared.onAdd(handleShared);
-    $(r.state).shared.onChange(handleShared);
-    $(r.state).shared.onRemove((_value, key) => {
-      lastShared.delete(key);
-      if (key === HOST_KEY) {
-        if (hostId !== void 0) {
-          hostId = void 0;
-          emit("host", void 0);
-        }
-        return;
-      }
-      if (key.startsWith(OBJ_PREFIX)) {
-        const id = key.slice(OBJ_PREFIX.length);
-        clearStream(key);
-        objRaw.delete(id);
-        objOwners.delete(id);
-        objEpochs.delete(id);
-        localObjState.delete(id);
-        emit("object", id);
-      }
-    });
-    const hydrateShared = (state) => {
-      const shared = state?.shared;
-      shared?.forEach((value, key) => handleShared(value, key));
-      if (!shared) return;
-      for (const id of /* @__PURE__ */ new Set([...objOwners.keys(), ...objRaw.keys(), ...localObjState.keys()])) {
-        const key = OBJ_PREFIX + id;
-        if (shared.has(key)) continue;
-        lastShared.delete(key);
-        clearStream(key);
-        objRaw.delete(id);
-        objOwners.delete(id);
-        objEpochs.delete(id);
-        localObjState.delete(id);
-        emit("object", id);
-      }
-      if (hostId !== void 0 && !shared.has(HOST_KEY)) {
-        lastShared.delete(HOST_KEY);
-        hostId = void 0;
-        emit("host", void 0);
-      }
-    };
-    if (r.state?.shared) {
-      hydrateShared(r.state);
-      hydrated = Promise.resolve();
-    } else {
-      hydrated = new Promise((resolve) => {
-        r.onStateChange.once((state) => {
-          hydrateShared(state);
-          resolve();
-        });
-      });
-    }
-    r.onMessage(CAPABILITIES_MSG, (msg) => {
-      if (typeof msg?.objectControl === "number") {
-        objectControlVersion = Math.max(objectControlVersion, msg.objectControl);
-        flushCapabilityWaiters();
-      }
-    });
-    r.onMessage(CAPABILITIES_REQUEST_MSG, () => {
-    });
-    send0(CAPABILITIES_REQUEST_MSG, { objectControl: OBJECT_CONTROL_VERSION });
-    r.onMessage(VOICE_SIGNAL_MSG, (msg) => {
-      if (msg && typeof msg.from === "string") void voice.handleSignal(msg.from, msg.data);
-    });
-    r.onMessage(VOICE_REJECTED_MSG, (msg) => {
-      clearIceRefresh();
-      voice.stop();
-      emit("voice:rejected", msg ?? { reason: "full" });
-    });
-    r.onMessage(VOICE_ICE_MSG, (msg) => {
-      ice.deliver(msg ?? null);
-    });
-    for (const inert of [
-      VOICE_JOIN_MSG,
-      VOICE_LEAVE_MSG,
-      VOICE_ICE_REQUEST_MSG,
-      CHAT_HISTORY_REQUEST_MSG
-    ]) {
-      r.onMessage(inert, () => {
-      });
-    }
-    r.onMessage(CHAT_MSG, (msg) => acceptChat(msg));
-    r.onMessage(CHAT_HISTORY_MSG, (msg) => {
-      if (!Array.isArray(msg?.messages)) return;
-      for (const m of msg.messages) acceptChat(m);
-    });
-    send0(CHAT_HISTORY_REQUEST_MSG, {});
-    r.onMessage(OBJECT_CONTROL_RESULT_MSG, (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);
-    });
-    r.onMessage(INPUT_MSG, (msg) => {
-      if (msg && typeof msg.from === "string") emit(INPUT_MSG, msg.from, msg.d);
-    });
-    r.onMessage("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).`
-      );
-    });
-    for (const event of bridged) r.onMessage(event, (msg) => emit(event, msg));
-    r.onLeave((code) => handleLeave(r, code ?? 1006));
-    r.onError(() => {
-    });
-    return hydrated;
-  };
-  const handleLeave = (left, code) => {
-    if (left !== room || dead) return;
-    connected = false;
-    reconnectStartedAt ||= nowMs();
-    syncHostTicks();
-    if (intentionalLeave) return;
-    if (code === 1e3 || code >= 4e3) {
-      dead = true;
-      settleAllControls("disconnected");
-      emit("disconnect", code);
-      return;
-    }
-    void attemptReconnect(left.reconnectionToken, code);
-  };
-  const attemptReconnect = async (token, code) => {
-    for (let attempt = 1; attempt <= RECONNECT_DELAYS_MS.length + 1; attempt++) {
-      emit("reconnecting", { attempt, code });
-      if (intentionalLeave || dead) return;
-      try {
-        const next = await client.reconnect(token);
-        room = next;
-        const reconnectGap = reconnectStartedAt ? nowMs() - reconnectStartedAt : 0;
-        reconnectStartedAt = 0;
-        if (reconnectGap > 1e3) {
-          for (const streamKey of [...buffers.keys()]) clearStream(streamKey);
-        }
-        const hydrated = wireRoom(next);
-        await Promise.race([hydrated, new Promise((r) => setTimeout(r, 2e3))]);
-        if (room !== next || dead || intentionalLeave) return;
-        connected = true;
-        syncHostTicks();
-        for (const pending of pendingControls.values()) sendPendingControl(pending);
-        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;
-        }
-        return;
-      } catch {
-      }
-      if (attempt <= RECONNECT_DELAYS_MS.length) {
-        await new Promise((r) => setTimeout(r, RECONNECT_DELAYS_MS[attempt - 1]));
-        if (intentionalLeave || dead) return;
-      }
-    }
-    dead = true;
-    settleAllControls("disconnected");
-    emit("disconnect", code);
-  };
-  wireRoom(room);
-  const on = ((event, cb) => {
-    let set = emitters.get(event);
-    if (!set) emitters.set(event, set = /* @__PURE__ */ new Set());
-    set.add(cb);
-    if (!reserved.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();
-      room.state?.players?.forEach((p, id) => {
-        const latest = cachedParse(id, p.data);
-        let state = latest;
-        let raw = latest;
-        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 ?? "",
-          // old relay schemas did not carry the field
-          connected: p.connected !== false,
-          // old relay schemas did not carry the field
-          state,
-          stateRaw: raw
-        });
-      });
-      if (!connected && out.size === 0 && lastPlayersView.size > 0) return new Map(lastPlayersView);
-      lastPlayersView = out;
-      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;
-        send0("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;
-        send0(STATE_SNAP_MSG, JSON.stringify({ ...clean, [SEND_TIME_KEY]: now() }));
-      }
-    },
-    shared: {
-      get(key) {
-        if (key.startsWith(RESERVED_PREFIX)) return void 0;
-        return parseValue(room.state?.shared?.get(key));
-      },
-      set(key, value) {
-        if (key.startsWith(RESERVED_PREFIX)) return;
-        send0("shared", { key, value: JSON.stringify(sanitizeFinite(value)) });
-      },
-      keys() {
-        return room.state?.shared ? Array.from(room.state.shared.keys()).filter((k) => !k.startsWith(RESERVED_PREFIX)) : [];
-      }
-    },
-    objects: {
-      claim(id) {
-        const key = String(id);
-        objOwners.set(key, room.sessionId);
-        send0("claim", { id: key });
-      },
-      claimConfirmed(id, options) {
-        return confirmedControl("claim", id, options);
-      },
-      release(id) {
-        const key = String(id);
-        localObjState.delete(key);
-        if (objOwners.get(key) === room.sessionId) objOwners.delete(key);
-        clearStreamClock(OBJ_PREFIX + key);
-        send0("release", { id: key });
-      },
-      releaseConfirmed(id, options) {
-        return confirmedControl("release", id, options);
-      },
-      remove(id) {
-        const key = String(id);
-        if (objOwners.get(key) === room.sessionId) {
-          localObjState.delete(key);
-          objRaw.delete(key);
-          objOwners.delete(key);
-          clearStream(OBJ_PREFIX + key);
-        }
-        send0("destroy", { id: key });
-      },
-      removeConfirmed(id, options) {
-        return confirmedControl("remove", id, options);
-      },
-      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("obj", { 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(OBJECT_SNAP_MSG, { 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_PREFIX + key, mine);
-          smoothedAt.set(OBJ_PREFIX + key, now());
-        } else {
-          raw = objRaw.get(key) ?? {};
-          state = sampleSmoothed(OBJ_PREFIX + 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()])];
-      }
-    },
-    get isHost() {
-      return hostId !== void 0 && hostId === room.sessionId;
-    },
-    get host() {
-      return hostId;
-    },
-    inputs: {
-      send(payload) {
-        send0(INPUT_MSG, sanitizeFinite(payload), true);
-      },
-      on(cb) {
-        let set = emitters.get(INPUT_MSG);
-        if (!set) emitters.set(INPUT_MSG, 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, 250));
-            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 (isReservedSendType(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(CHAT_MSG, { 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(options) {
-        await voice.start(options, true);
-        if (!options?.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(VOICE_JOIN_MSG, {}, true);
-        voice.releasePeering();
-      },
-      leave() {
-        clearIceRefresh();
-        send0(VOICE_LEAVE_MSG, {}, 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) {
-      room.send(ROOM_OPEN_MSG, { open });
-    },
-    leave() {
-      intentionalLeave = true;
-      voice.stop();
-      connected = false;
-      syncHostTicks();
-      settleAllControls("aborted");
-      void room.leave();
-    }
-  };
-  Object.defineProperty(session, ROOM_REF, { value: () => room, enumerable: false });
-  return session;
-}
-var SEARCH_BACKOFF_MS = [1e3, 2e3, 4e3];
-var matchJoinOptions = (opts) => ({
-  gameId: opts.room,
-  name: opts.name,
-  embedToken: resolveAuth(opts.auth)?.embedToken,
-  __v: MP_PROTOCOL
-});
-function buildView(matchRoom, queueInfo) {
-  const raw = matchRoom?.state?.shared?.get(MATCH_KEY);
-  const parsed = raw != null ? 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"
-    };
-  }
-  const myId = matchRoom?.sessionId;
-  const championId = m.championId ?? null;
-  const challengerId = m.challengerId ?? null;
-  const teams = m.teams ?? {};
-  const players = m.players ?? [championId, challengerId].filter((x) => !!x);
-  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 ?? {};
-  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 ?? ""
-  };
-}
-async function matchmake(opts) {
-  const client = await relayClient(opts);
-  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 = await client.joinOrCreate(QUEUE_ROOM_TYPE, matchJoinOptions(opts));
-        } catch (err) {
-          if (cancelled) return;
-          const delay = SEARCH_BACKOFF_MS[attempt];
-          if (delay == null) {
-            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("queue", (msg) => {
-          queueInfo = { position: msg.position, size: msg.size };
-          emit("queue", msg);
-        });
-        q.onMessage("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 RECONNECT_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 = await client.consumeSeatReservation(reservation);
-      if (cancelled || epoch !== lifecycleEpoch) {
-        void mr.leave();
-        return;
-      }
-      matchRoom = mr;
-      const s = attachSession(client, mr);
-      session = s;
-      s.on("match:start", (m) => emit("matchStart", m));
-      s.on("match:ended", (m) => emit("matchEnded", m));
-      s.on("match:requeue", () => {
-        if (session === s) void requeue();
-      });
-      s.on("disconnect", () => {
-        if (!cancelled && session === s) 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?.shared?.get(MATCH_KEY) != null;
-    if (!hydrated && session && lastHydratedView) return lastHydratedView;
-    const next = buildView(live, queueInfo);
-    if (hydrated) lastHydratedView = next;
-    return next;
-  };
-  return {
-    get session() {
-      return session;
-    },
-    get matchmaking() {
-      return stableView();
-    },
-    on,
-    eliminated() {
-      liveRoom()?.send("match:eliminated", {});
-    },
-    score(delta = 1) {
-      liveRoom()?.send("match:score", { delta });
-    },
-    finish() {
-      liveRoom()?.send("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(client, room) {
-  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(client, room);
-  session.on("match:start", (m) => emit("matchStart", m));
-  session.on("match:ended", (m) => emit("matchEnded", m));
-  session.on("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 });
-    },
-    on,
-    eliminated() {
-      liveRoom()?.send("match:eliminated", {});
-    },
-    score(delta = 1) {
-      liveRoom()?.send("match:score", { delta });
-    },
-    finish() {
-      liveRoom()?.send("match:finish", {});
-    },
-    retry() {
-    },
-    cancel() {
-      session.leave();
-      live = false;
-    }
-  };
-}
-async function createPrivate(opts) {
-  const client = await relayClient(opts);
-  const room = await client.create(MATCH_ROOM_TYPE, matchJoinOptions(opts));
-  const handle = wirePrivate(client, room);
-  Object.defineProperty(handle, "code", { value: room.roomId, enumerable: true });
-  return handle;
-}
-async function joinPrivate(code, opts) {
-  const client = await relayClient(opts);
-  const room = await client.joinById(code, matchJoinOptions(opts));
-  return wirePrivate(client, room);
-}
+import {
+  connect,
+  createPrivate,
+  joinPrivate,
+  matchmake
+} from "./chunk-CTDU4IJ5.js";
+import "./chunk-C52XFIB6.js";
 export {
   connect,
   createPrivate,