quickvo-sdk-js 1.6.63 → 1.6.71

package/dist/src/QuickVO.d.ts

@@ -2,6 +2,7 @@ import { QuickOptions } from './types';
 export declare class QuickVO {
     static version: string;
     private _base;
+    /** 监听注册顺序：Base → ActionBase → ActionSFU → ActionP2P；同名 cws.on.* 以后构造者为准（房间/进房等由 ActionSFU 注册） */
     private _ACTION_BASE;
     private _ACTION_SFU;
     private _ACTION_P2P;
@@ -11,11 +12,7 @@ export declare class QuickVO {
         rnnoise?: import('./base/Base').PrRnnoise;
     }) => void;
     setCallStrategy: (callStrategy: import('./enums').K_callStrategy, mediaTypes?: import('./enums').K_mediaType[]) => Promise<void>;
-    addNotify: (notify: {
-        sn?: string;
-        event: "onJoinRoom" | "onQuitRoom" | "onPublish" | "onRoomActionChange" | "onBeforeTokenExpire" | "onTokenExpired" | "onDestroyRoom" | "onCDNPlayUrlAdd" | "onRoomUserSpeech" | "onLog" | "onRoomUsers" | "onRoomNetwork" | "onDevicechange" | "onPeerState" | "onRoomState";
-        callback?: (e: any) => void;
-    }) => string;
+    addNotify: (notify: import('./base/modules/notifyPayloadMap').QuickvoNotify) => string;
     setOptions: (options: Partial<QuickOptions & import('./types').RoomOptions>) => void;
     getLocalStream: (mediaType: import('./enums').K_mediaType) => MediaStream;
     getLocalStreams: () => {
@@ -51,20 +48,19 @@ export declare class QuickVO {
         mc_audio: string;
         mc_video: string;
     }>;
-    setLocalStream: (mediaTypes: import('./enums').K_mediaType[], active: boolean) => Promise<unknown>;
-    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => Promise<unknown>;
+    setLocalStream: (mediaTypes: import('./enums').K_mediaType[], active: boolean) => Promise<void>;
+    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => Promise<void>;
     setMediaTrackConstraints: (mediaType: import('./enums').K_mediaType, constraints: MediaTrackConstraints) => Promise<void>;
-    earlyConnect: (mediaTypes?: import('./enums').K_mediaType[]) => Promise<unknown>;
-    joinRoom: (roomOptions: import('./types').RoomOptions) => Promise<unknown>;
-    publish: (mediaTypes: import('./enums').K_mediaType[]) => Promise<boolean>;
-    stopPublish: (mediaTypes: import('./enums').K_mediaType[]) => Promise<boolean>;
-    pauseTracks: (mediaTypes: import('./enums').K_mediaType[], pause: boolean) => Promise<boolean>;
-    subscribe: (usersMediaTypes?: import('./types').UserMediaTypes[]) => Promise<unknown>;
-    stopSubscribe: (usersMediaTypes?: import('./types').UserMediaTypes[]) => Promise<boolean>;
-    setBanBehaviors: (usersBehaviors: Array<{
+    earlyConnect: () => Promise<true | undefined>;
+    joinRoom: (roomOptions: import('./types').RoomOptions) => Promise<string>;
+    publish: (mediaTypes: import('./enums').K_mediaType[]) => Promise<true>;
+    stopPublish: (mediaTypes: import('./enums').K_mediaType[]) => Promise<true>;
+    subscribe: (usersMediaTypes?: import('./types').UserMediaTypes[]) => Promise<true>;
+    stopSubscribe: (usersMediaTypes?: import('./types').UserMediaTypes[]) => Promise<true>;
+    setBehaviors: (usersBehaviors: Array<{
         id: string;
-        banBehaviors: { [key in import('./enums').K_mediaType]?: boolean; };
-    }>) => Promise<unknown>;
+        behaviors: { [key in import('./enums').K_mediaType]?: boolean; };
+    }>) => Promise<import('./protos/protoEvent').MessageRspCore<"preventUsersBehavior">>;
     updateSimulcast: (simulcast: "f" | "h" | "q") => Promise<void>;
     toggleRoomSpeechLang: (data: {
         input: string;
@@ -73,7 +69,7 @@ export declare class QuickVO {
     }) => void;
     updateToken: (sdkToken: string) => void;
     quitRoom: () => Promise<string>;
-    quitRoomEx: () => string;
+    quitRoomEx: () => Promise<string>;
     destroy: () => void;
     addRequestAnimationFrame: (key: string, func: FrameRequestCallback, options?: {
         fps?: number;
@@ -81,13 +77,7 @@ export declare class QuickVO {
     clearRequestAnimationFrame: (keys?: string[]) => void;
     getLocalUserTrackReports: (mediaType: import('./enums').K_mediaType) => import('./types').TrackReport;
     getRemoteUserTrackReports: (userId: string, origin: "sfu" | "p2p", direction: "sends" | "recvs", mediaType: import('./enums').K_mediaType) => import('./types').TrackReport | undefined;
-    getRoomAction: () => {
-        mc_audio: boolean;
-        mc_video: boolean;
-        ss_video: boolean;
-        ss_audio: boolean;
-    };
-    createRoomAction: (permissions: { [mediaType in import('./enums').K_mediaType]?: boolean; }) => number;
+    getRoomAction: () => number;
     _openP2P: (remoteUserId: string, mediaTypes: import('./enums').K_mediaType[], isRemotePush: boolean) => Promise<void>;
     _restoreRoom: () => Promise<void>;
     _debugger: () => Promise<void>;

package/dist/src/action/ActionSFU.d.ts

@@ -5,15 +5,27 @@ export declare class ActionSFU {
     base: Base;
     private _onOnline?;
     private _reconnectTimerId?;
-    private _isRestorePeer;
     /** 网络计算是否进行中，用于避免与 interval 重叠执行 */
     private _networkCalculating;
     /** 上次打印 generateTrackAnalysis 超时告警的时间，用于限流（每 30 秒最多一次） */
     private _lastTrackAnalysisWarnTime;
-    private _publisherController;
-    private _restorePeerPromise?;
-    private _syncRoomPromise?;
-    private _quitRoomPromise?;
+    /** 避免 Math.max(...arr) 在极大数组上触达引擎参数长度限制 */
+    private static _maxInNumberArray;
+    private static _minInNumberArray;
+    private _earlyConnectTask;
+    private _cwsConnectTask;
+    private _connectCFTask;
+    private _publishTask;
+    private _stopPublishTask;
+    private _subscribeTask;
+    private _stopSubscribeTask;
+    private _syncRoomInfoTask;
+    private _restorePeerTask;
+    private _quitRoomTask;
+    /** 串行化 joinRoom，避免并发进房互相覆盖 config / 用户列表 / 连接状态 */
+    private _joinRoomSerial;
+    /** 合并同一宏任务内多次 _autoCheckSubscribe 触发 */
+    private _autoCheckSubscribeCoalesce;
     constructor({ base }: {
         base: Base;
     });
@@ -22,13 +34,13 @@ export declare class ActionSFU {
      * @param mediaTypes K_mediaType[]
      * @param active boolean
      */
-    setLocalStream: (mediaTypes: K_mediaType[], active: boolean) => Promise<unknown>;
+    setLocalStream: (mediaTypes: K_mediaType[], active: boolean) => Promise<void>;
     /**
      * setMediaDeviceKind
      * @param mediaDeviceKind "audioinput" | "audiooutput" | "videoinput"
      * @param deviceId string | undefined
      */
-    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => Promise<unknown>;
+    setMediaDeviceKind: (mediaDeviceKind: MediaDeviceKind, deviceId: string | undefined) => Promise<void>;
     /**
      * setMediaTrackConstraints
      * @param mediaType K_mediaType
@@ -39,46 +51,39 @@ export declare class ActionSFU {
      * earlyConnect
      * @param mediaTypes ("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[]
      */
-    earlyConnect: (mediaTypes?: K_mediaType[]) => Promise<unknown>;
+    earlyConnect: () => Promise<true | undefined>;
     /**
      * joinRoom
      * @param roomOptions RoomOptions
      * @example quickvo.joinRoom({ userId: '', roomId: '', sdkToken: '', callType: '1' , newPublishAutoSubscribe: true })
      * @returns Promise<boolean>
      */
-    joinRoom: (roomOptions: RoomOptions) => Promise<unknown>;
+    joinRoom: (roomOptions: RoomOptions) => Promise<string>;
     /**
      * publish
      * @param mediaTypes MediaType[]
      * @example quickvo.publish(['mc_audio', 'mc_video'])
      */
-    publish: (mediaTypes: K_mediaType[]) => Promise<boolean>;
+    publish: (mediaTypes: K_mediaType[]) => Promise<true>;
     /**
      * stopPublish
      * @param trackNames  string[] = []
      * @example quickvo.stopPublish(['mc_audio'])
      */
-    stopPublish: (mediaTypes: K_mediaType[]) => Promise<boolean>;
-    /**
-     * pauseTracks
-     * @param mediaTypes MediaType[]
-     * @param pause boolean
-     * @example quickvo.pauseTracks(['mc_audio'], true)
-     */
-    pauseTracks: (mediaTypes: K_mediaType[], pause: boolean) => Promise<boolean>;
+    stopPublish: (mediaTypes: K_mediaType[]) => Promise<true>;
     /**
      * subscribe
      * @param usersMediaTypes: UserMediaTypes[] = [] 不传入订阅所有
      * @example quickvo.subscribe([{ userId: '123', mediaTypes: ['mc_audio', 'mc_video'] }])
      */
-    subscribe: (usersMediaTypes?: UserMediaTypes[]) => Promise<unknown>;
+    subscribe: (usersMediaTypes?: UserMediaTypes[]) => Promise<true>;
     /**
      * stopSubscribe
      * @param usersMediaTypes: UserMediaTypes[] = [] 不传入取消订阅所有
      * @example quickvo.stopSubscribe([{ userId: '123', mediaTypes: ['mc_audio', 'mc_video'] }])
      * @returns Promise<boolean>
      */
-    stopSubscribe: (usersMediaTypes?: UserMediaTypes[]) => Promise<boolean>;
+    stopSubscribe: (usersMediaTypes?: UserMediaTypes[]) => Promise<true>;
     /**
      * quitRoom
      * @example quickvo.quitRoom()
@@ -90,15 +95,15 @@ export declare class ActionSFU {
      * @example quickvo.quitRoomEx()
      * @returns Promise<boolean>
      */
-    quitRoomEx: () => string;
+    quitRoomEx: () => Promise<string>;
     /**
      * setBanBehaviors
      * @param usersBehaviors Array<{ id: string; banBehaviors: { [key in K_mediaType]?: boolean } }>
      */
-    setBanBehaviors: (usersBehaviors: Array<{
+    setBehaviors: (usersBehaviors: Array<{
         id: string;
-        banBehaviors: { [key in K_mediaType]?: boolean; };
-    }>) => Promise<unknown>;
+        behaviors: { [key in K_mediaType]?: boolean; };
+    }>) => Promise<import('../protos/protoEvent').MessageRspCore<"preventUsersBehavior">>;
     /**
      * toggleRoomSpeechLang
      * @param data { input: string; output: string; translateEnable?: boolean }
@@ -120,23 +125,43 @@ export declare class ActionSFU {
     /**
      * destroy
      */
-    destroy: () => void;
+    destroy: () => Promise<void>;
+    private _scheduleAutoCheckSubscribe;
+    private _waitPeerThenSubscribeTask;
+    private _clearTask;
     private _clear;
     private _connectCws;
+    /** joinRoom 专用：已 OPEN 则跳过；否则最多 3 次建连，单次超时 10s，均失败则 throw */
+    private static _JOIN_ROOM_WS_ATTEMPTS;
+    private static _JOIN_ROOM_WS_TIMEOUT_MS;
+    private _ensureWebSocketBeforeJoinRoom;
+    /**
+     * SFU Peer 建连：最多 3 次 `_connectCF`；单次信令（genTurnAddress / publish）超时 10s；ICE 等待 10s（见 `_connectCF` 内 `peerConnected`）。
+     * 用于进房与 disconnected→closed 后的 `_restorePeer`。
+     */
+    private static _RTC_RECOVERY_ATTEMPTS;
+    private static _RTC_RECOVERY_CWS_TIMEOUT_MS;
+    private _connectCFWithRecoveryRetries;
+    private _ensureWebRtcForJoinRoom;
     private _initHeartbeat;
+    /** 向服务端拉取 TURN/STUN 配置；失败或未返回有效 iceServers 时返回 undefined，由 Peer 回退默认 STUN */
+    private _fetchGenTurnAddress;
     private _connectCF;
     private _reportNetwork;
-    private _createTrack;
+    private _createTracks;
     private _closeTrack;
     private _pubNotify;
     private _renegotiate;
     private _ackMsg;
+    private _acquireJoinRoomSerial;
+    private _joinRoomExecute;
+    private _autoCheckSubscribe;
+    private _onRemoteUsersQuitRoom;
     private _notifySelfCallAction;
     private _calculateNetwork;
     private _checkAndSelectUserStreamOrigin;
     private _hasAsyncTask;
     private _syncRoomInfo;
     private _restorePeer;
-    private _onRemoteUsersQuitRoom;
     _restoreRoom: () => Promise<void>;
 }

package/dist/src/action/Task.d.ts

@@ -0,0 +1,40 @@
+export type TaskExeOptions = {
+    /**
+     * 默认 true：防抖结束后执行 fn，用其返回值 resolve，异常则 reject。
+     * false：仅调用 fn，由 fn 内部通过 task.resolve / task.reject 结束（如订阅队列回调）。
+     */
+    settle?: boolean;
+};
+/**
+ * 异步任务与防抖：constructor(debounceMs) 防抖毫秒数，默认 0。
+ * 多次 exe 会重置防抖；若需放弃上一轮可先判断 state === 'waiting' 再 clear()。
+ */
+export declare class Task<R = true> {
+    private readonly debounceMs;
+    private timer?;
+    /** 每次调度 / 清理 / 手动 settle 递增，用于丢弃过期的 setTimeout / microtask */
+    private scheduleGen;
+    state: 'ready' | 'waiting';
+    promise?: Promise<R>;
+    private _resolve?;
+    private _reject?;
+    private pendingFn?;
+    private pendingSettle;
+    constructor(debounceMs?: number);
+    /** 从 ready 进入 waiting 并创建 promise（不启动防抖）；用于 debounce 前仍需 await 其它逻辑的场景 */
+    begin(): Promise<R>;
+    /**
+     * 注册待执行函数：在防抖时间结束后执行。
+     * 若当前为 ready，会先 begin；若已在 waiting，会复用同一 promise 并重置防抖（尾触发）。
+     */
+    exe(fn: () => unknown | Promise<unknown>, options?: TaskExeOptions): Promise<R>;
+    /**
+     * 典型用于 publish：先 begin 占位，再 await prepare（如补本地流），最后对 fn 做防抖调度。
+     */
+    beginPrepareThenExe(prepare: () => void | Promise<void>, fn: () => unknown | Promise<unknown>): Promise<R>;
+    private _runFlush;
+    resolve: (value: R) => void;
+    reject: (error: unknown) => void;
+    /** SDK 内部清理：取消待执行的防抖，并以 resolve 结束，避免对外 Promise rejection */
+    clear: () => void;
+}

package/dist/src/base/Base.d.ts

@@ -41,6 +41,10 @@ export declare class Base {
     }) => void;
     setRoomState: (state: K_roomState) => void;
     setPeerState: (state: RTCPeerConnectionState) => void;
+    /**
+     * CWS 房间维度的通知是否与当前 config.roomId 一致（防串房误处理）
+     */
+    guardNotifyRoomId: (roomId: string | undefined, e: unknown) => boolean;
     setCallStrategy: (callStrategy: K_callStrategy, mediaTypes?: K_mediaType[]) => Promise<void>;
     _checkUserStreamOrigin: ({ p2pAverageQuality, sfuAverageQuality }: {
         p2pAverageQuality: number;
@@ -53,7 +57,7 @@ export declare class Base {
         mediaTypes: K_mediaType[];
         desc?: string;
         connectedTime?: string;
-    }) => Promise<Pick<import('../protos/protoEvent').MessageRsp<"reportP2PConnectEx">, "sn" | "event" | "data" | "code" | "desc">> | undefined;
+    }) => Promise<import('../protos/protoEvent').MessageRspCore<"reportP2PConnectEx">> | undefined;
     _reportLog: (_type: Report_Log_Type, describe?: string) => void;
 }
 export {};

package/dist/src/base/modules/Config.d.ts

@@ -1,6 +1,7 @@
 import { QuickOptions, RoomOptions } from '../../types';
 import { K_roomState } from '../../enums/roomState';
 import { K_mediaType } from '../../enums';
+import { K_callStrategy } from '../../enums/callStrategy';
 export declare class Config {
     /**
      * 信令服务地址
@@ -39,13 +40,9 @@ export declare class Config {
      */
     callType: number;
     /**
-     * 整体房间行为状态 0为默认不禁言
+     * 整体房间行为状态 0为默认不禁止
      */
-    banAction: number;
-    banActionStr: string;
-    banActionMap: {
-        [key in K_mediaType]: boolean;
-    };
+    roomAction: number;
     /**
      * 是否开启语音翻译
      */
@@ -63,9 +60,15 @@ export declare class Config {
      */
     useP2P: boolean;
     /**
-     * 新媒体流是否自动订阅
+     * 通话策略（QuickOptions.setOptions 传入时落库，实际编码参数由 Base.setCallStrategy 应用）
      */
-    newPublishAutoSubscribe: boolean;
+    callStrategy?: K_callStrategy;
+    /**
+     * 是否自动订阅
+     */
+    autoSubscribe: {
+        [key in K_mediaType]: boolean;
+    };
     /**
      * 房间状态
      */
@@ -130,16 +133,10 @@ export declare class Config {
         video: RTCRtpCodec[];
     };
     constructor();
-    updateRoomAction: (banAction: number) => void;
-    createRoomAction: (permissions: { [mediaType in K_mediaType]?: boolean; }) => number;
-    getRoomAction: () => {
-        mc_audio: boolean;
-        mc_video: boolean;
-        ss_video: boolean;
-        ss_audio: boolean;
-    };
+    updateRoomAction: (roomAction: number) => void;
+    getRoomAction: () => number;
     /**
-     * setOptions
+     * setOptions（显式字段赋值，避免任意 key 污染 Config）
      */
     setOptions: (options: Partial<QuickOptions & RoomOptions>) => void;
     createWsUrl: () => string;

package/dist/src/base/modules/Notifys.d.ts

@@ -1,41 +1,16 @@
-type NotifyName = 'onLog' | 'onRoomUsers' | 'onJoinRoom' | 'onPublish' | 'onQuitRoom' | 'onRoomNetwork' | 'onDevicechange' | 'onCDNPlayUrlAdd' | 'onRoomUserSpeech' | 'onBeforeTokenExpire' | 'onTokenExpired' | 'onPeerState' | 'onRoomState' | 'onDestroyRoom' | 'onRoomActionChange';
-/**
- * 广播
- */
-type Notify = {
-    /**
-     * 事件随机码
-     */
-    sn?: string;
-    /**
-     * 事件名称 支持同一事件名称在多个地方注册
-     */
-    event: NotifyName;
-    /**
-     * 自定义回调函数
-     */
-    callback?: (e: any) => void;
-};
-interface Result {
-    code: number;
-    data: any;
-    desc: string;
-    sn?: string;
-}
+import { K_quickvoNotifyName, NotifyPayloadMap, QuickvoNotify } from './notifyPayloadMap';
+export type { K_quickvoNotifyName, NotifyPayloadMap, QuickvoNotify, NotifyEmitPayloadFor, NotifyEmitPayloadUnion } from './notifyPayloadMap';
+export { defineQuickvoNotify } from './notifyPayloadMap';
 export declare class Notifys {
-    queue: Map<NotifyName, Notify[]>;
+    queue: Map<K_quickvoNotifyName, QuickvoNotify[]>;
     /**
-     * 派发广播事件
-     * @param event 事件名称
-     * @param result 事件响应值
+     * 派发广播事件（第二参类型随 event 变化）
      */
-    emit: (event: NotifyName, result: Result) => void;
+    emit: <E extends K_quickvoNotifyName>(event: E, result: NotifyPayloadMap[E]) => void;
     /**
      * 添加广播
      * @param notify
-     * @param _private
      * @returns sn
      */
-    add: (notify: Notify) => string;
+    add: (notify: QuickvoNotify) => string;
 }
-export {};

package/dist/src/base/modules/Peer.d.ts

@@ -1,21 +1,28 @@
 import { K_mediaType } from '../../enums/mediaType';
-import { UserTrack } from '../../types';
+import { TurnUrlsResponse } from '../../protos/gen/modules/Room_pb';
 import { Config } from './Config';
 import { Users } from './users/Users';
 import { PrResolves } from './PrResolves';
 interface On {
-    state?: (_state: 'connecting' | 'connected' | 'disconnected' | 'failed' | 'closed') => void;
+    state?: (_state: RTCPeerConnectionState) => void;
 }
 export declare class Peer {
     config: Config;
     users: Users;
     prResolves: PrResolves<"peerConnected">;
     pc: RTCPeerConnection;
+    initTime: number;
     transceiverMap: Map<"mc_audio" | "mc_video" | "ss_video" | "ss_audio", RTCRtpTransceiver>;
-    transceiverCreatedTimeMap: Map<"mc_audio" | "mc_video" | "ss_video" | "ss_audio", number>;
-    transceiverTrackMap: Map<"mc_audio" | "mc_video" | "ss_video" | "ss_audio", UserTrack>;
+    /**
+     * 已广播的轨道
+     */
+    broadcasted: {
+        [key in K_mediaType]?: Boolean;
+    };
     private iceConnectionTimer;
     simulcast: 'f' | 'h' | 'q';
+    /** 当前 SFU 连接使用的 TURN 配置过期时间（毫秒，来自 genTurnAddress.expiresAt） */
+    turnExpiresAtMs?: number;
     on: On;
     waitings: {
         peerConnected: () => Promise<unknown>;
@@ -24,20 +31,23 @@ export declare class Peer {
         config: Config;
         users: Users;
     });
+    /** 将服务端 genTurnAddress（TurnUrlsResponse）转为 RTCConfiguration；无有效数据时回退到公共 STUN */
+    private static rtcConfigurationFromTurnRsp;
+    setBroadcasted: (mediaTypes: K_mediaType[], active: boolean) => void;
+    getNoBroadcasted: (mediaTypes: K_mediaType[]) => ("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[];
+    checkValid: () => boolean;
     /**
      * setRTCRtpSenderParameters
      * @param parameters RTCRtpSendParameters
      */
     setRTCRtpSenderParameters: (parameters: Partial<RTCRtpSendParameters>, mediaTypes?: K_mediaType[]) => Promise<void>;
-    init: () => Promise<void>;
+    init: (turnRsp?: TurnUrlsResponse) => Promise<void>;
     close: () => void;
     addSenders: (mediaTypes: K_mediaType[]) => Promise<("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[]>;
     syncSenderStreamTrack: (mediaTypes: K_mediaType[]) => Promise<void>;
     stopSenders: (mediaTypes: K_mediaType[]) => void;
-    checkSendersCreatedTime: () => ("mc_audio" | "mc_video" | "ss_video" | "ss_audio")[];
     hasSender: (mediaType: K_mediaType) => boolean;
     replaceSenderTrack: (mediaType: K_mediaType, track: MediaStreamTrack) => Promise<void>;
-    getSenderUserTracks: (mediaTypes?: K_mediaType[]) => UserTrack[];
     getTransceiver: (mid: string | null) => RTCRtpTransceiver | undefined;
     getSenderTrack: (mediaType: K_mediaType) => MediaStreamTrack | null | undefined;
     getRecvierTrack: (mid: string | null) => MediaStreamTrack | undefined;

package/dist/src/base/modules/cws/CallsWebSocket.d.ts

@@ -1,8 +1,13 @@
-import { K_notifyName } from '../../../enums/notifyName';
 import { K_eventName } from '../../../enums/eventName';
-import { CallsWebSocketEvent, Options } from './CallsWebSocketEvent';
+import { CallsWebSocketOn } from '../../../protos/protoEvent';
+import { Options, CallsWebSocketEvent } from './CallsWebSocketEvent';
 import { Config } from '../Config';
 import { PrWebSocket } from './PrWebSocket';
+export type { CallsWebSocketOn };
+/**
+ * 从 IndexedDB 读取 `#quickvo.logs` 并触发浏览器下载 JSON 文件（控制台可执行 `getQVLogs()`）。
+ */
+export declare function getQVLogs(): Promise<void>;
 export interface CallsWebSocketOptions {
     /**
      * websocket服务地址
@@ -24,13 +29,8 @@ export declare class CallsWebSocket {
     timeout: number;
     prws: PrWebSocket;
     events: Events;
-    on: {
-        [key in K_notifyName]?: Function;
-    } & {
-        state?: (state: 'connecting' | 'reconnecting' | 'connected' | 'closed') => void;
-        log?: (e: any) => void;
-    };
-    /** 日志写入节流：先入内存缓冲，定时批量写 localStorage */
+    on: CallsWebSocketOn;
+    /** 日志写入节流：先入内存缓冲，定时批量写 IndexedDB（structured clone 可保留 BigInt） */
     private _logBuffer;
     private _logFlushTimer;
     private static _LOG_FLUSH_DELAY;
@@ -38,14 +38,15 @@ export declare class CallsWebSocket {
         config: Config;
     });
     needRestoreRoom: () => boolean;
+    isValid: () => boolean;
     connect: () => Promise<void>;
     reconnect: () => Promise<void>;
     close: () => void;
     createRequest: <T extends K_eventName>(eventName: T, options?: Options) => CallsWebSocketEvent<T>;
     hasEvent: (eventName: K_eventName) => boolean;
     clearEvents: () => void;
+    private _dispatchCwsDecodedMessage;
     retryEvents: () => Promise<void>;
-    private _updataLogs;
+    private _updateLogs;
     private _flushLogs;
 }
-export {};

package/dist/src/base/modules/cws/CallsWebSocketEvent.d.ts

@@ -1,5 +1,5 @@
 import { K_eventName } from '../../../enums/eventName';
-import { MessageReq, MessageRsp } from '../../../protos/protoEvent';
+import { MessageReq, MessageRsp, MessageRspCore } from '../../../protos/protoEvent';
 import { PrWebSocket } from './PrWebSocket';
 export interface Options {
     /**
@@ -17,8 +17,8 @@ export declare class CallsWebSocketEvent<T extends K_eventName> {
     message?: MessageReq<T>;
     needRetry: boolean;
     sn: number;
-    _resolve: (_value: Pick<MessageRsp<T>, "event" | "sn" | "data" | "code" | "desc">) => void;
-    _reject: (_reason?: any) => void;
+    _resolve: (_value: MessageRspCore<T>) => void;
+    _reject: (_reason?: unknown) => void;
     sendBefore?: (_message: MessageReq<T>) => void;
     sendAfter?: () => void;
     options: {
@@ -27,10 +27,10 @@ export declare class CallsWebSocketEvent<T extends K_eventName> {
     };
     timer: number;
     constructor(eventName: T, prws: PrWebSocket, options?: Options);
-    resolve: (_value: MessageRsp<T>) => void;
-    reject: (_reason?: any) => void;
+    resolve: (_value: MessageRspCore<T> & Partial<Pick<MessageRsp<T>, "time">>) => void;
+    reject: (_reason?: unknown) => void;
     retry: () => void;
-    send: (req_message: Pick<MessageReq<T>, "data" | "compress" | "version">) => Promise<Pick<MessageRsp<T>, "sn" | "event" | "data" | "code" | "desc">>;
+    send: (req_message: Pick<MessageReq<T>, "data" | "compress" | "version">) => Promise<MessageRspCore<T>>;
     private sendMsg;
     private _createTimer;
     destroy: () => void;

package/dist/src/base/modules/cws/PrWebSocket.d.ts

@@ -1,13 +1,13 @@
 interface On {
     /**
-     * 消息回调
+     * 消息回调（binaryType 为 arraybuffer 时为 ArrayBuffer）
      * @description 接收当前WebSocket的所有消息
      */
-    message?: (_e: any) => void;
+    message?: (data: ArrayBuffer) => void;
     /**
      * 检测是否重连
      */
-    checkReconnect?: (e: any) => void;
+    checkReconnect?: (e: CloseEvent) => void;
 }
 export declare class PrWebSocket {
     binaryType: BinaryType;
@@ -21,15 +21,16 @@ export declare class PrWebSocket {
     on: On;
     getUrl: () => string;
     constructor();
-    connect: () => Promise<unknown>;
+    connect: () => Promise<number>;
     /**
      * 重新连接
      */
-    reconnect: () => Promise<unknown>;
+    reconnect: () => Promise<number>;
+    private _reconnectAsync;
     /**
      * 发送消息
      */
-    send: (_data: string | ArrayBufferLike | Blob | ArrayBufferView) => void;
+    send: (data: Parameters<WebSocket["send"]>[0]) => void;
     /**
      * 关闭
      */

package/dist/src/base/modules/cws/callLogStorage.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 通话调试日志：IndexedDB 存储（structured clone 支持 BigInt，可原样持久化）
+ * - `#quickvo.logs` → object store `logs_main`
+ * - `#quickvo.ignoreEvents` → object store `logs_ignore`（与主日志分表，避免互相覆盖或迁移遗漏）
+ * 首次读取时从 localStorage 迁移旧数据；v1 单表 `call_logs` 在首次读取时惰性迁入对应新表
+ */
+/**
+ * 读取日志条目列表；优先 IndexedDB 新表，再尝试 v1 表与 localStorage 并写回新表
+ */
+export declare function loadCallLogs(key: string): Promise<any[]>;
+/**
+ * 持久化日志条目（可含 BigInt，不经 JSON）
+ */
+export declare function saveCallLogs(key: string, entries: any[]): Promise<void>;
+/**
+ * 深拷贝并将 BigInt 转为十进制字符串，供 on.log / JSON 等无法处理 BigInt 的场景
+ */
+export declare function cloneWithBigIntAsString<T>(value: T): T;

package/dist/src/base/modules/cws/quickvoCodecWorkerMain.d.ts

@@ -0,0 +1,6 @@
+import { OnMessageFormatResult } from '../../../protos/protoEvent';
+export declare function decodeCwsBinary<E extends string = string>(buffer: ArrayBuffer): Promise<OnMessageFormatResult<E>>;
+/** gzip 压缩（发送侧 / 日志上报）；失败时回退主线程 pako */
+export declare function gzipCompressBytes(data: Uint8Array): Promise<Uint8Array>;
+/** 终止 CWS 编解码 Worker；`QuickVO.destroy` 时应调用。之后可再次懒创建 Worker。 */
+export declare function destroyQuickvoCodecWorker(): void;