@vibexnpm/talkx 8.13.0 → 9.1.0

package/package.json

@@ -1,8 +1,8 @@
 {
     "name": "@vibexnpm/talkx",
-    "version": "8.13.0",
+    "version": "9.1.0",
     "type": "module",
-    "description": "TalkFlow SDK - Chat & WebRTC unified client",
+    "description": "TalkFlow SDK - Chat & video call (LiveKit SFU) unified client",
     "main": "dist/talkflow-sdk.umd.js",
     "module": "dist/talkflow-sdk.esm.js",
     "browser": "dist/talkflow-sdk.standalone.js",
@@ -28,6 +28,7 @@
         "talkflow",
         "chat",
         "webrtc",
+        "livekit",
         "websocket",
         "stomp",
         "realtime"
@@ -37,6 +38,7 @@
     "dependencies": {
         "@stomp/stompjs": "^7.0.0",
         "firebase": "^11.8.1",
+        "livekit-client": "2.22.4",
         "sockjs-client": "^1.6.0"
     },
     "devDependencies": {

package/src/TalkFlowClient.js

@@ -31,7 +31,7 @@ class TalkFlowClient extends EventEmitter {
      * @param {boolean} [options.useSockJS=true] - SockJS 사용 여부
      * @param {number} [options.reconnectDelay=5000] - 재연결 지연 (ms)
      * @param {number} [options.maxReconnectAttempts=10] - 최대 재연결 시도
-     * @param {Object[]} [options.iceServers] - ICE 서버 설정
+     * @param {number} [options.callRingTimeoutMs=65000] - 받는 쪽 울림을 스스로 끄는 시각(서버 «응답함»·«취소» 가 먼저 오면 그때 끈다)
      * @param {boolean} [options.autoSubscribeRoomList=true] - connect() 시 채팅방 리스트 자동 구독 여부 (카톡 스타일)
      * @param {number} [options.logLevel=LogLevel.WARN] - 로그 레벨
      *
@@ -89,7 +89,7 @@ class TalkFlowClient extends EventEmitter {
                 : DefaultConfig.rewindMillis,
             maxSyncPages: options.maxSyncPages || DefaultConfig.maxSyncPages,
             syncPageSize: options.syncPageSize || DefaultConfig.syncPageSize,
-            iceServers: options.iceServers || DefaultConfig.iceServers,
+            callRingTimeoutMs: options.callRingTimeoutMs || DefaultConfig.callRingTimeoutMs,
             // connect() 시 채팅방 리스트 자동 구독 여부 (카톡 스타일).
             // 기본 true — 앱 어디서든 리스트 이벤트를 놓치지 않음 (배지/알림 등).
             // false 로 설정 시 수동으로 client.chat.subscribeRoomList() 호출 필요.
@@ -241,6 +241,11 @@ class TalkFlowClient extends EventEmitter {
     }
 
     async _acceptAuthSession(data) {
+        // 로그인 세션은 클라이언트에 알리기 전에 새 신원의 토큰으로 바꾼다(AuthSession._accept) — 사용자·회사가 바뀌었으면 옛 신원의 통화
+        // 요청(나가기·재시도 등)은 새 신원 이름으로 간다. 이 기기에서만 끝내고 옛 신원의 요청을 멈춘다(서버는 미디어 끊김 뒤 참가를 닫는다).
+        if (this.options.projectId !== data.projectId || this.userId !== data.user.userId) {
+            await this._webrtc?._resetIdentity();
+        }
         if (this.options.projectId && this.options.projectId !== data.projectId && this.connectionManager) {
             await this._clearAuthSession();
         }
@@ -252,6 +257,10 @@ class TalkFlowClient extends EventEmitter {
     }
 
     async _clearAuthSession() {
+        // 신원이 지워졌거나(로그아웃·다른 탭·자격 만료) 다른 회사로 바뀌었다 — 통화 나가기를 보낼 자격이 없다. 이 기기에서만 끝내고 옛
+        // 신원의 요청을 멈춘다(보내면 갱신 토큰 없는 갱신 → 로그아웃 표식이 다른 탭 로그인까지 끊는다). 이 탭의 logout() 은 자격이 살아
+        // 있을 때 먼저 나갔다.
+        await this._webrtc?._resetIdentity();
         this._authConnectionRequested = false;
         this.options.jwtToken = null;
         this._userId = null;
@@ -682,9 +691,8 @@ class TalkFlowClient extends EventEmitter {
             } : null,
             webrtc: this.webrtc ? {
                 isInCall: this.webrtc.isInCall(),
-                currentRoom: this.webrtc.getCurrentRoom(),
-                participants: this.webrtc.getParticipants(),
-                mediaState: this.webrtc.getMediaState()
+                currentCall: this.webrtc.getCurrentCall(),
+                ringingCalls: this.webrtc.getRingingCalls()
             } : null
         };
     }

package/src/chat/ChatClient.js

@@ -1488,6 +1488,161 @@ class ChatClient extends EventEmitter {
         return this.apiClient.get(`/api/v1/pm-reports/${encodeURIComponent(reportId)}`);
     }
 
+    // ── 예약 보고 ──────────────────────────────────────
+    //
+    // 정해 둔 시각마다 PM 이 정해 둔 일을 해서 예약의 전용 방에 올린다 — 가이드는 docs/scheduled-reports.md.
+    // 요청한 사람이 만든 사람이고, 남의 예약은 없는 예약과 같은 404 다. 결과는 전용 방의 보통 글이라 방 목록·
+    // 메시지·푸시는 기존 경로 그대로고, 여기에는 예약을 다루는 메서드만 있다.
+    //
+    // 커서 페이지가 없는 응답이라 투표처럼 데이터만 돌려준다. 실패 코드는 {@code error.response.code}.
+
+    /**
+     * 내가 만든 예약 목록 (만든 순).
+     *
+     * @returns {Promise<Array<Object>>} 예약 목록
+     */
+    async getScheduledReports() {
+        const response = await this.apiClient.get('/api/v1/scheduled-reports');
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 예약 하나와 최근 회차 (예정 늦은 순, 최대 10개).
+     *
+     * @param {string} reportId - 예약 id
+     * @returns {Promise<{report: Object, recentRuns: Array<Object>}>}
+     * @throws {Error} 없거나 남의 예약이면 404 {@code SCHEDULED_REPORT_NOT_FOUND}
+     */
+    async getScheduledReport(reportId) {
+        if (!reportId) {
+            throw new Error('reportId is required');
+        }
+        const response = await this.apiClient.get(`/api/v1/scheduled-reports/${encodeURIComponent(reportId)}`);
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 지금 새로 만들 수 있는 작업 종류.
+     *
+     * <p>키에 PM 권한이 없거나 일시정지 중인 종류는 빠진다. 빈 배열이면 만들기를 막는다.</p>
+     *
+     * @returns {Promise<Array<'RESEARCH'|'ROOM_DIGEST'>>}
+     */
+    async getScheduledReportKinds() {
+        const response = await this.apiClient.get('/api/v1/scheduled-reports/kinds');
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 방 정리의 원천 방 고르기 — 내가 지금 참여 중이고 메시지 보관 기간이 없는 방.
+     *
+     * @returns {Promise<Array<{roomId: string, name?: string, roomType?: string}>>}
+     */
+    async getScheduledReportSourceRooms() {
+        const response = await this.apiClient.get('/api/v1/scheduled-reports/source-rooms');
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 보낼 방 고르기 — 만들기·고치기와 같은 판정으로 거른 방이다.
+     *
+     * <p>만들기 화면은 {@code kind}(방 정리는 {@code sourceRoomId} 도), 고치기 화면은 {@code reportId} 를 넘긴다.
+     * {@code reportId} 를 주면 나머지는 보지 않는다.</p>
+     *
+     * @param {Object} params
+     * @param {'RESEARCH'|'ROOM_DIGEST'} [params.kind] - 만들기 화면의 작업 종류
+     * @param {string} [params.sourceRoomId] - 방 정리일 때 필수 — 방 정리는 원천 방으로만 보낸다
+     * @param {string} [params.reportId] - 고치기 화면의 예약 id
+     * @returns {Promise<Array<{roomId: string, name?: string, roomType?: string}>>}
+     * @throws {Error} 고를 기준이 모자라면 400 {@code SCHEDULED_REPORT_SPEC_INVALID}
+     */
+    async getScheduledReportDeliveryRooms(params = {}) {
+        const { kind, sourceRoomId, reportId } = params;
+        const response = await this.apiClient.get('/api/v1/scheduled-reports/delivery-rooms', { kind, sourceRoomId, reportId });
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 예약 만들기 — 전용 방을 만들고 예약을 저장한다. 응답 {@code homeRoomId} 가 결과가 올라갈 방이다.
+     *
+     * <p>🔴 <b>{@code idempotencyKey} 는 필수다.</b> SDK 가 대신 만들지 않는다 — 만들면 그 값이 호출자에게 남지 않아,
+     * 응답만 유실된 타임아웃에서 같은 키로 다시 보낼 수 없다(새 키는 예약과 방을 하나 더 만든다). 폼마다 한 번 만들고,
+     * 재시도에는 <b>같은 키</b>를 넘긴다 — 서버가 처음 만든 예약을 돌려준다. 503
+     * {@code SCHEDULED_REPORT_CREATE_RESULT_UNKNOWN}·{@code SCHEDULED_REPORT_RETRY_LATER} 도 같은 키로 다시 보낸다.</p>
+     *
+     * @param {Object} report - 예약 폼
+     * @param {string} report.title - 제목 (앞뒤 공백을 뺀 1~50자). 전용 방 이름으로도 쓴다
+     * @param {Object} report.spec - 작업 칸, {@code kind} 로 가른다. {@code RESEARCH} 는 {@code instruction}(1~2,000자),
+     *   {@code ROOM_DIGEST} 는 {@code sourceRoomId}·{@code period}·{@code format}·{@code focus}(선택, 0~500자)
+     * @param {Object} report.cadence - 주기. {@code type}·{@code days}({@code WEEKLY} 만)·{@code time}({@code HH:mm})·
+     *   {@code zoneId}(비우면 내 프로필 시간대)
+     * @param {string[]} [report.deliveryRoomIds] - 결과를 복사할 방 (0~3개)
+     * @param {Object} options
+     * @param {string} options.idempotencyKey - <b>필수.</b> 공백 없는 인쇄 가능 ASCII 1~200자. 재시도에는 반드시 같은 값
+     * @returns {Promise<Object>} 만든 예약
+     * @throws {Error} {@code idempotencyKey} 가 없으면 서버를 호출하지 않고 즉시 실패한다
+     * @example
+     * const key = crypto.randomUUID();
+     * const report = await chat.createScheduledReport({
+     *   title: '개발팀 주간 정리',
+     *   spec: { kind: 'ROOM_DIGEST', sourceRoomId, period: 'LAST_7_DAYS', format: 'MINUTES' },
+     *   cadence: { type: 'WEEKLY', days: ['MONDAY'], time: '09:00' }
+     * }, { idempotencyKey: key });
+     */
+    async createScheduledReport(report, options = {}) {
+        const { idempotencyKey } = options;
+        if (!idempotencyKey) {
+            // SDK 가 만들어 주면 호출자는 그 값을 볼 수 없다 — 타임아웃으로 응답만 유실됐을 때
+            // 같은 키로 재시도할 방법이 사라지고, 다음 호출이 예약과 방을 하나 더 만든다.
+            throw new Error(
+                'createScheduledReport: options.idempotencyKey is required — '
+                + 'generate it once per form and reuse the same value on retry '
+                + '(재시도에 같은 키를 넘겨야 예약과 방이 중복 생성되지 않는다).'
+            );
+        }
+        const response = await this.apiClient.post(
+            '/api/v1/scheduled-reports',
+            report,
+            undefined,
+            { 'X-Idempotency-Key': idempotencyKey }
+        );
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 예약 고치기·멈추기·다시 켜기 — 고칠 칸만 보낸다.
+     *
+     * <p>{@code spec} 은 보내면 칸 전체이고 작업 종류·원천 방은 지금 값과 같아야 한다. {@code cadence} 는 보내면 주기
+     * 전체이고 {@code zoneId} 를 비우면 지금 시간대를 쓴다. {@code deliveryRoomIds} 는 보내면 목록 전체다(빈 배열 =
+     * 보내지 않음). 멈추기는 {@code status: 'PAUSED'}, 다시 켜기는 {@code status: 'ACTIVE'} 다.</p>
+     *
+     * @param {string} reportId - 예약 id
+     * @param {Object} changes - 고칠 칸 ({@code title}·{@code spec}·{@code cadence}·{@code deliveryRoomIds}·{@code status})
+     * @returns {Promise<Object>} 바꾼 예약
+     * @throws {Error} 없거나 남의 예약이면 404 {@code SCHEDULED_REPORT_NOT_FOUND}
+     */
+    async updateScheduledReport(reportId, changes) {
+        if (!reportId) {
+            throw new Error('reportId is required');
+        }
+        const response = await this.apiClient.patch(`/api/v1/scheduled-reports/${encodeURIComponent(reportId)}`, changes);
+        return this._unwrapSuccessResponse(response);
+    }
+
+    /**
+     * 예약 지우기 — 예약만 지우고 전용 방은 남긴다. 방은 {@link #leaveRoom}·{@link #deleteRoom} 으로 정리한다.
+     *
+     * @param {string} reportId - 예약 id
+     * @returns {Promise<void>}
+     * @throws {Error} 없거나 남의 예약이면 404 {@code SCHEDULED_REPORT_NOT_FOUND}
+     */
+    async deleteScheduledReport(reportId) {
+        if (!reportId) {
+            throw new Error('reportId is required');
+        }
+        await this.apiClient.delete(`/api/v1/scheduled-reports/${encodeURIComponent(reportId)}`);
+    }
+
     /**
      * 메시지 목록 조회
      * @param {string} roomId - 채팅방 ID

package/src/constants.js

@@ -40,15 +40,15 @@ export const ErrorTypes = {
     CHAT_MESSAGE_FAILED: 'CHAT_MESSAGE_FAILED',
     CHAT_SUBSCRIPTION_FAILED: 'CHAT_SUBSCRIPTION_FAILED',
 
-    // WebRTC errors
+    // 통화 errors
     MEDIA_ACCESS_DENIED: 'MEDIA_ACCESS_DENIED',
     SCREEN_SHARE_DENIED: 'SCREEN_SHARE_DENIED',
-    PEER_CONNECTION_FAILED: 'PEER_CONNECTION_FAILED',
-    ICE_CONNECTION_FAILED: 'ICE_CONNECTION_FAILED',
-    SIGNALING_FAILED: 'SIGNALING_FAILED',
+    MEDIA_CONNECTION_FAILED: 'MEDIA_CONNECTION_FAILED',
     DEVICE_SWITCH_FAILED: 'DEVICE_SWITCH_FAILED',
     ENUMERATE_DEVICES_FAILED: 'ENUMERATE_DEVICES_FAILED',
     CALL_ROOM_NOT_FOUND: 'CALL_ROOM_NOT_FOUND',
+    CALL_ALREADY_ACTIVE: 'CALL_ALREADY_ACTIVE',
+    NO_ACTIVE_CALL: 'NO_ACTIVE_CALL',
 
     // General errors
     INVALID_STATE: 'INVALID_STATE',
@@ -56,36 +56,38 @@ export const ErrorTypes = {
 };
 
 /**
- * WebRTC 시그널 타입 (서버 WebRTCMessageType과 일치)
+ * 서버 → 클라이언트 통화 이벤트 종류(서버 WebRTCMessageType 의 값). 클라이언트는 통화 신호를 보내지 않는다 — 통화 제어는 REST,
+ * 미디어는 LiveKit 이 맡는다(화상통화 SFU 설계 v0.7 I7).
  */
-export const SignalTypes = {
-    // Offer/Answer (WebRTC SDP)
-    CALL_OFFER: 'call_offer',
-    CALL_ANSWER: 'call_answer',
-
-    // ICE
-    ICE_CANDIDATE: 'ice_candidate',
-
-    // Room events
-    JOIN_ROOM: 'join_room',
-    LEAVE_ROOM: 'leave_room',
-    PEER_JOINED: 'peer_joined',
-    PEER_LEFT: 'peer_left',
-
-    // Media state
-    VIDEO_STATE_CHANGED: 'video_state_changed',
-    AUDIO_STATE_CHANGED: 'audio_state_changed',
-    SCREEN_SHARE_STARTED: 'screen_share_started',
-    SCREEN_SHARE_ENDED: 'screen_share_ended',
-
-    // Call events (UI 레벨)
-    CALL_REQUEST: 'call_request',
-    CALL_ACCEPT: 'call_accept',
-    CALL_REJECT: 'call_reject',
-    CALL_CANCEL: 'call_cancel',
-    CALL_END: 'call_end',
-    CALL_INVITATION: 'call_invitation',
-    CALL_BUSY: 'call_busy'
+export const CallEventTypes = {
+    /** 통화 초대 — 초대 대상의 모든 기기. */
+    INVITATION: 'call_invitation',
+    /** 그 사용자가 어느 기기에서 응답했다 — 그 사람의 다른 기기는 울림을 끈다. */
+    ANSWERED: 'call_answered',
+    /** 거절·무응답 — 방장에게. */
+    REJECT: 'call_reject',
+    /** 울림을 멈춘다 — 취소·종료·무응답 때 참가 기록 없는 초대 대상에게. */
+    CANCEL: 'call_cancel',
+    /** 통화 종료 — 통화방 토픽. */
+    END: 'call_end'
+};
+
+/** 통화 종류(서버 CallKind). */
+export const CallKind = {
+    DIRECT: 'DIRECT',
+    GROUP: 'GROUP'
+};
+
+/**
+ * 통화 상태(`callStateChanged` 의 state). ringing = 받는 쪽 울림, connecting = 입장·미디어 접속 중, connected = 미디어 연결,
+ * reconnecting = LiveKit 재접속 또는 «제거됨» 뒤 다시 입장 중, ended = 끝(사유는 reason).
+ */
+export const CallState = {
+    RINGING: 'ringing',
+    CONNECTING: 'connecting',
+    CONNECTED: 'connected',
+    RECONNECTING: 'reconnecting',
+    ENDED: 'ended'
 };
 
 /**
@@ -397,15 +399,14 @@ export const WebSocketPaths = {
     // 서버가 convertAndSendToUser(userId, "/queue/mail", MAIL_CHANGED) 로 전송 — 새 메일이면 messages[] 미리보기 포함
     MAIL_USER_DESTINATION: '/user/queue/mail',
 
-    // WebRTC destinations
+    // 통화 이벤트 — 서버만 보낸다(통화방 토픽은 종료, 개인 큐는 초대·응답·거절·취소)
     getWebRTCDestination: (roomId) => `/topic/webrtc/${roomId}`,
     getWebRTCUserDestination: () => `/user/queue/webrtc`,
 
     // Send destinations
     CHAT_SEND: '/app/chat/send',
     CHAT_READ: '/app/chat/read',
-    CHAT_TYPING: '/app/chat/typing',
-    WEBRTC_SIGNAL: '/app/webrtc/signal'
+    CHAT_TYPING: '/app/chat/typing'
 };
 
 /**
@@ -465,11 +466,8 @@ export const DefaultConfig = {
     // API
     apiTimeout: 30000,
 
-    // WebRTC
-    iceServers: [
-        { urls: 'stun:stun.l.google.com:19302' },
-        { urls: 'stun:stun1.l.google.com:19302' }
-    ],
+    // 통화 — 받는 쪽 울림을 끄는 시각(서버 울림 상한 60초 + 여유). 서버 «응답함»·«취소» 가 먼저 오면 그때 끈다.
+    callRingTimeoutMs: 65000,
 
     // Logging
     logLevel: 2 // WARN

package/src/core/ConnectionManager.js

@@ -781,9 +781,19 @@ class ConnectionManager extends EventEmitter {
     /**
      * 구독 해제
      * @param {string} destination - 구독 경로
+     * @param {Object} [subscription] - 이 구독만 푼다(subscribe 가 돌려준 객체). 끊긴 사이 같은 목적지 구독이 대기 줄에 여럿 섰다가 함께
+     *   붙으면 맵에는 마지막 것만 남는다 — 맵 항목은 그것이 이 구독일 때만 지운다. 생략하면 그 목적지의 지금(맵의) 구독을 푼다.
      */
-    unsubscribe(destination) {
+    unsubscribe(destination, subscription) {
         const entry = this.subscriptions.get(destination);
+        if (subscription) {
+            subscription.unsubscribe();
+            if (entry?.subscription === subscription) {
+                this.subscriptions.delete(destination);
+            }
+            this.logger.debug(`Unsubscribed from: ${destination}`);
+            return;
+        }
         if (entry) {
             entry.subscription.unsubscribe();
             this.subscriptions.delete(destination);

package/src/index.js

@@ -41,7 +41,9 @@ import TalkFlowClient from './TalkFlowClient.js';
 export {
     ConnectionState,
     ErrorTypes,
-    SignalTypes,
+    CallEventTypes,
+    CallKind,
+    CallState,
     ChatMessageType,
     DecisionCardLimits,
     ChatRoomType,
@@ -81,10 +83,8 @@ export { default as ChatClient } from './chat/ChatClient.js';
 // 방 미독 계산기 — ROOM_UNREAD_UPDATED / MESSAGE_RECEIVED 를 순서 역전에 안전하게 합산(READ_SYNC_DESIGN §6).
 export { RoomUnreadReconciler } from './chat/RoomUnreadReconciler.js';
 
-// WebRTC
+// 화상통화 (LiveKit SFU)
 export { default as WebRTCClient } from './webrtc/WebRTCClient.js';
-export { default as MediaStreamManager } from './webrtc/MediaStreamManager.js';
-export { default as PeerConnectionManager } from './webrtc/PeerConnectionManager.js';
 
 // Push — PushError/PushErrorCode 는 호출자가 instanceof / code 분기에 사용 가능하도록 noamed export.
 export { default as PushManager, PushError, PushErrorCode } from './push/PushManager.js';

package/src/talkflow/delegates.js

@@ -25,6 +25,15 @@ const CHAT_DELEGATE_METHODS = [
     // PM 보고서 — 참여 중인 방들에 PM 이 올린 작업 결과(지금은 자료조사) 목록·상세.
     'getPmReports',
     'getPmReport',
+    // 예약 보고 — 정해 둔 시각마다 PM 이 전용 방에 올리는 보고의 만들기·고치기·지우기와 고르기 목록.
+    'getScheduledReports',
+    'getScheduledReport',
+    'getScheduledReportKinds',
+    'getScheduledReportSourceRooms',
+    'getScheduledReportDeliveryRooms',
+    'createScheduledReport',
+    'updateScheduledReport',
+    'deleteScheduledReport',
     'fetchLinkPreview',
     'sendMessage',
     'sendMessageOptimistic',
@@ -99,41 +108,28 @@ const CHAT_DELEGATE_METHODS = [
 ];
 
 const WEBRTC_DELEGATE_METHODS = [
-    'initializeIceServers',
-    'getTurnCredentials',
-    'createCallRoom',
-    'getCallRoom',
-    'joinCallRoomApi',
-    'leaveCallRoomApi',
     'enableIncomingCalls',
     'disableIncomingCalls',
     'isIncomingCallsEnabled',
-    'startCall',
     'callUser',
+    'createGroupCall',
     'acceptCall',
+    'joinCall',
     'rejectCall',
     'cancelCall',
-    'endCall',
-    'toggleVideo',
-    'toggleAudio',
-    'setVideoEnabled',
-    'setAudioEnabled',
+    'leaveCall',
+    'endCallForAll',
+    'setCameraEnabled',
+    'setMicrophoneEnabled',
     'startScreenShare',
     'stopScreenShare',
-    'getLocalStream',
     'getDevices',
     'switchDevice',
-    'startDeviceChangeDetection',
-    'stopDeviceChangeDetection',
-    'applyVideoConstraints',
-    'getVideoSettings',
-    'getAudioSettings',
+    'getCallRoom',
+    'getParticipation',
     'isInCall',
-    'getCurrentRoom',
-    'getParticipants',
-    'getMediaState',
-    'getConnectionSummary',
-    'getStats'
+    'getCurrentCall',
+    'getRingingCalls'
 ];
 
 function defineDelegates(prototype, targetKey, methods) {

package/src/talkflow/eventForwarding.js

@@ -63,32 +63,20 @@ const CHAT_EVENT_MAP = [
 ];
 
 const WEBRTC_EVENT_MAP = [
-    ['localStreamStarted', 'localStreamStarted'],
-    ['localStreamStopped', 'localStreamStopped'],
-    ['remoteTrack', 'remoteTrack'],
-    ['screenShareStarted', 'screenShareStarted'],
-    ['screenShareEnded', 'screenShareEnded'],
-    ['deviceChange', 'deviceChange'],
-    ['mediaStateChanged', 'mediaStateChanged'],
-    ['callStarted', 'callStarted'],
+    ['incomingCall', 'incomingCall'],
+    ['ringStopped', 'ringStopped'],
+    ['callStateChanged', 'callStateChanged'],
     ['callEnded', 'callEnded'],
-    ['callRecoveryFailed', 'callRecoveryFailed'],
-    ['callRequested', 'callRequested'],
-    ['callAccepted', 'callAccepted'],
     ['callRejected', 'callRejected'],
-    ['callCancelled', 'callCancelled'],
-    ['callBusy', 'callBusy'],
-    ['incomingCall', 'incomingCall'],
-    ['incomingCallWhileBusy', 'incomingCallWhileBusy'],
-    ['callInvitation', 'callInvitation'],
-    ['userJoined', 'userJoined'],
-    ['userLeft', 'userLeft'],
+    ['participantJoined', 'participantJoined'],
     ['participantLeft', 'participantLeft'],
-    ['participantMediaState', 'participantMediaState'],
-    ['peerConnected', 'peerConnected'],
-    ['peerDisconnected', 'peerDisconnected'],
-    ['peerClosed', 'peerClosed'],
-    ['error', 'webrtcError']
+    ['trackSubscribed', 'trackSubscribed'],
+    ['trackUnsubscribed', 'trackUnsubscribed'],
+    ['localTrackPublished', 'localTrackPublished'],
+    ['localTrackUnpublished', 'localTrackUnpublished'],
+    ['participantMediaChanged', 'participantMediaChanged'],
+    ['callRecoveryFailed', 'callRecoveryFailed'],
+    ['callError', 'callError']
 ];
 
 function forwardMappedEvents(source, target, eventMap) {

package/src/talkflow/session.js

@@ -5,6 +5,23 @@ import WebRTCClient from '../webrtc/WebRTCClient.js';
 import PushManager from '../push/PushManager.js';
 import { handleMailPush } from './mailNotifications.js';
 
+/** 로그아웃·사용자 전환·연결 끊기 전에 통화에서 나가기를 기다리는 상한 — 망이 매달려도 오래 막지 않는다(미디어는 바로 끊긴다). */
+export const LEAVE_CALL_ON_EXIT_TIMEOUT_MS = 3000;
+
+/**
+ * 통화 중이면 나간다 — 자격(토큰·로그인)이 바뀌기 «전» 에 보내야 서버에 닿는다(바꾼 뒤면 다른 사용자 이름으로 가거나 로그아웃 표식
+ * 때문에 보내지 못한다). 실패·지연은 기다리지 않는다 — 서버는 끊김 유예 뒤 닫는다.
+ */
+async function leaveCallBeforeExit(client) {
+    if (!client.webrtc?.isInCall()) {
+        return;
+    }
+    let timer;
+    const leave = client.webrtc.leaveCall().catch(error => client.logger.warn('Failed to leave the call before exit:', error));
+    await Promise.race([leave, new Promise((resolve) => { timer = setTimeout(resolve, LEAVE_CALL_ON_EXIT_TIMEOUT_MS); })]);
+    clearTimeout(timer);
+}
+
 export function initializeSubClients(client) {
     if (client.connectionManager) {
         return;
@@ -52,7 +69,7 @@ export function initializeSubClients(client) {
         connectionManager: client.connectionManager,
         apiClient: client.apiClient,
         userId: client._userId,
-        iceServers: client.options.iceServers,
+        ringTimeoutMs: client.options.callRingTimeoutMs,
         logLevel: client.options.logLevel
     });
 
@@ -120,9 +137,7 @@ export function applySessionMethods(TalkFlowClient) {
             return;
         }
 
-        if (this.webrtc && this.webrtc.isInCall()) {
-            this.webrtc.endCall();
-        }
+        await leaveCallBeforeExit(this);
 
         if (this.webrtc) {
             this.webrtc.disableIncomingCalls();
@@ -139,6 +154,10 @@ export function applySessionMethods(TalkFlowClient) {
     };
 
     TalkFlowClient.prototype.logout = async function logout() {
+        await leaveCallBeforeExit(this);
+        // 이 신원의 통화는 여기서 끝 — 늦게 끝나는 요청(만드는 중이던 통화의 취소·재시도 등)이 자격이 바뀐 뒤에 나가지 않게 한다. 토큰
+        // 직접 방식은 WebRTCClient 를 다음 setToken 에 그대로 쓴다.
+        await this._webrtc?._resetIdentity();
         if (this.authSession) return this.authSession.logout();
         try {
             await this.apiClient.post('/v1/auth/signout');
@@ -362,6 +381,15 @@ export function applySessionMethods(TalkFlowClient) {
         const { userId } = validateAndParseJWT(token, { validateExpiry: false });
         const needReinitialize = this.userId && this.userId !== userId;
 
+        if (needReinitialize && this.connectionManager) {
+            // 다른 사용자로 바꾸기 전에 지금 사용자의 통화에서 나간다 — 토큰을 바꾼 뒤면 나가기가 새 사용자 이름으로 간다. 나간 뒤 화상통화를
+            // 바로 닫아 늦게 끝나는 요청(만드는 중이던 통화의 취소 등)도 새 사용자 이름으로 나가지 않게 한다. 로그인 세션 방식은 토큰이
+            // 이미 바뀌어 있어 _acceptAuthSession 이 먼저 이 기기에서만 끝냈다.
+            await leaveCallBeforeExit(this);
+            await this._webrtc?._resetIdentity();
+            this._webrtc?.destroy();
+        }
+
         this.options.jwtToken = token;
         this._userId = userId;
         this.apiClient.setJwtToken(token);
@@ -386,6 +414,11 @@ export function applySessionMethods(TalkFlowClient) {
             this._initializeSubClients();
         } else if (this.connectionManager) {
             this.connectionManager.updateToken(token);
+            // 토큰 직접 방식의 로그아웃 뒤 다른 사용자로 setToken 하면 재초기화 없이 여기로 온다 — «다른 기기에서 받음» 판정이 새 사용자로
+            // 하게 한다(옛 신원은 logout 이 _resetIdentity 로 끝냈다).
+            if (this._webrtc) {
+                this._webrtc.userId = userId;
+            }
         } else {
             this._initializeSubClients();
         }