@remix-gg/sdk 0.9.0 → 0.10.0

package/dist/index.min.js

@@ -32,15 +32,813 @@
   __export(exports_src, {
     sdk: () => sdk,
     ZERO_SAFE_AREA_INSET: () => ZERO_SAFE_AREA_INSET,
-    RemixSDK: () => RemixSDK
+    RemixSDK: () => RemixSDK,
+    RealtimeRoomError: () => RealtimeRoomError
   });
+
+  // src/mesh.ts
+  function isPolitePeer(selfId, peerId) {
+    return selfId < peerId;
+  }
+  var EVENTS_CHANNEL_ID = 1;
+  var STATE_CHANNEL_ID = 2;
+  var MAX_STATE_BUFFERED_BYTES = 64 * 1024;
+  var DEFAULT_TUNING = {
+    connectTimeoutMs: 12000,
+    disconnectedGraceMs: 4000,
+    maxRebuilds: 3,
+    giveUpRetryMs: 15000,
+    maxQueuedEventMessages: 64
+  };
+  function wireDescription(description, epoch) {
+    return epoch === undefined ? { type: description.type, sdp: description.sdp } : { type: description.type, sdp: description.sdp, epoch };
+  }
+  function parseWireDescription(payload) {
+    const value = parseJson(payload);
+    if (!isRecord(value))
+      return null;
+    const { type, sdp, epoch } = value;
+    if (type !== "offer" && type !== "answer")
+      return null;
+    if (typeof sdp !== "string")
+      return null;
+    if (epoch === undefined)
+      return { type, sdp };
+    if (typeof epoch !== "number" || !Number.isFinite(epoch))
+      return null;
+    return { type, sdp, epoch };
+  }
+  function parseCandidate(payload) {
+    const value = parseJson(payload);
+    return isRecord(value) ? value : null;
+  }
+  function byeIsDeparture(payload) {
+    const value = parseJson(payload);
+    if (!isRecord(value))
+      return true;
+    return value.reason === undefined;
+  }
+  function parseJson(payload) {
+    try {
+      return JSON.parse(payload);
+    } catch {
+      return null;
+    }
+  }
+  function isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  function createDataMesh(opts) {
+    const { selfId, host } = opts;
+    const timing = { ...DEFAULT_TUNING, ...opts.tuning };
+    const slots = new Map;
+    const backlogs = new Map;
+    const rebuildCounts = new Map;
+    const reportedFailures = new Set;
+    const wanted = new Set;
+    const giveUpRetries = new Map;
+    const clearGiveUpRetry = (peerId) => {
+      const timer = giveUpRetries.get(peerId);
+      if (timer) {
+        clearTimeout(timer);
+        giveUpRetries.delete(peerId);
+      }
+    };
+    let iceServers = opts.iceServers;
+    let running = true;
+    let epochCounter = 0;
+    let signalChain = Promise.resolve();
+    const clearSlotTimers = (slot) => {
+      if (slot.connectTimer) {
+        clearTimeout(slot.connectTimer);
+        slot.connectTimer = null;
+      }
+      if (slot.disconnectedTimer) {
+        clearTimeout(slot.disconnectedTimer);
+        slot.disconnectedTimer = null;
+      }
+    };
+    const teardownSlot = (peerId, options = {}) => {
+      if (options.departed)
+        backlogs.delete(peerId);
+      const slot = slots.get(peerId);
+      if (!slot) {
+        if (options.departed)
+          host.onPeerGone(peerId);
+        return;
+      }
+      slots.delete(peerId);
+      clearSlotTimers(slot);
+      slot.events.onopen = null;
+      slot.events.onmessage = null;
+      slot.state.onmessage = null;
+      slot.pc.close();
+      if (options.departed)
+        host.onPeerGone(peerId);
+    };
+    const scheduleGiveUpRetry = (peerId) => {
+      clearGiveUpRetry(peerId);
+      giveUpRetries.set(peerId, setTimeout(() => {
+        giveUpRetries.delete(peerId);
+        if (!running || !wanted.has(peerId) || slots.has(peerId))
+          return;
+        host.onDiagnostic?.(`mesh: retrying peer ${peerId} after the give-up rest`);
+        ensureSlot(peerId);
+      }, timing.giveUpRetryMs));
+    };
+    const rebuildSlot = (peerId, why) => {
+      if (!running || !slots.has(peerId))
+        return;
+      const attempts = (rebuildCounts.get(peerId) ?? 0) + 1;
+      teardownSlot(peerId);
+      if (attempts > timing.maxRebuilds) {
+        rebuildCounts.delete(peerId);
+        host.onDiagnostic?.(`mesh: gave up connecting peer ${peerId} after ${timing.maxRebuilds} rebuilds`);
+        scheduleGiveUpRetry(peerId);
+        host.onRelayRefreshNeeded?.();
+        if (!reportedFailures.has(peerId)) {
+          reportedFailures.add(peerId);
+          host.onError("Could not connect to a player. One of you may be on a network that blocks direct connections.");
+        }
+        return;
+      }
+      rebuildCounts.set(peerId, attempts);
+      host.post({ toUserId: peerId, kind: "bye", payload: JSON.stringify({ reason: why }) });
+      ensureSlot(peerId);
+    };
+    const armConnectWatchdog = (peerId, slot) => {
+      if (slot.connectTimer)
+        clearTimeout(slot.connectTimer);
+      slot.connectTimer = setTimeout(() => {
+        slot.connectTimer = null;
+        if (slots.get(peerId) !== slot)
+          return;
+        if (slot.pc.connectionState !== "connected")
+          rebuildSlot(peerId, "connect-timeout");
+      }, timing.connectTimeoutMs);
+    };
+    const reportConnectedPairType = (peerId, pc) => {
+      const diagnostic = host.onDiagnostic;
+      if (!diagnostic || typeof pc.getStats !== "function")
+        return;
+      pc.getStats().then((stats) => {
+        const candidateTypes = new Map;
+        const nominatedPairs = [];
+        for (const report of stats.values()) {
+          const row = report;
+          if (row.type === "local-candidate" || row.type === "remote-candidate") {
+            if (row.id && row.candidateType)
+              candidateTypes.set(row.id, row.candidateType);
+          } else if (row.type === "candidate-pair" && row.nominated && row.state === "succeeded") {
+            nominatedPairs.push(row);
+          }
+        }
+        const pair = nominatedPairs[0];
+        if (!pair)
+          return;
+        const local = candidateTypes.get(pair.localCandidateId ?? "") ?? "unknown";
+        const remote = candidateTypes.get(pair.remoteCandidateId ?? "") ?? "unknown";
+        diagnostic(`mesh: peer ${peerId} connected via ${local}/${remote}`);
+      }).catch(() => {});
+    };
+    const flushQueued = (peerId, slot) => {
+      const backlog = backlogs.get(peerId) ?? [];
+      backlogs.delete(peerId);
+      for (const data of backlog) {
+        try {
+          slot.events.send(data);
+        } catch (error) {
+          host.onDiagnostic?.(`mesh: flush to ${peerId} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+    };
+    const ensureSlot = (peerId) => {
+      const existing = slots.get(peerId);
+      if (existing)
+        return existing;
+      const pc = new RTCPeerConnection({ iceServers });
+      const events = pc.createDataChannel("events", { negotiated: true, id: EVENTS_CHANNEL_ID });
+      const state = pc.createDataChannel("state", {
+        negotiated: true,
+        id: STATE_CHANNEL_ID,
+        ordered: false,
+        maxRetransmits: 0
+      });
+      events.binaryType = "arraybuffer";
+      state.binaryType = "arraybuffer";
+      const slot = {
+        pc,
+        events,
+        state,
+        makingOffer: false,
+        opened: false,
+        connectTimer: null,
+        disconnectedTimer: null,
+        pendingCandidates: [],
+        offerEpoch: 0,
+        answeringEpoch: null
+      };
+      slots.set(peerId, slot);
+      const isCurrent = () => slots.get(peerId)?.pc === pc;
+      events.onopen = () => {
+        if (!isCurrent())
+          return;
+        flushQueued(peerId, slot);
+        if (!slot.opened) {
+          slot.opened = true;
+          host.onPeerOpen(peerId);
+        }
+      };
+      events.onmessage = (event) => {
+        if (!isCurrent())
+          return;
+        host.onMessage(peerId, "events", event.data);
+      };
+      state.onmessage = (event) => {
+        if (!isCurrent())
+          return;
+        host.onMessage(peerId, "state", event.data);
+      };
+      pc.onicecandidate = (event) => {
+        if (!isCurrent())
+          return;
+        if (!event.candidate)
+          return;
+        host.post({ toUserId: peerId, kind: "ice", payload: JSON.stringify(event.candidate) });
+      };
+      pc.onnegotiationneeded = async () => {
+        if (!isCurrent())
+          return;
+        try {
+          slot.makingOffer = true;
+          await pc.setLocalDescription();
+          if (!isCurrent())
+            return;
+          if (pc.localDescription) {
+            epochCounter += 1;
+            slot.offerEpoch = epochCounter;
+            host.post({
+              toUserId: peerId,
+              kind: "offer",
+              payload: JSON.stringify(wireDescription(pc.localDescription, slot.offerEpoch))
+            });
+          }
+        } catch (error) {
+          if (isCurrent()) {
+            host.onError(error instanceof Error ? error.message : "Mesh negotiation failed");
+          }
+        } finally {
+          slot.makingOffer = false;
+        }
+      };
+      pc.onconnectionstatechange = () => {
+        if (!isCurrent())
+          return;
+        const connection = pc.connectionState;
+        if (connection === "connected") {
+          clearSlotTimers(slot);
+          rebuildCounts.delete(peerId);
+          reportConnectedPairType(peerId, pc);
+          return;
+        }
+        if (connection === "failed") {
+          slot.pc.restartIce();
+          armConnectWatchdog(peerId, slot);
+          return;
+        }
+        if (connection === "disconnected") {
+          if (slot.disconnectedTimer)
+            return;
+          slot.disconnectedTimer = setTimeout(() => {
+            slot.disconnectedTimer = null;
+            if (slot.pc.connectionState === "disconnected") {
+              slot.pc.restartIce();
+              armConnectWatchdog(peerId, slot);
+            }
+          }, timing.disconnectedGraceMs);
+          return;
+        }
+        if (connection === "closed")
+          teardownSlot(peerId, { departed: true });
+      };
+      armConnectWatchdog(peerId, slot);
+      return slot;
+    };
+    const applySignal = async (fromUserId, kind, payload) => {
+      if (!running)
+        return;
+      if (kind === "bye") {
+        rebuildCounts.delete(fromUserId);
+        teardownSlot(fromUserId, { departed: byeIsDeparture(payload) });
+        return;
+      }
+      const slot = ensureSlot(fromUserId);
+      const polite = isPolitePeer(selfId, fromUserId);
+      const stale = () => slots.get(fromUserId) !== slot;
+      if (kind === "ice") {
+        const candidate = parseCandidate(payload);
+        if (!candidate)
+          return;
+        if (!slot.pc.remoteDescription) {
+          slot.pendingCandidates.push(candidate);
+          return;
+        }
+        try {
+          await slot.pc.addIceCandidate(candidate);
+        } catch {}
+        return;
+      }
+      if (kind !== "offer" && kind !== "answer")
+        return;
+      const description = parseWireDescription(payload);
+      if (!description)
+        return;
+      const flushPending = async () => {
+        const queued = slot.pendingCandidates;
+        slot.pendingCandidates = [];
+        for (const candidate of queued) {
+          if (stale())
+            return;
+          try {
+            await slot.pc.addIceCandidate(candidate);
+          } catch {}
+        }
+      };
+      const offerCollision = description.type === "offer" && (slot.makingOffer || slot.pc.signalingState !== "stable");
+      if (!polite && offerCollision)
+        return;
+      if (description.type === "answer" && slot.pc.signalingState !== "have-local-offer")
+        return;
+      if (description.type === "answer" && description.epoch !== undefined && description.epoch !== slot.offerEpoch) {
+        return;
+      }
+      if (description.type === "offer")
+        slot.answeringEpoch = description.epoch ?? null;
+      try {
+        await slot.pc.setRemoteDescription(description);
+      } catch (error) {
+        if (stale())
+          return;
+        throw error;
+      }
+      if (stale())
+        return;
+      await flushPending();
+      if (description.type === "answer" || stale())
+        return;
+      await slot.pc.setLocalDescription();
+      if (stale())
+        return;
+      if (slot.pc.localDescription) {
+        host.post({
+          toUserId: fromUserId,
+          kind: "answer",
+          payload: JSON.stringify(wireDescription(slot.pc.localDescription, slot.answeringEpoch ?? undefined))
+        });
+      }
+    };
+    return {
+      setIceServers(next) {
+        iceServers = next;
+      },
+      setPeers(peers) {
+        if (!running)
+          return;
+        wanted.clear();
+        for (const peer of peers) {
+          if (peer.userId !== selfId)
+            wanted.add(peer.userId);
+        }
+        for (const peerId of [...slots.keys()]) {
+          if (!wanted.has(peerId)) {
+            rebuildCounts.delete(peerId);
+            teardownSlot(peerId, { departed: true });
+          }
+        }
+        for (const peerId of [...giveUpRetries.keys()]) {
+          if (!wanted.has(peerId))
+            clearGiveUpRetry(peerId);
+        }
+        for (const peerId of backlogs.keys()) {
+          if (!wanted.has(peerId))
+            backlogs.delete(peerId);
+        }
+        for (const peerId of wanted) {
+          if (!giveUpRetries.has(peerId))
+            ensureSlot(peerId);
+        }
+      },
+      handleSignal(fromUserId, kind, payload) {
+        const chained = signalChain.then(() => applySignal(fromUserId, kind, payload).catch((error) => {
+          if (running) {
+            host.onError(error instanceof Error ? error.message : "Mesh signal failed");
+          }
+        }));
+        signalChain = chained;
+        return chained;
+      },
+      send(toUserId, channel, data) {
+        if (!running)
+          return false;
+        const slot = slots.get(toUserId);
+        if (!slot && !wanted.has(toUserId))
+          return false;
+        const target = channel === "events" ? slot?.events : slot?.state;
+        if (!target || target.readyState !== "open") {
+          if (channel !== "events")
+            return false;
+          const queued = backlogs.get(toUserId) ?? [];
+          if (queued.length >= timing.maxQueuedEventMessages) {
+            queued.shift();
+            host.onDiagnostic?.(`mesh: event backlog for ${toUserId} overflowed; dropped oldest`);
+          }
+          queued.push(data);
+          backlogs.set(toUserId, queued);
+          return true;
+        }
+        if (channel === "state" && target.bufferedAmount >= MAX_STATE_BUFFERED_BYTES)
+          return false;
+        try {
+          target.send(data);
+          return true;
+        } catch (error) {
+          host.onDiagnostic?.(`mesh: send to ${toUserId} failed: ${error instanceof Error ? error.message : String(error)}`);
+          return false;
+        }
+      },
+      broadcast(channel, data) {
+        for (const peerId of slots.keys())
+          this.send(peerId, channel, data);
+      },
+      stop() {
+        running = false;
+        for (const peerId of [...slots.keys()])
+          teardownSlot(peerId);
+        for (const peerId of [...giveUpRetries.keys()])
+          clearGiveUpRetry(peerId);
+        wanted.clear();
+        rebuildCounts.clear();
+        reportedFailures.clear();
+        backlogs.clear();
+      }
+    };
+  }
+
+  // src/rooms.ts
+  class RealtimeRoomError extends Error {
+    code;
+    constructor(code, message) {
+      super(message);
+      this.name = "RealtimeRoomError";
+      this.code = code;
+    }
+  }
+  var subscribe = (set, callback) => {
+    set.add(callback);
+    return () => set.delete(callback);
+  };
+  var textDecoder = new TextDecoder;
+  var DEFAULT_REQUEST_TIMEOUT_MS = 45000;
+  var MAX_JOIN_CODE_LENGTH = 32;
+  function isPeers(value) {
+    return Array.isArray(value) && value.every((peer) => {
+      if (typeof peer !== "object" || peer === null)
+        return false;
+      const row = peer;
+      return typeof row.userId === "string" && typeof row.username === "string" && (row.pfp === null || typeof row.pfp === "string") && (row.joinedAt === null || typeof row.joinedAt === "string");
+    });
+  }
+  function isIceServers(value) {
+    return Array.isArray(value) && value.every((server) => {
+      if (typeof server !== "object" || server === null)
+        return false;
+      const row = server;
+      return (typeof row.urls === "string" || Array.isArray(row.urls) && row.urls.every((url) => typeof url === "string")) && (row.username === undefined || typeof row.username === "string") && (row.credential === undefined || typeof row.credential === "string");
+    });
+  }
+  function createRealtimeController(wire, options = {}) {
+    const requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+    let live = null;
+    let pending = null;
+    const roomListeners = new Set;
+    const roomErrorListeners = new Set;
+    let unheardRoomError = null;
+    const reportRoomError = (failure) => {
+      if (roomErrorListeners.size === 0)
+        unheardRoomError = failure;
+      else
+        for (const callback of roomErrorListeners)
+          callback(failure);
+    };
+    const endRoom = (room, reason) => {
+      if (room.ended)
+        return;
+      room.ended = true;
+      if (live === room)
+        live = null;
+      room.mesh.stop();
+      for (const callback of room.callbacks.ended)
+        callback(reason);
+    };
+    const requestRoom = (post) => {
+      if (pending) {
+        return Promise.reject(new RealtimeRoomError("join_failed", "A room request is already in flight."));
+      }
+      if (live) {
+        const previous = live;
+        endRoom(previous, "closed");
+        wire.post("multiplayer_leave_room");
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          if (pending !== mine)
+            return;
+          pending = null;
+          reject(new RealtimeRoomError("join_failed", "The platform did not answer. Realtime rooms are available on Remix Desktop only."));
+        }, requestTimeoutMs);
+        const mine = {
+          resolve: (room) => {
+            clearTimeout(timer);
+            resolve(room);
+          },
+          reject: (error) => {
+            clearTimeout(timer);
+            reject(error);
+          }
+        };
+        pending = mine;
+        post();
+      });
+    };
+    const channelFor = (reliable) => reliable ? "events" : "state";
+    const encodePayload = (data) => JSON.stringify(data === undefined ? null : data);
+    const withoutSelf = (peers, selfId) => peers.filter((peer) => peer.userId !== selfId);
+    const startRoom = (session) => {
+      const peers = withoutSelf(session.peers, session.selfId);
+      const roster = new Map(peers.map((peer) => [peer.userId, peer]));
+      const callbacks = {
+        message: new Set,
+        join: new Set,
+        leave: new Set,
+        ended: new Set,
+        error: new Set
+      };
+      const mesh = createDataMesh({
+        selfId: session.selfId,
+        iceServers: session.iceServers,
+        host: {
+          post: (signal) => wire.post("multiplayer_signal", {
+            toUserId: signal.toUserId,
+            kind: signal.kind,
+            payload: signal.payload
+          }),
+          onMessage: (userId, _channel, data) => {
+            if (room.ended)
+              return;
+            let parsed;
+            try {
+              parsed = JSON.parse(typeof data === "string" ? data : textDecoder.decode(data));
+            } catch {
+              return;
+            }
+            for (const callback of room.callbacks.message)
+              callback(userId, parsed);
+          },
+          onPeerOpen: () => {},
+          onPeerGone: () => {},
+          onError: (message) => {
+            if (room.ended)
+              return;
+            for (const callback of room.callbacks.error)
+              callback(message);
+          },
+          onRelayRefreshNeeded: () => {
+            if (!room.ended)
+              wire.post("multiplayer_refresh_ice");
+          }
+        }
+      });
+      const surface = {
+        roomId: session.roomId,
+        code: session.code,
+        selfId: session.selfId,
+        hostUserId: session.hostUserId,
+        isHost: session.hostUserId === session.selfId,
+        get peers() {
+          return room.peerList;
+        },
+        get ended() {
+          return room.ended;
+        },
+        send: (data, options2) => {
+          if (room.ended)
+            return;
+          const channel = channelFor(options2?.reliable !== false);
+          const encoded = encodePayload(data);
+          for (const userId of room.roster.keys())
+            room.mesh.send(userId, channel, encoded);
+        },
+        sendTo: (userId, data, options2) => {
+          if (room.ended)
+            return;
+          room.mesh.send(userId, channelFor(options2?.reliable !== false), encodePayload(data));
+        },
+        onMessage: (callback) => subscribe(room.callbacks.message, callback),
+        onPeerJoin: (callback) => subscribe(room.callbacks.join, callback),
+        onPeerLeave: (callback) => subscribe(room.callbacks.leave, callback),
+        onEnded: (callback) => subscribe(room.callbacks.ended, callback),
+        onError: (callback) => subscribe(room.callbacks.error, callback),
+        invite: () => {
+          if (!room.ended)
+            wire.post("multiplayer_request_invite");
+        },
+        leave: () => {
+          if (room.ended)
+            return;
+          endRoom(room, "left");
+          wire.post("multiplayer_leave_room");
+        }
+      };
+      const room = {
+        session,
+        roster,
+        peerList: peers,
+        ended: false,
+        mesh,
+        surface,
+        callbacks
+      };
+      try {
+        mesh.setPeers(peers);
+      } catch (error) {
+        mesh.stop();
+        throw error;
+      }
+      return room;
+    };
+    const readSession = (data) => {
+      if (typeof data !== "object" || data === null)
+        return null;
+      const session = data;
+      if (typeof session.roomId !== "string" || typeof session.selfId !== "string" || typeof session.code !== "string" || typeof session.gameId !== "string" || typeof session.hostUserId !== "string" || !isPeers(session.peers) || !isIceServers(session.iceServers)) {
+        return null;
+      }
+      return {
+        roomId: session.roomId,
+        code: session.code,
+        gameId: session.gameId,
+        selfId: session.selfId,
+        hostUserId: session.hostUserId,
+        peers: session.peers,
+        iceServers: session.iceServers
+      };
+    };
+    return {
+      createRoom() {
+        return requestRoom(() => wire.post("multiplayer_create_room"));
+      },
+      joinRoom(code) {
+        const trimmed = code.trim();
+        if (trimmed.length === 0 || trimmed.length > MAX_JOIN_CODE_LENGTH) {
+          return Promise.reject(new RealtimeRoomError("room_not_found", "That is not an invite code."));
+        }
+        return requestRoom(() => wire.post("multiplayer_join_room", { code: trimmed }));
+      },
+      get room() {
+        return live?.surface ?? null;
+      },
+      onRoom(callback) {
+        const off = subscribe(roomListeners, callback);
+        if (live && !live.ended)
+          callback(live.surface);
+        return off;
+      },
+      onRoomError(callback) {
+        const off = subscribe(roomErrorListeners, callback);
+        if (unheardRoomError) {
+          const failure = unheardRoomError;
+          unheardRoomError = null;
+          callback(failure);
+        }
+        return off;
+      },
+      handleHostEvent(type, data) {
+        switch (type) {
+          case "multiplayer_session": {
+            const session = readSession(data);
+            if (!session) {
+              const waiting2 = pending;
+              pending = null;
+              waiting2?.reject(new RealtimeRoomError("join_failed", "The platform sent a malformed session."));
+              return;
+            }
+            if (live)
+              endRoom(live, "closed");
+            unheardRoomError = null;
+            const waiting = pending;
+            pending = null;
+            let room;
+            try {
+              room = startRoom(session);
+            } catch (error) {
+              const failure = new RealtimeRoomError("join_failed", error instanceof Error ? error.message : "Could not start the room transport.");
+              wire.post("multiplayer_leave_room");
+              if (waiting)
+                waiting.reject(failure);
+              else
+                reportRoomError(failure);
+              return;
+            }
+            live = room;
+            waiting?.resolve(room.surface);
+            for (const callback of roomListeners)
+              callback(room.surface);
+            return;
+          }
+          case "multiplayer_peers": {
+            const room = live;
+            if (!room)
+              return;
+            const raw = data?.peers;
+            if (!isPeers(raw))
+              return;
+            const peers = withoutSelf(raw, room.session.selfId);
+            const next = new Map(peers.map((peer) => [peer.userId, peer]));
+            const joined = [];
+            const left = [];
+            for (const [userId, peer] of next) {
+              if (!room.roster.has(userId))
+                joined.push(peer);
+            }
+            for (const [userId, peer] of room.roster) {
+              if (!next.has(userId))
+                left.push(peer);
+            }
+            room.roster = next;
+            room.peerList = peers;
+            room.mesh.setPeers(peers);
+            for (const peer of joined)
+              for (const callback of room.callbacks.join)
+                callback(peer);
+            for (const peer of left)
+              for (const callback of room.callbacks.leave)
+                callback(peer);
+            return;
+          }
+          case "multiplayer_signals": {
+            const room = live;
+            if (!room)
+              return;
+            const signals = data?.signals;
+            if (!Array.isArray(signals))
+              return;
+            for (const signal of signals) {
+              if (typeof signal?.fromUserId !== "string" || typeof signal.kind !== "string" || typeof signal.payload !== "string") {
+                continue;
+              }
+              room.mesh.handleSignal(signal.fromUserId, signal.kind, signal.payload);
+            }
+            return;
+          }
+          case "multiplayer_ice_servers": {
+            const iceServers = data?.iceServers;
+            if (live && isIceServers(iceServers))
+              live.mesh.setIceServers(iceServers);
+            return;
+          }
+          case "multiplayer_session_ended": {
+            const reason = data?.reason ?? "closed";
+            if (live)
+              endRoom(live, reason);
+            return;
+          }
+          case "multiplayer_error": {
+            const payload = data;
+            const failure = new RealtimeRoomError(payload?.code ?? "join_failed", payload?.message ?? "The room request failed.");
+            const waiting = pending;
+            pending = null;
+            if (waiting) {
+              waiting.reject(failure);
+            } else {
+              reportRoomError(failure);
+            }
+            return;
+          }
+          default:
+            return;
+        }
+      }
+    };
+  }
+
+  // src/index.ts
   var ZERO_SAFE_AREA_INSET = {
     top: 0,
     right: 0,
     bottom: 0,
     left: 0
   };
-  var SDK_VERSION = "0.9.0";
+  var SDK_VERSION = "0.10.0";
 
   class RemixSDK {
     version = SDK_VERSION;
@@ -207,7 +1005,12 @@
         }
       }
     };
+    realtimeController = createRealtimeController({
+      post: (type, data) => this.sendMessage(type, data)
+    });
+    realtime = this.realtimeController;
     emit(eventType, data) {
+      this.realtimeController.handleHostEvent(eventType, data);
       if (eventType === "game_info") {
         const eventData = data;
         this._gameInfo = eventData;
@@ -290,4 +1093,4 @@
   }
 })();
 
-//# debugId=3963BA8C33858F2A64756E2164756E21
+//# debugId=69C4A9F79EEEBD5964756E2164756E21