@edge-base/web 0.2.4 → 0.2.6

package/dist/room-p2p-media.js

@@ -1,9 +1,18 @@
+import { EdgeBaseError } from '@edge-base/core';
 import { createSubscription } from './room.js';
 const DEFAULT_SIGNAL_PREFIX = 'edgebase.media.p2p';
 const DEFAULT_ICE_SERVERS = [
     { urls: 'stun:stun.l.google.com:19302' },
 ];
 const DEFAULT_MEMBER_READY_TIMEOUT_MS = 10_000;
+const DEFAULT_MISSING_MEDIA_GRACE_MS = 1_200;
+const DEFAULT_DISCONNECTED_RECOVERY_DELAY_MS = 1_800;
+const DEFAULT_MAX_RECOVERY_ATTEMPTS = 2;
+const DEFAULT_ICE_BATCH_DELAY_MS = 40;
+const DEFAULT_RATE_LIMIT_RETRY_DELAYS_MS = [160, 320, 640];
+const DEFAULT_MEDIA_HEALTH_CHECK_INTERVAL_MS = 4_000;
+const DEFAULT_VIDEO_FLOW_GRACE_MS = 8_000;
+const DEFAULT_VIDEO_FLOW_STALL_GRACE_MS = 12_000;
 function buildTrackKey(memberId, trackId) {
     return `${memberId}:${trackId}`;
 }
@@ -29,6 +38,70 @@ function serializeCandidate(candidate) {
     }
     return candidate;
 }
+function normalizeIceServerUrls(urls) {
+    if (Array.isArray(urls)) {
+        return urls.filter((value) => typeof value === 'string' && value.trim().length > 0);
+    }
+    if (typeof urls === 'string' && urls.trim().length > 0) {
+        return [urls];
+    }
+    return [];
+}
+function normalizeIceServers(iceServers) {
+    if (!Array.isArray(iceServers)) {
+        return [];
+    }
+    const normalized = [];
+    for (const server of iceServers) {
+        const urls = normalizeIceServerUrls(server?.urls);
+        if (urls.length === 0) {
+            continue;
+        }
+        normalized.push({
+            urls: urls.length === 1 ? urls[0] : urls,
+            username: typeof server.username === 'string' ? server.username : undefined,
+            credential: typeof server.credential === 'string' ? server.credential : undefined,
+        });
+    }
+    return normalized;
+}
+function getPublishedKindsFromState(state) {
+    if (!state) {
+        return [];
+    }
+    const publishedKinds = [];
+    if (state.audio?.published)
+        publishedKinds.push('audio');
+    if (state.video?.published)
+        publishedKinds.push('video');
+    if (state.screen?.published)
+        publishedKinds.push('screen');
+    return publishedKinds;
+}
+function isStableAnswerError(error) {
+    const message = typeof error === 'object' && error && 'message' in error
+        ? String(error.message ?? '')
+        : '';
+    return (message.includes('Called in wrong state: stable')
+        || message.includes('Failed to set remote answer sdp')
+        || (message.includes('setRemoteDescription') && message.includes('stable')));
+}
+function isRateLimitError(error) {
+    const message = typeof error === 'object' && error && 'message' in error
+        ? String(error.message ?? '')
+        : String(error ?? '');
+    return message.toLowerCase().includes('rate limited');
+}
+function sameIceServer(candidate, urls) {
+    const candidateUrls = normalizeIceServerUrls(candidate.urls);
+    return candidateUrls.length === urls.length && candidateUrls.every((url, index) => url === urls[index]);
+}
+function getErrorMessage(error) {
+    if (error instanceof Error && typeof error.message === 'string' && error.message.length > 0) {
+        return error.message;
+    }
+    return 'Unknown room media error.';
+}
 export class RoomP2PMediaTransport {
     room;
     options;
@@ -38,9 +111,15 @@ export class RoomP2PMediaTransport {
     remoteTrackKinds = new Map();
     emittedRemoteTracks = new Set();
     pendingRemoteTracks = new Map();
+    pendingIceCandidates = new Map();
     subscriptions = [];
     localMemberId = null;
     connected = false;
+    iceServersResolved = false;
+    localUpdateBatchDepth = 0;
+    syncAllPeerSendersScheduled = false;
+    syncAllPeerSendersPending = false;
+    healthCheckTimer = null;
     constructor(room, options) {
         this.room = room;
         this.options = {
@@ -55,6 +134,13 @@ export class RoomP2PMediaTransport {
             mediaDevices: options?.mediaDevices
                 ?? (typeof navigator !== 'undefined' ? navigator.mediaDevices : undefined),
             signalPrefix: options?.signalPrefix ?? DEFAULT_SIGNAL_PREFIX,
+            turnCredentialTtlSeconds: options?.turnCredentialTtlSeconds ?? 3600,
+            missingMediaGraceMs: options?.missingMediaGraceMs ?? DEFAULT_MISSING_MEDIA_GRACE_MS,
+            disconnectedRecoveryDelayMs: options?.disconnectedRecoveryDelayMs ?? DEFAULT_DISCONNECTED_RECOVERY_DELAY_MS,
+            maxRecoveryAttempts: options?.maxRecoveryAttempts ?? DEFAULT_MAX_RECOVERY_ATTEMPTS,
+            mediaHealthCheckIntervalMs: options?.mediaHealthCheckIntervalMs ?? DEFAULT_MEDIA_HEALTH_CHECK_INTERVAL_MS,
+            videoFlowGraceMs: options?.videoFlowGraceMs ?? DEFAULT_VIDEO_FLOW_GRACE_MS,
+            videoFlowStallGraceMs: options?.videoFlowStallGraceMs ?? DEFAULT_VIDEO_FLOW_STALL_GRACE_MS,
         };
     }
     getSessionId() {
@@ -73,14 +159,27 @@ export class RoomP2PMediaTransport {
         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.');
         }
+        const capabilities = await this.collectCapabilities({ includeProviderChecks: false });
+        const fatalIssue = capabilities.issues.find((issue) => issue.fatal);
+        if (fatalIssue) {
+            const error = new EdgeBaseError(400, fatalIssue.message, { preflight: { code: fatalIssue.code, message: fatalIssue.message } }, 'room-media-preflight-failed');
+            Object.assign(error, {
+                provider: capabilities.provider,
+                issue: fatalIssue,
+                capabilities,
+            });
+            throw error;
+        }
         const currentMember = await this.waitForCurrentMember();
         if (!currentMember) {
             throw new Error('Join the room before connecting a P2P media transport.');
         }
         this.localMemberId = currentMember.memberId;
+        await this.resolveRtcConfiguration();
         this.connected = true;
         this.hydrateRemoteTrackKinds();
         this.attachRoomSubscriptions();
+        this.startHealthChecks();
         try {
             for (const member of this.room.members.list()) {
                 if (member.memberId !== this.localMemberId) {
@@ -94,6 +193,124 @@ export class RoomP2PMediaTransport {
         }
         return this.localMemberId;
     }
+    async getCapabilities() {
+        return this.collectCapabilities({ includeProviderChecks: true });
+    }
+    async collectCapabilities(options) {
+        const issues = [];
+        const currentMember = this.room.members.current();
+        const roomIssueFatal = !currentMember;
+        let room = {
+            ok: true,
+            type: 'room_connect_ready',
+            category: 'ready',
+            message: 'Room WebSocket preflight passed',
+        };
+        if (typeof this.room.checkConnection === 'function') {
+            try {
+                room = await this.room.checkConnection();
+            }
+            catch (error) {
+                issues.push({
+                    code: 'room_connect_check_failed',
+                    category: 'room',
+                    message: `Room connect-check failed: ${getErrorMessage(error)}`,
+                    fatal: roomIssueFatal,
+                });
+            }
+        }
+        if (!room.ok) {
+            issues.push({
+                code: room.type,
+                category: 'room',
+                message: room.message,
+                fatal: roomIssueFatal,
+            });
+        }
+        if (!currentMember) {
+            issues.push({
+                code: 'room_member_not_joined',
+                category: 'room',
+                message: 'Join the room before connecting a P2P media transport.',
+                fatal: true,
+            });
+        }
+        const browser = {
+            mediaDevices: !!this.options.mediaDevices,
+            getUserMedia: typeof this.options.mediaDevices?.getUserMedia === 'function',
+            getDisplayMedia: typeof this.options.mediaDevices?.getDisplayMedia === 'function',
+            enumerateDevices: typeof this.options.mediaDevices?.enumerateDevices === 'function',
+            rtcPeerConnection: typeof this.options.peerConnectionFactory === 'function'
+                || typeof RTCPeerConnection !== 'undefined',
+        };
+        if (!browser.rtcPeerConnection) {
+            issues.push({
+                code: 'webrtc_unavailable',
+                category: 'browser',
+                message: 'RTCPeerConnection is not available in this environment.',
+                fatal: true,
+            });
+        }
+        if (!browser.getUserMedia) {
+            issues.push({
+                code: 'media_devices_get_user_media_unavailable',
+                category: 'browser',
+                message: 'getUserMedia() is not available; local audio/video capture will be unavailable.',
+                fatal: false,
+            });
+        }
+        if (!browser.getDisplayMedia) {
+            issues.push({
+                code: 'media_devices_get_display_media_unavailable',
+                category: 'browser',
+                message: 'getDisplayMedia() is not available; screen sharing will be unavailable.',
+                fatal: false,
+            });
+        }
+        let turn;
+        const loadIceServers = this.room.media.realtime?.iceServers;
+        if (options.includeProviderChecks && typeof loadIceServers === 'function') {
+            turn = {
+                requested: true,
+                available: false,
+                iceServerCount: 0,
+            };
+            try {
+                const response = await loadIceServers({ ttl: this.options.turnCredentialTtlSeconds });
+                const servers = normalizeIceServers(response?.iceServers);
+                turn.available = servers.length > 0;
+                turn.iceServerCount = servers.length;
+                if (!turn.available) {
+                    issues.push({
+                        code: 'turn_credentials_unavailable',
+                        category: 'provider',
+                        message: 'No TURN credentials were returned; the transport will fall back to its configured ICE servers.',
+                        fatal: false,
+                    });
+                }
+            }
+            catch (error) {
+                turn.error = getErrorMessage(error);
+                issues.push({
+                    code: 'turn_credentials_failed',
+                    category: 'provider',
+                    message: `Failed to resolve TURN credentials: ${turn.error}`,
+                    fatal: false,
+                });
+            }
+        }
+        return {
+            provider: 'p2p',
+            canConnect: !issues.some((issue) => issue.fatal),
+            issues,
+            room,
+            joined: !!currentMember,
+            currentMemberId: currentMember?.memberId ?? null,
+            sessionId: this.getSessionId(),
+            browser,
+            turn,
+        };
+    }
     async waitForCurrentMember(timeoutMs = DEFAULT_MEMBER_READY_TIMEOUT_MS) {
         const startedAt = Date.now();
         while (Date.now() - startedAt < timeoutMs) {
@@ -105,6 +322,39 @@ export class RoomP2PMediaTransport {
         }
         return this.room.members.current();
     }
+    async resolveRtcConfiguration() {
+        if (this.iceServersResolved) {
+            return;
+        }
+        const loadIceServers = this.room.media.realtime?.iceServers;
+        if (typeof loadIceServers !== 'function') {
+            this.iceServersResolved = true;
+            return;
+        }
+        try {
+            const response = await loadIceServers({ ttl: this.options.turnCredentialTtlSeconds });
+            const realtimeIceServers = normalizeIceServers(response?.iceServers);
+            if (realtimeIceServers.length === 0) {
+                return;
+            }
+            const fallbackIceServers = normalizeIceServers(DEFAULT_ICE_SERVERS);
+            const mergedIceServers = [
+                ...realtimeIceServers,
+                ...fallbackIceServers.filter((server) => {
+                    const urls = normalizeIceServerUrls(server.urls);
+                    return !realtimeIceServers.some((candidate) => sameIceServer(candidate, urls));
+                }),
+            ];
+            this.options.rtcConfiguration = {
+                ...this.options.rtcConfiguration,
+                iceServers: mergedIceServers,
+            };
+            this.iceServersResolved = true;
+        }
+        catch (error) {
+            console.warn('[RoomP2PMediaTransport] Failed to load TURN / ICE credentials. Falling back to default STUN.', error);
+        }
+    }
     async enableAudio(constraints = true) {
         const track = await this.createUserMediaTrack('audio', constraints);
         if (!track) {
@@ -112,12 +362,12 @@ export class RoomP2PMediaTransport {
         }
         const providerSessionId = await this.ensureConnectedMemberId();
         this.rememberLocalTrack('audio', track, track.getSettings().deviceId, true);
-        await this.room.media.audio.enable?.({
+        await this.withRateLimitRetry('enable audio', () => this.room.media.audio.enable?.({
             trackId: track.id,
             deviceId: track.getSettings().deviceId,
             providerSessionId,
-        });
-        this.syncAllPeerSenders();
+        }) ?? Promise.resolve());
+        this.requestSyncAllPeerSenders();
         return track;
     }
     async enableVideo(constraints = true) {
@@ -127,12 +377,12 @@ export class RoomP2PMediaTransport {
         }
         const providerSessionId = await this.ensureConnectedMemberId();
         this.rememberLocalTrack('video', track, track.getSettings().deviceId, true);
-        await this.room.media.video.enable?.({
+        await this.withRateLimitRetry('enable video', () => this.room.media.video.enable?.({
             trackId: track.id,
             deviceId: track.getSettings().deviceId,
             providerSessionId,
-        });
-        this.syncAllPeerSenders();
+        }) ?? Promise.resolve());
+        this.requestSyncAllPeerSenders();
         return track;
     }
     async startScreenShare(constraints = { video: true, audio: false }) {
@@ -150,28 +400,28 @@ export class RoomP2PMediaTransport {
         }, { once: true });
         const providerSessionId = await this.ensureConnectedMemberId();
         this.rememberLocalTrack('screen', track, track.getSettings().deviceId, true);
-        await this.room.media.screen.start?.({
+        await this.withRateLimitRetry('start screen share', () => this.room.media.screen.start?.({
             trackId: track.id,
             deviceId: track.getSettings().deviceId,
             providerSessionId,
-        });
-        this.syncAllPeerSenders();
+        }) ?? Promise.resolve());
+        this.requestSyncAllPeerSenders();
         return track;
     }
     async disableAudio() {
         this.releaseLocalTrack('audio');
-        this.syncAllPeerSenders();
-        await this.room.media.audio.disable();
+        this.requestSyncAllPeerSenders();
+        await this.withRateLimitRetry('disable audio', () => this.room.media.audio.disable());
     }
     async disableVideo() {
         this.releaseLocalTrack('video');
-        this.syncAllPeerSenders();
-        await this.room.media.video.disable();
+        this.requestSyncAllPeerSenders();
+        await this.withRateLimitRetry('disable video', () => this.room.media.video.disable());
     }
     async stopScreenShare() {
         this.releaseLocalTrack('screen');
-        this.syncAllPeerSenders();
-        await this.room.media.screen.stop();
+        this.requestSyncAllPeerSenders();
+        await this.withRateLimitRetry('stop screen share', () => this.room.media.screen.stop());
     }
     async setMuted(kind, muted) {
         const localTrack = this.localTracks.get(kind)?.track;
@@ -179,10 +429,23 @@ export class RoomP2PMediaTransport {
             localTrack.enabled = !muted;
         }
         if (kind === 'audio') {
-            await this.room.media.audio.setMuted?.(muted);
+            await this.withRateLimitRetry('set audio muted', () => this.room.media.audio.setMuted?.(muted) ?? Promise.resolve());
         }
         else {
-            await this.room.media.video.setMuted?.(muted);
+            await this.withRateLimitRetry('set video muted', () => this.room.media.video.setMuted?.(muted) ?? Promise.resolve());
+        }
+    }
+    async batchLocalUpdates(callback) {
+        this.localUpdateBatchDepth += 1;
+        try {
+            return await callback();
+        }
+        finally {
+            this.localUpdateBatchDepth = Math.max(0, this.localUpdateBatchDepth - 1);
+            if (this.localUpdateBatchDepth === 0 && this.syncAllPeerSendersPending) {
+                this.syncAllPeerSendersPending = false;
+                this.requestSyncAllPeerSenders();
+            }
         }
     }
     async switchDevices(payload) {
@@ -213,6 +476,10 @@ export class RoomP2PMediaTransport {
     destroy() {
         this.connected = false;
         this.localMemberId = null;
+        if (this.healthCheckTimer != null) {
+            globalThis.clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
         for (const subscription of this.subscriptions.splice(0)) {
             subscription.unsubscribe();
         }
@@ -223,6 +490,12 @@ export class RoomP2PMediaTransport {
         for (const kind of Array.from(this.localTracks.keys())) {
             this.releaseLocalTrack(kind);
         }
+        for (const pending of this.pendingIceCandidates.values()) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+        }
+        this.pendingIceCandidates.clear();
         this.remoteTrackKinds.clear();
         this.emittedRemoteTracks.clear();
         this.pendingRemoteTracks.clear();
@@ -234,6 +507,7 @@ export class RoomP2PMediaTransport {
         this.subscriptions.push(this.room.members.onJoin((member) => {
             if (member.memberId !== this.localMemberId) {
                 this.ensurePeer(member.memberId);
+                this.schedulePeerRecoveryCheck(member.memberId, 'member-join');
             }
         }), this.room.members.onSync((members) => {
             const activeMemberIds = new Set();
@@ -241,6 +515,7 @@ export class RoomP2PMediaTransport {
                 if (member.memberId !== this.localMemberId) {
                     activeMemberIds.add(member.memberId);
                     this.ensurePeer(member.memberId);
+                    this.schedulePeerRecoveryCheck(member.memberId, 'member-sync');
                 }
             }
             for (const memberId of Array.from(this.peers.keys())) {
@@ -259,6 +534,7 @@ export class RoomP2PMediaTransport {
         }), this.room.media.onTrack((track, member) => {
             if (member.memberId !== this.localMemberId) {
                 this.ensurePeer(member.memberId);
+                this.schedulePeerRecoveryCheck(member.memberId, 'media-track');
             }
             this.rememberRemoteTrackKind(track, member);
         }), this.room.media.onTrackRemoved((track, member) => {
@@ -268,7 +544,17 @@ export class RoomP2PMediaTransport {
             this.remoteTrackKinds.delete(key);
             this.emittedRemoteTracks.delete(key);
             this.pendingRemoteTracks.delete(key);
+            this.schedulePeerRecoveryCheck(member.memberId, 'media-track-removed');
         }));
+        if (typeof this.room.media.onStateChange === 'function') {
+            this.subscriptions.push(this.room.media.onStateChange((member, state) => {
+                if (member.memberId === this.localMemberId) {
+                    return;
+                }
+                this.rememberRemoteTrackKindsFromState(member, state);
+                this.schedulePeerRecoveryCheck(member.memberId, 'media-state');
+            }));
+        }
     }
     hydrateRemoteTrackKinds() {
         this.remoteTrackKinds.clear();
@@ -278,6 +564,32 @@ export class RoomP2PMediaTransport {
             for (const track of mediaMember.tracks) {
                 this.rememberRemoteTrackKind(track, mediaMember.member);
             }
+            this.rememberRemoteTrackKindsFromState(mediaMember.member, mediaMember.state);
+        }
+    }
+    rememberRemoteTrackKindsFromState(member, state) {
+        if (member.memberId === this.localMemberId || !state) {
+            return;
+        }
+        const mediaKinds = ['audio', 'video', 'screen'];
+        for (const kind of mediaKinds) {
+            const kindState = state[kind];
+            if (!kindState?.published) {
+                continue;
+            }
+            if (typeof kindState.trackId === 'string' && kindState.trackId) {
+                this.rememberRemoteTrackKind({
+                    kind,
+                    trackId: kindState.trackId,
+                    muted: kindState.muted === true,
+                    deviceId: kindState.deviceId,
+                    publishedAt: kindState.publishedAt,
+                    adminDisabled: kindState.adminDisabled,
+                    providerSessionId: kindState.providerSessionId,
+                }, member);
+                continue;
+            }
+            this.flushPendingRemoteTracks(member.memberId, kind);
         }
     }
     rememberRemoteTrackKind(track, member) {
@@ -310,17 +622,32 @@ export class RoomP2PMediaTransport {
             isSettingRemoteAnswerPending: false,
             pendingCandidates: [],
             senders: new Map(),
+            pendingNegotiation: false,
+            recoveryAttempts: 0,
+            recoveryTimer: null,
+            healthCheckInFlight: false,
+            remoteVideoFlows: new Map(),
         };
         pc.onicecandidate = (event) => {
-            if (!event.candidate)
+            if (!event.candidate) {
+                void this.flushPendingIceCandidates(memberId);
                 return;
-            void this.room.signals.sendTo(memberId, this.iceEvent, {
-                candidate: serializeCandidate(event.candidate),
-            });
+            }
+            this.queueIceCandidate(memberId, serializeCandidate(event.candidate));
         };
         pc.onnegotiationneeded = () => {
             void this.negotiatePeer(peer);
         };
+        pc.onsignalingstatechange = () => {
+            this.maybeRetryPendingNegotiation(peer);
+        };
+        pc.oniceconnectionstatechange = () => {
+            this.handlePeerConnectivityChange(peer, 'ice');
+        };
+        pc.onconnectionstatechange = () => {
+            this.handlePeerConnectivityChange(peer, 'connection');
+            this.maybeRetryPendingNegotiation(peer);
+        };
         pc.ontrack = (event) => {
             const stream = event.streams[0] ?? new MediaStream([event.track]);
             const key = buildTrackKey(memberId, event.track.id);
@@ -332,26 +659,33 @@ export class RoomP2PMediaTransport {
                 return;
             }
             this.emitRemoteTrack(memberId, event.track, stream, kind);
+            this.registerPeerRemoteTrack(peer, event.track, kind);
+            this.resetPeerRecovery(peer);
         };
         this.peers.set(memberId, peer);
         this.syncPeerSenders(peer);
+        this.schedulePeerRecoveryCheck(memberId, 'peer-created');
         return peer;
     }
     async negotiatePeer(peer) {
         if (!this.connected
-            || peer.pc.connectionState === 'closed'
-            || peer.makingOffer
+            || peer.pc.connectionState === 'closed') {
+            return;
+        }
+        if (peer.makingOffer
             || peer.isSettingRemoteAnswerPending
             || peer.pc.signalingState !== 'stable') {
+            peer.pendingNegotiation = true;
             return;
         }
         try {
+            peer.pendingNegotiation = false;
             peer.makingOffer = true;
             await peer.pc.setLocalDescription();
             if (!peer.pc.localDescription) {
                 return;
             }
-            await this.room.signals.sendTo(peer.memberId, this.offerEvent, {
+            await this.sendSignalWithRetry(peer.memberId, this.offerEvent, {
                 description: serializeDescription(peer.pc.localDescription),
             });
         }
@@ -383,6 +717,17 @@ export class RoomP2PMediaTransport {
             return;
         }
         try {
+            if (description.type === 'answer'
+                && peer.pc.signalingState === 'stable'
+                && !peer.isSettingRemoteAnswerPending) {
+                return;
+            }
+            if (description.type === 'offer'
+                && offerCollision
+                && peer.polite
+                && peer.pc.signalingState !== 'stable') {
+                await peer.pc.setLocalDescription({ type: 'rollback' });
+            }
             peer.isSettingRemoteAnswerPending = description.type === 'answer';
             await peer.pc.setRemoteDescription(description);
             peer.isSettingRemoteAnswerPending = false;
@@ -393,12 +738,15 @@ export class RoomP2PMediaTransport {
                 if (!peer.pc.localDescription) {
                     return;
                 }
-                await this.room.signals.sendTo(senderId, this.answerEvent, {
+                await this.sendSignalWithRetry(senderId, this.answerEvent, {
                     description: serializeDescription(peer.pc.localDescription),
                 });
             }
         }
         catch (error) {
+            if (description.type === 'answer' && peer.pc.signalingState === 'stable' && isStableAnswerError(error)) {
+                return;
+            }
             console.warn('[RoomP2PMediaTransport] Failed to apply remote session description.', {
                 memberId: senderId,
                 expectedType,
@@ -407,31 +755,36 @@ export class RoomP2PMediaTransport {
             });
             peer.isSettingRemoteAnswerPending = false;
         }
+        finally {
+            this.maybeRetryPendingNegotiation(peer);
+        }
     }
     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) {
+        const candidates = this.normalizeCandidates(payload);
+        if (candidates.length === 0) {
             return;
         }
         const peer = this.ensurePeer(senderId);
         if (!peer.pc.remoteDescription) {
-            peer.pendingCandidates.push(candidate);
+            peer.pendingCandidates.push(...candidates);
             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);
+        for (const candidate of candidates) {
+            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);
+                }
             }
         }
     }
@@ -456,6 +809,72 @@ export class RoomP2PMediaTransport {
             }
         }
     }
+    queueIceCandidate(memberId, candidate) {
+        let pending = this.pendingIceCandidates.get(memberId);
+        if (!pending) {
+            pending = {
+                candidates: [],
+                timer: null,
+                flushing: false,
+            };
+            this.pendingIceCandidates.set(memberId, pending);
+        }
+        pending.candidates.push(candidate);
+        if (pending.timer || pending.flushing) {
+            return;
+        }
+        pending.timer = globalThis.setTimeout(() => {
+            pending.timer = null;
+            void this.flushPendingIceCandidates(memberId);
+        }, DEFAULT_ICE_BATCH_DELAY_MS);
+    }
+    async flushPendingIceCandidates(memberId) {
+        const pending = this.pendingIceCandidates.get(memberId);
+        if (!pending || pending.flushing) {
+            return;
+        }
+        if (pending.timer) {
+            clearTimeout(pending.timer);
+            pending.timer = null;
+        }
+        if (pending.candidates.length === 0) {
+            this.pendingIceCandidates.delete(memberId);
+            return;
+        }
+        const batch = pending.candidates.splice(0);
+        pending.flushing = true;
+        try {
+            await this.sendSignalWithRetry(memberId, this.iceEvent, { candidates: batch });
+        }
+        finally {
+            pending.flushing = false;
+            if (pending.candidates.length > 0) {
+                pending.timer = globalThis.setTimeout(() => {
+                    pending.timer = null;
+                    void this.flushPendingIceCandidates(memberId);
+                }, 0);
+            }
+            else {
+                this.pendingIceCandidates.delete(memberId);
+            }
+        }
+    }
+    requestSyncAllPeerSenders() {
+        if (this.localUpdateBatchDepth > 0) {
+            this.syncAllPeerSendersPending = true;
+            return;
+        }
+        if (this.syncAllPeerSendersScheduled) {
+            this.syncAllPeerSendersPending = true;
+            return;
+        }
+        this.syncAllPeerSendersScheduled = true;
+        queueMicrotask(() => {
+            this.syncAllPeerSendersScheduled = false;
+            this.syncAllPeerSendersPending = false;
+            this.syncAllPeerSenders();
+        });
+    }
     syncAllPeerSenders() {
         for (const peer of this.peers.values()) {
             this.syncPeerSenders(peer);
@@ -515,6 +934,15 @@ export class RoomP2PMediaTransport {
         for (const handler of this.remoteTrackHandlers) {
             handler(payload);
         }
+        const peer = this.peers.get(memberId);
+        if (peer) {
+            if (!this.hasMissingPublishedMedia(memberId)) {
+                this.resetPeerRecovery(peer);
+            }
+            else {
+                this.schedulePeerRecoveryCheck(memberId, 'partial-remote-track');
+            }
+        }
     }
     resolveFallbackRemoteTrackKind(memberId, track) {
         const normalizedKind = normalizeTrackKind(track);
@@ -548,6 +976,11 @@ export class RoomP2PMediaTransport {
                 publishedKinds.add(track.kind);
             }
         }
+        for (const kind of getPublishedKindsFromState(mediaMember.state)) {
+            if (kind === 'video' || kind === 'screen') {
+                publishedKinds.add(kind);
+            }
+        }
         return Array.from(publishedKinds);
     }
     getNextUnassignedPublishedVideoLikeKind(memberId) {
@@ -598,6 +1031,10 @@ export class RoomP2PMediaTransport {
     rollbackConnectedState() {
         this.connected = false;
         this.localMemberId = null;
+        if (this.healthCheckTimer != null) {
+            globalThis.clearInterval(this.healthCheckTimer);
+            this.healthCheckTimer = null;
+        }
         for (const subscription of this.subscriptions.splice(0)) {
             subscription.unsubscribe();
         }
@@ -605,13 +1042,27 @@ export class RoomP2PMediaTransport {
             this.destroyPeer(peer);
         }
         this.peers.clear();
+        for (const pending of this.pendingIceCandidates.values()) {
+            if (pending.timer) {
+                clearTimeout(pending.timer);
+            }
+        }
+        this.pendingIceCandidates.clear();
         this.remoteTrackKinds.clear();
         this.emittedRemoteTracks.clear();
         this.pendingRemoteTracks.clear();
     }
     destroyPeer(peer) {
+        this.clearPeerRecoveryTimer(peer);
+        for (const flow of peer.remoteVideoFlows.values()) {
+            flow.cleanup();
+        }
+        peer.remoteVideoFlows.clear();
         peer.pc.onicecandidate = null;
         peer.pc.onnegotiationneeded = null;
+        peer.pc.onsignalingstatechange = null;
+        peer.pc.oniceconnectionstatechange = null;
+        peer.pc.onconnectionstatechange = null;
         peer.pc.ontrack = null;
         try {
             peer.pc.close();
@@ -620,6 +1071,147 @@ export class RoomP2PMediaTransport {
             // Ignore duplicate closes.
         }
     }
+    startHealthChecks() {
+        if (this.healthCheckTimer != null) {
+            return;
+        }
+        this.healthCheckTimer = globalThis.setInterval(() => {
+            void this.runHealthChecks();
+        }, this.options.mediaHealthCheckIntervalMs);
+    }
+    async runHealthChecks() {
+        if (!this.connected) {
+            return;
+        }
+        for (const peer of this.peers.values()) {
+            if (peer.healthCheckInFlight || peer.pc.connectionState === 'closed') {
+                continue;
+            }
+            peer.healthCheckInFlight = true;
+            try {
+                const issue = await this.inspectPeerVideoHealth(peer);
+                if (issue) {
+                    this.schedulePeerRecoveryCheck(peer.memberId, issue, 0);
+                }
+            }
+            finally {
+                peer.healthCheckInFlight = false;
+            }
+        }
+    }
+    registerPeerRemoteTrack(peer, track, kind) {
+        if (kind !== 'video' && kind !== 'screen') {
+            return;
+        }
+        if (peer.remoteVideoFlows.has(track.id)) {
+            return;
+        }
+        const flow = {
+            track,
+            receivedAt: Date.now(),
+            lastHealthyAt: track.muted ? 0 : Date.now(),
+            lastBytesReceived: null,
+            lastFramesDecoded: null,
+            cleanup: () => { },
+        };
+        const markHealthy = () => {
+            flow.lastHealthyAt = Date.now();
+        };
+        const handleEnded = () => {
+            flow.cleanup();
+            peer.remoteVideoFlows.delete(track.id);
+        };
+        track.addEventListener('unmute', markHealthy);
+        track.addEventListener('ended', handleEnded);
+        flow.cleanup = () => {
+            track.removeEventListener('unmute', markHealthy);
+            track.removeEventListener('ended', handleEnded);
+        };
+        peer.remoteVideoFlows.set(track.id, flow);
+    }
+    async inspectPeerVideoHealth(peer) {
+        if (this.hasMissingPublishedMedia(peer.memberId)) {
+            return 'health-missing-published-media';
+        }
+        const mediaMember = this.room.media.list().find((entry) => entry.member.memberId === peer.memberId);
+        const publishedVideoState = mediaMember?.state?.video;
+        const publishedScreenState = mediaMember?.state?.screen;
+        const publishedAt = Math.max(publishedVideoState?.publishedAt ?? 0, publishedScreenState?.publishedAt ?? 0);
+        const expectsVideoFlow = Boolean(publishedVideoState?.published
+            || publishedScreenState?.published
+            || mediaMember?.tracks.some((track) => (track.kind === 'video' || track.kind === 'screen') && track.trackId));
+        if (!expectsVideoFlow) {
+            return null;
+        }
+        const videoReceivers = peer.pc
+            .getReceivers()
+            .filter((receiver) => receiver.track?.kind === 'video');
+        if (videoReceivers.length === 0) {
+            const firstObservedAt = Math.max(publishedAt, ...Array.from(peer.remoteVideoFlows.values()).map((flow) => flow.receivedAt));
+            if (firstObservedAt > 0 && Date.now() - firstObservedAt > this.options.videoFlowGraceMs) {
+                return 'health-no-video-receiver';
+            }
+            return null;
+        }
+        let sawHealthyFlow = false;
+        let lastObservedAt = publishedAt;
+        for (const receiver of videoReceivers) {
+            const track = receiver.track;
+            if (!track) {
+                continue;
+            }
+            const flow = peer.remoteVideoFlows.get(track.id);
+            if (!flow) {
+                continue;
+            }
+            lastObservedAt = Math.max(lastObservedAt, flow.receivedAt, flow.lastHealthyAt);
+            if (!track.muted) {
+                flow.lastHealthyAt = Math.max(flow.lastHealthyAt, Date.now());
+            }
+            try {
+                const stats = await receiver.getStats();
+                for (const report of stats.values()) {
+                    if (report.type !== 'inbound-rtp' || report.kind !== 'video') {
+                        continue;
+                    }
+                    const bytesReceived = typeof report.bytesReceived === 'number' ? report.bytesReceived : null;
+                    const framesDecoded = typeof report.framesDecoded === 'number' ? report.framesDecoded : null;
+                    const bytesIncreased = bytesReceived != null
+                        && flow.lastBytesReceived != null
+                        && bytesReceived > flow.lastBytesReceived;
+                    const framesIncreased = framesDecoded != null
+                        && flow.lastFramesDecoded != null
+                        && framesDecoded > flow.lastFramesDecoded;
+                    if ((bytesReceived != null && bytesReceived > 0) || (framesDecoded != null && framesDecoded > 0)) {
+                        flow.lastHealthyAt = Math.max(flow.lastHealthyAt, Date.now());
+                    }
+                    if (bytesIncreased || framesIncreased) {
+                        flow.lastHealthyAt = Date.now();
+                    }
+                    flow.lastBytesReceived = bytesReceived;
+                    flow.lastFramesDecoded = framesDecoded;
+                    break;
+                }
+            }
+            catch {
+                // Ignore stats read failures and rely on track state.
+            }
+            if (flow.lastHealthyAt > 0) {
+                sawHealthyFlow = true;
+            }
+            lastObservedAt = Math.max(lastObservedAt, flow.lastHealthyAt);
+        }
+        if (sawHealthyFlow) {
+            return null;
+        }
+        if (lastObservedAt > 0 && Date.now() - lastObservedAt > this.options.videoFlowStallGraceMs) {
+            return 'health-stalled-video-flow';
+        }
+        if (publishedAt > 0 && Date.now() - publishedAt > this.options.videoFlowGraceMs) {
+            return 'health-video-flow-timeout';
+        }
+        return null;
+    }
     async createUserMediaTrack(kind, constraints) {
         const devices = this.options.mediaDevices;
         if (!devices?.getUserMedia || constraints === false) {
@@ -667,15 +1259,44 @@ export class RoomP2PMediaTransport {
             sdp: typeof raw.sdp === 'string' ? raw.sdp : undefined,
         };
     }
-    normalizeCandidate(payload) {
+    normalizeCandidates(payload) {
         if (!payload || typeof payload !== 'object') {
-            return null;
+            return [];
+        }
+        const batch = payload.candidates;
+        if (Array.isArray(batch)) {
+            return batch.filter((candidate) => !!candidate && typeof candidate.candidate === 'string');
         }
         const raw = payload.candidate;
         if (!raw || typeof raw.candidate !== 'string') {
-            return null;
+            return [];
+        }
+        return [raw];
+    }
+    async sendSignalWithRetry(memberId, event, payload) {
+        await this.withRateLimitRetry(`signal ${event}`, () => this.room.signals.sendTo(memberId, event, payload));
+    }
+    async withRateLimitRetry(label, action) {
+        let lastError;
+        for (let attempt = 0; attempt <= DEFAULT_RATE_LIMIT_RETRY_DELAYS_MS.length; attempt += 1) {
+            try {
+                return await action();
+            }
+            catch (error) {
+                lastError = error;
+                if (!isRateLimitError(error) || attempt === DEFAULT_RATE_LIMIT_RETRY_DELAYS_MS.length) {
+                    throw error;
+                }
+                const delayMs = DEFAULT_RATE_LIMIT_RETRY_DELAYS_MS[attempt];
+                console.warn('[RoomP2PMediaTransport] Rate limited room operation. Retrying.', {
+                    label,
+                    attempt: attempt + 1,
+                    delayMs,
+                });
+                await new Promise((resolve) => globalThis.setTimeout(resolve, delayMs));
+            }
         }
-        return raw;
+        throw lastError;
     }
     get offerEvent() {
         return `${this.options.signalPrefix}.offer`;
@@ -686,5 +1307,169 @@ export class RoomP2PMediaTransport {
     get iceEvent() {
         return `${this.options.signalPrefix}.ice`;
     }
+    maybeRetryPendingNegotiation(peer) {
+        if (!peer.pendingNegotiation
+            || !this.connected
+            || peer.pc.connectionState === 'closed'
+            || peer.makingOffer
+            || peer.isSettingRemoteAnswerPending
+            || peer.pc.signalingState !== 'stable') {
+            return;
+        }
+        peer.pendingNegotiation = false;
+        queueMicrotask(() => {
+            void this.negotiatePeer(peer);
+        });
+    }
+    handlePeerConnectivityChange(peer, source) {
+        if (!this.connected || peer.pc.connectionState === 'closed') {
+            return;
+        }
+        const connectionState = peer.pc.connectionState;
+        const iceConnectionState = peer.pc.iceConnectionState;
+        if (connectionState === 'connected'
+            || iceConnectionState === 'connected'
+            || iceConnectionState === 'completed') {
+            this.resetPeerRecovery(peer);
+            return;
+        }
+        if (connectionState === 'failed' || iceConnectionState === 'failed') {
+            this.schedulePeerRecoveryCheck(peer.memberId, `${source}-failed`, 0);
+            return;
+        }
+        if (connectionState === 'disconnected' || iceConnectionState === 'disconnected') {
+            this.schedulePeerRecoveryCheck(peer.memberId, `${source}-disconnected`, this.options.disconnectedRecoveryDelayMs);
+        }
+    }
+    schedulePeerRecoveryCheck(memberId, reason, delayMs = this.options.missingMediaGraceMs) {
+        const peer = this.peers.get(memberId);
+        if (!peer || !this.connected || peer.pc.connectionState === 'closed') {
+            return;
+        }
+        const healthSensitiveReason = reason.includes('health')
+            || reason.includes('stalled')
+            || reason.includes('flow');
+        if (!this.hasMissingPublishedMedia(memberId)
+            && !healthSensitiveReason
+            && !reason.includes('failed')
+            && !reason.includes('disconnected')) {
+            this.resetPeerRecovery(peer);
+            return;
+        }
+        this.clearPeerRecoveryTimer(peer);
+        peer.recoveryTimer = globalThis.setTimeout(() => {
+            peer.recoveryTimer = null;
+            void this.recoverPeer(peer, reason);
+        }, Math.max(0, delayMs));
+    }
+    async recoverPeer(peer, reason) {
+        if (!this.connected || peer.pc.connectionState === 'closed') {
+            return;
+        }
+        const stillMissingPublishedMedia = this.hasMissingPublishedMedia(peer.memberId);
+        const connectivityIssue = peer.pc.connectionState === 'failed'
+            || peer.pc.connectionState === 'disconnected'
+            || peer.pc.iceConnectionState === 'failed'
+            || peer.pc.iceConnectionState === 'disconnected';
+        const healthIssue = !stillMissingPublishedMedia && !connectivityIssue
+            ? await this.inspectPeerVideoHealth(peer)
+            : null;
+        if (!stillMissingPublishedMedia && !connectivityIssue && !healthIssue) {
+            this.resetPeerRecovery(peer);
+            return;
+        }
+        if (peer.recoveryAttempts >= this.options.maxRecoveryAttempts) {
+            this.resetPeer(peer.memberId, reason);
+            return;
+        }
+        peer.recoveryAttempts += 1;
+        this.requestIceRestart(peer, reason);
+    }
+    requestIceRestart(peer, reason) {
+        try {
+            if (typeof peer.pc.restartIce === 'function') {
+                peer.pc.restartIce();
+            }
+        }
+        catch (error) {
+            console.warn('[RoomP2PMediaTransport] Failed to request ICE restart.', {
+                memberId: peer.memberId,
+                reason,
+                error,
+            });
+        }
+        peer.pendingNegotiation = true;
+        this.maybeRetryPendingNegotiation(peer);
+    }
+    resetPeer(memberId, reason) {
+        const existing = this.peers.get(memberId);
+        if (existing) {
+            this.destroyPeer(existing);
+            this.peers.delete(memberId);
+        }
+        const replacement = this.ensurePeer(memberId);
+        replacement.recoveryAttempts = 0;
+        replacement.pendingNegotiation = true;
+        this.maybeRetryPendingNegotiation(replacement);
+        this.schedulePeerRecoveryCheck(memberId, `${reason}:after-reset`);
+    }
+    resetPeerRecovery(peer) {
+        peer.recoveryAttempts = 0;
+        peer.pendingNegotiation = false;
+        this.clearPeerRecoveryTimer(peer);
+    }
+    clearPeerRecoveryTimer(peer) {
+        if (peer.recoveryTimer != null) {
+            globalThis.clearTimeout(peer.recoveryTimer);
+            peer.recoveryTimer = null;
+        }
+    }
+    hasMissingPublishedMedia(memberId) {
+        const mediaMember = this.room.media.list().find((entry) => entry.member.memberId === memberId);
+        if (!mediaMember) {
+            return false;
+        }
+        const publishedKinds = new Set();
+        for (const track of mediaMember.tracks) {
+            if (track.trackId) {
+                publishedKinds.add(track.kind);
+            }
+        }
+        for (const kind of getPublishedKindsFromState(mediaMember.state)) {
+            publishedKinds.add(kind);
+        }
+        const emittedKinds = new Set();
+        for (const key of this.emittedRemoteTracks) {
+            if (!key.startsWith(`${memberId}:`)) {
+                continue;
+            }
+            const kind = this.remoteTrackKinds.get(key);
+            if (kind) {
+                emittedKinds.add(kind);
+            }
+        }
+        let pendingAudioCount = 0;
+        let pendingVideoLikeCount = 0;
+        for (const pending of this.pendingRemoteTracks.values()) {
+            if (pending.memberId !== memberId) {
+                continue;
+            }
+            if (pending.track.kind === 'audio') {
+                pendingAudioCount += 1;
+            }
+            else if (pending.track.kind === 'video') {
+                pendingVideoLikeCount += 1;
+            }
+        }
+        if (publishedKinds.has('audio') && !emittedKinds.has('audio') && pendingAudioCount === 0) {
+            return true;
+        }
+        const expectedVideoLikeKinds = Array.from(publishedKinds).filter((kind) => kind === 'video' || kind === 'screen');
+        if (expectedVideoLikeKinds.length === 0) {
+            return false;
+        }
+        const emittedVideoLikeCount = Array.from(emittedKinds).filter((kind) => kind === 'video' || kind === 'screen').length;
+        return emittedVideoLikeCount + pendingVideoLikeCount < expectedVideoLikeKinds.length;
+    }
 }
 //# sourceMappingURL=room-p2p-media.js.map