@remix-gg/sdk 0.9.0 → 0.10.0

package/dist/index.js

@@ -37,18 +37,868 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  RealtimeRoomError: () => RealtimeRoomError,
   RemixSDK: () => RemixSDK,
   ZERO_SAFE_AREA_INSET: () => ZERO_SAFE_AREA_INSET,
   sdk: () => sdk
 });
 module.exports = __toCommonJS(src_exports);
+
+// 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: 12e3,
+  disconnectedGraceMs: 4e3,
+  maxRebuilds: 3,
+  giveUpRetryMs: 15e3,
+  maxQueuedEventMessages: 64
+};
+function wireDescription(description, epoch) {
+  return epoch === void 0 ? { 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 === void 0)
+    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 === void 0;
+}
+function parseJson(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch (e) {
+    return null;
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createDataMesh(opts) {
+  const { selfId, host } = opts;
+  const timing = __spreadValues(__spreadValues({}, DEFAULT_TUNING), opts.tuning);
+  const slots = /* @__PURE__ */ new Map();
+  const backlogs = /* @__PURE__ */ new Map();
+  const rebuildCounts = /* @__PURE__ */ new Map();
+  const reportedFailures = /* @__PURE__ */ new Set();
+  const wanted = /* @__PURE__ */ new Set();
+  const giveUpRetries = /* @__PURE__ */ 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(() => {
+        var _a;
+        giveUpRetries.delete(peerId);
+        if (!running || !wanted.has(peerId) || slots.has(peerId))
+          return;
+        (_a = host.onDiagnostic) == null ? void 0 : _a.call(host, `mesh: retrying peer ${peerId} after the give-up rest`);
+        ensureSlot(peerId);
+      }, timing.giveUpRetryMs)
+    );
+  };
+  const rebuildSlot = (peerId, why) => {
+    var _a, _b, _c;
+    if (!running || !slots.has(peerId))
+      return;
+    const attempts = ((_a = rebuildCounts.get(peerId)) != null ? _a : 0) + 1;
+    teardownSlot(peerId);
+    if (attempts > timing.maxRebuilds) {
+      rebuildCounts.delete(peerId);
+      (_b = host.onDiagnostic) == null ? void 0 : _b.call(
+        host,
+        `mesh: gave up connecting peer ${peerId} after ${timing.maxRebuilds} rebuilds`
+      );
+      scheduleGiveUpRetry(peerId);
+      (_c = host.onRelayRefreshNeeded) == null ? void 0 : _c.call(host);
+      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;
+    void pc.getStats().then((stats) => {
+      var _a, _b, _c, _d;
+      const candidateTypes = /* @__PURE__ */ 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 = (_b = candidateTypes.get((_a = pair.localCandidateId) != null ? _a : "")) != null ? _b : "unknown";
+      const remote = (_d = candidateTypes.get((_c = pair.remoteCandidateId) != null ? _c : "")) != null ? _d : "unknown";
+      diagnostic(`mesh: peer ${peerId} connected via ${local}/${remote}`);
+    }).catch(() => {
+    });
+  };
+  const flushQueued = (peerId, slot) => {
+    var _a, _b;
+    const backlog = (_a = backlogs.get(peerId)) != null ? _a : [];
+    backlogs.delete(peerId);
+    for (const data of backlog) {
+      try {
+        slot.events.send(data);
+      } catch (error) {
+        (_b = host.onDiagnostic) == null ? void 0 : _b.call(
+          host,
+          `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 = () => {
+      var _a;
+      return ((_a = slots.get(peerId)) == null ? void 0 : _a.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) => {
+    var _a, _b;
+    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 (e) {
+      }
+      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 (e) {
+        }
+      }
+    };
+    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 !== void 0 && description.epoch !== slot.offerEpoch) {
+      return;
+    }
+    if (description.type === "offer")
+      slot.answeringEpoch = (_a = description.epoch) != null ? _a : 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, (_b = slot.answeringEpoch) != null ? _b : void 0)
+        )
+      });
+    }
+  };
+  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) {
+      var _a, _b, _c;
+      if (!running)
+        return false;
+      const slot = slots.get(toUserId);
+      if (!slot && !wanted.has(toUserId))
+        return false;
+      const target = channel === "events" ? slot == null ? void 0 : slot.events : slot == null ? void 0 : slot.state;
+      if (!target || target.readyState !== "open") {
+        if (channel !== "events")
+          return false;
+        const queued = (_a = backlogs.get(toUserId)) != null ? _a : [];
+        if (queued.length >= timing.maxQueuedEventMessages) {
+          queued.shift();
+          (_b = host.onDiagnostic) == null ? void 0 : _b.call(host, `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) {
+        (_c = host.onDiagnostic) == null ? void 0 : _c.call(
+          host,
+          `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
+var RealtimeRoomError = class extends Error {
+  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 = 45e3;
+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 === void 0 || typeof row.username === "string") && (row.credential === void 0 || typeof row.credential === "string");
+  });
+}
+function createRealtimeController(wire, options = {}) {
+  var _a;
+  const requestTimeoutMs = (_a = options.requestTimeoutMs) != null ? _a : DEFAULT_REQUEST_TIMEOUT_MS;
+  let live = null;
+  let pending = null;
+  const roomListeners = /* @__PURE__ */ new Set();
+  const roomErrorListeners = /* @__PURE__ */ 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 === void 0 ? 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: /* @__PURE__ */ new Set(),
+      join: /* @__PURE__ */ new Set(),
+      leave: /* @__PURE__ */ new Set(),
+      ended: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ 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 (e) {
+            return;
+          }
+          for (const callback of room.callbacks.message)
+            callback(userId, parsed);
+        },
+        // Membership is the roster's; transport churn stays out of the game.
+        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 == null ? void 0 : 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 == null ? void 0 : 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() {
+      var _a2;
+      return (_a2 = live == null ? void 0 : live.surface) != null ? _a2 : 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) {
+      var _a2, _b, _c;
+      switch (type) {
+        case "multiplayer_session": {
+          const session = readSession(data);
+          if (!session) {
+            const waiting2 = pending;
+            pending = null;
+            waiting2 == null ? void 0 : 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 == null ? void 0 : 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 == null ? void 0 : 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 == null ? void 0 : data.signals;
+          if (!Array.isArray(signals))
+            return;
+          for (const signal of signals) {
+            if (typeof (signal == null ? void 0 : signal.fromUserId) !== "string" || typeof signal.kind !== "string" || typeof signal.payload !== "string") {
+              continue;
+            }
+            void room.mesh.handleSignal(signal.fromUserId, signal.kind, signal.payload);
+          }
+          return;
+        }
+        case "multiplayer_ice_servers": {
+          const iceServers = data == null ? void 0 : data.iceServers;
+          if (live && isIceServers(iceServers))
+            live.mesh.setIceServers(iceServers);
+          return;
+        }
+        case "multiplayer_session_ended": {
+          const reason = (_a2 = data == null ? void 0 : data.reason) != null ? _a2 : "closed";
+          if (live)
+            endRoom(live, reason);
+          return;
+        }
+        case "multiplayer_error": {
+          const payload = data;
+          const failure = new RealtimeRoomError(
+            (_b = payload == null ? void 0 : payload.code) != null ? _b : "join_failed",
+            (_c = payload == null ? void 0 : payload.message) != null ? _c : "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 = true ? "0.9.0" : UNKNOWN_SDK_VERSION;
+var SDK_VERSION = true ? "0.10.0" : UNKNOWN_SDK_VERSION;
 var RemixSDK = class {
   constructor() {
     /**
@@ -118,6 +968,17 @@ var RemixSDK = class {
         }
       })
     };
+    /**
+     * Realtime multiplayer rooms (Remix Desktop): create or join a room, then
+     * talk to peers over `room.send` / `room.onMessage`. Distinct from
+     * `sdk.multiplayer`, which is the platform-arbitrated turn-based flow.
+     * The transport underneath is the platform's business; games see rooms,
+     * peers, and messages, and nothing else.
+     */
+    this.realtimeController = createRealtimeController({
+      post: (type, data) => this.sendMessage(type, data)
+    });
+    this.realtime = this.realtimeController;
     this.handleMessage = (event) => {
       var _a;
       if (((_a = event.data) == null ? void 0 : _a.type) !== "game_event")
@@ -270,6 +1131,7 @@ var RemixSDK = class {
   }
   emit(eventType, data) {
     var _a;
+    this.realtimeController.handleHostEvent(eventType, data);
     if (eventType === "game_info") {
       const eventData = data;
       this._gameInfo = eventData;
@@ -324,6 +1186,7 @@ if (typeof window !== "undefined") {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RealtimeRoomError,
   RemixSDK,
   ZERO_SAFE_AREA_INSET,
   sdk