@edge-base/react-native 0.2.6 → 0.2.8

package/dist/index.cjs

@@ -756,7 +756,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.2.6" });
+    this.sendRaw({ type: "auth", token, sdkVersion: "0.2.8" });
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => reject(new core.EdgeBaseError(401, "Auth timeout")), 1e4);
       const original = this.ws?.onmessage;
@@ -876,7 +876,7 @@ var DatabaseLiveClient = class {
   refreshAuth() {
     const token = this.tokenManager.currentAccessToken;
     if (!token || !this.ws || !this.connected) return;
-    this.sendRaw({ type: "auth", token, sdkVersion: "0.2.6" });
+    this.sendRaw({ type: "auth", token, sdkVersion: "0.2.8" });
   }
   handleAuthStateChange(user) {
     if (user) {
@@ -1022,1110 +1022,6 @@ function matchesDatabaseLiveChannel(channel, change, messageChannel) {
   }
   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(".");
@@ -2163,18 +1059,21 @@ function cloneRecord(value) {
 var WS_CONNECTING = 0;
 var WS_OPEN = 1;
 var ROOM_EXPLICIT_LEAVE_CLOSE_CODE = 4005;
+var ROOM_AUTH_STATE_LOST_CLOSE_CODE = 4006;
 var ROOM_EXPLICIT_LEAVE_REASON = "Client left room";
-var ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS = 40;
+var ROOM_HEARTBEAT_INTERVAL_MS = 8e3;
+var ROOM_HEARTBEAT_STALE_TIMEOUT_MS = 2e4;
 function isSocketOpenOrConnecting(socket) {
   return !!socket && (socket.readyState === WS_OPEN || socket.readyState === WS_CONNECTING);
 }
 function closeSocketAfterLeave(socket, reason) {
-  globalThis.setTimeout(() => {
-    try {
-      socket.close(ROOM_EXPLICIT_LEAVE_CLOSE_CODE, reason);
-    } catch {
-    }
-  }, ROOM_EXPLICIT_LEAVE_CLOSE_DELAY_MS);
+  try {
+    socket.close(ROOM_EXPLICIT_LEAVE_CLOSE_CODE, reason);
+  } catch {
+  }
+}
+function getDefaultHeartbeatStaleTimeoutMs(heartbeatIntervalMs) {
+  return Math.max(Math.floor(heartbeatIntervalMs * 2.5), ROOM_HEARTBEAT_STALE_TIMEOUT_MS);
 }
 var RoomClient = class _RoomClient {
   baseUrl;
@@ -2190,7 +1089,7 @@ var RoomClient = class _RoomClient {
   _playerState = {};
   _playerVersion = 0;
   _members = [];
-  _mediaMembers = [];
+  lastLocalMemberState = null;
   // ─── Connection ───
   ws = null;
   reconnectAttempts = 0;
@@ -2203,16 +1102,41 @@ var RoomClient = class _RoomClient {
   reconnectInfo = null;
   connectingPromise = null;
   heartbeatTimer = null;
+  lastHeartbeatAckAt = Date.now();
+  disconnectResetTimer = null;
   intentionallyLeft = false;
   waitingForAuth = false;
   joinRequested = false;
   unsubAuthState = null;
+  browserNetworkListenersAttached = false;
+  browserOfflineHandler = () => {
+    if (this.intentionallyLeft || !this.joinRequested) {
+      return;
+    }
+    if (this.connectionState === "connected") {
+      this.setConnectionState("reconnecting");
+    }
+    if (isSocketOpenOrConnecting(this.ws)) {
+      try {
+        this.ws?.close();
+      } catch {
+      }
+    }
+  };
+  browserOnlineHandler = () => {
+    if (this.intentionallyLeft || !this.joinRequested || this.connectingPromise || isSocketOpenOrConnecting(this.ws)) {
+      return;
+    }
+    if (this.connectionState === "reconnecting" || this.connectionState === "disconnected") {
+      this.ensureConnection().catch(() => {
+      });
+    }
+  };
   // ─── Pending send() requests (requestId → { resolve, reject, timeout }) ───
   pendingRequests = /* @__PURE__ */ new Map();
   pendingSignalRequests = /* @__PURE__ */ new Map();
   pendingAdminRequests = /* @__PURE__ */ new Map();
   pendingMemberStateRequests = /* @__PURE__ */ new Map();
-  pendingMediaRequests = /* @__PURE__ */ new Map();
   // ─── Subscriptions ───
   sharedStateHandlers = [];
   playerStateHandlers = [];
@@ -2222,16 +1146,14 @@ var RoomClient = class _RoomClient {
   errorHandlers = [];
   kickedHandlers = [];
   memberSyncHandlers = [];
+  memberSnapshotHandlers = [];
   memberJoinHandlers = [];
   memberLeaveHandlers = [];
   memberStateHandlers = [];
   signalHandlers = /* @__PURE__ */ new Map();
   anySignalHandlers = [];
-  mediaTrackHandlers = [];
-  mediaTrackRemovedHandlers = [];
-  mediaStateHandlers = [];
-  mediaDeviceHandlers = [];
   reconnectHandlers = [];
+  recoveryFailureHandlers = [];
   connectionStateHandlers = [];
   state = {
     getShared: () => this.getSharedState(),
@@ -2241,7 +1163,8 @@ var RoomClient = class _RoomClient {
     send: (actionType, payload) => this.send(actionType, payload)
   };
   meta = {
-    get: () => this.getMetadata()
+    get: () => this.getMetadata(),
+    summary: () => this.getSummary()
   };
   signals = {
     send: (event, payload, options) => this.sendSignal(event, payload, options),
@@ -2250,7 +1173,7 @@ var RoomClient = class _RoomClient {
     onAny: (handler) => this.onAnySignal(handler)
   };
   members = {
-    list: () => cloneValue(this._members),
+    list: () => this._members.map((member) => cloneValue(member)),
     current: () => {
       const connectionId = this.currentConnectionId;
       if (connectionId) {
@@ -2266,7 +1189,9 @@ var RoomClient = class _RoomClient {
       const member = this._members.find((entry) => entry.userId === userId) ?? null;
       return member ? cloneValue(member) : null;
     },
+    awaitCurrent: (timeoutMs = 1e4) => this.waitForCurrentMember(timeoutMs),
     onSync: (handler) => this.onMembersSync(handler),
+    onSnapshot: (handler) => this.onMemberSnapshot(handler),
     onJoin: (handler) => this.onMemberJoin(handler),
     onLeave: (handler) => this.onMemberLeave(handler),
     setState: (state) => this.sendMemberState(state),
@@ -2275,53 +1200,16 @@ var RoomClient = class _RoomClient {
   };
   admin = {
     kick: (memberId) => this.sendAdmin("kick", memberId),
-    mute: (memberId) => this.sendAdmin("mute", memberId),
     block: (memberId) => this.sendAdmin("block", memberId),
-    setRole: (memberId, role) => this.sendAdmin("setRole", memberId, { role }),
-    disableVideo: (memberId) => this.sendAdmin("disableVideo", memberId),
-    stopScreenShare: (memberId) => this.sendAdmin("stopScreenShare", memberId)
-  };
-  media = {
-    list: () => cloneValue(this._mediaMembers),
-    audio: {
-      enable: (payload) => this.sendMedia("publish", "audio", payload),
-      disable: () => this.sendMedia("unpublish", "audio"),
-      setMuted: (muted) => this.sendMedia("mute", "audio", { muted })
-    },
-    video: {
-      enable: (payload) => this.sendMedia("publish", "video", payload),
-      disable: () => this.sendMedia("unpublish", "video"),
-      setMuted: (muted) => this.sendMedia("mute", "video", { muted })
-    },
-    screen: {
-      start: (payload) => this.sendMedia("publish", "screen", payload),
-      stop: () => this.sendMedia("unpublish", "screen")
-    },
-    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),
-    onDeviceChange: (handler) => this.onMediaDeviceChange(handler)
+    setRole: (memberId, role) => this.sendAdmin("setRole", memberId, { role })
   };
   session = {
     onError: (handler) => this.onError(handler),
     onKicked: (handler) => this.onKicked(handler),
     onReconnect: (handler) => this.onReconnect(handler),
-    onConnectionStateChange: (handler) => this.onConnectionStateChange(handler)
+    onConnectionStateChange: (handler) => this.onConnectionStateChange(handler),
+    onRecoveryFailure: (handler) => this.onRecoveryFailure(handler),
+    getDebugSnapshot: () => this.getDebugSnapshot()
   };
   constructor(baseUrl, namespace, roomId, tokenManager, options) {
     this.baseUrl = baseUrl;
@@ -2333,11 +1221,16 @@ var RoomClient = class _RoomClient {
       maxReconnectAttempts: options?.maxReconnectAttempts ?? 10,
       reconnectBaseDelay: options?.reconnectBaseDelay ?? 1e3,
       sendTimeout: options?.sendTimeout ?? 1e4,
-      connectionTimeout: options?.connectionTimeout ?? 15e3
+      connectionTimeout: options?.connectionTimeout ?? 15e3,
+      heartbeatIntervalMs: options?.heartbeatIntervalMs ?? ROOM_HEARTBEAT_INTERVAL_MS,
+      heartbeatStaleTimeoutMs: options?.heartbeatStaleTimeoutMs ?? getDefaultHeartbeatStaleTimeoutMs(options?.heartbeatIntervalMs ?? ROOM_HEARTBEAT_INTERVAL_MS),
+      networkRecoveryGraceMs: options?.networkRecoveryGraceMs ?? 3500,
+      disconnectResetTimeoutMs: options?.disconnectResetTimeoutMs ?? 8e3
     };
     this.unsubAuthState = this.tokenManager.onAuthStateChange((user) => {
       this.handleAuthStateChange(user);
     });
+    this.attachBrowserNetworkListeners();
   }
   // ─── State Accessors ───
   /** Get current shared state (read-only snapshot) */
@@ -2348,71 +1241,128 @@ var RoomClient = class _RoomClient {
   getPlayerState() {
     return cloneRecord(this._playerState);
   }
+  async waitForCurrentMember(timeoutMs = 1e4) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+      const member = this.members.current();
+      if (member) {
+        return member;
+      }
+      await new Promise((resolve) => globalThis.setTimeout(resolve, 50));
+    }
+    return this.members.current();
+  }
   // ─── Metadata (HTTP, no WebSocket needed) ───
   /**
    * Get room metadata without joining (HTTP GET).
    * Returns developer-defined metadata set by room.setMetadata() on the server.
-   */
-  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 before calling room media APIs. Sign in and join the room first.");
-    }
-    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;
+   */
+  async getMetadata() {
+    return _RoomClient.getMetadata(this.baseUrl, this.namespace, this.roomId);
+  }
+  async getSummary() {
+    return _RoomClient.getSummary(this.baseUrl, this.namespace, this.roomId);
+  }
+  async checkConnection() {
+    return _RoomClient.checkConnection(this.baseUrl, this.namespace, this.roomId);
   }
   /**
    * Static: Get room metadata without creating a RoomClient instance.
    * Useful for lobby screens where you need room info before joining.
    */
   static async getMetadata(baseUrl, namespace, roomId) {
-    const url = `${baseUrl.replace(/\/$/, "")}/api/room/metadata?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
+    return _RoomClient.requestPublicRoomResource(
+      baseUrl,
+      "metadata",
+      namespace,
+      roomId,
+      "Failed to get room metadata"
+    );
+  }
+  static async getSummary(baseUrl, namespace, roomId) {
+    return _RoomClient.requestPublicRoomResource(
+      baseUrl,
+      "summary",
+      namespace,
+      roomId,
+      "Failed to get room summary"
+    );
+  }
+  static async getSummaries(baseUrl, namespace, roomIds) {
+    const url = `${baseUrl.replace(/\/$/, "")}/api/room/summaries`;
     let res;
     try {
-      res = await fetch(url);
+      res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ namespace, ids: roomIds })
+      });
     } catch (error) {
       throw core.networkError(
-        `Room metadata request could not reach ${url}. Make sure the EdgeBase server is running and reachable.`,
+        `Failed to get room summaries. Could not reach ${baseUrl.replace(/\/$/, "")}. Make sure the EdgeBase server is running and reachable.`,
         { cause: error }
       );
     }
     const data = await res.json().catch(() => null);
     if (!res.ok) {
       const parsed = core.parseErrorResponse(res.status, data);
-      if (data && typeof data === "object" && typeof data.message === "string") {
-        throw parsed;
-      }
+      parsed.message = `Failed to get room summaries: ${parsed.message}`;
+      throw parsed;
+    }
+    return data;
+  }
+  static async checkConnection(baseUrl, namespace, roomId) {
+    const url = `${baseUrl.replace(/\/$/, "")}/api/room/connect-check?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
+    let response;
+    try {
+      response = await fetch(url);
+    } catch (error) {
+      throw core.networkError(
+        `Room connect-check could not reach ${baseUrl.replace(/\/$/, "")}. Make sure the EdgeBase server is running and reachable.`,
+        { cause: error }
+      );
+    }
+    const data = await response.json().catch(() => null);
+    if (!response.ok) {
+      throw core.parseErrorResponse(response.status, data);
+    }
+    if (typeof data?.ok !== "boolean" || typeof data?.type !== "string" || typeof data?.category !== "string" || typeof data?.message !== "string") {
       throw new core.EdgeBaseError(
-        res.status,
-        `Failed to load room metadata for '${roomId}' in namespace '${namespace}'. ${parsed.message}`
+        response.status || 500,
+        "Room connect-check returned an unexpected response. The EdgeBase server and SDK may be out of sync."
+      );
+    }
+    const diagnostic = data;
+    return {
+      ok: diagnostic.ok,
+      type: diagnostic.type,
+      category: diagnostic.category,
+      message: diagnostic.message,
+      namespace: typeof diagnostic.namespace === "string" ? diagnostic.namespace : void 0,
+      roomId: typeof diagnostic.roomId === "string" ? diagnostic.roomId : void 0,
+      runtime: typeof diagnostic.runtime === "string" ? diagnostic.runtime : void 0,
+      pendingCount: typeof diagnostic.pendingCount === "number" ? diagnostic.pendingCount : void 0,
+      maxPending: typeof diagnostic.maxPending === "number" ? diagnostic.maxPending : void 0
+    };
+  }
+  static async requestPublicRoomResource(baseUrl, resource, namespace, roomId, failureMessage) {
+    const url = `${baseUrl.replace(/\/$/, "")}/api/room/${resource}?namespace=${encodeURIComponent(namespace)}&id=${encodeURIComponent(roomId)}`;
+    let res;
+    try {
+      res = await fetch(url);
+    } catch (error) {
+      throw core.networkError(
+        `${failureMessage}. Could not reach ${baseUrl.replace(/\/$/, "")}. Make sure the EdgeBase server is running and reachable.`,
+        { cause: error }
       );
     }
-    return data ?? {};
+    if (!res.ok) {
+      const data = await res.json().catch(() => null);
+      const parsed = core.parseErrorResponse(res.status, data);
+      parsed.message = `${failureMessage}: ${parsed.message}`;
+      throw parsed;
+    }
+    return res.json();
   }
   // ─── Connection Lifecycle ───
   /** Connect to the room, authenticate, and join */
@@ -2431,15 +1381,8 @@ var RoomClient = class _RoomClient {
     this.joinRequested = false;
     this.waitingForAuth = false;
     this.stopHeartbeat();
-    for (const [, pending] of this.pendingRequests) {
-      clearTimeout(pending.timeout);
-      pending.reject(new core.EdgeBaseError(499, "Room left"));
-    }
-    this.pendingRequests.clear();
-    this.rejectPendingVoidRequests(this.pendingSignalRequests, new core.EdgeBaseError(499, "Room left"));
-    this.rejectPendingVoidRequests(this.pendingAdminRequests, new core.EdgeBaseError(499, "Room left"));
-    this.rejectPendingVoidRequests(this.pendingMemberStateRequests, new core.EdgeBaseError(499, "Room left"));
-    this.rejectPendingVoidRequests(this.pendingMediaRequests, new core.EdgeBaseError(499, "Room left"));
+    this.clearDisconnectResetTimer();
+    this.rejectAllPendingRequests(new core.EdgeBaseError(499, "Room left"));
     if (this.ws) {
       const socket = this.ws;
       this.sendRaw({ type: "leave" });
@@ -2455,15 +1398,28 @@ var RoomClient = class _RoomClient {
     this._playerState = {};
     this._playerVersion = 0;
     this._members = [];
-    this._mediaMembers = [];
+    this.lastLocalMemberState = null;
     this.currentUserId = null;
     this.currentConnectionId = null;
     this.reconnectInfo = null;
     this.setConnectionState("disconnected");
   }
-  /** Destroy the room client, cleaning up all listeners and the auth subscription. */
+  assertConnected(action) {
+    if (!this.ws || !this.connected || !this.authenticated) {
+      throw new core.EdgeBaseError(
+        400,
+        `Room connection required before ${action}. Call room.join() and wait for the connection to finish.`
+      );
+    }
+  }
+  /**
+   * Destroy the RoomClient and release all resources.
+   * Calls leave() if still connected, unsubscribes from auth state changes,
+   * and clears all handler arrays to allow garbage collection.
+   */
   destroy() {
     this.leave();
+    this.detachBrowserNetworkListeners();
     this.unsubAuthState?.();
     this.unsubAuthState = null;
     this.sharedStateHandlers.length = 0;
@@ -2478,10 +1434,6 @@ var RoomClient = class _RoomClient {
     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;
   }
@@ -2494,9 +1446,7 @@ var RoomClient = class _RoomClient {
    * const result = await room.send('SET_SCORE', { score: 42 });
    */
   async send(actionType, payload) {
-    if (!this.ws || !this.connected || !this.authenticated) {
-      throw new core.EdgeBaseError(400, "Not connected to room. Call room.join() and wait for the room to connect before sending actions, signals, or media.");
-    }
+    this.assertConnected(`sending action '${actionType}'`);
     const requestId = generateRequestId();
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -2614,6 +1564,13 @@ var RoomClient = class _RoomClient {
       if (index >= 0) this.memberSyncHandlers.splice(index, 1);
     });
   }
+  onMemberSnapshot(handler) {
+    this.memberSnapshotHandlers.push(handler);
+    return core.createSubscription(() => {
+      const index = this.memberSnapshotHandlers.indexOf(handler);
+      if (index >= 0) this.memberSnapshotHandlers.splice(index, 1);
+    });
+  }
   onMemberJoin(handler) {
     this.memberJoinHandlers.push(handler);
     return core.createSubscription(() => {
@@ -2642,6 +1599,13 @@ var RoomClient = class _RoomClient {
       if (index >= 0) this.reconnectHandlers.splice(index, 1);
     });
   }
+  onRecoveryFailure(handler) {
+    this.recoveryFailureHandlers.push(handler);
+    return core.createSubscription(() => {
+      const index = this.recoveryFailureHandlers.indexOf(handler);
+      if (index >= 0) this.recoveryFailureHandlers.splice(index, 1);
+    });
+  }
   onConnectionStateChange(handler) {
     this.connectionStateHandlers.push(handler);
     return core.createSubscription(() => {
@@ -2649,38 +1613,8 @@ var RoomClient = class _RoomClient {
       if (index >= 0) this.connectionStateHandlers.splice(index, 1);
     });
   }
-  onMediaTrack(handler) {
-    this.mediaTrackHandlers.push(handler);
-    return core.createSubscription(() => {
-      const index = this.mediaTrackHandlers.indexOf(handler);
-      if (index >= 0) this.mediaTrackHandlers.splice(index, 1);
-    });
-  }
-  onMediaTrackRemoved(handler) {
-    this.mediaTrackRemovedHandlers.push(handler);
-    return core.createSubscription(() => {
-      const index = this.mediaTrackRemovedHandlers.indexOf(handler);
-      if (index >= 0) this.mediaTrackRemovedHandlers.splice(index, 1);
-    });
-  }
-  onMediaStateChange(handler) {
-    this.mediaStateHandlers.push(handler);
-    return core.createSubscription(() => {
-      const index = this.mediaStateHandlers.indexOf(handler);
-      if (index >= 0) this.mediaStateHandlers.splice(index, 1);
-    });
-  }
-  onMediaDeviceChange(handler) {
-    this.mediaDeviceHandlers.push(handler);
-    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) {
-      throw new core.EdgeBaseError(400, "Not connected to room. Call room.join() and wait for the room to connect before sending actions, signals, or media.");
-    }
+    this.assertConnected(`sending signal '${event}'`);
     const requestId = generateRequestId();
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -2699,34 +1633,39 @@ var RoomClient = class _RoomClient {
     });
   }
   async sendMemberState(state) {
+    const nextState = {
+      ...this.lastLocalMemberState ?? {},
+      ...cloneRecord(state)
+    };
     return this.sendMemberStateRequest({
       type: "member_state",
       state
+    }, () => {
+      this.lastLocalMemberState = nextState;
     });
   }
   async clearMemberState() {
+    const clearedState = {};
     return this.sendMemberStateRequest({
       type: "member_state_clear"
+    }, () => {
+      this.lastLocalMemberState = clearedState;
     });
   }
-  async sendMemberStateRequest(payload) {
-    if (!this.ws || !this.connected || !this.authenticated) {
-      throw new core.EdgeBaseError(400, "Not connected to room. Call room.join() and wait for the room to connect before sending actions, signals, or media.");
-    }
+  async sendMemberStateRequest(payload, onSuccess) {
+    this.assertConnected("updating member state");
     const requestId = generateRequestId();
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
         this.pendingMemberStateRequests.delete(requestId);
         reject(new core.EdgeBaseError(408, "Member state update timed out"));
       }, this.options.sendTimeout);
-      this.pendingMemberStateRequests.set(requestId, { resolve, reject, timeout });
+      this.pendingMemberStateRequests.set(requestId, { resolve, reject, timeout, onSuccess });
       this.sendRaw({ ...payload, requestId });
     });
   }
   async sendAdmin(operation, memberId, payload) {
-    if (!this.ws || !this.connected || !this.authenticated) {
-      throw new core.EdgeBaseError(400, "Not connected to room. Call room.join() and wait for the room to connect before sending actions, signals, or media.");
-    }
+    this.assertConnected(`running admin operation '${operation}'`);
     const requestId = generateRequestId();
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
@@ -2743,39 +1682,6 @@ var RoomClient = class _RoomClient {
       });
     });
   }
-  async sendMedia(operation, kind, payload) {
-    if (!this.ws || !this.connected || !this.authenticated) {
-      throw new core.EdgeBaseError(400, "Not connected to room. Call room.join() and wait for the room to connect before sending actions, signals, or media.");
-    }
-    const requestId = generateRequestId();
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        this.pendingMediaRequests.delete(requestId);
-        reject(new core.EdgeBaseError(408, `Media operation '${operation}' timed out`));
-      }, this.options.sendTimeout);
-      this.pendingMediaRequests.set(requestId, { resolve, reject, timeout });
-      this.sendRaw({
-        type: "media",
-        operation,
-        kind,
-        payload: payload ?? {},
-        requestId
-      });
-    });
-  }
-  async switchMediaDevices(payload) {
-    const operations = [];
-    if (payload.audioInputId) {
-      operations.push(this.sendMedia("device", "audio", { deviceId: payload.audioInputId }));
-    }
-    if (payload.videoInputId) {
-      operations.push(this.sendMedia("device", "video", { deviceId: payload.videoInputId }));
-    }
-    if (payload.screenInputId) {
-      operations.push(this.sendMedia("device", "screen", { deviceId: payload.screenInputId }));
-    }
-    await Promise.all(operations);
-  }
   // ─── Private: Connection ───
   async establishConnection() {
     return new Promise((resolve, reject) => {
@@ -2823,11 +1729,16 @@ var RoomClient = class _RoomClient {
         this.joined = false;
         this.ws = null;
         this.stopHeartbeat();
-        if (event.code === 4004 && this.connectionState !== "kicked") {
-          this.handleKicked();
+        const closeMessage = event.reason?.trim() ? `Room authentication lost: ${event.reason}` : "Room authentication lost";
+        const closeError = event.code === ROOM_AUTH_STATE_LOST_CLOSE_CODE ? new core.EdgeBaseError(401, closeMessage) : new core.EdgeBaseError(499, "WebSocket connection lost");
+        if (event.code === ROOM_AUTH_STATE_LOST_CLOSE_CODE && this.connectionState !== "auth_lost") {
+          this.setConnectionState("auth_lost");
         }
         if (!this.intentionallyLeft) {
-          this.rejectAllPendingRequests(new core.EdgeBaseError(499, "WebSocket connection lost"));
+          this.rejectAllPendingRequests(closeError);
+        }
+        if (event.code === 4004 && this.connectionState !== "kicked") {
+          this.handleKicked();
         }
         if (!this.intentionallyLeft && !this.waitingForAuth && this.options.autoReconnect && this.reconnectAttempts < this.options.maxReconnectAttempts) {
           this.scheduleReconnect();
@@ -2861,11 +1772,19 @@ var RoomClient = class _RoomClient {
       (refreshToken) => refreshAccessToken(this.baseUrl, refreshToken)
     );
     if (!token) {
-      throw new core.EdgeBaseError(401, "No access token available. Sign in first.");
+      throw new core.EdgeBaseError(
+        401,
+        "Room authentication requires a signed-in session. Sign in before joining the room."
+      );
     }
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
-        reject(new core.EdgeBaseError(401, "Room auth timeout"));
+        reject(
+          new core.EdgeBaseError(
+            401,
+            "Room authentication timed out. Check the server auth response and room connectivity."
+          )
+        );
       }, 1e4);
       const originalOnMessage = this.ws?.onmessage;
       if (this.ws) {
@@ -2882,7 +1801,8 @@ var RoomClient = class _RoomClient {
               lastSharedState: this._sharedState,
               lastSharedVersion: this._sharedVersion,
               lastPlayerState: this._playerState,
-              lastPlayerVersion: this._playerVersion
+              lastPlayerVersion: this._playerVersion,
+              lastMemberState: this.getReconnectMemberState()
             });
             this.joined = true;
             resolve();
@@ -2939,9 +1859,6 @@ var RoomClient = class _RoomClient {
       case "members_sync":
         this.handleMembersSync(msg);
         break;
-      case "media_sync":
-        this.handleMediaSync(msg);
-        break;
       case "member_join":
         this.handleMemberJoinFrame(msg);
         break;
@@ -2954,24 +1871,6 @@ var RoomClient = class _RoomClient {
       case "member_state_error":
         this.handleMemberStateError(msg);
         break;
-      case "media_track":
-        this.handleMediaTrackFrame(msg);
-        break;
-      case "media_track_removed":
-        this.handleMediaTrackRemovedFrame(msg);
-        break;
-      case "media_state":
-        this.handleMediaStateFrame(msg);
-        break;
-      case "media_device":
-        this.handleMediaDeviceFrame(msg);
-        break;
-      case "media_result":
-        this.handleMediaResult(msg);
-        break;
-      case "media_error":
-        this.handleMediaError(msg);
-        break;
       case "admin_result":
         this.handleAdminResult(msg);
         break;
@@ -2984,6 +1883,9 @@ var RoomClient = class _RoomClient {
       case "error":
         this.handleError(msg);
         break;
+      case "pong":
+        this.lastHeartbeatAckAt = Date.now();
+        break;
     }
   }
   handleSync(msg) {
@@ -3099,22 +2001,18 @@ var RoomClient = class _RoomClient {
   handleMembersSync(msg) {
     const members = this.normalizeMembers(msg.members);
     this._members = members;
-    for (const member of members) {
-      this.syncMediaMemberInfo(member);
-    }
-    const snapshot = cloneValue(this._members);
+    const snapshot = this._members.map((member) => cloneValue(member));
     for (const handler of this.memberSyncHandlers) {
       handler(snapshot);
     }
-  }
-  handleMediaSync(msg) {
-    this._mediaMembers = this.normalizeMediaMembers(msg.members);
+    for (const handler of this.memberSnapshotHandlers) {
+      handler(snapshot);
+    }
   }
   handleMemberJoinFrame(msg) {
     const member = this.normalizeMember(msg.member);
     if (!member) return;
     this.upsertMember(member);
-    this.syncMediaMemberInfo(member);
     const snapshot = cloneValue(member);
     for (const handler of this.memberJoinHandlers) {
       handler(snapshot);
@@ -3124,7 +2022,6 @@ var RoomClient = class _RoomClient {
     const member = this.normalizeMember(msg.member);
     if (!member) return;
     this.removeMember(member.memberId);
-    this.removeMediaMember(member.memberId);
     const reason = this.normalizeLeaveReason(msg.reason);
     const snapshot = cloneValue(member);
     for (const handler of this.memberLeaveHandlers) {
@@ -3137,13 +2034,13 @@ var RoomClient = class _RoomClient {
     if (!member) return;
     member.state = state;
     this.upsertMember(member);
-    this.syncMediaMemberInfo(member);
     const requestId = msg.requestId;
-    if (requestId && member.memberId === this.currentUserId) {
+    if (requestId) {
       const pending = this.pendingMemberStateRequests.get(requestId);
       if (pending) {
         clearTimeout(pending.timeout);
         this.pendingMemberStateRequests.delete(requestId);
+        pending.onSuccess?.();
         pending.resolve();
       }
     }
@@ -3162,93 +2059,6 @@ var RoomClient = class _RoomClient {
     this.pendingMemberStateRequests.delete(requestId);
     pending.reject(new core.EdgeBaseError(400, msg.message || "Member state update failed"));
   }
-  handleMediaTrackFrame(msg) {
-    const member = this.normalizeMember(msg.member);
-    const track = this.normalizeMediaTrack(msg.track);
-    if (!member || !track) return;
-    const mediaMember = this.ensureMediaMember(member);
-    this.upsertMediaTrack(mediaMember, track);
-    this.mergeMediaState(mediaMember, track.kind, {
-      published: true,
-      muted: track.muted,
-      trackId: track.trackId,
-      deviceId: track.deviceId,
-      publishedAt: track.publishedAt,
-      adminDisabled: track.adminDisabled
-    });
-    const memberSnapshot = cloneValue(mediaMember.member);
-    const trackSnapshot = cloneValue(track);
-    for (const handler of this.mediaTrackHandlers) {
-      handler(trackSnapshot, memberSnapshot);
-    }
-  }
-  handleMediaTrackRemovedFrame(msg) {
-    const member = this.normalizeMember(msg.member);
-    const track = this.normalizeMediaTrack(msg.track);
-    if (!member || !track) return;
-    const mediaMember = this.ensureMediaMember(member);
-    this.removeMediaTrack(mediaMember, track);
-    mediaMember.state = {
-      ...mediaMember.state,
-      [track.kind]: {
-        published: false,
-        muted: false,
-        adminDisabled: false
-      }
-    };
-    const memberSnapshot = cloneValue(mediaMember.member);
-    const trackSnapshot = cloneValue(track);
-    for (const handler of this.mediaTrackRemovedHandlers) {
-      handler(trackSnapshot, memberSnapshot);
-    }
-  }
-  handleMediaStateFrame(msg) {
-    const member = this.normalizeMember(msg.member);
-    if (!member) return;
-    const mediaMember = this.ensureMediaMember(member);
-    mediaMember.state = this.normalizeMediaState(msg.state);
-    const memberSnapshot = cloneValue(mediaMember.member);
-    const stateSnapshot = cloneValue(mediaMember.state);
-    for (const handler of this.mediaStateHandlers) {
-      handler(memberSnapshot, stateSnapshot);
-    }
-  }
-  handleMediaDeviceFrame(msg) {
-    const member = this.normalizeMember(msg.member);
-    const kind = this.normalizeMediaKind(msg.kind);
-    const deviceId = typeof msg.deviceId === "string" ? msg.deviceId : "";
-    if (!member || !kind || !deviceId) return;
-    const mediaMember = this.ensureMediaMember(member);
-    this.mergeMediaState(mediaMember, kind, { deviceId });
-    for (const track of mediaMember.tracks) {
-      if (track.kind === kind) {
-        track.deviceId = deviceId;
-      }
-    }
-    const memberSnapshot = cloneValue(mediaMember.member);
-    const change = { kind, deviceId };
-    for (const handler of this.mediaDeviceHandlers) {
-      handler(memberSnapshot, change);
-    }
-  }
-  handleMediaResult(msg) {
-    const requestId = msg.requestId;
-    if (!requestId) return;
-    const pending = this.pendingMediaRequests.get(requestId);
-    if (!pending) return;
-    clearTimeout(pending.timeout);
-    this.pendingMediaRequests.delete(requestId);
-    pending.resolve();
-  }
-  handleMediaError(msg) {
-    const requestId = msg.requestId;
-    if (!requestId) return;
-    const pending = this.pendingMediaRequests.get(requestId);
-    if (!pending) return;
-    clearTimeout(pending.timeout);
-    this.pendingMediaRequests.delete(requestId);
-    pending.reject(new core.EdgeBaseError(400, msg.message || "Media operation failed"));
-  }
   handleAdminResult(msg) {
     const requestId = msg.requestId;
     if (!requestId) return;
@@ -3274,8 +2084,13 @@ var RoomClient = class _RoomClient {
     this.setConnectionState("kicked");
   }
   handleError(msg) {
+    const code = typeof msg.code === "string" ? msg.code : "";
+    const message = typeof msg.message === "string" ? msg.message : "";
+    if (this.shouldTreatErrorAsAuthLoss(code)) {
+      this.handleRoomAuthStateLoss(message);
+    }
     for (const handler of this.errorHandlers) {
-      handler({ code: msg.code, message: msg.message });
+      handler({ code, message });
     }
   }
   refreshAuth() {
@@ -3284,9 +2099,6 @@ 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();
@@ -3303,6 +2115,7 @@ var RoomClient = class _RoomClient {
     this.waitingForAuth = this.joinRequested;
     this.reconnectInfo = null;
     this.setConnectionState("auth_lost");
+    this.rejectAllPendingRequests(new core.EdgeBaseError(401, "Auth state lost"));
     if (this.ws) {
       const socket = this.ws;
       this.sendRaw({ type: "leave" });
@@ -3311,7 +2124,6 @@ var RoomClient = class _RoomClient {
       this.connected = false;
       this.authenticated = false;
       this.joined = false;
-      this._mediaMembers = [];
       this.currentUserId = null;
       this.currentConnectionId = null;
       try {
@@ -3323,7 +2135,6 @@ var RoomClient = class _RoomClient {
     this.connected = false;
     this.authenticated = false;
     this.joined = false;
-    this._mediaMembers = [];
   }
   handleAuthenticationFailure(error) {
     const authError = error instanceof core.EdgeBaseError ? error : new core.EdgeBaseError(500, "Room authentication failed.");
@@ -3342,17 +2153,35 @@ var RoomClient = class _RoomClient {
       }
     }
   }
-  normalizeMembers(value) {
-    if (!Array.isArray(value)) {
-      return [];
+  shouldTreatErrorAsAuthLoss(code) {
+    if (code === "AUTH_STATE_LOST") {
+      return true;
     }
-    return value.map((member) => this.normalizeMember(member)).filter((member) => !!member);
+    if (code !== "NOT_AUTHENTICATED") {
+      return false;
+    }
+    return this.authenticated || this.hasPendingRequests();
+  }
+  hasPendingRequests() {
+    return this.pendingRequests.size > 0 || this.pendingSignalRequests.size > 0 || this.pendingAdminRequests.size > 0 || this.pendingMemberStateRequests.size > 0;
   }
-  normalizeMediaMembers(value) {
+  handleRoomAuthStateLoss(message) {
+    const detail = message?.trim();
+    const authLossMessage = detail ? `Room authentication lost: ${detail}` : "Room authentication lost";
+    this.setConnectionState("auth_lost");
+    this.rejectAllPendingRequests(new core.EdgeBaseError(401, authLossMessage));
+    if (this.ws && this.ws.readyState === WS_OPEN) {
+      try {
+        this.ws.close(ROOM_AUTH_STATE_LOST_CLOSE_CODE, authLossMessage);
+      } catch {
+      }
+    }
+  }
+  normalizeMembers(value) {
     if (!Array.isArray(value)) {
       return [];
     }
-    return value.map((member) => this.normalizeMediaMember(member)).filter((member) => !!member);
+    return value.map((member) => this.normalizeMember(member)).filter((member) => !!member);
   }
   normalizeMember(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -3377,80 +2206,6 @@ var RoomClient = class _RoomClient {
     }
     return cloneRecord(value);
   }
-  normalizeMediaMember(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return null;
-    }
-    const entry = value;
-    const member = this.normalizeMember(entry.member);
-    if (!member) {
-      return null;
-    }
-    return {
-      member,
-      state: this.normalizeMediaState(entry.state),
-      tracks: this.normalizeMediaTracks(entry.tracks)
-    };
-  }
-  normalizeMediaState(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return {};
-    }
-    const state = value;
-    return {
-      audio: this.normalizeMediaKindState(state.audio),
-      video: this.normalizeMediaKindState(state.video),
-      screen: this.normalizeMediaKindState(state.screen)
-    };
-  }
-  normalizeMediaKindState(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return void 0;
-    }
-    const state = value;
-    return {
-      published: state.published === true,
-      muted: state.muted === true,
-      trackId: typeof state.trackId === "string" ? state.trackId : void 0,
-      deviceId: typeof state.deviceId === "string" ? state.deviceId : void 0,
-      publishedAt: typeof state.publishedAt === "number" ? state.publishedAt : void 0,
-      adminDisabled: state.adminDisabled === true
-    };
-  }
-  normalizeMediaTracks(value) {
-    if (!Array.isArray(value)) {
-      return [];
-    }
-    return value.map((track) => this.normalizeMediaTrack(track)).filter((track) => !!track);
-  }
-  normalizeMediaTrack(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      return null;
-    }
-    const track = value;
-    const kind = this.normalizeMediaKind(track.kind);
-    if (!kind) {
-      return null;
-    }
-    return {
-      kind,
-      trackId: typeof track.trackId === "string" ? track.trackId : void 0,
-      deviceId: typeof track.deviceId === "string" ? track.deviceId : void 0,
-      muted: track.muted === true,
-      publishedAt: typeof track.publishedAt === "number" ? track.publishedAt : void 0,
-      adminDisabled: track.adminDisabled === true
-    };
-  }
-  normalizeMediaKind(value) {
-    switch (value) {
-      case "audio":
-      case "video":
-      case "screen":
-        return value;
-      default:
-        return null;
-    }
-  }
   normalizeSignalMeta(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
       return {};
@@ -3474,6 +2229,20 @@ var RoomClient = class _RoomClient {
         return "leave";
     }
   }
+  getDebugSnapshot() {
+    return {
+      connectionState: this.connectionState,
+      connected: this.connected,
+      authenticated: this.authenticated,
+      joined: this.joined,
+      currentUserId: this.currentUserId,
+      currentConnectionId: this.currentConnectionId,
+      membersCount: this._members.length,
+      reconnectAttempts: this.reconnectAttempts,
+      joinRequested: this.joinRequested,
+      waitingForAuth: this.waitingForAuth
+    };
+  }
   upsertMember(member) {
     const index = this._members.findIndex((entry) => entry.memberId === member.memberId);
     if (index >= 0) {
@@ -3485,62 +2254,7 @@ var RoomClient = class _RoomClient {
   removeMember(memberId) {
     this._members = this._members.filter((member) => member.memberId !== memberId);
   }
-  syncMediaMemberInfo(member) {
-    const mediaMember = this._mediaMembers.find((entry) => entry.member.memberId === member.memberId);
-    if (!mediaMember) {
-      return;
-    }
-    mediaMember.member = cloneValue(member);
-  }
-  ensureMediaMember(member) {
-    const existing = this._mediaMembers.find((entry) => entry.member.memberId === member.memberId);
-    if (existing) {
-      existing.member = cloneValue(member);
-      return existing;
-    }
-    const created = {
-      member: cloneValue(member),
-      state: {},
-      tracks: []
-    };
-    this._mediaMembers.push(created);
-    return created;
-  }
-  removeMediaMember(memberId) {
-    this._mediaMembers = this._mediaMembers.filter((member) => member.member.memberId !== memberId);
-  }
-  upsertMediaTrack(mediaMember, track) {
-    const index = mediaMember.tracks.findIndex(
-      (entry) => entry.kind === track.kind && entry.trackId === track.trackId
-    );
-    if (index >= 0) {
-      mediaMember.tracks[index] = cloneValue(track);
-      return;
-    }
-    mediaMember.tracks = mediaMember.tracks.filter((entry) => !(entry.kind === track.kind && !track.trackId)).concat(cloneValue(track));
-  }
-  removeMediaTrack(mediaMember, track) {
-    mediaMember.tracks = mediaMember.tracks.filter((entry) => {
-      if (track.trackId) {
-        return !(entry.kind === track.kind && entry.trackId === track.trackId);
-      }
-      return entry.kind !== track.kind;
-    });
-  }
-  mergeMediaState(mediaMember, kind, partial) {
-    const next = {
-      published: partial.published ?? mediaMember.state[kind]?.published ?? false,
-      muted: partial.muted ?? mediaMember.state[kind]?.muted ?? false,
-      trackId: partial.trackId ?? mediaMember.state[kind]?.trackId,
-      deviceId: partial.deviceId ?? mediaMember.state[kind]?.deviceId,
-      publishedAt: partial.publishedAt ?? mediaMember.state[kind]?.publishedAt,
-      adminDisabled: partial.adminDisabled ?? mediaMember.state[kind]?.adminDisabled
-    };
-    mediaMember.state = {
-      ...mediaMember.state,
-      [kind]: next
-    };
-  }
+  /** Reject all 5 pending request maps at once. */
   rejectAllPendingRequests(error) {
     for (const [, pending] of this.pendingRequests) {
       clearTimeout(pending.timeout);
@@ -3550,7 +2264,6 @@ var RoomClient = class _RoomClient {
     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) {
@@ -3559,11 +2272,56 @@ var RoomClient = class _RoomClient {
     }
     pendingRequests.clear();
   }
+  shouldScheduleDisconnectReset(next) {
+    if (this.intentionallyLeft || !this.joinRequested) {
+      return false;
+    }
+    return next === "disconnected";
+  }
+  clearDisconnectResetTimer() {
+    if (this.disconnectResetTimer) {
+      clearTimeout(this.disconnectResetTimer);
+      this.disconnectResetTimer = null;
+    }
+  }
+  scheduleDisconnectReset(stateAtSchedule) {
+    this.clearDisconnectResetTimer();
+    const timeoutMs = this.options.disconnectResetTimeoutMs;
+    if (!(timeoutMs > 0)) {
+      return;
+    }
+    this.disconnectResetTimer = setTimeout(() => {
+      this.disconnectResetTimer = null;
+      if (this.intentionallyLeft || !this.joinRequested) {
+        return;
+      }
+      if (this.connectionState !== stateAtSchedule) {
+        return;
+      }
+      if (this.connectionState === "connected") {
+        return;
+      }
+      for (const handler of this.recoveryFailureHandlers) {
+        try {
+          handler({
+            state: this.connectionState,
+            timeoutMs
+          });
+        } catch {
+        }
+      }
+    }, timeoutMs);
+  }
   setConnectionState(next) {
     if (this.connectionState === next) {
       return;
     }
     this.connectionState = next;
+    if (this.shouldScheduleDisconnectReset(next)) {
+      this.scheduleDisconnectReset(next);
+    } else {
+      this.clearDisconnectResetTimer();
+    }
     for (const handler of this.connectionStateHandlers) {
       handler(next);
     }
@@ -3580,6 +2338,30 @@ var RoomClient = class _RoomClient {
     const wsUrl = httpUrl.replace(/^http/, "ws");
     return `${wsUrl}/api/room?namespace=${encodeURIComponent(this.namespace)}&id=${encodeURIComponent(this.roomId)}`;
   }
+  attachBrowserNetworkListeners() {
+    if (this.browserNetworkListenersAttached) {
+      return;
+    }
+    const eventTarget = typeof globalThis !== "undefined" && typeof globalThis.addEventListener === "function" ? globalThis : null;
+    if (!eventTarget) {
+      return;
+    }
+    eventTarget.addEventListener("offline", this.browserOfflineHandler);
+    eventTarget.addEventListener("online", this.browserOnlineHandler);
+    this.browserNetworkListenersAttached = true;
+  }
+  detachBrowserNetworkListeners() {
+    if (!this.browserNetworkListenersAttached) {
+      return;
+    }
+    const eventTarget = typeof globalThis !== "undefined" && typeof globalThis.removeEventListener === "function" ? globalThis : null;
+    if (!eventTarget) {
+      return;
+    }
+    eventTarget.removeEventListener("offline", this.browserOfflineHandler);
+    eventTarget.removeEventListener("online", this.browserOnlineHandler);
+    this.browserNetworkListenersAttached = false;
+  }
   scheduleReconnect() {
     const attempt = this.reconnectAttempts + 1;
     const baseDelay = this.options.reconnectBaseDelay * Math.pow(2, this.reconnectAttempts);
@@ -3598,11 +2380,19 @@ var RoomClient = class _RoomClient {
   }
   startHeartbeat() {
     this.stopHeartbeat();
+    this.lastHeartbeatAckAt = Date.now();
     this.heartbeatTimer = setInterval(() => {
       if (this.ws && this.connected) {
+        if (Date.now() - this.lastHeartbeatAckAt > this.options.heartbeatStaleTimeoutMs) {
+          try {
+            this.ws.close();
+          } catch {
+          }
+          return;
+        }
         this.ws.send(JSON.stringify({ type: "ping" }));
       }
-    }, 3e4);
+    }, this.options.heartbeatIntervalMs);
   }
   stopHeartbeat() {
     if (this.heartbeatTimer) {
@@ -3610,6 +2400,12 @@ var RoomClient = class _RoomClient {
       this.heartbeatTimer = null;
     }
   }
+  getReconnectMemberState() {
+    if (!this.lastLocalMemberState) {
+      return void 0;
+    }
+    return cloneRecord(this.lastLocalMemberState);
+  }
 };
 var PushClient = class {
   constructor(http, storage, core) {