@edge-base/react-native 0.1.5 → 0.2.1

package/dist/index.cjs

@@ -652,7 +652,7 @@ var DatabaseLiveClient = class {
     }
     this.connect(channel).catch(() => {
     });
-    return () => {
+    return core.createSubscription(() => {
       const subs = this.subscriptions.get(channel);
       if (!subs) return;
       const idx = subs.indexOf(sub);
@@ -663,14 +663,14 @@ var DatabaseLiveClient = class {
         this.channelOrFilters.delete(channel);
         this.sendUnsubscribe(channel);
       }
-    };
+    });
   }
   onError(handler) {
     this.errorHandlers.push(handler);
-    return () => {
+    return core.createSubscription(() => {
       const idx = this.errorHandlers.indexOf(handler);
       if (idx >= 0) this.errorHandlers.splice(idx, 1);
-    };
+    });
   }
   async connect(channel) {
     this.connectedChannels.add(channel);
@@ -758,7 +758,7 @@ var DatabaseLiveClient = class {
       (refreshToken) => refreshAccessToken(this.baseUrl, refreshToken)
     );
     if (!token) throw new core.EdgeBaseError(401, "No access token available. Sign in first.");
-    this.sendRaw({ type: "auth", token, sdkVersion: "0.1.5" });
+    this.sendRaw({ type: "auth", token, sdkVersion: "0.2.1" });
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => reject(new core.EdgeBaseError(401, "Auth timeout")), 1e4);
       const original = this.ws?.onmessage;
@@ -878,7 +878,7 @@ var DatabaseLiveClient = class {
   refreshAuth() {
     const token = this.tokenManager.currentAccessToken;
     if (!token || !this.ws || !this.connected) return;
-    this.sendRaw({ type: "auth", token, sdkVersion: "0.1.5" });
+    this.sendRaw({ type: "auth", token, sdkVersion: "0.2.1" });
   }
   handleAuthStateChange(user) {
     if (user) {
@@ -941,7 +941,9 @@ var DatabaseLiveClient = class {
     }
   }
   scheduleReconnect(channel) {
-    const delay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    const baseDelay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    const jitter = Math.random() * baseDelay * 0.25;
+    const delay = baseDelay + jitter;
     this.reconnectAttempts++;
     setTimeout(() => {
       this.connect(channel).catch(() => {
@@ -1017,11 +1019,1115 @@ function matchesDatabaseLiveChannel(channel, change, messageChannel) {
   if (parts.length === 2) return parts[1] === change.table;
   if (parts.length === 3) return parts[2] === change.table;
   if (parts.length === 4) {
-    if (parts[2] === change.table) return change.docId === parts[3];
+    if (parts[2] === change.table && change.docId === parts[3]) return true;
     return parts[3] === change.table;
   }
   return parts[3] === change.table && change.docId === parts[4];
 }
+
+// src/room-cloudflare-media.ts
+function buildRemoteTrackKey(participantId, kind) {
+  return `${participantId}:${kind}`;
+}
+function installMessage(packageName) {
+  return `Install ${packageName} to use React Native room media transport. See https://edgebase.fun/docs/room/media`;
+}
+var RoomCloudflareMediaTransport = class {
+  room;
+  options;
+  localTracks = /* @__PURE__ */ new Map();
+  remoteTrackHandlers = [];
+  participantListeners = /* @__PURE__ */ new Map();
+  remoteTrackIds = /* @__PURE__ */ new Map();
+  clientFactoryPromise = null;
+  connectPromise = null;
+  lifecycleVersion = 0;
+  meeting = null;
+  sessionId = null;
+  joinedMapSubscriptionsAttached = false;
+  onParticipantJoined = (participant) => {
+    this.attachParticipant(participant);
+  };
+  onParticipantLeft = (participant) => {
+    this.detachParticipant(participant.id);
+  };
+  onParticipantsCleared = () => {
+    this.clearParticipantListeners();
+  };
+  onParticipantsUpdate = () => {
+    this.syncAllParticipants();
+  };
+  constructor(room, options) {
+    this.room = room;
+    this.options = {
+      autoSubscribe: options?.autoSubscribe ?? true,
+      mediaDevices: options?.mediaDevices ?? (typeof navigator !== "undefined" ? navigator.mediaDevices : void 0),
+      clientFactory: options?.clientFactory
+    };
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  getPeerConnection() {
+    return null;
+  }
+  async connect(payload) {
+    if (this.meeting && this.sessionId) {
+      return this.sessionId;
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    const connectPromise = (async () => {
+      const lifecycleVersion = this.lifecycleVersion;
+      const session = await this.room.media.cloudflareRealtimeKit.createSession(payload);
+      this.assertConnectStillActive(lifecycleVersion);
+      const factory = await this.resolveClientFactory();
+      this.assertConnectStillActive(lifecycleVersion);
+      const meeting = await factory.init({
+        authToken: session.authToken,
+        defaults: {
+          audio: false,
+          video: false
+        }
+      });
+      this.assertConnectStillActive(lifecycleVersion, meeting);
+      this.meeting = meeting;
+      this.sessionId = session.sessionId;
+      this.attachParticipantMapListeners();
+      try {
+        if (meeting.join) {
+          await meeting.join();
+        } else if (meeting.joinRoom) {
+          await meeting.joinRoom();
+        } else {
+          throw new Error("RealtimeKit client does not expose join()/joinRoom().");
+        }
+        this.assertConnectStillActive(lifecycleVersion, meeting);
+        this.syncAllParticipants();
+        return session.sessionId;
+      } catch (error) {
+        if (this.meeting === meeting) {
+          this.cleanupMeeting();
+        } else {
+          this.leaveMeetingSilently(meeting);
+        }
+        throw error;
+      }
+    })();
+    this.connectPromise = connectPromise;
+    try {
+      return await connectPromise;
+    } finally {
+      if (this.connectPromise === connectPromise) {
+        this.connectPromise = null;
+      }
+    }
+  }
+  async enableAudio(constraints = true) {
+    const meeting = await this.ensureMeeting();
+    const customTrack = await this.createUserMediaTrack("audio", constraints);
+    await meeting.self.enableAudio(customTrack ?? void 0);
+    const track = meeting.self.audioTrack ?? customTrack;
+    if (!track) {
+      throw new Error("RealtimeKit did not expose a local audio track after enabling audio.");
+    }
+    this.rememberLocalTrack("audio", track, track.getSettings().deviceId ?? customTrack?.getSettings().deviceId, !!customTrack);
+    await this.room.media.audio.enable?.({
+      trackId: track.id,
+      deviceId: this.localTracks.get("audio")?.deviceId,
+      providerSessionId: meeting.self.id
+    });
+    return track;
+  }
+  async enableVideo(constraints = true) {
+    const meeting = await this.ensureMeeting();
+    const customTrack = await this.createUserMediaTrack("video", constraints);
+    await meeting.self.enableVideo(customTrack ?? void 0);
+    const track = meeting.self.videoTrack ?? customTrack;
+    if (!track) {
+      throw new Error("RealtimeKit did not expose a local video track after enabling video.");
+    }
+    this.rememberLocalTrack("video", track, track.getSettings().deviceId ?? customTrack?.getSettings().deviceId, !!customTrack);
+    await this.room.media.video.enable?.({
+      trackId: track.id,
+      deviceId: this.localTracks.get("video")?.deviceId,
+      providerSessionId: meeting.self.id
+    });
+    return track;
+  }
+  async startScreenShare(_constraints = { video: true, audio: false }) {
+    const meeting = await this.ensureMeeting();
+    await meeting.self.enableScreenShare();
+    const track = meeting.self.screenShareTracks?.video;
+    if (!track) {
+      throw new Error("RealtimeKit did not expose a screen-share video track.");
+    }
+    track.addEventListener("ended", () => {
+      void this.stopScreenShare();
+    }, { once: true });
+    this.rememberLocalTrack("screen", track, track.getSettings().deviceId, false);
+    await this.room.media.screen.start?.({
+      trackId: track.id,
+      deviceId: track.getSettings().deviceId,
+      providerSessionId: meeting.self.id
+    });
+    return track;
+  }
+  async disableAudio() {
+    if (!this.meeting) return;
+    await this.meeting.self.disableAudio();
+    this.releaseLocalTrack("audio");
+    await this.room.media.audio.disable();
+  }
+  async disableVideo() {
+    if (!this.meeting) return;
+    await this.meeting.self.disableVideo();
+    this.releaseLocalTrack("video");
+    await this.room.media.video.disable();
+  }
+  async stopScreenShare() {
+    if (!this.meeting) return;
+    await this.meeting.self.disableScreenShare();
+    this.releaseLocalTrack("screen");
+    await this.room.media.screen.stop();
+  }
+  async setMuted(kind, muted) {
+    const localTrack = this.localTracks.get(kind)?.track ?? (kind === "audio" ? this.meeting?.self.audioTrack : this.meeting?.self.videoTrack);
+    if (localTrack) {
+      localTrack.enabled = !muted;
+    }
+    if (kind === "audio") {
+      await this.room.media.audio.setMuted?.(muted);
+    } else {
+      await this.room.media.video.setMuted?.(muted);
+    }
+  }
+  async switchDevices(payload) {
+    const meeting = await this.ensureMeeting();
+    if (payload.audioInputId) {
+      const audioDevice = await meeting.self.getDeviceById(payload.audioInputId, "audio");
+      await meeting.self.setDevice(audioDevice);
+      const audioTrack = meeting.self.audioTrack;
+      if (audioTrack) {
+        this.rememberLocalTrack("audio", audioTrack, payload.audioInputId, false);
+      }
+    }
+    if (payload.videoInputId) {
+      const videoDevice = await meeting.self.getDeviceById(payload.videoInputId, "video");
+      await meeting.self.setDevice(videoDevice);
+      const videoTrack = meeting.self.videoTrack;
+      if (videoTrack) {
+        this.rememberLocalTrack("video", videoTrack, payload.videoInputId, false);
+      }
+    }
+    await this.room.media.devices.switch(payload);
+  }
+  onRemoteTrack(handler) {
+    this.remoteTrackHandlers.push(handler);
+    return core.createSubscription(() => {
+      const index = this.remoteTrackHandlers.indexOf(handler);
+      if (index >= 0) {
+        this.remoteTrackHandlers.splice(index, 1);
+      }
+    });
+  }
+  destroy() {
+    this.lifecycleVersion += 1;
+    this.connectPromise = null;
+    for (const kind of this.localTracks.keys()) {
+      this.releaseLocalTrack(kind);
+    }
+    this.clearParticipantListeners();
+    this.detachParticipantMapListeners();
+    this.cleanupMeeting();
+  }
+  async ensureMeeting() {
+    if (!this.meeting) {
+      await this.connect();
+    }
+    if (!this.meeting) {
+      throw new Error("Cloudflare media transport is not connected");
+    }
+    return this.meeting;
+  }
+  async resolveClientFactory() {
+    if (this.options.clientFactory) {
+      return this.options.clientFactory;
+    }
+    this.clientFactoryPromise ??= import('@cloudflare/realtimekit-react-native').then((mod) => mod.default ?? mod).catch((error) => {
+      throw new Error(`${installMessage("@cloudflare/realtimekit-react-native")}
+${String(error)}`);
+    });
+    return this.clientFactoryPromise;
+  }
+  async createUserMediaTrack(kind, constraints) {
+    const devices = this.options.mediaDevices;
+    if (!devices?.getUserMedia || constraints === false) {
+      return null;
+    }
+    const stream = await devices.getUserMedia(
+      kind === "audio" ? { audio: constraints, video: false } : { audio: false, video: constraints }
+    );
+    return kind === "audio" ? stream.getAudioTracks()[0] ?? null : stream.getVideoTracks()[0] ?? null;
+  }
+  rememberLocalTrack(kind, track, deviceId, stopOnCleanup) {
+    this.releaseLocalTrack(kind);
+    this.localTracks.set(kind, {
+      kind,
+      track,
+      deviceId,
+      stopOnCleanup
+    });
+  }
+  releaseLocalTrack(kind) {
+    const local = this.localTracks.get(kind);
+    if (!local) return;
+    if (local.stopOnCleanup) {
+      local.track.stop();
+    }
+    this.localTracks.delete(kind);
+  }
+  attachParticipantMapListeners() {
+    const participantMap = this.getParticipantMap();
+    if (!participantMap || !this.meeting || this.joinedMapSubscriptionsAttached) {
+      return;
+    }
+    participantMap.on("participantJoined", this.onParticipantJoined);
+    participantMap.on("participantLeft", this.onParticipantLeft);
+    participantMap.on("participantsCleared", this.onParticipantsCleared);
+    participantMap.on("participantsUpdate", this.onParticipantsUpdate);
+    this.joinedMapSubscriptionsAttached = true;
+  }
+  detachParticipantMapListeners() {
+    const participantMap = this.getParticipantMap();
+    if (!participantMap || !this.meeting || !this.joinedMapSubscriptionsAttached) {
+      return;
+    }
+    participantMap.off("participantJoined", this.onParticipantJoined);
+    participantMap.off("participantLeft", this.onParticipantLeft);
+    participantMap.off("participantsCleared", this.onParticipantsCleared);
+    participantMap.off("participantsUpdate", this.onParticipantsUpdate);
+    this.joinedMapSubscriptionsAttached = false;
+  }
+  syncAllParticipants() {
+    const participantMap = this.getParticipantMap();
+    if (!participantMap || !this.meeting || !this.options.autoSubscribe) {
+      return;
+    }
+    for (const participant of participantMap.values()) {
+      this.attachParticipant(participant);
+    }
+  }
+  getParticipantMap() {
+    if (!this.meeting) {
+      return null;
+    }
+    return this.meeting.participants.active ?? this.meeting.participants.joined ?? null;
+  }
+  attachParticipant(participant) {
+    if (!this.options.autoSubscribe || !this.meeting) {
+      return;
+    }
+    if (participant.id === this.meeting.self.id || this.participantListeners.has(participant.id)) {
+      this.syncParticipantTracks(participant);
+      return;
+    }
+    const listenerSet = {
+      participant,
+      onAudioUpdate: ({ audioEnabled, audioTrack }) => {
+        this.handleRemoteTrackUpdate("audio", participant, audioTrack, audioEnabled);
+      },
+      onVideoUpdate: ({ videoEnabled, videoTrack }) => {
+        this.handleRemoteTrackUpdate("video", participant, videoTrack, videoEnabled);
+      },
+      onScreenShareUpdate: ({ screenShareEnabled, screenShareTracks }) => {
+        this.handleRemoteTrackUpdate("screen", participant, screenShareTracks.video, screenShareEnabled);
+      }
+    };
+    participant.on("audioUpdate", listenerSet.onAudioUpdate);
+    participant.on("videoUpdate", listenerSet.onVideoUpdate);
+    participant.on("screenShareUpdate", listenerSet.onScreenShareUpdate);
+    this.participantListeners.set(participant.id, listenerSet);
+    this.syncParticipantTracks(participant);
+  }
+  detachParticipant(participantId) {
+    const listenerSet = this.participantListeners.get(participantId);
+    if (!listenerSet) return;
+    listenerSet.participant.off("audioUpdate", listenerSet.onAudioUpdate);
+    listenerSet.participant.off("videoUpdate", listenerSet.onVideoUpdate);
+    listenerSet.participant.off("screenShareUpdate", listenerSet.onScreenShareUpdate);
+    this.participantListeners.delete(participantId);
+    for (const kind of ["audio", "video", "screen"]) {
+      this.remoteTrackIds.delete(buildRemoteTrackKey(participantId, kind));
+    }
+  }
+  clearParticipantListeners() {
+    for (const participantId of Array.from(this.participantListeners.keys())) {
+      this.detachParticipant(participantId);
+    }
+    this.remoteTrackIds.clear();
+  }
+  syncParticipantTracks(participant) {
+    this.handleRemoteTrackUpdate("audio", participant, participant.audioTrack, participant.audioEnabled === true);
+    this.handleRemoteTrackUpdate("video", participant, participant.videoTrack, participant.videoEnabled === true);
+    this.handleRemoteTrackUpdate("screen", participant, participant.screenShareTracks?.video, participant.screenShareEnabled === true);
+  }
+  handleRemoteTrackUpdate(kind, participant, track, enabled) {
+    const key = buildRemoteTrackKey(participant.id, kind);
+    if (!enabled || !track) {
+      this.remoteTrackIds.delete(key);
+      return;
+    }
+    const previousTrackId = this.remoteTrackIds.get(key);
+    if (previousTrackId === track.id) {
+      return;
+    }
+    this.remoteTrackIds.set(key, track.id);
+    const payload = {
+      kind,
+      track,
+      stream: new MediaStream([track]),
+      trackName: track.id,
+      providerSessionId: participant.id,
+      participantId: participant.id,
+      customParticipantId: participant.customParticipantId,
+      userId: participant.userId
+    };
+    for (const handler of this.remoteTrackHandlers) {
+      handler(payload);
+    }
+  }
+  cleanupMeeting() {
+    const meeting = this.meeting;
+    this.detachParticipantMapListeners();
+    this.clearParticipantListeners();
+    this.meeting = null;
+    this.sessionId = null;
+    this.leaveMeetingSilently(meeting);
+  }
+  assertConnectStillActive(lifecycleVersion, meeting) {
+    if (lifecycleVersion === this.lifecycleVersion) {
+      return;
+    }
+    if (meeting) {
+      this.leaveMeetingSilently(meeting);
+    }
+    throw new Error("Cloudflare media transport was destroyed during connect.");
+  }
+  leaveMeetingSilently(meeting) {
+    if (!meeting) {
+      return;
+    }
+    const leavePromise = meeting.leave?.() ?? meeting.leaveRoom?.();
+    if (leavePromise) {
+      void leavePromise.catch(() => {
+      });
+    }
+  }
+};
+
+// src/room-p2p-media.ts
+var DEFAULT_SIGNAL_PREFIX = "edgebase.media.p2p";
+var DEFAULT_ICE_SERVERS = [
+  { urls: "stun:stun.l.google.com:19302" }
+];
+var DEFAULT_MEMBER_READY_TIMEOUT_MS = 1e4;
+function buildTrackKey(memberId, trackId) {
+  return `${memberId}:${trackId}`;
+}
+function buildExactDeviceConstraint(deviceId) {
+  return { deviceId: { exact: deviceId } };
+}
+function normalizeTrackKind(track) {
+  if (track.kind === "audio") return "audio";
+  if (track.kind === "video") return "video";
+  return null;
+}
+function serializeDescription(description) {
+  return {
+    type: description.type,
+    sdp: description.sdp ?? void 0
+  };
+}
+function serializeCandidate(candidate) {
+  if ("toJSON" in candidate && typeof candidate.toJSON === "function") {
+    return candidate.toJSON();
+  }
+  return candidate;
+}
+function installMessage2(packageName) {
+  return `Install ${packageName} to use React Native P2P media transport. See https://edgebase.fun/docs/room/media`;
+}
+var RoomP2PMediaTransport = class {
+  room;
+  options;
+  localTracks = /* @__PURE__ */ new Map();
+  peers = /* @__PURE__ */ new Map();
+  remoteTrackHandlers = [];
+  remoteTrackKinds = /* @__PURE__ */ new Map();
+  emittedRemoteTracks = /* @__PURE__ */ new Set();
+  pendingRemoteTracks = /* @__PURE__ */ new Map();
+  subscriptions = [];
+  localMemberId = null;
+  connected = false;
+  runtimePromise = null;
+  constructor(room, options) {
+    this.room = room;
+    this.options = {
+      rtcConfiguration: {
+        ...options?.rtcConfiguration,
+        iceServers: options?.rtcConfiguration?.iceServers && options.rtcConfiguration.iceServers.length > 0 ? options.rtcConfiguration.iceServers : DEFAULT_ICE_SERVERS
+      },
+      peerConnectionFactory: options?.peerConnectionFactory,
+      mediaDevices: options?.mediaDevices,
+      signalPrefix: options?.signalPrefix ?? DEFAULT_SIGNAL_PREFIX
+    };
+  }
+  getSessionId() {
+    return this.localMemberId;
+  }
+  getPeerConnection() {
+    if (this.peers.size !== 1) {
+      return null;
+    }
+    return this.peers.values().next().value?.pc ?? null;
+  }
+  async connect(payload) {
+    if (this.connected && this.localMemberId) {
+      return this.localMemberId;
+    }
+    if (payload && typeof payload === "object" && "sessionDescription" in payload) {
+      throw new Error(
+        "RoomP2PMediaTransport.connect() does not accept sessionDescription; use room.signals through the built-in transport instead."
+      );
+    }
+    await this.ensureRuntime();
+    const currentMember = await this.waitForCurrentMember();
+    if (!currentMember) {
+      throw new Error("Join the room before connecting a P2P media transport.");
+    }
+    this.localMemberId = currentMember.memberId;
+    this.connected = true;
+    this.hydrateRemoteTrackKinds();
+    this.attachRoomSubscriptions();
+    try {
+      for (const member of this.room.members.list()) {
+        if (member.memberId !== this.localMemberId) {
+          this.ensurePeer(member.memberId);
+        }
+      }
+    } catch (error) {
+      this.rollbackConnectedState();
+      throw error;
+    }
+    return this.localMemberId;
+  }
+  async waitForCurrentMember(timeoutMs = DEFAULT_MEMBER_READY_TIMEOUT_MS) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+      const member = this.room.members.current();
+      if (member) {
+        return member;
+      }
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 50));
+    }
+    return this.room.members.current();
+  }
+  async enableAudio(constraints = true) {
+    const track = await this.createUserMediaTrack("audio", constraints);
+    if (!track) {
+      throw new Error("P2P transport could not create a local audio track.");
+    }
+    const providerSessionId = await this.ensureConnectedMemberId();
+    this.rememberLocalTrack("audio", track, track.getSettings().deviceId, true);
+    await this.room.media.audio.enable?.({
+      trackId: track.id,
+      deviceId: track.getSettings().deviceId,
+      providerSessionId
+    });
+    this.syncAllPeerSenders();
+    return track;
+  }
+  async enableVideo(constraints = true) {
+    const track = await this.createUserMediaTrack("video", constraints);
+    if (!track) {
+      throw new Error("P2P transport could not create a local video track.");
+    }
+    const providerSessionId = await this.ensureConnectedMemberId();
+    this.rememberLocalTrack("video", track, track.getSettings().deviceId, true);
+    await this.room.media.video.enable?.({
+      trackId: track.id,
+      deviceId: track.getSettings().deviceId,
+      providerSessionId
+    });
+    this.syncAllPeerSenders();
+    return track;
+  }
+  async startScreenShare(constraints = { video: true, audio: false }) {
+    const devices = await this.resolveMediaDevices();
+    if (!devices?.getDisplayMedia) {
+      throw new Error("Screen sharing is not available in this environment.");
+    }
+    const stream = await devices.getDisplayMedia(constraints);
+    const track = stream.getVideoTracks()[0] ?? null;
+    if (!track) {
+      throw new Error("P2P transport could not create a screen-share track.");
+    }
+    track.addEventListener("ended", () => {
+      void this.stopScreenShare();
+    }, { once: true });
+    const providerSessionId = await this.ensureConnectedMemberId();
+    this.rememberLocalTrack("screen", track, track.getSettings().deviceId, true);
+    await this.room.media.screen.start?.({
+      trackId: track.id,
+      deviceId: track.getSettings().deviceId,
+      providerSessionId
+    });
+    this.syncAllPeerSenders();
+    return track;
+  }
+  async disableAudio() {
+    this.releaseLocalTrack("audio");
+    this.syncAllPeerSenders();
+    await this.room.media.audio.disable();
+  }
+  async disableVideo() {
+    this.releaseLocalTrack("video");
+    this.syncAllPeerSenders();
+    await this.room.media.video.disable();
+  }
+  async stopScreenShare() {
+    this.releaseLocalTrack("screen");
+    this.syncAllPeerSenders();
+    await this.room.media.screen.stop();
+  }
+  async setMuted(kind, muted) {
+    const localTrack = this.localTracks.get(kind)?.track;
+    if (localTrack) {
+      localTrack.enabled = !muted;
+    }
+    if (kind === "audio") {
+      await this.room.media.audio.setMuted?.(muted);
+    } else {
+      await this.room.media.video.setMuted?.(muted);
+    }
+  }
+  async switchDevices(payload) {
+    if (payload.audioInputId && this.localTracks.has("audio")) {
+      const nextAudioTrack = await this.createUserMediaTrack("audio", buildExactDeviceConstraint(payload.audioInputId));
+      if (nextAudioTrack) {
+        this.rememberLocalTrack("audio", nextAudioTrack, payload.audioInputId, true);
+      }
+    }
+    if (payload.videoInputId && this.localTracks.has("video")) {
+      const nextVideoTrack = await this.createUserMediaTrack("video", buildExactDeviceConstraint(payload.videoInputId));
+      if (nextVideoTrack) {
+        this.rememberLocalTrack("video", nextVideoTrack, payload.videoInputId, true);
+      }
+    }
+    this.syncAllPeerSenders();
+    await this.room.media.devices.switch(payload);
+  }
+  onRemoteTrack(handler) {
+    this.remoteTrackHandlers.push(handler);
+    return core.createSubscription(() => {
+      const index = this.remoteTrackHandlers.indexOf(handler);
+      if (index >= 0) {
+        this.remoteTrackHandlers.splice(index, 1);
+      }
+    });
+  }
+  destroy() {
+    this.connected = false;
+    this.localMemberId = null;
+    for (const subscription of this.subscriptions.splice(0)) {
+      subscription.unsubscribe();
+    }
+    for (const peer of this.peers.values()) {
+      this.destroyPeer(peer);
+    }
+    this.peers.clear();
+    for (const kind of Array.from(this.localTracks.keys())) {
+      this.releaseLocalTrack(kind);
+    }
+    this.remoteTrackKinds.clear();
+    this.emittedRemoteTracks.clear();
+    this.pendingRemoteTracks.clear();
+  }
+  attachRoomSubscriptions() {
+    if (this.subscriptions.length > 0) {
+      return;
+    }
+    this.subscriptions.push(
+      this.room.members.onJoin((member) => {
+        if (member.memberId !== this.localMemberId) {
+          this.ensurePeer(member.memberId);
+        }
+      }),
+      this.room.members.onSync((members) => {
+        const activeMemberIds = /* @__PURE__ */ new Set();
+        for (const member of members) {
+          if (member.memberId !== this.localMemberId) {
+            activeMemberIds.add(member.memberId);
+            this.ensurePeer(member.memberId);
+          }
+        }
+        for (const memberId of Array.from(this.peers.keys())) {
+          if (!activeMemberIds.has(memberId)) {
+            this.removeRemoteMember(memberId);
+          }
+        }
+      }),
+      this.room.members.onLeave((member) => {
+        this.removeRemoteMember(member.memberId);
+      }),
+      this.room.signals.on(this.offerEvent, (payload, meta) => {
+        void this.handleDescriptionSignal("offer", payload, meta);
+      }),
+      this.room.signals.on(this.answerEvent, (payload, meta) => {
+        void this.handleDescriptionSignal("answer", payload, meta);
+      }),
+      this.room.signals.on(this.iceEvent, (payload, meta) => {
+        void this.handleIceSignal(payload, meta);
+      }),
+      this.room.media.onTrack((track, member) => {
+        if (member.memberId !== this.localMemberId) {
+          this.ensurePeer(member.memberId);
+        }
+        this.rememberRemoteTrackKind(track, member);
+      }),
+      this.room.media.onTrackRemoved((track, member) => {
+        if (!track.trackId) return;
+        const key = buildTrackKey(member.memberId, track.trackId);
+        this.remoteTrackKinds.delete(key);
+        this.emittedRemoteTracks.delete(key);
+        this.pendingRemoteTracks.delete(key);
+      })
+    );
+  }
+  hydrateRemoteTrackKinds() {
+    this.remoteTrackKinds.clear();
+    this.emittedRemoteTracks.clear();
+    this.pendingRemoteTracks.clear();
+    for (const mediaMember of this.room.media.list()) {
+      for (const track of mediaMember.tracks) {
+        this.rememberRemoteTrackKind(track, mediaMember.member);
+      }
+    }
+  }
+  rememberRemoteTrackKind(track, member) {
+    if (!track.trackId || member.memberId === this.localMemberId) {
+      return;
+    }
+    const key = buildTrackKey(member.memberId, track.trackId);
+    this.remoteTrackKinds.set(key, track.kind);
+    const pending = this.pendingRemoteTracks.get(key);
+    if (pending) {
+      this.pendingRemoteTracks.delete(key);
+      this.emitRemoteTrack(member.memberId, pending.track, pending.stream, track.kind);
+      return;
+    }
+    this.flushPendingRemoteTracks(member.memberId, track.kind);
+  }
+  ensurePeer(memberId) {
+    const existing = this.peers.get(memberId);
+    if (existing) {
+      this.syncPeerSenders(existing);
+      return existing;
+    }
+    const factory = this.options.peerConnectionFactory ?? ((configuration) => new RTCPeerConnection(configuration));
+    const pc = factory(this.options.rtcConfiguration);
+    const peer = {
+      memberId,
+      pc,
+      polite: !!this.localMemberId && this.localMemberId.localeCompare(memberId) > 0,
+      makingOffer: false,
+      ignoreOffer: false,
+      isSettingRemoteAnswerPending: false,
+      pendingCandidates: [],
+      senders: /* @__PURE__ */ new Map()
+    };
+    pc.onicecandidate = (event) => {
+      if (!event.candidate) return;
+      void this.room.signals.sendTo(memberId, this.iceEvent, {
+        candidate: serializeCandidate(event.candidate)
+      });
+    };
+    pc.onnegotiationneeded = () => {
+      void this.negotiatePeer(peer);
+    };
+    pc.ontrack = (event) => {
+      const stream = event.streams[0] ?? new MediaStream([event.track]);
+      const key = buildTrackKey(memberId, event.track.id);
+      const exactKind = this.remoteTrackKinds.get(key);
+      const fallbackKind = exactKind ? null : this.resolveFallbackRemoteTrackKind(memberId, event.track);
+      const kind = exactKind ?? fallbackKind ?? normalizeTrackKind(event.track);
+      if (!kind || !exactKind && !fallbackKind && kind === "video" && event.track.kind === "video") {
+        this.pendingRemoteTracks.set(key, { memberId, track: event.track, stream });
+        return;
+      }
+      this.emitRemoteTrack(memberId, event.track, stream, kind);
+    };
+    this.peers.set(memberId, peer);
+    this.syncPeerSenders(peer);
+    return peer;
+  }
+  async negotiatePeer(peer) {
+    if (!this.connected || peer.pc.connectionState === "closed" || peer.makingOffer || peer.isSettingRemoteAnswerPending || peer.pc.signalingState !== "stable") {
+      return;
+    }
+    try {
+      peer.makingOffer = true;
+      await peer.pc.setLocalDescription();
+      if (!peer.pc.localDescription) {
+        return;
+      }
+      await this.room.signals.sendTo(peer.memberId, this.offerEvent, {
+        description: serializeDescription(peer.pc.localDescription)
+      });
+    } catch (error) {
+      console.warn("[RoomP2PMediaTransport] Failed to negotiate peer offer.", {
+        memberId: peer.memberId,
+        signalingState: peer.pc.signalingState,
+        error
+      });
+    } finally {
+      peer.makingOffer = false;
+    }
+  }
+  async handleDescriptionSignal(expectedType, payload, meta) {
+    const senderId = typeof meta.memberId === "string" && meta.memberId.trim() ? meta.memberId.trim() : "";
+    if (!senderId || senderId === this.localMemberId) {
+      return;
+    }
+    const description = this.normalizeDescription(payload);
+    if (!description || description.type !== expectedType) {
+      return;
+    }
+    const peer = this.ensurePeer(senderId);
+    const readyForOffer = !peer.makingOffer && (peer.pc.signalingState === "stable" || peer.isSettingRemoteAnswerPending);
+    const offerCollision = description.type === "offer" && !readyForOffer;
+    peer.ignoreOffer = !peer.polite && offerCollision;
+    if (peer.ignoreOffer) {
+      return;
+    }
+    try {
+      peer.isSettingRemoteAnswerPending = description.type === "answer";
+      await peer.pc.setRemoteDescription(description);
+      peer.isSettingRemoteAnswerPending = false;
+      await this.flushPendingCandidates(peer);
+      if (description.type === "offer") {
+        this.syncPeerSenders(peer);
+        await peer.pc.setLocalDescription();
+        if (!peer.pc.localDescription) {
+          return;
+        }
+        await this.room.signals.sendTo(senderId, this.answerEvent, {
+          description: serializeDescription(peer.pc.localDescription)
+        });
+      }
+    } catch (error) {
+      console.warn("[RoomP2PMediaTransport] Failed to apply remote session description.", {
+        memberId: senderId,
+        expectedType,
+        signalingState: peer.pc.signalingState,
+        error
+      });
+      peer.isSettingRemoteAnswerPending = false;
+    }
+  }
+  async handleIceSignal(payload, meta) {
+    const senderId = typeof meta.memberId === "string" && meta.memberId.trim() ? meta.memberId.trim() : "";
+    if (!senderId || senderId === this.localMemberId) {
+      return;
+    }
+    const candidate = this.normalizeCandidate(payload);
+    if (!candidate) {
+      return;
+    }
+    const peer = this.ensurePeer(senderId);
+    if (!peer.pc.remoteDescription) {
+      peer.pendingCandidates.push(candidate);
+      return;
+    }
+    try {
+      await peer.pc.addIceCandidate(candidate);
+    } catch (error) {
+      console.warn("[RoomP2PMediaTransport] Failed to add ICE candidate.", {
+        memberId: senderId,
+        error
+      });
+      if (!peer.ignoreOffer) {
+        peer.pendingCandidates.push(candidate);
+      }
+    }
+  }
+  async flushPendingCandidates(peer) {
+    if (!peer.pc.remoteDescription || peer.pendingCandidates.length === 0) {
+      return;
+    }
+    const pending = [...peer.pendingCandidates];
+    peer.pendingCandidates.length = 0;
+    for (const candidate of pending) {
+      try {
+        await peer.pc.addIceCandidate(candidate);
+      } catch (error) {
+        console.warn("[RoomP2PMediaTransport] Failed to flush pending ICE candidate.", {
+          memberId: peer.memberId,
+          error
+        });
+        if (!peer.ignoreOffer) {
+          peer.pendingCandidates.push(candidate);
+        }
+      }
+    }
+  }
+  syncAllPeerSenders() {
+    for (const peer of this.peers.values()) {
+      this.syncPeerSenders(peer);
+    }
+  }
+  syncPeerSenders(peer) {
+    const activeKinds = /* @__PURE__ */ new Set();
+    let changed = false;
+    for (const [kind, localTrack] of this.localTracks.entries()) {
+      activeKinds.add(kind);
+      const sender = peer.senders.get(kind);
+      if (sender) {
+        if (sender.track !== localTrack.track) {
+          void sender.replaceTrack(localTrack.track);
+          changed = true;
+        }
+        continue;
+      }
+      const addedSender = peer.pc.addTrack(localTrack.track, new MediaStream([localTrack.track]));
+      peer.senders.set(kind, addedSender);
+      changed = true;
+    }
+    for (const [kind, sender] of Array.from(peer.senders.entries())) {
+      if (activeKinds.has(kind)) {
+        continue;
+      }
+      try {
+        peer.pc.removeTrack(sender);
+      } catch {
+      }
+      peer.senders.delete(kind);
+      changed = true;
+    }
+    if (changed) {
+      void this.negotiatePeer(peer);
+    }
+  }
+  emitRemoteTrack(memberId, track, stream, kind) {
+    const key = buildTrackKey(memberId, track.id);
+    if (this.emittedRemoteTracks.has(key)) {
+      return;
+    }
+    this.emittedRemoteTracks.add(key);
+    this.remoteTrackKinds.set(key, kind);
+    const participant = this.findMember(memberId);
+    const payload = {
+      kind,
+      track,
+      stream,
+      trackName: track.id,
+      providerSessionId: memberId,
+      participantId: memberId,
+      userId: participant?.userId
+    };
+    for (const handler of this.remoteTrackHandlers) {
+      handler(payload);
+    }
+  }
+  resolveFallbackRemoteTrackKind(memberId, track) {
+    const normalizedKind = normalizeTrackKind(track);
+    if (!normalizedKind) {
+      return null;
+    }
+    if (normalizedKind === "audio") {
+      return "audio";
+    }
+    return this.getNextUnassignedPublishedVideoLikeKind(memberId);
+  }
+  flushPendingRemoteTracks(memberId, roomKind) {
+    const expectedTrackKind = roomKind === "audio" ? "audio" : "video";
+    for (const [key, pending] of this.pendingRemoteTracks.entries()) {
+      if (pending.memberId !== memberId || pending.track.kind !== expectedTrackKind) {
+        continue;
+      }
+      this.pendingRemoteTracks.delete(key);
+      this.emitRemoteTrack(memberId, pending.track, pending.stream, roomKind);
+      return;
+    }
+  }
+  getPublishedVideoLikeKinds(memberId) {
+    const mediaMember = this.room.media.list().find((entry) => entry.member.memberId === memberId);
+    if (!mediaMember) {
+      return [];
+    }
+    const publishedKinds = /* @__PURE__ */ new Set();
+    for (const track of mediaMember.tracks) {
+      if ((track.kind === "video" || track.kind === "screen") && track.trackId) {
+        publishedKinds.add(track.kind);
+      }
+    }
+    return Array.from(publishedKinds);
+  }
+  getNextUnassignedPublishedVideoLikeKind(memberId) {
+    const publishedKinds = this.getPublishedVideoLikeKinds(memberId);
+    if (publishedKinds.length === 0) {
+      return null;
+    }
+    const assignedKinds = /* @__PURE__ */ new Set();
+    for (const key of this.emittedRemoteTracks) {
+      if (!key.startsWith(`${memberId}:`)) {
+        continue;
+      }
+      const kind = this.remoteTrackKinds.get(key);
+      if (kind === "video" || kind === "screen") {
+        assignedKinds.add(kind);
+      }
+    }
+    return publishedKinds.find((kind) => !assignedKinds.has(kind)) ?? null;
+  }
+  closePeer(memberId) {
+    const peer = this.peers.get(memberId);
+    if (!peer) return;
+    this.destroyPeer(peer);
+    this.peers.delete(memberId);
+  }
+  removeRemoteMember(memberId) {
+    this.remoteTrackKinds.forEach((_kind, key) => {
+      if (key.startsWith(`${memberId}:`)) {
+        this.remoteTrackKinds.delete(key);
+      }
+    });
+    this.emittedRemoteTracks.forEach((key) => {
+      if (key.startsWith(`${memberId}:`)) {
+        this.emittedRemoteTracks.delete(key);
+      }
+    });
+    this.pendingRemoteTracks.forEach((_pending, key) => {
+      if (key.startsWith(`${memberId}:`)) {
+        this.pendingRemoteTracks.delete(key);
+      }
+    });
+    this.closePeer(memberId);
+  }
+  findMember(memberId) {
+    return this.room.members.list().find((member) => member.memberId === memberId);
+  }
+  rollbackConnectedState() {
+    this.connected = false;
+    this.localMemberId = null;
+    for (const subscription of this.subscriptions.splice(0)) {
+      subscription.unsubscribe();
+    }
+    for (const peer of this.peers.values()) {
+      this.destroyPeer(peer);
+    }
+    this.peers.clear();
+    this.remoteTrackKinds.clear();
+    this.emittedRemoteTracks.clear();
+    this.pendingRemoteTracks.clear();
+  }
+  destroyPeer(peer) {
+    peer.pc.onicecandidate = null;
+    peer.pc.onnegotiationneeded = null;
+    peer.pc.ontrack = null;
+    try {
+      peer.pc.close();
+    } catch {
+    }
+  }
+  async createUserMediaTrack(kind, constraints) {
+    const devices = await this.resolveMediaDevices();
+    if (!devices?.getUserMedia || constraints === false) {
+      return null;
+    }
+    const stream = await devices.getUserMedia(
+      kind === "audio" ? { audio: constraints, video: false } : { audio: false, video: constraints }
+    );
+    return kind === "audio" ? stream.getAudioTracks()[0] ?? null : stream.getVideoTracks()[0] ?? null;
+  }
+  rememberLocalTrack(kind, track, deviceId, stopOnCleanup) {
+    this.releaseLocalTrack(kind);
+    this.localTracks.set(kind, {
+      kind,
+      track,
+      deviceId,
+      stopOnCleanup
+    });
+  }
+  releaseLocalTrack(kind) {
+    const local = this.localTracks.get(kind);
+    if (!local) return;
+    if (local.stopOnCleanup) {
+      local.track.stop();
+    }
+    this.localTracks.delete(kind);
+  }
+  async ensureConnectedMemberId() {
+    if (this.localMemberId) {
+      return this.localMemberId;
+    }
+    return this.connect();
+  }
+  normalizeDescription(payload) {
+    if (!payload || typeof payload !== "object") {
+      return null;
+    }
+    const raw = payload.description;
+    if (!raw || typeof raw.type !== "string") {
+      return null;
+    }
+    return {
+      type: raw.type,
+      sdp: typeof raw.sdp === "string" ? raw.sdp : void 0
+    };
+  }
+  normalizeCandidate(payload) {
+    if (!payload || typeof payload !== "object") {
+      return null;
+    }
+    const raw = payload.candidate;
+    if (!raw || typeof raw.candidate !== "string") {
+      return null;
+    }
+    return raw;
+  }
+  async ensureRuntime() {
+    this.runtimePromise ??= import('@cloudflare/react-native-webrtc').then((mod) => {
+      const runtime = mod;
+      runtime.registerGlobals?.();
+      return runtime;
+    }).catch((error) => {
+      throw new Error(`${installMessage2("@cloudflare/react-native-webrtc")}
+${String(error)}`);
+    });
+    return this.runtimePromise;
+  }
+  async resolveMediaDevices() {
+    if (this.options.mediaDevices) {
+      return this.options.mediaDevices;
+    }
+    const runtime = await this.ensureRuntime();
+    return runtime.mediaDevices ?? (typeof navigator !== "undefined" ? navigator.mediaDevices : void 0);
+  }
+  get offerEvent() {
+    return `${this.options.signalPrefix}.offer`;
+  }
+  get answerEvent() {
+    return `${this.options.signalPrefix}.answer`;
+  }
+  get iceEvent() {
+    return `${this.options.signalPrefix}.ice`;
+  }
+};
+
+// src/room.ts
 var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
 function deepSet(obj, path, value) {
   const parts = path.split(".");
@@ -1147,6 +2253,21 @@ var RoomClient = class _RoomClient {
   };
   members = {
     list: () => cloneValue(this._members),
+    current: () => {
+      const connectionId = this.currentConnectionId;
+      if (connectionId) {
+        const byConnection = this._members.find((member2) => member2.connectionId === connectionId);
+        if (byConnection) {
+          return cloneValue(byConnection);
+        }
+      }
+      const userId = this.currentUserId;
+      if (!userId) {
+        return null;
+      }
+      const member = this._members.find((entry) => entry.userId === userId) ?? null;
+      return member ? cloneValue(member) : null;
+    },
     onSync: (handler) => this.onMembersSync(handler),
     onJoin: (handler) => this.onMemberJoin(handler),
     onLeave: (handler) => this.onMemberLeave(handler),
@@ -1181,6 +2302,18 @@ var RoomClient = class _RoomClient {
     devices: {
       switch: (payload) => this.switchMediaDevices(payload)
     },
+    cloudflareRealtimeKit: {
+      createSession: (payload) => this.requestCloudflareRealtimeKitMedia("session", "POST", payload)
+    },
+    transport: (options) => {
+      const provider = options?.provider ?? "cloudflare_realtimekit";
+      if (provider === "p2p") {
+        const p2pOptions = options?.p2p;
+        return new RoomP2PMediaTransport(this, p2pOptions);
+      }
+      const cloudflareOptions = options?.cloudflareRealtimeKit;
+      return new RoomCloudflareMediaTransport(this, cloudflareOptions);
+    },
     onTrack: (handler) => this.onMediaTrack(handler),
     onTrackRemoved: (handler) => this.onMediaTrackRemoved(handler),
     onStateChange: (handler) => this.onMediaStateChange(handler),
@@ -1201,7 +2334,8 @@ var RoomClient = class _RoomClient {
       autoReconnect: options?.autoReconnect ?? true,
       maxReconnectAttempts: options?.maxReconnectAttempts ?? 10,
       reconnectBaseDelay: options?.reconnectBaseDelay ?? 1e3,
-      sendTimeout: options?.sendTimeout ?? 1e4
+      sendTimeout: options?.sendTimeout ?? 1e4,
+      connectionTimeout: options?.connectionTimeout ?? 15e3
     };
     this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
       this.handleAuthStateChange(user);
@@ -1224,6 +2358,36 @@ var RoomClient = class _RoomClient {
   async getMetadata() {
     return _RoomClient.getMetadata(this.baseUrl, this.namespace, this.roomId);
   }
+  async requestCloudflareRealtimeKitMedia(path, method, payload) {
+    return this.requestRoomMedia("cloudflare_realtimekit", path, method, payload);
+  }
+  async requestRoomMedia(providerPath, path, method, payload) {
+    const token = await this.tokenManager.getAccessToken(
+      (refreshToken) => refreshAccessToken(this.baseUrl, refreshToken)
+    );
+    if (!token) {
+      throw new core.EdgeBaseError(401, "Authentication required");
+    }
+    const url = new URL(`${this.baseUrl.replace(/\/$/, "")}/api/room/media/${providerPath}/${path}`);
+    url.searchParams.set("namespace", this.namespace);
+    url.searchParams.set("id", this.roomId);
+    const response = await fetch(url.toString(), {
+      method,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
+      },
+      body: method === "GET" ? void 0 : JSON.stringify(payload ?? {})
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new core.EdgeBaseError(
+        response.status,
+        typeof data.message === "string" && data.message || `Room media request failed: ${response.statusText}`
+      );
+    }
+    return data;
+  }
   /**
    * Static: Get room metadata without creating a RoomClient instance.
    * Useful for lobby screens where you need room info before joining.
@@ -1283,6 +2447,30 @@ var RoomClient = class _RoomClient {
     this.reconnectInfo = null;
     this.setConnectionState("disconnected");
   }
+  /** Destroy the room client, cleaning up all listeners and the auth subscription. */
+  destroy() {
+    this.leave();
+    this.unsubAuthState?.();
+    this.unsubAuthState = null;
+    this.sharedStateHandlers.length = 0;
+    this.playerStateHandlers.length = 0;
+    this.messageHandlers.clear();
+    this.allMessageHandlers.length = 0;
+    this.errorHandlers.length = 0;
+    this.kickedHandlers.length = 0;
+    this.memberSyncHandlers.length = 0;
+    this.memberJoinHandlers.length = 0;
+    this.memberLeaveHandlers.length = 0;
+    this.memberStateHandlers.length = 0;
+    this.signalHandlers.clear();
+    this.anySignalHandlers.length = 0;
+    this.mediaTrackHandlers.length = 0;
+    this.mediaTrackRemovedHandlers.length = 0;
+    this.mediaStateHandlers.length = 0;
+    this.mediaDeviceHandlers.length = 0;
+    this.reconnectHandlers.length = 0;
+    this.connectionStateHandlers.length = 0;
+  }
   // ─── Actions ───
   /**
    * Send an action to the server.
@@ -1315,31 +2503,27 @@ var RoomClient = class _RoomClient {
    * Subscribe to shared state changes.
    * Called on full sync and on each shared_delta.
    *
-   * @returns Subscription with unsubscribe()
+   * @returns Subscription (callable & .unsubscribe())
    */
   onSharedState(handler) {
     this.sharedStateHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const idx = this.sharedStateHandlers.indexOf(handler);
-        if (idx >= 0) this.sharedStateHandlers.splice(idx, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const idx = this.sharedStateHandlers.indexOf(handler);
+      if (idx >= 0) this.sharedStateHandlers.splice(idx, 1);
+    });
   }
   /**
    * Subscribe to player state changes.
    * Called on full sync and on each player_delta.
    *
-   * @returns Subscription with unsubscribe()
+   * @returns Subscription (callable & .unsubscribe())
    */
   onPlayerState(handler) {
     this.playerStateHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const idx = this.playerStateHandlers.indexOf(handler);
-        if (idx >= 0) this.playerStateHandlers.splice(idx, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const idx = this.playerStateHandlers.indexOf(handler);
+      if (idx >= 0) this.playerStateHandlers.splice(idx, 1);
+    });
   }
   /**
    * Subscribe to messages of a specific type sent by room.sendMessage().
@@ -1347,169 +2531,137 @@ var RoomClient = class _RoomClient {
    * @example
    * room.onMessage('game_over', (data) => { console.log(data.winner); });
    *
-   * @returns Subscription with unsubscribe()
+   * @returns Subscription (callable & .unsubscribe())
    */
   onMessage(messageType, handler) {
     if (!this.messageHandlers.has(messageType)) {
       this.messageHandlers.set(messageType, []);
     }
     this.messageHandlers.get(messageType).push(handler);
-    return {
-      unsubscribe: () => {
-        const handlers = this.messageHandlers.get(messageType);
-        if (handlers) {
-          const idx = handlers.indexOf(handler);
-          if (idx >= 0) handlers.splice(idx, 1);
-        }
+    return core.createSubscription(() => {
+      const handlers = this.messageHandlers.get(messageType);
+      if (handlers) {
+        const idx = handlers.indexOf(handler);
+        if (idx >= 0) handlers.splice(idx, 1);
       }
-    };
+    });
   }
   /**
    * Subscribe to ALL messages regardless of type.
    *
-   * @returns Subscription with unsubscribe()
+   * @returns Subscription (callable & .unsubscribe())
    */
   onAnyMessage(handler) {
     this.allMessageHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const idx = this.allMessageHandlers.indexOf(handler);
-        if (idx >= 0) this.allMessageHandlers.splice(idx, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const idx = this.allMessageHandlers.indexOf(handler);
+      if (idx >= 0) this.allMessageHandlers.splice(idx, 1);
+    });
   }
   /** Subscribe to errors */
   onError(handler) {
     this.errorHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const idx = this.errorHandlers.indexOf(handler);
-        if (idx >= 0) this.errorHandlers.splice(idx, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const idx = this.errorHandlers.indexOf(handler);
+      if (idx >= 0) this.errorHandlers.splice(idx, 1);
+    });
   }
   /** Subscribe to kick events */
   onKicked(handler) {
     this.kickedHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const idx = this.kickedHandlers.indexOf(handler);
-        if (idx >= 0) this.kickedHandlers.splice(idx, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const idx = this.kickedHandlers.indexOf(handler);
+      if (idx >= 0) this.kickedHandlers.splice(idx, 1);
+    });
   }
   onSignal(event, handler) {
     if (!this.signalHandlers.has(event)) {
       this.signalHandlers.set(event, []);
     }
     this.signalHandlers.get(event).push(handler);
-    return {
-      unsubscribe: () => {
-        const handlers = this.signalHandlers.get(event);
-        if (!handlers) return;
-        const index = handlers.indexOf(handler);
-        if (index >= 0) handlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const handlers = this.signalHandlers.get(event);
+      if (!handlers) return;
+      const index = handlers.indexOf(handler);
+      if (index >= 0) handlers.splice(index, 1);
+    });
   }
   onAnySignal(handler) {
     this.anySignalHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.anySignalHandlers.indexOf(handler);
-        if (index >= 0) this.anySignalHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.anySignalHandlers.indexOf(handler);
+      if (index >= 0) this.anySignalHandlers.splice(index, 1);
+    });
   }
   onMembersSync(handler) {
     this.memberSyncHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.memberSyncHandlers.indexOf(handler);
-        if (index >= 0) this.memberSyncHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.memberSyncHandlers.indexOf(handler);
+      if (index >= 0) this.memberSyncHandlers.splice(index, 1);
+    });
   }
   onMemberJoin(handler) {
     this.memberJoinHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.memberJoinHandlers.indexOf(handler);
-        if (index >= 0) this.memberJoinHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.memberJoinHandlers.indexOf(handler);
+      if (index >= 0) this.memberJoinHandlers.splice(index, 1);
+    });
   }
   onMemberLeave(handler) {
     this.memberLeaveHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.memberLeaveHandlers.indexOf(handler);
-        if (index >= 0) this.memberLeaveHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.memberLeaveHandlers.indexOf(handler);
+      if (index >= 0) this.memberLeaveHandlers.splice(index, 1);
+    });
   }
   onMemberStateChange(handler) {
     this.memberStateHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.memberStateHandlers.indexOf(handler);
-        if (index >= 0) this.memberStateHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.memberStateHandlers.indexOf(handler);
+      if (index >= 0) this.memberStateHandlers.splice(index, 1);
+    });
   }
   onReconnect(handler) {
     this.reconnectHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.reconnectHandlers.indexOf(handler);
-        if (index >= 0) this.reconnectHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.reconnectHandlers.indexOf(handler);
+      if (index >= 0) this.reconnectHandlers.splice(index, 1);
+    });
   }
   onConnectionStateChange(handler) {
     this.connectionStateHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.connectionStateHandlers.indexOf(handler);
-        if (index >= 0) this.connectionStateHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.connectionStateHandlers.indexOf(handler);
+      if (index >= 0) this.connectionStateHandlers.splice(index, 1);
+    });
   }
   onMediaTrack(handler) {
     this.mediaTrackHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.mediaTrackHandlers.indexOf(handler);
-        if (index >= 0) this.mediaTrackHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.mediaTrackHandlers.indexOf(handler);
+      if (index >= 0) this.mediaTrackHandlers.splice(index, 1);
+    });
   }
   onMediaTrackRemoved(handler) {
     this.mediaTrackRemovedHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.mediaTrackRemovedHandlers.indexOf(handler);
-        if (index >= 0) this.mediaTrackRemovedHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.mediaTrackRemovedHandlers.indexOf(handler);
+      if (index >= 0) this.mediaTrackRemovedHandlers.splice(index, 1);
+    });
   }
   onMediaStateChange(handler) {
     this.mediaStateHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.mediaStateHandlers.indexOf(handler);
-        if (index >= 0) this.mediaStateHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.mediaStateHandlers.indexOf(handler);
+      if (index >= 0) this.mediaStateHandlers.splice(index, 1);
+    });
   }
   onMediaDeviceChange(handler) {
     this.mediaDeviceHandlers.push(handler);
-    return {
-      unsubscribe: () => {
-        const index = this.mediaDeviceHandlers.indexOf(handler);
-        if (index >= 0) this.mediaDeviceHandlers.splice(index, 1);
-      }
-    };
+    return core.createSubscription(() => {
+      const index = this.mediaDeviceHandlers.indexOf(handler);
+      if (index >= 0) this.mediaDeviceHandlers.splice(index, 1);
+    });
   }
   async sendSignal(event, payload, options) {
     if (!this.ws || !this.connected || !this.authenticated) {
@@ -1616,22 +2768,42 @@ var RoomClient = class _RoomClient {
       const wsUrl = this.buildWsUrl();
       const ws = new WebSocket(wsUrl);
       this.ws = ws;
+      let settled = false;
+      const connectionTimer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          try {
+            ws.close();
+          } catch (_) {
+          }
+          this.ws = null;
+          reject(new core.EdgeBaseError(408, `Room WebSocket connection timed out after ${this.options.connectionTimeout}ms. Is the server running?`));
+        }
+      }, this.options.connectionTimeout);
       ws.onopen = () => {
+        clearTimeout(connectionTimer);
         this.connected = true;
         this.reconnectAttempts = 0;
         this.startHeartbeat();
         this.authenticate().then(() => {
-          this.waitingForAuth = false;
-          resolve();
+          if (!settled) {
+            settled = true;
+            this.waitingForAuth = false;
+            resolve();
+          }
         }).catch((error) => {
-          this.handleAuthenticationFailure(error);
-          reject(error);
+          if (!settled) {
+            settled = true;
+            this.handleAuthenticationFailure(error);
+            reject(error);
+          }
         });
       };
       ws.onmessage = (event) => {
         this.handleMessage(event.data);
       };
       ws.onclose = (event) => {
+        clearTimeout(connectionTimer);
         this.connected = false;
         this.authenticated = false;
         this.joined = false;
@@ -1640,6 +2812,9 @@ var RoomClient = class _RoomClient {
         if (event.code === 4004 && this.connectionState !== "kicked") {
           this.handleKicked();
         }
+        if (!this.intentionallyLeft) {
+          this.rejectAllPendingRequests(new core.EdgeBaseError(499, "WebSocket connection lost"));
+        }
         if (!this.intentionallyLeft && !this.waitingForAuth && this.options.autoReconnect && this.reconnectAttempts < this.options.maxReconnectAttempts) {
           this.scheduleReconnect();
         } else if (!this.intentionallyLeft && this.connectionState !== "kicked" && this.connectionState !== "auth_lost") {
@@ -1647,7 +2822,11 @@ var RoomClient = class _RoomClient {
         }
       };
       ws.onerror = () => {
-        reject(new core.EdgeBaseError(500, "Room WebSocket connection error"));
+        clearTimeout(connectionTimer);
+        if (!settled) {
+          settled = true;
+          reject(new core.EdgeBaseError(500, "Room WebSocket connection error"));
+        }
       };
     });
   }
@@ -2091,6 +3270,9 @@ var RoomClient = class _RoomClient {
     this.sendRaw({ type: "auth", token });
   }
   handleAuthStateChange(user) {
+    if (user === null) {
+      this.rejectAllPendingRequests(new core.EdgeBaseError(401, "Auth state lost"));
+    }
     if (user) {
       if (this.ws && this.connected && this.authenticated) {
         this.refreshAuth();
@@ -2345,6 +3527,17 @@ var RoomClient = class _RoomClient {
       [kind]: next
     };
   }
+  rejectAllPendingRequests(error) {
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timeout);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+    this.rejectPendingVoidRequests(this.pendingSignalRequests, error);
+    this.rejectPendingVoidRequests(this.pendingAdminRequests, error);
+    this.rejectPendingVoidRequests(this.pendingMemberStateRequests, error);
+    this.rejectPendingVoidRequests(this.pendingMediaRequests, error);
+  }
   rejectPendingVoidRequests(pendingRequests, error) {
     for (const [, pending] of pendingRequests) {
       clearTimeout(pending.timeout);
@@ -2375,7 +3568,9 @@ var RoomClient = class _RoomClient {
   }
   scheduleReconnect() {
     const attempt = this.reconnectAttempts + 1;
-    const delay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    const baseDelay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
+    const jitter = Math.random() * baseDelay * 0.25;
+    const delay = baseDelay + jitter;
     this.reconnectAttempts++;
     this.reconnectInfo = { attempt };
     this.setConnectionState("reconnecting");