@vibexnpm/talkx 8.4.1 → 8.6.0

package/src/webrtc/WebRTCClient.js

@@ -9,6 +9,15 @@ import MediaStreamManager from './MediaStreamManager.js';
 import PeerConnectionManager from './PeerConnectionManager.js';
 import { WebSocketPaths, SignalTypes, ErrorTypes, DefaultConfig, LogLevel } from '../constants.js';
 
+/** 1:1 통화 제어 신호. 받는 쪽은 roomId 가 없어야 1:1 신호로 받는다(_acceptsSignal). */
+const DIRECT_CONTROL_SIGNALS = new Set([
+    SignalTypes.CALL_REQUEST, SignalTypes.CALL_ACCEPT, SignalTypes.CALL_REJECT,
+    SignalTypes.CALL_CANCEL, SignalTypes.CALL_BUSY
+]);
+
+/** 받은 초대·내가 연 방은 응답 전까지만 의미가 있다. 오래된 것부터 잊는다. */
+const MAX_REMEMBERED_CALL_ROOMS = 32;
+
 class WebRTCClient extends EventEmitter {
     /**
      * @param {Object} options
@@ -39,6 +48,25 @@ class WebRTCClient extends EventEmitter {
         this.currentRoom = null;
         this.isGroupCall = false;
         this.participants = new Map();
+        this._callActive = false;
+        this._callGeneration = 0;
+        this._deferredGroupPeers = new Map();
+        this._joinedGroupRoom = null;
+        this._groupJoin = null;
+        this._directCallPeer = null;
+        this._incomingCallPeer = null;
+        // 서버(REST)가 roomId 를 붙여 보내는 그룹 초대 취소·거절을 받을 방. callRoomId -> host / 나
+        this._receivedInvitations = new Map();
+        this._hostedCallRooms = new Map();
+        // 서버는 생성 응답 전에 초대를 보낸다(CreateCallRoomService). 응답보다 먼저 온 거절은 응답을 받을 때까지 보관한다.
+        this._pendingRoomCreations = 0;
+        this._earlyRoomRejects = [];
+        this._groupRecoveryTimer = null;
+        this._groupRecoveryAttempts = 0;
+        this._onReconnected = () => {
+            this._recoverGroupParticipation().catch(error => this.logger.error('Call recovery failed:', error));
+        };
+        this.connectionManager.on?.('reconnected', this._onReconnected);
 
         // ICE 서버 초기화 상태
         this._iceServersFetched = false;
@@ -152,14 +180,26 @@ class WebRTCClient extends EventEmitter {
      * 통화방 생성
      * @public
      * @param {Object} data
-     * @param {string} data.roomName - 방 이름
-     * @param {boolean} data.isGroup - 그룹 통화 여부
-     * @param {string} [data.chatRoomId] - 연결할 채팅방 ID
+     * @param {string[]} [data.invitedUsers] - 초대할 사용자 ID
+     * @param {string} [data.title] - 통화방 제목
+     * @param {number} [data.maxParticipants] - 최대 참가자 수 (생략 시 서버 기본값)
      * @returns {Promise<Object>}
      */
     // noinspection JSUnusedGlobalSymbols
     async createCallRoom(data) {
-        return this.apiClient.post('/api/v1/webrtc/rooms', data);
+        this._pendingRoomCreations++;
+        try {
+            const response = await this.apiClient.post('/api/v1/webrtc/rooms', data);
+            const callRoomId = response?.data?.callRoomId;
+            if (callRoomId) this._rememberCallRoom(this._hostedCallRooms, callRoomId, this.userId);
+            return response;
+        } finally {
+            this._pendingRoomCreations--;
+            // 보관한 거절을 같은 경로로 다시 판정한다. 연 방의 것은 전달되고, 진행 중인 생성이 남았으면 다시 보관되며, 아니면 버려진다.
+            for (const message of this._earlyRoomRejects.splice(0)) {
+                this._handleSignal(message).catch(error => this.logger.error('Early rejection handling failed:', error));
+            }
+        }
     }
 
     /**
@@ -181,7 +221,20 @@ class WebRTCClient extends EventEmitter {
      */
     // noinspection JSUnusedGlobalSymbols
     async joinCallRoomApi(roomId) {
-        return this.apiClient.post(`/api/v1/webrtc/rooms/${roomId}/join`);
+        // REST 응답보다 PEER_JOINED에 대한 offer가 먼저 도착할 수 있다.
+        // 로컬에서 요청한 방만 허용하고, 실패·종료 뒤에는 이 권한을 남기지 않는다.
+        const join = { roomId, generation: this._callGeneration };
+        this._groupJoin = join;
+        try {
+            const response = await this.apiClient.post(`/api/v1/webrtc/rooms/${roomId}/join`);
+            if (this._groupJoin === join && this._callGeneration === join.generation) this._joinedGroupRoom = roomId;
+            return response;
+        } catch (error) {
+            if (this._groupJoin === join && this.currentRoom !== roomId) this._clearDeferredGroup(roomId);
+            throw error;
+        } finally {
+            if (this._groupJoin === join) this._groupJoin = null;
+        }
     }
 
     /**
@@ -192,7 +245,11 @@ class WebRTCClient extends EventEmitter {
      */
     // noinspection JSUnusedGlobalSymbols
     async leaveCallRoomApi(roomId) {
-        return this.apiClient.delete(`/api/v1/webrtc/rooms/${roomId}/leave`);
+        const response = await this.apiClient.post(`/api/v1/webrtc/rooms/${roomId}/leave`);
+        if (this._joinedGroupRoom === roomId) this._joinedGroupRoom = null;
+        if (this._groupJoin?.roomId === roomId) this._groupJoin = null;
+        if (this.currentRoom !== roomId) this._clearDeferredGroup(roomId);
+        return response;
     }
 
     // ==================== 통화 수신 대기 ====================
@@ -251,21 +308,40 @@ class WebRTCClient extends EventEmitter {
      */
     async startCall(options) {
         const { roomId, isGroup = false, mediaConstraints = { video: true, audio: true } } = options;
+        if (this._pendingStart) throw new Error('A call is already starting');
+        // 조기 offer의 peer 존재만으로 막지 않는다. 이미 소유한 통화만 보호한다.
+        if (this.currentRoom !== null || this._callActive || this._waitingForCallAccept) {
+            throw new Error('A call is already active');
+        }
+        this._callGeneration++;
+        this._cancelGroupRecoveryRetry();
+        this._groupRecoveryAttempts = 0;
+        this._groupRecovery = null;
+        const start = { cancelled: false };
+        this._pendingStart = start;
+        const checkCancelled = () => { if (start.cancelled) throw new Error('Call start cancelled'); };
 
         try {
-            // TURN 서버 설정 초기화
-            await this.initializeIceServers();
-
-            // 로컬 미디어 획득
-            const localStream = await this.mediaManager.getUserMedia(mediaConstraints);
-            this.peerManager.setLocalStream(localStream);
-
-            // 현재 방 설정
             this.currentRoom = roomId;
             this.isGroupCall = isGroup;
-
-            // WebSocket 구독
+            for (const deferredRoom of new Set(this._deferredGroupPeers.values())) {
+                if (!isGroup || deferredRoom !== roomId) this._clearDeferredGroup(deferredRoom);
+            }
+            // 그룹 참가 임대를 먼저 연결한다. 권한 팝업/TURN 조회가 90초를 넘어도 갱신된다.
             await this._subscribeToSignaling(roomId, isGroup);
+            checkCancelled();
+            await this.initializeIceServers();
+            checkCancelled();
+            const localStream = await this.mediaManager.getUserMedia(mediaConstraints);
+            checkCancelled();
+            // 먼저 수신한 offer의 peer에도 트랙을 추가하고 재협상한다.
+            // 권한 대기 중 시그널을 버리면 상대의 기존 peer가 offer를 다시 보내지 않을 수 있다.
+            this.peerManager.setLocalStream(localStream);
+            for (const peerId of this._deferredGroupPeers.keys()) {
+                await this._resumeGroupNegotiation(peerId);
+                checkCancelled();
+            }
+            this._callActive = true;
 
             // 입장 시그널 전송
             this._sendSignal({
@@ -279,6 +355,19 @@ class WebRTCClient extends EventEmitter {
             return localStream;
 
         } catch (error) {
+            if (isGroup) this.connectionManager.unsubscribe(WebSocketPaths.getWebRTCDestination(roomId));
+            this._unsubscribeFromSignaling();
+            this.mediaManager.stopAll();
+            this.peerManager.closeAllPeerConnections();
+            this.peerManager.setLocalStream(null);
+            this.participants.clear();
+            this._pendingIceCandidates.clear();
+            this._deferredGroupPeers.clear();
+            this._callActive = false;
+            this.currentRoom = null;
+            this.isGroupCall = false;
+            this._joinedGroupRoom = null;
+            this._groupJoin = null;
             this.logger.error('Failed to start call:', error);
             this.emit('error', {
                 type: ErrorTypes.PEER_CONNECTION_FAILED,
@@ -286,6 +375,8 @@ class WebRTCClient extends EventEmitter {
                 error
             });
             throw error;
+        } finally {
+            this._pendingStart = null;
         }
     }
 
@@ -308,8 +399,10 @@ class WebRTCClient extends EventEmitter {
 
             // CALL_ACCEPT 대기 상태 설정
             // PeerConnection은 CALL_ACCEPT를 받은 후에 생성하여 자동 negotiation 방지
+            this._callActive = true;
             this._waitingForCallAccept = true;
             this._pendingCallTarget = targetUserId;
+            this._incomingCallPeer = null;
 
             // 통화 요청 시그널
             this._sendSignal({
@@ -347,6 +440,8 @@ class WebRTCClient extends EventEmitter {
             // 피어 연결 생성 (Polite - 수신자)
             // skipAutoNegotiation: true - 수신자는 offer를 받아서 answer를 보내므로 자동 negotiation 불필요
             this.peerManager.createPeerConnection(callerId, true, { skipAutoNegotiation: true });
+            this._directCallPeer = callerId;
+            this._incomingCallPeer = null;
 
             // 수락 시그널
             this._sendSignal({
@@ -354,6 +449,7 @@ class WebRTCClient extends EventEmitter {
                 receiverId: callerId
             });
 
+            this._callActive = true;
             this.emit('callAccepted', { callerId });
 
         } catch (error) {
@@ -367,6 +463,7 @@ class WebRTCClient extends EventEmitter {
      * @param {string} callerId - 발신자 ID
      */
     rejectCall(callerId) {
+        if (this._incomingCallPeer === callerId) this._incomingCallPeer = null;
         this._sendSignal({
             type: SignalTypes.CALL_REJECT,
             receiverId: callerId
@@ -392,6 +489,7 @@ class WebRTCClient extends EventEmitter {
             this._pendingCallTarget = null;
 
             // 미디어 정리
+            this._callActive = false;
             this.mediaManager.stopAll();
         }
     }
@@ -400,8 +498,22 @@ class WebRTCClient extends EventEmitter {
      * 통화 종료
      */
     endCall() {
+        this._endCall(true);
+    }
+
+    _endCall(notifyPeers) {
+        this._callGeneration++;
+        this._cancelGroupRecoveryRetry();
+        this._groupRecoveryAttempts = 0;
+        this._groupRecovery = null;
+        this._callActive = false;
+        this._deferredGroupPeers.clear();
+        this._joinedGroupRoom = null;
+        this._groupJoin = null;
+        this._incomingCallPeer = null;
+        if (this._pendingStart) this._pendingStart.cancelled = true;
         // 대기 중인 통화가 있으면 취소 처리
-        if (this._waitingForCallAccept && this._pendingCallTarget) {
+        if (notifyPeers && this._waitingForCallAccept && this._pendingCallTarget) {
             this._sendSignal({
                 type: SignalTypes.CALL_CANCEL,
                 receiverId: this._pendingCallTarget
@@ -414,7 +526,7 @@ class WebRTCClient extends EventEmitter {
 
         if (this.currentRoom) {
             // 퇴장 시그널 전송
-            this._sendSignal({
+            if (notifyPeers) this._sendSignal({
                 type: SignalTypes.LEAVE_ROOM,
                 roomId: this.currentRoom
             });
@@ -424,15 +536,18 @@ class WebRTCClient extends EventEmitter {
         }
 
         // 모든 피어에게 종료 시그널
-        this.peerManager.getPeerIds().forEach(peerId => {
+        if (notifyPeers) this.peerManager.getPeerIds().forEach(peerId => {
             this._sendSignal({
                 type: SignalTypes.CALL_END,
                 receiverId: peerId
             });
         });
+        // 1:1 상대에게 가는 CALL_END 에 그룹 roomId 가 붙지 않도록 보낸 뒤에 지운다(_groupRoomFor).
+        this._directCallPeer = null;
 
         // 정리
         this.peerManager.closeAllPeerConnections();
+        this.peerManager.setLocalStream(null);
         this.mediaManager.stopAll();
         this.participants.clear();
         this._pendingIceCandidates.clear();
@@ -664,7 +779,7 @@ class WebRTCClient extends EventEmitter {
     _sendSignal(signal) {
         const payload = {
             type: signal.type,
-            roomId: signal.roomId || this.currentRoom,
+            roomId: signal.roomId || this._groupRoomFor(signal),
             receiverId: signal.receiverId,
             data: signal.data
         };
@@ -673,6 +788,17 @@ class WebRTCClient extends EventEmitter {
         this.logger.debug('Signal sent:', payload);
     }
 
+    /**
+     * 그룹 roomId 는 그룹 상대·그룹 방 신호에만 붙인다.
+     * 1:1 신호에 붙으면 상대가 방 신호로 보고 버린다(그룹 통화 중 자동 BUSY 유실).
+     * @private
+     */
+    _groupRoomFor({ type, receiverId }) {
+        if (DIRECT_CONTROL_SIGNALS.has(type)) return undefined;
+        if (receiverId && receiverId === this._directCallPeer) return undefined;
+        return this.currentRoom || this._deferredGroupPeers.get(receiverId);
+    }
+
     /**
      * 미디어 상태 전송
      * @private
@@ -707,12 +833,15 @@ class WebRTCClient extends EventEmitter {
             return;
         }
 
+        if (this._holdsEarlyRoomReject(message)) return;
+        if (!this._acceptsSignal(message)) return;
+
         this.logger.debug(`Signal received: ${type} from ${senderId}`);
 
         switch (type) {
             case SignalTypes.JOIN_ROOM:
             case SignalTypes.PEER_JOINED:
-                await this._handleUserJoined(senderId);
+                await this._handleUserJoined(senderId, message.roomId);
                 break;
 
             case SignalTypes.LEAVE_ROOM:
@@ -721,7 +850,7 @@ class WebRTCClient extends EventEmitter {
                 break;
 
             case SignalTypes.CALL_OFFER:
-                await this._handleOffer(senderId, data.sdp);
+                await this._handleOffer(senderId, data.sdp, message.roomId);
                 break;
 
             case SignalTypes.CALL_ANSWER:
@@ -746,6 +875,7 @@ class WebRTCClient extends EventEmitter {
                     });
                     this.emit('incomingCallWhileBusy', { callerId: senderId });
                 } else {
+                    this._incomingCallPeer = senderId;
                     this.emit('incomingCall', { callerId: senderId });
                 }
                 break;
@@ -754,35 +884,53 @@ class WebRTCClient extends EventEmitter {
                 // 상대방이 통화 중
                 this._waitingForCallAccept = false;
                 this._pendingCallTarget = null;
+                this._callActive = false;
                 this.mediaManager.stopAll();
                 this.emit('callBusy', { userId: senderId });
                 break;
 
-            case SignalTypes.CALL_INVITATION:
+            case SignalTypes.CALL_INVITATION: {
                 // 그룹 통화 초대 (createCallRoom으로 초대받은 경우)
+                const callRoomId = data?.callRoomId || message.roomId;
+                // 취소 수락 기준은 서버가 채운 roomId·senderId(host)다. data 는 보낸 쪽이 정한 값이라 기억 키로 쓰지 않는다.
+                if (message.roomId) this._rememberCallRoom(this._receivedInvitations, message.roomId, senderId);
                 this.emit('callInvitation', {
-                    callRoomId: data?.callRoomId || message.roomId,
+                    callRoomId,
                     title: data?.title,
                     hostUserId: data?.hostUserId || senderId,
                     maxParticipants: data?.maxParticipants,
                     createdAt: data?.createdAt
                 });
                 break;
+            }
 
             case SignalTypes.CALL_ACCEPT:
                 await this._handleCallAccepted(senderId);
                 break;
 
             case SignalTypes.CALL_REJECT:
+                if (message.roomId) {
+                    // 그룹 초대 거절(서버 REST 발신). host 의 통화·미디어는 그대로 둔다.
+                    this.emit('callRejected', { userId: senderId, roomId: message.roomId });
+                    break;
+                }
                 // 대기 상태 초기화
                 this._waitingForCallAccept = false;
                 this._pendingCallTarget = null;
+                this._callActive = false;
                 // 발신자 미디어 정리 (거절당했으므로 통화 불가)
                 this.mediaManager.stopAll();
                 this.emit('callRejected', { userId: senderId });
                 break;
 
             case SignalTypes.CALL_CANCEL:
+                if (message.roomId) {
+                    // 그룹 초대 취소(서버 REST 발신). 1:1 대기 상태는 건드리지 않는다.
+                    this._receivedInvitations.delete(message.roomId);
+                    this.emit('callCancelled', { userId: senderId, roomId: message.roomId });
+                    break;
+                }
+                this._incomingCallPeer = null;
                 // 대기 상태 초기화
                 this._waitingForCallAccept = false;
                 this._pendingCallTarget = null;
@@ -790,7 +938,11 @@ class WebRTCClient extends EventEmitter {
                 break;
 
             case SignalTypes.CALL_END:
-                this._handleCallEnded(senderId);
+                if (data?.callEndScope === 'ROOM') {
+                    this._endCall(false); // _acceptsSignal에서 현재/참가 요청한 그룹 방 일치를 확인했다.
+                } else {
+                    this._handleCallEnded(senderId);
+                }
                 break;
 
             default:
@@ -798,17 +950,65 @@ class WebRTCClient extends EventEmitter {
         }
     }
 
+    /** 미디어를 공유할 상대/방은 로컬 참가·발신·수락으로만 결정한다. */
+    _acceptsSignal({ type, senderId, roomId }) {
+        if (!senderId) return false;
+        if (type === SignalTypes.CALL_INVITATION) return true;
+        if (type === SignalTypes.CALL_REQUEST) return !roomId;
+        // 그룹 초대 거절·취소는 서버가 roomId 를 붙여 보낸다. 내가 연 방·받은 초대의 host 것만 받는다.
+        if (roomId && type === SignalTypes.CALL_REJECT) return this._hostedCallRooms.has(roomId);
+        if (roomId && type === SignalTypes.CALL_CANCEL) return this._receivedInvitations.get(roomId) === senderId;
+        if ([SignalTypes.CALL_ACCEPT, SignalTypes.CALL_BUSY, SignalTypes.CALL_REJECT].includes(type)) {
+            return !roomId && this._waitingForCallAccept && senderId === this._pendingCallTarget;
+        }
+        if (type === SignalTypes.CALL_CANCEL) return !roomId && senderId === this._incomingCallPeer;
+        // 수락한 1:1 상대의 신호는 roomId 없이 온다. 그룹 통화 중에 수락했어도 받는다.
+        if (!roomId && senderId === this._directCallPeer) return true;
+        const groupRoom = this.isGroupCall ? this.currentRoom
+            : (!this._callActive && !this._waitingForCallAccept ? this._groupJoin?.roomId || this._joinedGroupRoom : null);
+        if (groupRoom) return roomId === groupRoom;
+        return !roomId && senderId === this._pendingCallTarget;
+    }
+
+    /** 방 생성 응답 전에 온 그룹 거절은 응답의 방 ID 로 판정할 수 있을 때까지 보관한다. */
+    _holdsEarlyRoomReject(message) {
+        const { type, roomId } = message;
+        if (type !== SignalTypes.CALL_REJECT || !roomId || this._pendingRoomCreations === 0
+                || this._hostedCallRooms.has(roomId)) return false;
+        this._earlyRoomRejects.push(message);
+        if (this._earlyRoomRejects.length > MAX_REMEMBERED_CALL_ROOMS) this._earlyRoomRejects.shift();
+        return true;
+    }
+
+    _rememberCallRoom(rooms, roomId, userId) {
+        rooms.delete(roomId);
+        rooms.set(roomId, userId);
+        if (rooms.size > MAX_REMEMBERED_CALL_ROOMS) rooms.delete(rooms.keys().next().value);
+    }
+
+    _clearDeferredGroup(roomId) {
+        for (const [peerId, peerRoom] of this._deferredGroupPeers) {
+            if (peerRoom !== roomId) continue;
+            this.peerManager.closePeerConnection(peerId);
+            this.participants.delete(peerId);
+            this._pendingIceCandidates.delete(peerId);
+            this._deferredGroupPeers.delete(peerId);
+        }
+    }
+
     /**
      * 사용자 입장 처리
      * @private
      */
-    async _handleUserJoined(userId) {
+    async _handleUserJoined(userId, roomId) {
         this.participants.set(userId, { joinedAt: new Date() });
 
         // userId 비교로 Polite/Impolite 결정 (작은 쪽이 Polite)
         // Perfect Negotiation에서 충돌 시 한 쪽만 양보하도록 보장
         const polite = this.userId < userId;
-        this.peerManager.createPeerConnection(userId, polite);
+        const defer = !!roomId && !this.peerManager.localStream;
+        this.peerManager.createPeerConnection(userId, polite, { skipAutoNegotiation: defer });
+        if (defer) this._deferredGroupPeers.set(userId, roomId);
 
         this.emit('userJoined', { userId });
         this.logger.info(`User joined: ${userId} (I am ${polite ? 'polite' : 'impolite'})`);
@@ -830,7 +1030,7 @@ class WebRTCClient extends EventEmitter {
      * Offer 처리
      * @private
      */
-    async _handleOffer(senderId, sdp) {
+    async _handleOffer(senderId, sdp, roomId = this.isGroupCall ? this.currentRoom : null) {
         // 피어 연결이 없으면 생성
         if (!this.peerManager.getPeerConnection(senderId)) {
             // userId 비교로 Polite/Impolite 결정
@@ -838,14 +1038,69 @@ class WebRTCClient extends EventEmitter {
             // skipAutoNegotiation: true - offer를 먼저 처리한 후 answer 전송
             // 트랙 추가 시 자동 negotiation이 발생하면 offer 충돌 발생
             this.peerManager.createPeerConnection(senderId, polite, { skipAutoNegotiation: true });
+            // REST join의 PEER_JOINED는 startCall보다 먼저 올 수 있다.
+            // 메시지의 roomId로 그룹을 식별하되, 1:1 수동 협상에는 적용하지 않는다.
+            if (roomId && !this.peerManager.localStream) this._deferredGroupPeers.set(senderId, roomId);
         }
 
         await this.peerManager.handleRemoteDescription(senderId, sdp);
+        await this._resumeGroupNegotiation(senderId);
 
         // remoteDescription 설정 후 대기 중인 ICE candidates 처리
         await this._processPendingIceCandidates(senderId);
     }
 
+    async _resumeGroupNegotiation(peerId) {
+        if (!this.isGroupCall || this._deferredGroupPeers.get(peerId) !== this.currentRoom
+            || !this.peerManager.localStream) return;
+        if (await this.peerManager.resumeAutoNegotiation(peerId)) this._deferredGroupPeers.delete(peerId);
+    }
+
+    /** 재구독은 참가 이력을 복구하지 않는다. 동일 사용자의 다른 기기 참가도 이 조회에 반영된다. */
+    async _recoverGroupParticipation() {
+        if (!this.isGroupCall || !this.currentRoom || this._groupRecovery) return;
+        this._cancelGroupRecoveryRetry();
+        const roomId = this.currentRoom;
+        const generation = this._callGeneration;
+        const stillCurrent = () => this.currentRoom === roomId && this._callGeneration === generation;
+        const recovery = (async () => {
+            try {
+                const response = await this.apiClient.get(`/api/v1/webrtc/rooms/${roomId}/participation`);
+                if (!stillCurrent()) return;
+                if (!response.data.participating) {
+                    await this.joinCallRoomApi(roomId);
+                    if (!stillCurrent()) return;
+                    this._sendSignal({ type: SignalTypes.JOIN_ROOM, roomId });
+                }
+                this._groupRecoveryAttempts = 0;
+            } catch (error) {
+                if (!stillCurrent()) return;
+                if ([403, 404, 409].includes(error?.status ?? error?.response?.status)) {
+                    // 확정 실패만 로컬 종료한다. 다른 기기 참가를 지우는 LEAVE는 보내지 않는다.
+                    this._endCall(false);
+                    this.emit('callRecoveryFailed', { roomId, error });
+                } else {
+                    // 일시 오류 동안 미디어·peer·구독을 유지하고 1s→2s→…→30s 간격으로 재시도한다.
+                    const delay = Math.min(30000, 1000 * 2 ** Math.min(this._groupRecoveryAttempts++, 5));
+                    this._groupRecoveryTimer = setTimeout(() => {
+                        this._groupRecoveryTimer = null;
+                        if (stillCurrent()) this._onReconnected();
+                    }, delay);
+                    this._groupRecoveryTimer.unref?.();
+                    this.logger.warn('Call participation recovery will retry:', error);
+                }
+            }
+        })();
+        this._groupRecovery = recovery;
+        try { await recovery; }
+        finally { if (this._groupRecovery === recovery) this._groupRecovery = null; }
+    }
+
+    _cancelGroupRecoveryRetry() {
+        clearTimeout(this._groupRecoveryTimer);
+        this._groupRecoveryTimer = null;
+    }
+
     /**
      * Answer 처리
      * @private
@@ -922,6 +1177,7 @@ class WebRTCClient extends EventEmitter {
      * @private
      */
     async _handleCallAccepted(userId) {
+        this._directCallPeer = userId;
         // 대기 상태 초기화
         this._waitingForCallAccept = false;
         this._pendingCallTarget = null;
@@ -948,6 +1204,8 @@ class WebRTCClient extends EventEmitter {
     _handleCallEnded(userId) {
         this.peerManager.closePeerConnection(userId);
         this.participants.delete(userId);
+        // 끝난 1:1 상대는 더 이상 선택한 상대가 아니다. 그룹 통화가 남아도 그의 roomId 없는 신호를 받지 않는다.
+        if (userId === this._directCallPeer) this._directCallPeer = null;
 
         this.emit('participantLeft', { userId });
 
@@ -1030,6 +1288,7 @@ class WebRTCClient extends EventEmitter {
      * 리소스 정리
      */
     destroy() {
+        this.connectionManager.off?.('reconnected', this._onReconnected);
         this.endCall();
         this.mediaManager.destroy();
         this.peerManager.destroy();