call-engine-wx 0.1.0

package/dist/index.esm.mjs

@@ -0,0 +1,2372 @@
+/*! call-engine-wx | (c) 2024 Tencent | MIT */
+import TRTCCloud from '@tencentcloud/trtc-component-wx';
+import TencentCloudChat from '@tencentcloud/lite-chat';
+export { default as TencentCloudChat } from '@tencentcloud/lite-chat';
+
+class EventEmitter {
+    constructor() {
+        this._handlers = new Map();
+    }
+    on(event, fn) {
+        if (typeof fn !== 'function')
+            return this;
+        let list = this._handlers.get(event);
+        if (!list) {
+            list = [];
+            this._handlers.set(event, list);
+        }
+        list.push({ fn, once: false });
+        return this;
+    }
+    once(event, fn) {
+        if (typeof fn !== 'function')
+            return this;
+        let list = this._handlers.get(event);
+        if (!list) {
+            list = [];
+            this._handlers.set(event, list);
+        }
+        list.push({ fn, once: true });
+        return this;
+    }
+    off(event, fn) {
+        if (!event) {
+            this._handlers.clear();
+            return this;
+        }
+        const list = this._handlers.get(event);
+        if (!list)
+            return this;
+        if (!fn) {
+            this._handlers.delete(event);
+            return this;
+        }
+        const next = list.filter((h) => h.fn !== fn);
+        if (next.length === 0) {
+            this._handlers.delete(event);
+        }
+        else {
+            this._handlers.set(event, next);
+        }
+        return this;
+    }
+    emit(event, ...args) {
+        const list = this._handlers.get(event);
+        if (!list || list.length === 0)
+            return false;
+        // Snapshot — listener may mutate the list via off/once.
+        const snapshot = list.slice();
+        for (const h of snapshot) {
+            try {
+                h.fn.apply(null, args);
+            }
+            catch (err) {
+                // Never let one bad listener break the rest.
+                // eslint-disable-next-line no-console
+                console.error('[call-engine-wx] listener threw:', err);
+            }
+            if (h.once)
+                this.off(event, h.fn);
+        }
+        return true;
+    }
+    removeAllListeners(event) {
+        if (event) {
+            this._handlers.delete(event);
+        }
+        else {
+            this._handlers.clear();
+        }
+        return this;
+    }
+    listenerCount(event) {
+        const list = this._handlers.get(event);
+        return list ? list.length : 0;
+    }
+}
+
+// ====================== enum =======================
+var CallStatus;
+(function (CallStatus) {
+    CallStatus[CallStatus["NONE"] = 0] = "NONE";
+    CallStatus[CallStatus["WAITING"] = 1] = "WAITING";
+    CallStatus[CallStatus["CALLING"] = 2] = "CALLING";
+})(CallStatus || (CallStatus = {}));
+var CallRole;
+(function (CallRole) {
+    CallRole[CallRole["NONE"] = 0] = "NONE";
+    CallRole[CallRole["CALLER"] = 1] = "CALLER";
+    CallRole[CallRole["CALLEE"] = 2] = "CALLEE";
+})(CallRole || (CallRole = {}));
+var CallMediaType;
+(function (CallMediaType) {
+    CallMediaType[CallMediaType["UNKNOWN"] = 0] = "UNKNOWN";
+    CallMediaType[CallMediaType["AUDIO"] = 1] = "AUDIO";
+    CallMediaType[CallMediaType["VIDEO"] = 2] = "VIDEO";
+})(CallMediaType || (CallMediaType = {}));
+var CallScene;
+(function (CallScene) {
+    CallScene[CallScene["NONE"] = 0] = "NONE";
+    CallScene[CallScene["GROUP"] = 1] = "GROUP";
+    CallScene[CallScene["MULTI"] = 2] = "MULTI";
+    CallScene[CallScene["SINGLE"] = 3] = "SINGLE";
+})(CallScene || (CallScene = {}));
+var IOSOfflinePushType;
+(function (IOSOfflinePushType) {
+    IOSOfflinePushType[IOSOfflinePushType["APNs"] = 0] = "APNs";
+    IOSOfflinePushType[IOSOfflinePushType["VoIP"] = 1] = "VoIP";
+})(IOSOfflinePushType || (IOSOfflinePushType = {}));
+var CallInvitationResultCodeType;
+(function (CallInvitationResultCodeType) {
+    CallInvitationResultCodeType[CallInvitationResultCodeType["SUCCESS"] = 0] = "SUCCESS";
+    CallInvitationResultCodeType[CallInvitationResultCodeType["INVITED"] = 1] = "INVITED";
+    CallInvitationResultCodeType[CallInvitationResultCodeType["LINE_BUSY"] = 2] = "LINE_BUSY";
+})(CallInvitationResultCodeType || (CallInvitationResultCodeType = {}));
+var CallEndReason;
+(function (CallEndReason) {
+    CallEndReason[CallEndReason["UNKNOWN"] = 0] = "UNKNOWN";
+    CallEndReason[CallEndReason["HANGUP"] = 1] = "HANGUP";
+    CallEndReason[CallEndReason["REJECT"] = 2] = "REJECT";
+    CallEndReason[CallEndReason["NO_RESPONSE"] = 3] = "NO_RESPONSE";
+    CallEndReason[CallEndReason["OFFLINE"] = 4] = "OFFLINE";
+    CallEndReason[CallEndReason["LINE_BUSY"] = 5] = "LINE_BUSY";
+    CallEndReason[CallEndReason["CANCELED"] = 6] = "CANCELED";
+    CallEndReason[CallEndReason["OTHER_DEVICE_ACCEPTED"] = 7] = "OTHER_DEVICE_ACCEPTED";
+    CallEndReason[CallEndReason["OTHER_DEVICE_REJECT"] = 8] = "OTHER_DEVICE_REJECT";
+    CallEndReason[CallEndReason["END_BY_SERVER"] = 9] = "END_BY_SERVER";
+})(CallEndReason || (CallEndReason = {}));
+var LOG_LEVEL;
+(function (LOG_LEVEL) {
+    LOG_LEVEL[LOG_LEVEL["DEBUG"] = 0] = "DEBUG";
+    LOG_LEVEL[LOG_LEVEL["INFO"] = 1] = "INFO";
+    LOG_LEVEL[LOG_LEVEL["WARN"] = 2] = "WARN";
+    LOG_LEVEL[LOG_LEVEL["ERROR"] = 3] = "ERROR";
+    LOG_LEVEL[LOG_LEVEL["NONE"] = 4] = "NONE";
+})(LOG_LEVEL || (LOG_LEVEL = {}));
+var CameraPosition;
+(function (CameraPosition) {
+    CameraPosition[CameraPosition["FRONT"] = 1] = "FRONT";
+    CameraPosition[CameraPosition["BACK"] = 0] = "BACK";
+})(CameraPosition || (CameraPosition = {}));
+var AudioPlayBackDevice;
+(function (AudioPlayBackDevice) {
+    AudioPlayBackDevice[AudioPlayBackDevice["SPEAKER"] = 0] = "SPEAKER";
+    AudioPlayBackDevice[AudioPlayBackDevice["EAR"] = 1] = "EAR";
+})(AudioPlayBackDevice || (AudioPlayBackDevice = {}));
+const CallInvitationRespondedType = Object.freeze({
+    None: 0,
+    AcceptedByInvitee: 1,
+    RejectedByInvitee: 2,
+    NoResponseUntilTimeout: 3,
+    Hangup: 4,
+    Join: 5,
+    Offline: 6,
+    InviteUser: 7,
+});
+const TUIErrorCode = Object.freeze({
+    ERR_FAILED: -1, // generic, uncategorised failure
+});
+const TUICallEvent = Object.freeze({
+    ERROR: 'onError',
+    SDK_READY: 'sdkReady',
+    KICKED_OUT: 'onKickedOffline',
+    onUserSigExpired: 'onUserSigExpired',
+    ON_CALL_BEGIN: 'onCallBegin',
+    ON_CALL_END: 'onCallEnd',
+    ON_CALL_RECEIVED: 'onCallReceived',
+    ON_CALL_CANCELED: 'onCallCanceled',
+    ON_CALL_NOT_CONNECTED: 'onCallNotConnected',
+    INVITED: 'onInvited',
+    USER_ENTER: 'onUserJoin',
+    USER_LEAVE: 'onUserLeave',
+    VIEW_LAYOUT_CHANGED: 'viewLayoutChanged',
+});
+
+// 日志上报相关
+// 常量
+const NAME = {
+    NUMBER: 'number',
+    OBJECT: 'object',
+    ARRAY: 'array',
+    FUNCTION: 'function'};
+
+const isObject = function (input) {
+    return input !== null && typeof input === NAME.OBJECT;
+};
+const isNumber = function (input) {
+    return typeof input === NAME.NUMBER;
+};
+/**
+ * 检测input类型是否为数组
+ * @param {*} input 任意类型的输入
+ * @returns {Boolean} true->array / false->not an array
+ */
+const isArray = function (input) {
+    if (typeof Array.isArray === NAME.FUNCTION) {
+        return Array.isArray(input);
+    }
+    return getType(input) === NAME.ARRAY;
+};
+/**
+ * 检测input类型是否为function
+ * @param {*} input 任意类型的输入
+ * @returns {Boolean} true->input is a function
+ */
+const isFunction = function (input) {
+    return typeof input === NAME.FUNCTION;
+};
+/**
+ * Get the object type string
+ * @param {*} input 任意类型的输入
+ * @returns {String} the object type string
+ */
+const getType = function (input) {
+    return Object.prototype.toString
+        .call(input)
+        .match(/^\[object (.*)\]$/)[1]
+        .toLowerCase();
+};
+// ----------------- SSO Head -----------------
+// Pinned at build time so heartbeats / start_call requests carry a
+// consistent client identifier the backend can use for diagnostics.
+const SDK_VERSION = '1.0.0.0';
+const SDK_HEAD_VERSION = 2;
+// Cached device snapshot. `wx.getSystemInfoSync()` is cheap but does
+// touch native, so resolve once at module load and reuse for every
+// outgoing SSO packet.
+let _cachedDeviceInfo = null;
+/**
+ * Resolve the current device's OS / model info for the SSO Head.
+ *
+ * Detection order:
+ *   1. WeChat Mini Program  — `wx.getSystemInfoSync()` (system="iOS 18.0", model)
+ *   2. uni-app              — `uni.getSystemInfoSync()` (same shape)
+ *   3. Browser fallback     — parse `navigator.userAgent`
+ *   4. Hard-coded default   — last resort so we never throw at runtime
+ */
+const getDeviceInfo = function () {
+    if (_cachedDeviceInfo)
+        return _cachedDeviceInfo;
+    const info = { osName: 'Unknown', osVersion: '0.0.0', deviceName: 'Unknown' };
+    try {
+        // @ts-ignore — `wx` is a runtime global in the WeChat Mini Program env
+        const wxGlobal = typeof wx !== 'undefined' ? wx : null;
+        // @ts-ignore — `uni` is the uni-app runtime global
+        const uniGlobal = typeof uni !== 'undefined' ? uni : null;
+        if (wxGlobal && typeof wxGlobal.getSystemInfoSync === 'function') {
+            const sys = wxGlobal.getSystemInfoSync() || {};
+            const [osName = 'Unknown', osVersion = '0.0.0'] = String(sys.system || '').split(' ');
+            info.osName = osName;
+            info.osVersion = osVersion;
+            info.deviceName = sys.model || sys.brand || 'Unknown';
+        }
+        else if (uniGlobal && typeof uniGlobal.getSystemInfoSync === 'function') {
+            const sys = uniGlobal.getSystemInfoSync() || {};
+            const [osName = 'Unknown', osVersion = '0.0.0'] = String(sys.system || '').split(' ');
+            info.osName = osName;
+            info.osVersion = osVersion;
+            info.deviceName = sys.model || sys.brand || 'Unknown';
+        }
+        else if (typeof navigator !== 'undefined' && navigator.userAgent) {
+            // Lightweight UA parse — good enough for the Head field.
+            const ua = navigator.userAgent;
+            if (/Mac OS X/i.test(ua)) {
+                info.osName = 'MacOS';
+                const m = ua.match(/Mac OS X ([\d_\.]+)/);
+                info.osVersion = m ? m[1].replace(/_/g, '.') : '0.0.0';
+                info.deviceName = 'Mac';
+            }
+            else if (/Windows/i.test(ua)) {
+                info.osName = 'Windows';
+                const m = ua.match(/Windows NT ([\d\.]+)/);
+                info.osVersion = m ? m[1] : '0.0.0';
+                info.deviceName = 'PC';
+            }
+            else if (/Android/i.test(ua)) {
+                info.osName = 'Android';
+                const m = ua.match(/Android ([\d\.]+)/);
+                info.osVersion = m ? m[1] : '0.0.0';
+                info.deviceName = 'Android';
+            }
+            else if (/iPhone|iPad|iPod/i.test(ua)) {
+                info.osName = 'iOS';
+                const m = ua.match(/OS ([\d_]+)/);
+                info.osVersion = m ? m[1].replace(/_/g, '.') : '0.0.0';
+                info.deviceName = /iPad/i.test(ua) ? 'iPad' : 'iPhone';
+            }
+        }
+    }
+    catch (_) { /* swallow — fall through to defaults */ }
+    _cachedDeviceInfo = info;
+    return info;
+};
+/**
+ * Build the common `Head` block for SSO requests
+ * (`start_call`, `heart_beat`, etc.).
+ *
+ * Only `Command` changes per request — every other field is derived
+ * from the device once and cached.
+ */
+const buildSSOHead = function (command) {
+    const device = getDeviceInfo();
+    return {
+        Command: command,
+        DeviceName: device.deviceName,
+        LongPollingKey: '',
+        OSName: device.osName,
+        OSVersion: device.osVersion,
+        RoomId: '',
+        SdkVersion: SDK_VERSION,
+        Version: SDK_HEAD_VERSION,
+    };
+};
+// ----------------- Terminal ID -----------------
+/**
+ * Generate a per-device terminal id used by `call_engine_srv.handle_call`.
+ *
+ * Layout: 16 random bytes rendered as uppercase hex, segmented 4-2-2-2-6
+ *   e.g. "A1B2C3D4-E5F6-7890-ABCD-1122334455FF"
+ *
+ * The format mirrors what the reference iOS / Android clients send so the
+ * backend (and the multi-device sync flow) treat us identically.
+ */
+const generateTerminalId = function () {
+    // Prefer crypto.getRandomValues when available (Mini Program 2.x+, browser).
+    const bytes = new Array(16);
+    // @ts-ignore — crypto is available in modern WXMP / browsers
+    const cryptoObj = (typeof crypto !== 'undefined' && crypto)
+        // @ts-ignore — uni-app exposes uni.getRandomValues / wx.getRandomValues asynchronously,
+        // so we don't rely on them here.
+        || null;
+    if (cryptoObj && typeof cryptoObj.getRandomValues === 'function') {
+        const buf = new Uint8Array(16);
+        cryptoObj.getRandomValues(buf);
+        for (let i = 0; i < 16; i++)
+            bytes[i] = buf[i];
+    }
+    else {
+        for (let i = 0; i < 16; i++)
+            bytes[i] = Math.floor(Math.random() * 256);
+    }
+    const hex = bytes.map((b) => b.toString(16).padStart(2, '0')).join('').toUpperCase();
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+};
+// ----------------- call 函数-----------------
+const generateRandomStrRoomId = function (strRoomId) {
+    if (strRoomId)
+        return strRoomId;
+    return `roomId_${Math.floor(Math.random() * 1000000)}`;
+};
+const generateCallInfo = function (params = {}) {
+    let scene = CallScene.NONE;
+    const inviteeList = params.userIDList || [];
+    if (inviteeList.length > 1)
+        scene = CallScene.MULTI;
+    if (inviteeList.length === 1)
+        scene = CallScene.SINGLE;
+    return {
+        callId: params.callId || '',
+        roomId: {
+            strRoomId: params.strRoomID || params.strRoomId || '',
+            intRoomId: params.roomID || params.roomId || 0,
+        },
+        inviter: params.inviter || '',
+        inviteeList,
+        groupId: params.chatGroupID || '',
+        mediaType: params.type,
+        status: params.status || CallStatus.NONE,
+        role: params.role || CallRole.NONE,
+        scene,
+        callStartTime: 0,
+    };
+};
+
+/** Backend `RoomIdType` enum (1: number, 2: string). */
+const CallRoomIdType = Object.freeze({
+    IntRoomId: 1,
+    StrRoomId: 2,
+});
+// ---------- C -> S ----------
+/**
+ * Build the `OfflinePushInfo` JSON sub-tree.
+ * @private
+ */
+function encodeOfflinePushInfo(pushInfo, mediaType) {
+    pushInfo = pushInfo || {};
+    const apnsInfo = {
+        Title: pushInfo.title || '',
+        Sound: pushInfo.iosSound || '',
+        BadgeMode: pushInfo.ignoreIosBadge ? 1 : 0,
+        IsVoipPush: pushInfo.iosPushType || 0,
+        ContentAvailable: pushInfo.enableIosBackgroundNotification ? 1 : 0,
+        InterruptionLevel: pushInfo.iosInterruptionLevel || '',
+        Image: pushInfo.iosImage || '',
+    };
+    const androidInfo = {
+        Sound: pushInfo.androidSound || '',
+        Title: pushInfo.title || '',
+        OPPOChannelID: pushInfo.androidOppoChannelId || '',
+        OPPOCategory: pushInfo.oppoCategory || 'IM',
+        OPPONotifyLevel: pushInfo.oppoNotifyLevel || 0,
+        GoogleChannelID: pushInfo.androidFcmChannelId || '',
+        GoogleImage: pushInfo.fcmImage || '',
+        XiaoMiChannelID: pushInfo.androidXiaomiChannelId || '',
+        VIVOClassification: pushInfo.androidVivoClassification || 0,
+        VIVOCategory: pushInfo.vivoCategory || 'IM',
+        HuaWeiCategory: pushInfo.androidHuaweiCategory || 'IM',
+        HuaWeiImage: pushInfo.huaweiImage || '',
+        HonorImportance: pushInfo.honorImportance || 'NORMAL',
+        HonorImage: pushInfo.honorImage || '',
+    };
+    const voipExt = {
+        entity: { action: 2 },
+        timPushFeatures: { fcmPushType: 0, fcmNotificationType: 1 },
+        voip_ext: {
+            voip_type: 'call',
+            voip_media_type: mediaType === CallMediaType.VIDEO ? 'video' : 'audio',
+        },
+    };
+    return {
+        Title: pushInfo.title || '',
+        Description: pushInfo.description || '',
+        Ext: JSON.stringify(voipExt),
+        AndroidInfo: androidInfo,
+        ApnsInfo: apnsInfo,
+    };
+}
+/**
+ * Build the request body for `call_engine_srv.start_call`.
+ * @param {string} inviter
+ * @param {string[]} userIdList
+ * @param {number} mediaType  CallMediaType.Audio | Video
+ * @param {{
+ *   roomId?: { intRoomId?: number, strRoomId?: string },
+ *   timeout?: number,                  // seconds; default 30
+ *   userData?: string,
+ *   isEphemeralCall?: boolean,
+ *   offlinePushInfo?: object,
+ * }} callParams
+ * @param {string} groupId
+ * @returns {object} JSON-encodable body
+ */
+function encodeStartCallRequest(inviter, userIdList, mediaType, callParams, groupId) {
+    const params = callParams || {};
+    const roomId = params.roomId || {};
+    const callInfo = {
+        CallId: '',
+        CallMediaType: mediaType >>> 0,
+    };
+    if (typeof roomId.intRoomId === 'number' && roomId.intRoomId > 0) {
+        callInfo.RoomId = String(roomId.intRoomId);
+        callInfo.RoomIdType = CallRoomIdType.IntRoomId;
+    }
+    else if ((!roomId.intRoomId || roomId.intRoomId === 0) &&
+        typeof roomId.strRoomId === 'string' &&
+        roomId.strRoomId.length > 0) {
+        callInfo.RoomId = roomId.strRoomId;
+        callInfo.RoomIdType = CallRoomIdType.StrRoomId;
+    }
+    callInfo.ExcludeFromHistoryMessage = false;
+    callInfo.GroupId = groupId || '';
+    callInfo.IsEphemeralCall = !!params.isEphemeralCall;
+    const timeoutSec = typeof params.timeout === 'number' ? params.timeout : 30;
+    return {
+        Body: {
+            Caller_Account: inviter,
+            CalleeList_Account: (userIdList || []).slice(),
+            CallInfo: callInfo,
+            Timeout: timeoutSec * 1000,
+            UserData: params.userData || '',
+            OfflinePushInfo: encodeOfflinePushInfo(params.offlinePushInfo, mediaType),
+        },
+        Head: buildSSOHead('call_engine_srv.start_call'),
+    };
+}
+/**
+ * Build the request body for `call_engine_srv.handle_call`
+ * (callee accepts or rejects an incoming invitation).
+ * @param {string} callId
+ * @param {string} terminalId
+ * @param {number} actionType  CallInvitationRespondedType.Accepted | .Rejected
+ * @returns {object} JSON-encodable body
+ */
+function encodeRespondInvitationRequest(callId, terminalId, actionType, command) {
+    return {
+        Body: {
+            CallId: callId || '',
+            TerminalId: terminalId || '',
+            ActionType: actionType >>> 0,
+        },
+        Head: buildSSOHead(command),
+    };
+}
+/**
+ * Build the request body for `call_engine_srv.cancel_invite`
+ * @param {string} inviter      caller user id
+ * @param {string} callId       invitation id
+ * @param {string[]} calleeList invitees to cancel
+ * @param {string} [command]    SSO command (defaults to cancel_invite)
+ * @returns {object} JSON-encodable body
+ */
+function encodeCancelRequest(inviter, callId, calleeList, command) {
+    const list = Array.isArray(calleeList) ? calleeList.filter(Boolean) : [];
+    return {
+        Body: {
+            CallId: callId || '',
+            Operator_Account: inviter || '',
+            CalleeList_Account: list,
+        },
+        Head: buildSSOHead(command),
+    };
+}
+/**
+ * @param {string} userId  callee user id (the login user)
+ * @param {string} [command]  SSO command (defaults to get_invitation)
+ * @returns {object} JSON-encodable body
+ */
+function encodeGetInvitationRequest(userId, command) {
+    return {
+        Body: {
+            User_Account: userId || '',
+        },
+        Head: buildSSOHead(command),
+    };
+}
+
+const SEND_KEY = 'sendTRTCCustomData';
+const CMD_START_CALL = 'call_engine_srv.start_call';
+const CMD_HEART_BEAT = 'call_engine_srv.heart_beat';
+const CMD_HANDLE_CALL = 'call_engine_srv.handle_call'; // accept、reject
+const CMD_HANGUP_CALL = 'call_engine_srv.hangup';
+const CMD_CANCEL_CALL = 'call_engine_srv.cancel_invite';
+const CMD_GET_INVITATION = 'call_engine_srv.get_invitation'; // 登录后主动获取一下 useId 的通话信息
+// Heartbeat tuning (mirrors call-engine-wx/call-constants.js).
+const HEARTBEAT_INTERVAL_MS = 2000;
+const HEARTBEAT_FAIL_RETRY_DEFAULT = 5; // 5 misses ≈ 10s before giving up
+const HEARTBEAT_FAIL_INTERVAL_MS = 2000;
+const TRANSPORT_ERR = -1;
+const callResponse = { errCode: 0, errMsg: '', inviteId: '', callResultList: [] };
+/**
+ * Issue `call_engine_srv.start_call` and decode the response.
+ */
+async function startCall(options) {
+    const opts = options || {};
+    const chat = opts.chat;
+    if (!chat || !isFunction(chat.callExperimentalAPI)) {
+        return {
+            ...callResponse,
+            errCode: TRANSPORT_ERR,
+            errMsg: 'chat.callExperimentalAPI is not available',
+        };
+    }
+    if (!opts.inviter) {
+        return { ...callResponse, errCode: TRANSPORT_ERR, errMsg: 'inviter is required' };
+    }
+    if (!isArray(opts.userIdList) || opts.userIdList.length === 0) {
+        return { ...callResponse, errCode: TRANSPORT_ERR, errMsg: 'userIdList cannot be empty' };
+    }
+    if (opts.mediaType !== CallMediaType.AUDIO && opts.mediaType !== CallMediaType.VIDEO) {
+        return { ...callResponse, errCode: TRANSPORT_ERR, errMsg: 'invalid mediaType' };
+    }
+    const callParams = {
+        roomId: opts.roomId || {},
+        timeout: opts.timeout,
+        userData: opts.userData,
+        isEphemeralCall: !!opts.isEphemeralCall,
+        offlinePushInfo: opts.offlinePushInfo,
+    };
+    const body = encodeStartCallRequest(opts.inviter, opts.userIdList, opts.mediaType, callParams, opts.groupId || '');
+    let res;
+    try {
+        const payload = {
+            serviceCommand: CMD_START_CALL,
+            data: JSON.stringify(body),
+        };
+        res = await chat.callExperimentalAPI(SEND_KEY, payload);
+    }
+    catch (err) {
+        const code = (err && (err.code || err.errorCode)) || TRANSPORT_ERR;
+        const msg = (err && (err.message || err.errorInfo)) || 'send failed';
+        return { ...callResponse, errCode: code, errMsg: msg };
+    }
+    const resData = (res && res.data) || res || {};
+    if (resData.ErrorCode !== 0) {
+        return { ...callResponse, errCode: resData.ErrorCode, errMsg: resData.ErrorInfo };
+    }
+    return {
+        errCode: resData?.ErrorCode || 0,
+        errMsg: resData?.errMsg || '',
+        inviteId: resData?.Response?.CallId || '',
+        callResultList: resData?.Response?.CallResult || [],
+    };
+}
+// ====================== Heartbeat ======================
+let _hbTimer = null;
+let _hbCallId = '';
+let _hbFailCount = 0;
+function stopHeartBeat() {
+    if (_hbTimer) {
+        clearInterval(_hbTimer);
+        _hbTimer = null;
+    }
+    _hbCallId = '';
+    _hbFailCount = 0;
+}
+/**
+ * Send one heartbeat packet. Returns a normalised
+ * @private
+ */
+async function _sendHeartBeat(chat, callId, userId) {
+    const heartBeatBody = {
+        Body: {
+            User_Account: userId,
+            CallId: callId,
+        },
+        Head: buildSSOHead(CMD_HEART_BEAT),
+    };
+    try {
+        const payload = {
+            serviceCommand: CMD_HEART_BEAT,
+            data: JSON.stringify(heartBeatBody),
+        };
+        const res = await chat.callExperimentalAPI(SEND_KEY, payload);
+        const resData = (res && res.data) || res || {};
+        // Backend uses either ErrorCode (capitalised) or errorCode depending
+        // on the route; accept both to avoid false positives.
+        const errCode = isNumber(resData.ErrorCode)
+            ? resData.ErrorCode
+            : (isNumber(resData.errorCode) ? resData.errorCode : 0);
+        if (errCode !== 0) {
+            return { errCode, errMsg: resData.ErrorInfo || resData.errorInfo || '' };
+        }
+        return { errCode: 0, errMsg: '' };
+    }
+    catch (err) {
+        const code = (err && (err.code || err.errorCode)) || TRANSPORT_ERR;
+        const msg = (err && (err.message || err.errorInfo)) || 'send failed';
+        return { errCode: code, errMsg: msg };
+    }
+}
+function startHeartBeat(options) {
+    const opts = options || {};
+    const { chat, callId, userId } = opts;
+    if (!chat || !isFunction(chat.callExperimentalAPI)) {
+        console.warn('[SSOChannel] startHeartBeat: chat.callExperimentalAPI unavailable');
+        return;
+    }
+    if (!callId || !userId) {
+        console.warn('[SSOChannel] startHeartBeat: callId and userId are required');
+        return;
+    }
+    stopHeartBeat();
+    const intervalMs = isNumber(opts.intervalMs) && opts.intervalMs > 0
+        ? opts.intervalMs : HEARTBEAT_INTERVAL_MS;
+    const retryCount = isNumber(opts.retryCount) && opts.retryCount > 0
+        ? opts.retryCount : HEARTBEAT_FAIL_RETRY_DEFAULT;
+    _hbCallId = callId;
+    const tick = async () => {
+        if (!_hbCallId || _hbCallId !== callId)
+            return;
+        const sent = await _sendHeartBeat(chat, callId, userId);
+        if (!_hbCallId || _hbCallId !== callId)
+            return;
+        if (sent.errCode === 0) {
+            _hbFailCount = 0;
+            return;
+        }
+        _hbFailCount += 1;
+        console.warn('[SSOChannel] heartbeat failed', _hbFailCount, sent.errCode, sent.errMsg);
+        if (_hbFailCount >= retryCount) {
+            const dropped = _hbCallId;
+            stopHeartBeat();
+            if (typeof opts.onTimeout === 'function') {
+                try {
+                    opts.onTimeout(dropped);
+                }
+                catch (_) { /* ignore */ }
+            }
+        }
+    };
+    _hbTimer = setInterval(tick, intervalMs);
+}
+async function _respondInvitation(options, actionType) {
+    const opts = options || {};
+    const chat = opts.chat;
+    if (!chat || !isFunction(chat.callExperimentalAPI)) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'chat.callExperimentalAPI is not available' };
+    }
+    if (!opts.callId) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'callId is required' };
+    }
+    if (!opts.terminalId) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'terminalId is required' };
+    }
+    let serviceCommand = CMD_HANDLE_CALL;
+    if (actionType === CallInvitationRespondedType.Hangup) {
+        serviceCommand = CMD_HANGUP_CALL;
+    }
+    const body = encodeRespondInvitationRequest(opts.callId, opts.terminalId, actionType, serviceCommand);
+    try {
+        const payload = {
+            serviceCommand,
+            data: JSON.stringify(body),
+        };
+        const res = await chat.callExperimentalAPI(SEND_KEY, payload);
+        const resData = (res && res.data) || res || {};
+        const errCode = isNumber(resData.ErrorCode)
+            ? resData.ErrorCode
+            : (isNumber(resData.errorCode) ? resData.errorCode : 0);
+        if (errCode !== 0) {
+            return { errCode, errMsg: resData.ErrorInfo || resData.errorInfo || '' };
+        }
+        return { errCode: 0, errMsg: '' };
+    }
+    catch (err) {
+        const code = (err && (err.code || err.errorCode)) || TRANSPORT_ERR;
+        const msg = (err && (err.message || err.errorInfo)) || 'send failed';
+        return { errCode: code, errMsg: msg };
+    }
+}
+/**
+ * Callee accepts an incoming invitation.
+ * Wraps `_respondInvitation` with ActionType = Accepted.
+ */
+async function accept(options) {
+    return _respondInvitation(options, CallInvitationRespondedType.AcceptedByInvitee);
+}
+/**
+ * Callee rejects an incoming invitation.
+ * Wraps `_respondInvitation` with ActionType = Rejected.
+ */
+async function reject(options) {
+    return _respondInvitation(options, CallInvitationRespondedType.RejectedByInvitee);
+}
+/**
+ * In-call hangup (the call has already reached CALLING).
+ * Routes through `call_engine_srv.hangup` with the same
+ * `{Body, Head}` envelope handle_call uses; only ActionType differs.
+ */
+async function hangup(options) {
+    return _respondInvitation(options, CallInvitationRespondedType.Hangup);
+}
+/**
+ * Caller cancels a pending invitation. Returns the same
+ * `{errCode, errMsg}` shape as accept / reject / hangup.
+ */
+async function cancel(options) {
+    const opts = options || {};
+    const chat = opts.chat;
+    if (!chat || !isFunction(chat.callExperimentalAPI)) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'chat.callExperimentalAPI is not available' };
+    }
+    if (!opts.callId) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'callId is required' };
+    }
+    if (!opts.inviter) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'inviter is required' };
+    }
+    if (!isArray(opts.calleeList) || opts.calleeList.length === 0) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'calleeList cannot be empty' };
+    }
+    const body = encodeCancelRequest(opts.inviter, opts.callId, opts.calleeList, CMD_CANCEL_CALL);
+    try {
+        const payload = {
+            serviceCommand: CMD_CANCEL_CALL,
+            data: JSON.stringify(body),
+        };
+        const res = await chat.callExperimentalAPI(SEND_KEY, payload);
+        const resData = (res && res.data) || res || {};
+        const errCode = isNumber(resData.ErrorCode)
+            ? resData.ErrorCode
+            : isNumber(resData.ErrorCode) ? resData.errorCode : 0;
+        if (errCode !== 0) {
+            return { errCode, errMsg: resData.ErrorInfo || resData.errorInfo || '' };
+        }
+        return { errCode: 0, errMsg: '' };
+    }
+    catch (err) {
+        const code = (err && (err.code || err.errorCode)) || TRANSPORT_ERR;
+        const msg = (err && (err.message || err.errorInfo)) || 'send failed';
+        return { errCode: code, errMsg: msg };
+    }
+}
+/**
+ * Send `call_engine_srv.get_invitation` and return the raw notify-
+ * shaped payload (or null if no pending invitation exists for the
+ * given user).
+ */
+async function getInvitation(options) {
+    const opts = options || {};
+    const chat = opts.chat;
+    if (!chat || !isFunction(chat.callExperimentalAPI)) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'chat.callExperimentalAPI is not available', data: null };
+    }
+    if (!opts.userId) {
+        return { errCode: TRANSPORT_ERR, errMsg: 'userId is required', data: null };
+    }
+    const body = encodeGetInvitationRequest(opts.userId, CMD_GET_INVITATION);
+    try {
+        const payload = {
+            serviceCommand: CMD_GET_INVITATION,
+            data: JSON.stringify(body),
+        };
+        const res = await chat.callExperimentalAPI(SEND_KEY, payload);
+        const resData = (res && res.data) || res || {};
+        const errCode = isNumber(resData.ErrorCode)
+            ? resData.ErrorCode
+            : isNumber(resData.ErrorCode) ? resData.errorCode : 0;
+        if (errCode !== 0) {
+            return { errCode, errMsg: resData.ErrorInfo || resData.errorInfo || '', data: null };
+        }
+        const notifyData = resData?.Response;
+        if (!notifyData || !isObject(notifyData) || Object.keys(notifyData).length === 0) {
+            return { errCode: 0, errMsg: '', data: null };
+        }
+        return { errCode: 0, errMsg: '', data: notifyData };
+    }
+    catch (err) {
+        const code = (err && (err.code || err.errorCode)) || TRANSPORT_ERR;
+        const msg = (err && (err.message || err.errorInfo)) || 'send failed';
+        return { errCode: code, errMsg: msg, data: null };
+    }
+}
+const SSOChannel = {
+    CMD_START_CALL,
+    CMD_HEART_BEAT,
+    CMD_HANDLE_CALL,
+    CMD_HANGUP_CALL,
+    CMD_CANCEL_CALL,
+    CMD_GET_INVITATION,
+    HEARTBEAT_INTERVAL_MS,
+    HEARTBEAT_FAIL_RETRY_DEFAULT,
+    HEARTBEAT_FAIL_INTERVAL_MS,
+    startCall,
+    startHeartBeat,
+    stopHeartBeat,
+    accept,
+    reject,
+    hangup,
+    cancel,
+    getInvitation,
+};
+
+// Copyright (c) 2026 Tencent. All rights reserved.
+//
+// Port of `atomic_engine/src/engine/module/call/core_view_layout/
+// call_view_layout.{h,cc}` to TypeScript for the Mini-Program-side
+// `call-engine-wx` package.
+//
+// Goals:
+//   1. 1:1 algorithmic parity with the C++ implementation — including
+//      canvas dimensions (720x1280), the float-template secondary
+//      frame ({480,80,200,300}), the grid unit/half breakpoints
+//      (count <= 4 vs > 4, large-view vs no large-view).
+//   2. JSON output shape matches `CallViewLayout::ToJson()` field-by-
+//      field, so the same payload can travel between native peers
+//      and the wx client without translation.
+//   3. Self-contained — only depends on `CallMediaType` from types.ts.
+//      `CallStateInput` is a minimal subset of the C++ `CallState`
+//      and is meant to be built ad-hoc by the caller, NOT to mirror
+//      every field of the C++ class.
+//
+// Note: the PIP template (single-tile active-speaker view) from the
+// C++ implementation is intentionally NOT ported here — it is not
+// used by the wx-side renderer yet. Re-introducing it should be
+// straightforward (add LayoutTemplate.PIP, a PipLayoutResult variant,
+// a `calculatePipLayout` branch, and the speaker-volumes input field).
+//
+// Out of scope: native render integration. This module is purely
+// the layout calculator; the wx renderer consumes the JSON / typed
+// result and positions <video> / <image> nodes itself.
+// ============================ enums / consts ===========================
+var LayoutTemplate;
+(function (LayoutTemplate) {
+    LayoutTemplate[LayoutTemplate["FLOAT"] = 0] = "FLOAT";
+    LayoutTemplate[LayoutTemplate["GRID"] = 1] = "GRID";
+})(LayoutTemplate || (LayoutTemplate = {}));
+/**
+ * Mirror of C++ `CallParticipantStatus`. Only the values the layout
+ * algorithm actually distinguishes are listed here; any other value
+ * the caller may carry is preserved opaquely as long as it !== NONE.
+ */
+var CallParticipantStatus;
+(function (CallParticipantStatus) {
+    CallParticipantStatus[CallParticipantStatus["NONE"] = 0] = "NONE";
+    CallParticipantStatus[CallParticipantStatus["WAITING"] = 1] = "WAITING";
+    CallParticipantStatus[CallParticipantStatus["CALLING"] = 2] = "CALLING";
+})(CallParticipantStatus || (CallParticipantStatus = {}));
+const CANVAS_W = 720;
+const CANVAS_H = 1280;
+/** Default float-template secondary (small) frame — matches C++. */
+const SECONDARY_DEFAULT_FRAME = { x: 480, y: 80, w: 200, h: 300 };
+// =========================== public class =============================
+class CallViewLayout {
+    constructor() {
+        this.currentTemplate = LayoutTemplate.FLOAT;
+        /** Sticky toggle: same id passed twice = clear. */
+        this.largeViewUserId = '';
+        this.isViewReversed = false;
+        this.currentLayout = makeEmptyFloatResult();
+        this.previousLayout = makeEmptyFloatResult();
+    }
+    // --- user-driven setters (match C++ signatures) ---
+    setLayoutTemplate(template) {
+        this.currentTemplate = template;
+        this.largeViewUserId = '';
+        this.isViewReversed = false;
+    }
+    setLargeViewUser(userId) {
+        if (this.largeViewUserId === userId) {
+            this.largeViewUserId = '';
+        }
+        else {
+            this.largeViewUserId = userId;
+        }
+    }
+    toggleViewReversed() {
+        this.isViewReversed = !this.isViewReversed;
+    }
+    // --- accessors ---
+    getCurrentTemplate() {
+        return this.currentTemplate;
+    }
+    getCurrentLayout() {
+        return this.currentLayout;
+    }
+    /**
+     * Recalculate using `state`. Returns `true` when the resulting
+     * layout is observably different from the previous one — host
+     * apps should only push a layout-changed event when this returns
+     * `true` (matches the C++ contract).
+     */
+    recalculate(state) {
+        this.previousLayout = this.currentLayout;
+        switch (this.currentTemplate) {
+            case LayoutTemplate.FLOAT:
+                this.currentLayout = this.calculateFloatLayout(state);
+                break;
+            case LayoutTemplate.GRID:
+                this.currentLayout = this.calculateGridLayout(state);
+                break;
+        }
+        return this.isLayoutChanged();
+    }
+    /**
+     * JSON shape matches `CallViewLayout::ToJson` exactly. We return a
+     * string (not a parsed object) to make the parity with the C++
+     * `ToJson()` totally explicit at call sites.
+     */
+    toJson() {
+        return JSON.stringify(this.toJsonObject());
+    }
+    /**
+     * Same as `toJson()` but skips the `JSON.stringify` step; useful
+     * for code paths that immediately serialise into a larger envelope.
+     */
+    toJsonObject() {
+        const layout = this.currentLayout;
+        const root = {
+            template: layoutTemplateToString(layout.template),
+        };
+        if (layout.template === LayoutTemplate.FLOAT) {
+            root.canvas = { w: layout.canvas.w, h: layout.canvas.h };
+            root.primaryUser = {
+                userId: layout.primaryUser.userId,
+                isLocal: layout.primaryUser.isLocal,
+            };
+            if (layout.secondaryUser) {
+                root.secondaryUser = {
+                    userId: layout.secondaryUser.userId,
+                    isLocal: layout.secondaryUser.isLocal,
+                    frame: { ...layout.secondaryUser.frame },
+                };
+            }
+            else {
+                root.secondaryUser = null;
+            }
+            root.showRemoteInfo = layout.showRemoteInfo;
+        }
+        else {
+            // GRID
+            root.canvas = { w: layout.canvas.w, h: layout.canvas.h };
+            root.participants = layout.participants.map((p) => ({
+                userId: p.userId,
+                frame: { ...p.frame },
+                isLocal: p.isLocal,
+                showName: p.showName,
+            }));
+        }
+        return root;
+    }
+    // ============================ private ==============================
+    isLayoutChanged() {
+        const prev = this.previousLayout;
+        const curr = this.currentLayout;
+        if (prev.template !== curr.template)
+            return true;
+        if (curr.template === LayoutTemplate.FLOAT && prev.template === LayoutTemplate.FLOAT) {
+            // Mirror C++ IsFloatLayoutChanged: only primary/secondary id +
+            // showRemoteInfo participate in the diff.
+            if (prev.primaryUser.userId !== curr.primaryUser.userId)
+                return true;
+            const prevSecId = prev.secondaryUser ? prev.secondaryUser.userId : '';
+            const currSecId = curr.secondaryUser ? curr.secondaryUser.userId : '';
+            if (prevSecId !== currSecId)
+                return true;
+            if (prev.showRemoteInfo !== curr.showRemoteInfo)
+                return true;
+            return false;
+        }
+        if (curr.template === LayoutTemplate.GRID && prev.template === LayoutTemplate.GRID) {
+            if (prev.participants.length !== curr.participants.length)
+                return true;
+            for (let i = 0; i < curr.participants.length; i++) {
+                const a = prev.participants[i];
+                const b = curr.participants[i];
+                if (a.userId !== b.userId)
+                    return true;
+                if (a.frame.x !== b.frame.x)
+                    return true;
+                if (a.frame.y !== b.frame.y)
+                    return true;
+                if (a.frame.w !== b.frame.w)
+                    return true;
+                if (a.frame.h !== b.frame.h)
+                    return true;
+                if (a.showName !== b.showName)
+                    return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    // ---- float ----
+    calculateFloatLayout(state) {
+        const selfId = state.selfId;
+        let remoteId = '';
+        for (const p of state.allParticipants) {
+            if (p.id !== selfId) {
+                remoteId = p.id;
+                break;
+            }
+        }
+        const isConnected = state.selfStatus === CallParticipantStatus.CALLING;
+        const isAudio = state.mediaType === CallMediaType.AUDIO;
+        let primaryId;
+        let primaryIsLocal;
+        let secondary;
+        let showRemoteInfo;
+        if (!isConnected && !isAudio) {
+            // Video waiting: self preview as background, remote info overlay.
+            primaryId = selfId;
+            primaryIsLocal = true;
+            secondary = null;
+            showRemoteInfo = true;
+        }
+        else if (!isConnected && isAudio) {
+            // Audio waiting: remote (avatar) as background.
+            primaryId = remoteId;
+            primaryIsLocal = false;
+            secondary = null;
+            showRemoteInfo = true;
+        }
+        else if (isAudio) {
+            // Audio connected: remote primary, no secondary tile.
+            primaryId = remoteId;
+            primaryIsLocal = false;
+            secondary = null;
+            showRemoteInfo = true;
+        }
+        else {
+            // Video connected: big = remote, small = self (unless reversed).
+            if (!this.isViewReversed) {
+                primaryId = remoteId;
+                primaryIsLocal = false;
+                secondary = {
+                    userId: selfId,
+                    isLocal: true,
+                    frame: { ...SECONDARY_DEFAULT_FRAME },
+                };
+            }
+            else {
+                primaryId = selfId;
+                primaryIsLocal = true;
+                secondary = {
+                    userId: remoteId,
+                    isLocal: false,
+                    frame: { ...SECONDARY_DEFAULT_FRAME },
+                };
+            }
+            showRemoteInfo = false;
+        }
+        return {
+            template: LayoutTemplate.FLOAT,
+            canvas: { w: CANVAS_W, h: CANVAS_H },
+            primaryUser: { userId: primaryId, isLocal: primaryIsLocal },
+            secondaryUser: secondary,
+            showRemoteInfo,
+        };
+    }
+    // ---- grid ----
+    calculateGridLayout(state) {
+        // Build participant list in stable order: inviter first, then
+        // invitees in original order. Only include status !== NONE.
+        const statusMap = new Map();
+        for (const p of state.allParticipants) {
+            statusMap.set(p.id, p.status);
+        }
+        const userIds = [];
+        if (state.inviter) {
+            const s = statusMap.get(state.inviter);
+            if (s !== undefined && s !== CallParticipantStatus.NONE) {
+                userIds.push(state.inviter);
+            }
+        }
+        for (const invitee of state.inviteeList) {
+            const s = statusMap.get(invitee);
+            if (s !== undefined && s !== CallParticipantStatus.NONE) {
+                userIds.push(invitee);
+            }
+        }
+        const participants = this.calculateGridPositions(userIds.length, userIds, state.selfId);
+        return {
+            template: LayoutTemplate.GRID,
+            canvas: { w: CANVAS_W, h: CANVAS_H },
+            participants,
+        };
+    }
+    /**
+     * Pure positional algorithm — does not mutate any class state.
+     * `count` parameter is redundant with `userIds.length` but kept
+     * to mirror the C++ signature.
+     */
+    calculateGridPositions(count, userIds, selfUserId) {
+        const result = [];
+        if (count <= 0)
+            return result;
+        const unit = (CANVAS_W / 3) | 0; // 240
+        const half = (CANVAS_W / 2) | 0; // 360
+        // Determine large_view_index
+        let largeIdx = -1;
+        if (this.largeViewUserId) {
+            for (let i = 0; i < count; i++) {
+                if (userIds[i] === this.largeViewUserId) {
+                    largeIdx = i;
+                    break;
+                }
+            }
+        }
+        // Branch 1: large view, count <= 4 — large square (full width),
+        // others square (1/3 width) on the row below.
+        if (largeIdx >= 0 && count <= 4) {
+            const order = [largeIdx];
+            for (let i = 0; i < count; i++)
+                if (i !== largeIdx)
+                    order.push(i);
+            const largeSide = CANVAS_W;
+            const smallSide = unit;
+            const remaining = count - 1;
+            const frames = [{ x: 0, y: 0, w: largeSide, h: largeSide }];
+            const bottomY = largeSide;
+            for (let i = 0; i < remaining; i++) {
+                frames.push({ x: i * smallSide, y: bottomY, w: smallSide, h: smallSide });
+            }
+            for (let i = 0; i < order.length && i < frames.length; i++) {
+                const uid = userIds[order[i]];
+                result.push({
+                    userId: uid,
+                    frame: frames[i],
+                    isLocal: uid === selfUserId,
+                    showName: i === 0,
+                });
+            }
+            return result;
+        }
+        // Branch 2: large view, count > 4 — large 2/3 top-left, others 1/3.
+        if (largeIdx >= 0 && count > 4) {
+            const largeW = unit * 2;
+            const largeH = unit * 2;
+            const order = [largeIdx];
+            for (let i = 0; i < count; i++)
+                if (i !== largeIdx)
+                    order.push(i);
+            // large at (0,0)
+            {
+                const uid = userIds[order[0]];
+                result.push({
+                    userId: uid,
+                    frame: { x: 0, y: 0, w: largeW, h: largeH },
+                    isLocal: uid === selfUserId,
+                    showName: true,
+                });
+            }
+            // right column next to large: up to 2 slots
+            let idx = 1;
+            if (idx < order.length) {
+                const uid = userIds[order[idx]];
+                result.push({
+                    userId: uid,
+                    frame: { x: largeW, y: 0, w: unit, h: unit },
+                    isLocal: uid === selfUserId,
+                    showName: false,
+                });
+                idx++;
+            }
+            if (idx < order.length) {
+                const uid = userIds[order[idx]];
+                result.push({
+                    userId: uid,
+                    frame: { x: largeW, y: unit, w: unit, h: unit },
+                    isLocal: uid === selfUserId,
+                    showName: false,
+                });
+                idx++;
+            }
+            // below large: 3 per row
+            let currentY = largeH;
+            while (idx < order.length) {
+                for (let col = 0; col < 3 && idx < order.length; col++) {
+                    const uid = userIds[order[idx]];
+                    result.push({
+                        userId: uid,
+                        frame: { x: col * unit, y: currentY, w: unit, h: unit },
+                        isLocal: uid === selfUserId,
+                        showName: false,
+                    });
+                    idx++;
+                }
+                currentY += unit;
+            }
+            return result;
+        }
+        // Branch 3: no large view — standard layouts by count.
+        if (count === 1) {
+            result.push({
+                userId: userIds[0],
+                frame: { x: 0, y: 0, w: CANVAS_W, h: CANVAS_H },
+                isLocal: userIds[0] === selfUserId,
+                showName: false,
+            });
+        }
+        else if (count === 2) {
+            result.push({
+                userId: userIds[0],
+                frame: { x: 0, y: 0, w: half, h: half },
+                isLocal: userIds[0] === selfUserId,
+                showName: false,
+            });
+            result.push({
+                userId: userIds[1],
+                frame: { x: half, y: 0, w: half, h: half },
+                isLocal: userIds[1] === selfUserId,
+                showName: false,
+            });
+        }
+        else if (count === 3) {
+            result.push({
+                userId: userIds[0],
+                frame: { x: 0, y: 0, w: half, h: half },
+                isLocal: userIds[0] === selfUserId,
+                showName: false,
+            });
+            result.push({
+                userId: userIds[1],
+                frame: { x: half, y: 0, w: half, h: half },
+                isLocal: userIds[1] === selfUserId,
+                showName: false,
+            });
+            result.push({
+                userId: userIds[2],
+                frame: { x: (half / 2) | 0, y: half, w: half, h: half },
+                isLocal: userIds[2] === selfUserId,
+                showName: false,
+            });
+        }
+        else if (count === 4) {
+            result.push({
+                userId: userIds[0],
+                frame: { x: 0, y: 0, w: half, h: half },
+                isLocal: userIds[0] === selfUserId,
+                showName: false,
+            });
+            result.push({
+                userId: userIds[1],
+                frame: { x: half, y: 0, w: half, h: half },
+                isLocal: userIds[1] === selfUserId,
+                showName: false,
+            });
+            result.push({
+                userId: userIds[2],
+                frame: { x: 0, y: half, w: half, h: half },
+                isLocal: userIds[2] === selfUserId,
+                showName: false,
+            });
+            result.push({
+                userId: userIds[3],
+                frame: { x: half, y: half, w: half, h: half },
+                isLocal: userIds[3] === selfUserId,
+                showName: false,
+            });
+        }
+        else {
+            // 5+ participants: 3 columns of unit width
+            let currentY = 0;
+            for (let i = 0; i < count; i += 3) {
+                const rowCount = Math.min(3, count - i);
+                for (let j = 0; j < rowCount; j++) {
+                    const k = i + j;
+                    result.push({
+                        userId: userIds[k],
+                        frame: { x: j * unit, y: currentY, w: unit, h: unit },
+                        isLocal: userIds[k] === selfUserId,
+                        showName: false,
+                    });
+                }
+                currentY += unit;
+            }
+        }
+        return result;
+    }
+}
+// ============================ helpers =================================
+function layoutTemplateToString(t) {
+    switch (t) {
+        case LayoutTemplate.FLOAT: return 'float';
+        case LayoutTemplate.GRID: return 'grid';
+        default: return 'float';
+    }
+}
+function makeEmptyFloatResult() {
+    return {
+        template: LayoutTemplate.FLOAT,
+        canvas: { w: CANVAS_W, h: CANVAS_H },
+        primaryUser: { userId: '', isLocal: false },
+        secondaryUser: null,
+        showRemoteInfo: false,
+    };
+}
+
+const moduleEvents = new EventEmitter();
+const TRTC_EVENT_NAMES = Object.freeze([
+    'onEnterRoom',
+    'onExitRoom',
+    'onSwitchRole',
+    'onError',
+    'onWarnning',
+    'onRemoteUserEnterRoom',
+    'onRemoteUserLeaveRoom',
+    'onUserVideoAvailable',
+    'onUserSubStreamAvailable',
+    'onUserAudioAvailable',
+    'onUserVoiceVolume',
+    'onNetworkQuality',
+    'onFirstVideoFrame',
+    'onSendFirstLocalVideoFrame',
+    'onSendFirstLocalAudioFrame',
+    'onMicDidReady',
+]);
+function getChatEventName(logical) {
+    const EVENT = (TencentCloudChat && TencentCloudChat.EVENT) || {};
+    switch (logical) {
+        case 'SDK_READY': return EVENT.SDK_READY || 'sdkStateReady';
+        case 'KICKED_OUT': return EVENT.KICKED_OUT || 'kickedOut';
+        case 'USER_SIG_EXPIRED': return EVENT.USER_SIG_EXPIRED || 'userSigExpired';
+        case 'ROOM_CUSTOM_DATA_RECEIVED': return EVENT.ROOM_CUSTOM_DATA_RECEIVED;
+        default: return null;
+    }
+}
+class TUICallEngine {
+    constructor(options) {
+        const opts = options || {};
+        this._emitter = new EventEmitter();
+        this._sdkAppId = opts.SDKAppID || opts.sdkAppID || 0;
+        this._userId = '';
+        this._userSig = '';
+        this._isExternalChat = false;
+        this._chatListenersBound = false;
+        this._trtcCloud = null;
+        this._trtcListenersBound = false;
+        this._trtcListenerHandlers = null;
+        this._callInfo = generateCallInfo();
+        this._callsInFlight = false;
+        // Lazily generated on first accept/reject; preserved for the lifetime
+        // of this engine instance so the backend can correlate retries.
+        this._terminalId = '';
+        // View-layout helper. Mirrors the C++ CallViewLayout: caller drives
+        // template / large-view / reversed state via the public setters
+        // below; the engine re-emits layout snapshots on every relevant
+        // participant event (TODO: wire recalculate() into onUserJoin etc.).
+        this._viewLayout = new CallViewLayout();
+        const externalChat = opts.chat || opts.tim;
+        if (externalChat) {
+            this._isExternalChat = true;
+            this._chat = externalChat;
+        }
+    }
+    // ============================ static ============================
+    /**
+     * Create / reuse the singleton instance.
+     * @param {{ SDKAppID?: number, sdkAppID?: number, tim?: any }} options
+     * @returns {TUICallEngine}
+     */
+    static createInstance(options) {
+        if (!TUICallEngine.instance) {
+            TUICallEngine.instance = new TUICallEngine(options);
+        }
+        return TUICallEngine.instance;
+    }
+    static once(event, fn) {
+        if (event !== 'ready') {
+            moduleEvents.once(event, fn);
+            return;
+        }
+        if (typeof fn !== 'function')
+            return;
+        // Always async — callers may rely on it.
+        Promise.resolve().then(() => {
+            try {
+                fn();
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.error('[call-engine-wx] ready callback threw:', err);
+            }
+        });
+    }
+    // =========================== lifecycle ===========================
+    async login(params) {
+        const p = params || {};
+        const userID = p.userID;
+        const userSig = p.userSig;
+        const sdkAppId = p.sdkAppID || p.SDKAppID || this._sdkAppId;
+        if (!userID || !userSig) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'login: userID and userSig are required');
+        }
+        if (!this._sdkAppId && sdkAppId) {
+            this._sdkAppId = sdkAppId;
+        }
+        this._userId = userID;
+        this._userSig = userSig;
+        this._bindChatListenersOnce();
+        try {
+            this._chat = TencentCloudChat.create({ SDKAppID: this._sdkAppId, devMode: true });
+            if (this._isLogined()) {
+                this._emitOnceReady();
+                return;
+            }
+            let res;
+            try {
+                res = await this._chat.login({ userID, userSig });
+                try {
+                    this.getTRTCCloudInstance();
+                }
+                catch (_) { }
+            }
+            catch (err) {
+                const code = err && err.code;
+                const message = (err && err.message) || '';
+                if (code === 2024 || code === 2025) {
+                    // eslint-disable-next-line no-console
+                    console.warn('[call-engine-wx] login: tolerated lite-chat code', code, message);
+                    this._emitOnceReady();
+                    return;
+                }
+                if (this._chatReadyFired && (/timeout/i.test(message) || code === 'NETWORK_TIMEOUT')) {
+                    // eslint-disable-next-line no-console
+                    console.warn('[call-engine-wx] login: chat.login() rejected with', message || code, 'AFTER SDK_READY — treating as success');
+                    this._emitOnceReady();
+                    return;
+                }
+                throw err;
+            }
+            if (res && res.data && res.data.repeatLogin) {
+                this._emitOnceReady();
+                return;
+            }
+            this._emitOnceReady();
+        }
+        catch (err) {
+            const code = (err && err.code) || TUIErrorCode.ERR_FAILED;
+            const message = (err && err.message) || 'login failed';
+            this._emitter.emit(TUICallEvent.ERROR, { code, message });
+            throw makeError(code, message);
+        }
+    }
+    /**
+     * Logout the underlying lite-chat session. If the chat instance was
+     * @returns {Promise<void>}
+     */
+    async logout() {
+        this._clearCallInfo();
+        try {
+            if (this._chat && typeof this._chat.logout === 'function') {
+                await this._chat.logout();
+            }
+        }
+        finally {
+            this._userId = '';
+            this._userSig = '';
+        }
+    }
+    /**
+     * Logout + release listeners + drop singleton. The instance is
+     * @returns {Promise<void>}
+     */
+    async destroyInstance() {
+        TUICallEngine.instance = null;
+        try {
+            await this.logout();
+        }
+        catch (_) { /* ignore */ }
+        this._unbindChatListeners();
+        this._unbindTRTCListeners();
+        this._emitter.removeAllListeners();
+        this._trtcCloud = null;
+    }
+    // ============================ events =============================
+    on(event, fn) {
+        this._emitter.on(event, fn);
+    }
+    off(event, fn) {
+        this._emitter.off(event, fn);
+    }
+    once(event, fn) {
+        this._emitter.once(event, fn);
+    }
+    // ============================ getters ============================
+    getTim() {
+        return this._chat;
+    }
+    getTRTCCloudInstance() {
+        if (this._trtcCloud)
+            return this._trtcCloud;
+        if (!TRTCCloud || typeof TRTCCloud.getTRTCShareInstance !== 'function') {
+            throw makeError(TUIErrorCode.ERR_FAILED, '[call-engine-wx] @tencentcloud/trtc-component-wx is not installed '
+                + 'or does not expose getTRTCShareInstance().');
+        }
+        this._trtcCloud = TRTCCloud.getTRTCShareInstance();
+        this._bindTRTCListenersOnce();
+        return this._trtcCloud;
+    }
+    // ============================ misc ===============================
+    setLogLevel(level) {
+        try {
+            if (this._chat && typeof this._chat.setLogLevel === 'function') {
+                this._chat.setLogLevel(level);
+            }
+        }
+        catch (_) { /* ignore */ }
+    }
+    // ============================ calls API ==============================
+    async calls(params) {
+        console.warn('---> calls 入参 ', JSON.stringify(params));
+        // 【1】state checks
+        if (!this._isLogined() && !this._chatReadyFired) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'calls: not logged in. Call login() first and wait for SDK_READY.');
+        }
+        if (this._callsInFlight) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'calls: a previous calls() is still in progress');
+        }
+        if (this._callInfo.status !== CallStatus.NONE) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'calls: there is an active call already; hang up before starting a new one');
+        }
+        // 【2】param normalisation
+        if (!isArray(params?.userIDList) || params?.userIDList?.length === 0) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'calls: userIDList cannot be empty');
+        }
+        if (params?.type !== CallMediaType.AUDIO && params?.type !== CallMediaType.VIDEO) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'calls: invalid mediaType');
+        }
+        const inviter = this._getLoginUserId();
+        if (!inviter) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'calls: cannot resolve login user id');
+        }
+        this._callInfo = generateCallInfo({
+            ...params,
+            strRoomId: generateRandomStrRoomId(params?.strRoomID),
+            status: CallStatus.WAITING,
+            role: CallRole.CALLER,
+            inviter,
+        });
+        this._callsInFlight = true;
+        let trtcEntered = false;
+        try {
+            // 【3】 enter TRTC room first
+            try {
+                await this._enterTRTCRoom();
+                trtcEntered = true;
+            }
+            catch (err) {
+                this._safeLeaveTRTCRoom();
+                const code = (err && err.code) || TUIErrorCode.ERR_FAILED;
+                const message = (err && err.message) || 'enter TRTC room failed';
+                this._emitter.emit(TUICallEvent.ERROR, { code, message });
+                throw makeError(code, message);
+            }
+            // 【4】send call_engine_srv.start_call ----
+            const resp = await SSOChannel.startCall({
+                chat: this._chat,
+                ...this._callInfo,
+                userIdList: this._callInfo.inviteeList,
+            });
+            if (resp.errCode !== 0) {
+                this._safeLeaveTRTCRoom();
+                trtcEntered = false;
+                this._emitter.emit(TUICallEvent.ERROR, { code: resp.errCode, message: resp.errMsg });
+                throw makeError(resp.errCode, resp.errMsg || 'start_call failed');
+            }
+            this._callInfo.callId = resp.inviteId;
+            this._callInfo.callStartTime = Date.now();
+            let busyCount = 0;
+            for (const r of resp.callResultList) {
+                switch (r.resultCode) {
+                    case CallInvitationResultCodeType.INVITED:
+                        this._emitter.emit(TUICallEvent.USER_ENTER, r.userId);
+                        break;
+                    case CallInvitationResultCodeType.SUCCESS:
+                        // server already sees this user as Calling (e.g. accepted
+                        // on another device of the same account before).
+                        this._emitter.emit('onUserInviting', r.userId);
+                        break;
+                    case CallInvitationResultCodeType.LINE_BUSY:
+                        this._emitter.emit('onUserLineBusy', r.userId);
+                        busyCount++;
+                        break;
+                    default:
+                        break;
+                }
+            }
+            // ---- 7) all callees are busy → wrap the call up locally ----
+            if (busyCount >= this._callInfo.inviteeList.length) {
+                const lastUser = resp.callResultList[resp.callResultList.length - 1];
+                this._safeLeaveTRTCRoom();
+                trtcEntered = false;
+                this._emitter.emit(TUICallEvent.ON_CALL_NOT_CONNECTED, {
+                    callInfo: { ...this._callInfo },
+                    userId: lastUser ? lastUser.userId : '',
+                    reason: CallEndReason.LINE_BUSY,
+                });
+                this._clearCallInfo();
+                return {
+                    inviteId: resp.inviteId,
+                    roomId: this._callInfo,
+                    callResultList: resp.callResultList,
+                };
+            }
+            // ---- 8) success — kick off the 2s heartbeat loop ----
+            // The backend will mark the call as dropped if it stops hearing
+            // from us. `_clearCallInfo` is the single tear-down point that
+            // stops the loop (hangup / reject / busy / error all funnel
+            // through it).
+            SSOChannel.startHeartBeat({
+                chat: this._chat,
+                callId: this._callInfo.callId,
+                userId: this._callInfo.inviter,
+                onTimeout: (droppedCallId) => {
+                    // Only react if this timeout still belongs to the active call.
+                    if (this._callInfo.callId !== droppedCallId)
+                        return;
+                    this._emitter.emit(TUICallEvent.ON_CALL_NOT_CONNECTED, {
+                        callInfo: { ...this._callInfo },
+                        userId: this._callInfo.inviter,
+                        reason: CallEndReason.LINE_BUSY,
+                    });
+                    this._safeLeaveTRTCRoom();
+                    this._clearCallInfo();
+                },
+            });
+            return {
+                inviteId: resp.inviteId,
+                roomId: this._callInfo,
+                callResultList: resp.callResultList,
+            };
+        }
+        catch (err) {
+            // Best-effort cleanup if anything threw between steps 4 and 6.
+            if (trtcEntered)
+                this._safeLeaveTRTCRoom();
+            this._clearCallInfo();
+            throw err;
+        }
+        finally {
+            this._callsInFlight = false;
+        }
+    }
+    /**
+     * Callee accepts the current incoming invitation.
+     */
+    async accept() {
+        if (!this._isLogined() && !this._chatReadyFired) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'accept: not logged in. Call login() first and wait for SDK_READY.');
+        }
+        if (this._callInfo.role !== CallRole.CALLEE) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'accept: current role is not CALLEE');
+        }
+        if (this._callInfo.status !== CallStatus.WAITING) {
+            throw makeError(TUIErrorCode.ERR_FAILED, `accept: invalid call status ${this._callInfo.status}; expected WAITING`);
+        }
+        const callId = this._callInfo.callId;
+        if (!callId) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'accept: no active invitation (callId is empty)');
+        }
+        let trtcEntered = false;
+        try {
+            await this._enterTRTCRoom();
+            trtcEntered = true;
+            // 2) Send handle_call(Accepted).
+            const terminalId = this._getOrCreateTerminalId();
+            const resp = await SSOChannel.accept({
+                chat: this._chat,
+                callId,
+                terminalId,
+            });
+            if (resp.errCode !== 0) {
+                throw makeError(resp.errCode, resp.errMsg || 'handle_call(accept) failed');
+            }
+            // 3) Local state -> CALLING; surface the begin event.
+            this._callInfo.status = CallStatus.CALLING;
+            this._callInfo.callStartTime = Date.now();
+            this._emitter.emit(TUICallEvent.ON_CALL_BEGIN, {
+                callInfo: { ...this._callInfo },
+            });
+            // 4) Heartbeat — same loop the caller side uses.
+            SSOChannel.startHeartBeat({
+                chat: this._chat,
+                callId: this._callInfo.callId,
+                userId: this._getLoginUserId(),
+                onTimeout: (droppedCallId) => {
+                    if (this._callInfo.callId !== droppedCallId)
+                        return;
+                    this._emitter.emit(TUICallEvent.ON_CALL_NOT_CONNECTED, {
+                        callInfo: { ...this._callInfo },
+                        userId: this._getLoginUserId(),
+                        reason: CallEndReason.LINE_BUSY,
+                    });
+                    this._safeLeaveTRTCRoom();
+                    this._clearCallInfo();
+                },
+            });
+            return { callId, roomId: this._callInfo.roomId };
+        }
+        catch (err) {
+            if (trtcEntered)
+                this._safeLeaveTRTCRoom();
+            this._clearCallInfo();
+            const code = (err && err.code) || TUIErrorCode.ERR_FAILED;
+            const message = (err && err.message) || 'accept failed';
+            this._emitter.emit(TUICallEvent.ERROR, { code, message });
+            throw makeError(code, message);
+        }
+    }
+    /**
+     * Callee rejects the current incoming invitation.
+     */
+    async reject() {
+        if (!this._isLogined() && !this._chatReadyFired) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'reject: not logged in. Call login() first and wait for SDK_READY.');
+        }
+        if (this._callInfo.role !== CallRole.CALLEE) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'reject: current role is not CALLEE');
+        }
+        if (this._callInfo.status !== CallStatus.WAITING) {
+            throw makeError(TUIErrorCode.ERR_FAILED, `reject: invalid call status ${this._callInfo.status}; expected WAITING`);
+        }
+        const callId = this._callInfo.callId;
+        if (!callId) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'reject: no active invitation (callId is empty)');
+        }
+        const snapshot = { ...this._callInfo };
+        try {
+            const terminalId = this._getOrCreateTerminalId();
+            const resp = await SSOChannel.reject({
+                chat: this._chat,
+                callId,
+                terminalId,
+            });
+            if (resp.errCode !== 0) {
+                console.warn('[call-engine-wx] reject: backend reported error', resp.errCode, resp.errMsg);
+            }
+            this._emitter.emit(TUICallEvent.ON_CALL_END, {
+                callInfo: snapshot,
+                reason: CallEndReason.REJECT,
+                userId: this._getLoginUserId(),
+            });
+            return { callId };
+        }
+        finally {
+            this._clearCallInfo();
+        }
+    }
+    /**
+     * Hang up an in-progress call. Both caller and callee may invoke
+     * this in either the WAITING state (callee hasn't accepted yet)
+     * or the CALLING state (call is fully established).
+     */
+    async hangup() {
+        if (!this._isLogined() && !this._chatReadyFired) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'hangup: not logged in. Call login() first and wait for SDK_READY.');
+        }
+        if (this._callInfo.status !== CallStatus.CALLING &&
+            this._callInfo.status !== CallStatus.WAITING) {
+            throw makeError(TUIErrorCode.ERR_FAILED, `hangup: invalid call status ${this._callInfo.status}; expected CALLING or WAITING`);
+        }
+        const callId = this._callInfo.callId;
+        if (!callId) {
+            throw makeError(TUIErrorCode.ERR_FAILED, 'hangup: no active call (callId is empty)');
+        }
+        const isCancel = this._callInfo.role === CallRole.CALLER && this._callInfo.status === CallStatus.WAITING;
+        const snapshot = { ...this._callInfo };
+        try {
+            if (isCancel) {
+                const inviter = this._callInfo.inviter || this._getLoginUserId();
+                const calleeList = Array.isArray(this._callInfo.inviteeList)
+                    ? this._callInfo.inviteeList.slice()
+                    : [];
+                if (calleeList.length > 0) {
+                    const resp = await SSOChannel.cancel({
+                        chat: this._chat,
+                        inviter,
+                        callId,
+                        calleeList,
+                    });
+                    if (resp.errCode !== 0) {
+                        console.warn('[call-engine-wx] hangup(cancel): backend reported error', resp.errCode, resp.errMsg);
+                    }
+                }
+            }
+            else {
+                const terminalId = this._getOrCreateTerminalId();
+                const resp = await SSOChannel.hangup({
+                    chat: this._chat,
+                    callId,
+                    terminalId,
+                });
+                if (resp.errCode !== 0) {
+                    console.warn('[call-engine-wx] hangup: backend reported error', resp.errCode, resp.errMsg);
+                }
+            }
+            this._safeLeaveTRTCRoom();
+            this._emitter.emit(TUICallEvent.ON_CALL_END, {
+                callInfo: snapshot,
+                reason: isCancel ? CallEndReason.CANCELED : CallEndReason.HANGUP,
+                userId: this._getLoginUserId(),
+            });
+            return { callId };
+        }
+        finally {
+            this._clearCallInfo();
+        }
+    }
+    // ============================ view layout interface ========================
+    /**
+     * Switch the layout template (FLOAT / GRID). Also resets the
+     * @param {LayoutTemplate} template Target template.
+     */
+    setLayoutTemplate(template) {
+        this._viewLayout.setLayoutTemplate(template);
+        this._recalcAndEmitLayout();
+    }
+    /**
+     * Pin a participant to the large view. Calling with the same
+     * userId twice clears the pin (sticky toggle).
+     * @param {string} userId Participant userId. Pass '' to clear.
+     */
+    setLargeViewUser(userId) {
+        this._viewLayout.setLargeViewUser(userId);
+        this._recalcAndEmitLayout();
+    }
+    /**
+     * Flip the primary / secondary roles in FLOAT layout
+     * (no-op semantics-wise for GRID, kept for parity with C++).
+     */
+    toggleViewReversed() {
+        this._viewLayout.toggleViewReversed();
+        this._recalcAndEmitLayout();
+    }
+    /**
+     * Build a `CallStateInput` snapshot from the engine's current
+     * `_callInfo` + login userId. Self-contained — does NOT mutate
+     * any engine state.
+     * @private
+     */
+    _buildLayoutState() {
+        const selfId = this._getLoginUserId() || '';
+        const info = this._callInfo || {};
+        const inviter = info.inviter || '';
+        const inviteeList = Array.isArray(info.inviteeList) ? info.inviteeList : [];
+        const selfStatus = typeof info.status === 'number'
+            ? info.status
+            : CallParticipantStatus.NONE;
+        const seen = new Set();
+        const allParticipants = [];
+        const push = (id, status) => {
+            if (!id || seen.has(id))
+                return;
+            seen.add(id);
+            allParticipants.push({ id, status });
+        };
+        push(selfId, selfStatus);
+        if (inviter)
+            push(inviter, selfStatus);
+        for (const u of inviteeList)
+            push(u, selfStatus);
+        const mediaType = typeof info.mediaType === 'number' ? info.mediaType : CallMediaType.VIDEO;
+        return {
+            selfId,
+            selfStatus,
+            mediaType: mediaType,
+            allParticipants,
+            inviter,
+            inviteeList,
+        };
+    }
+    /**
+     * Recalculate the layout from the engine's current state. If the
+     * resulting snapshot differs from the previous one, emit
+     * `viewLayoutChanged` with the `toJsonObject()` payload.
+     * @private
+     */
+    _recalcAndEmitLayout() {
+        try {
+            const changed = this._viewLayout.recalculate(this._buildLayoutState());
+            if (changed) {
+                this._emitter.emit(TUICallEvent.VIEW_LAYOUT_CHANGED, this._viewLayout.toJsonObject());
+            }
+        }
+        catch (err) {
+            // A layout-emit failure must never break the caller's flow.
+            // eslint-disable-next-line no-console
+            console.warn('[call-engine-wx] _recalcAndEmitLayout failed:', err && err.message);
+        }
+    }
+    /**
+     * Turn on the local camera preview.
+     * @param {string} videoViewDomID DOM id of the host preview node.
+     * @param {boolean} [isFrontCamera] true = front, false = rear,
+     *   undefined = keep SDK default (-1).
+     * @returns {Promise<unknown>}
+     */
+    async openCamera(videoViewDomID, isFrontCamera) {
+        let camera;
+        if (typeof isFrontCamera === 'undefined') {
+            camera = -1;
+        }
+        else {
+            camera = isFrontCamera ? 1 : 0;
+        }
+        if (!isFunction(this?._trtcCloud?.startLocalPreview))
+            return;
+        return this._trtcCloud.startLocalPreview(videoViewDomID, camera);
+    }
+    async closeCamera() {
+        if (!isFunction(this?._trtcCloud?.stopLocalPreview))
+            return undefined;
+        return this._trtcCloud.stopLocalPreview();
+    }
+    /**
+     * Switch between the front and rear camera (mobile only).
+     * @param {boolean} [isFrontCamera] target camera. true = front,
+     *   false = rear. If omitted, toggle current.
+     * @returns {Promise<unknown>}
+     */
+    async switchCamera(isFrontCamera) {
+        if (!isFunction(this?._trtcCloud?.switchCamera))
+            return;
+        await this._trtcCloud.switchCamera(!!isFrontCamera);
+    }
+    async openMicrophone() {
+        // this._logger.info(`openMicrophone.start`, { type: 'api' });
+        if (!isFunction(this?._trtcCloud?.startLocalAudio))
+            return;
+        await this._trtcCloud.startLocalAudio();
+    }
+    async closeMicrophone() {
+        // this._logger.info(`closeMicrophone.start`, { type: 'api' });
+        if (!isFunction(this?._trtcCloud?.stopLocalAudio))
+            return;
+        await this._trtcCloud.stopLocalAudio();
+    }
+    /**
+     * Switch the audio playback output between SPEAKER (loudspeaker)
+     * and EAR (earpiece). Mirrors the legacy WASM SDK shape so app code
+     * can stay the same:
+     * @param {number} device One of `AudioPlayBackDevice` (SPEAKER=0, EAR=1).
+     * @returns {Promise<unknown>}
+     */
+    async selectAudioPlaybackDevice(device) {
+        if (!isFunction(this?._trtcCloud?.setAudioRoute))
+            return;
+        const route = device === AudioPlayBackDevice.EAR || device === 1
+            ? AudioPlayBackDevice.EAR
+            : AudioPlayBackDevice.SPEAKER;
+        await this._trtcCloud.setAudioRoute(route);
+    }
+    /**
+     * Pull a remote user's video stream into the matching <TRTCPlayer>.
+     * @param {{ userId: string, view: string, streamType?: number }} params
+     * @returns {Promise<unknown>}
+     */
+    async startRemoteView(params) {
+        if (!this._trtcCloud || typeof this._trtcCloud.startRemoteView !== 'function') {
+            return undefined;
+        }
+        const { userId, view, streamType = 0 } = params || {};
+        return this._trtcCloud.startRemoteView(userId, view, streamType);
+    }
+    /**
+     * Stop pulling a remote user's stream.
+     * Mirrors trtc-cloud-wx's `stopRemoteView(userId, streamType)`.
+     * @param {{ userId: string, streamType?: number }} params
+     * @returns {Promise<unknown>}
+     */
+    async stopRemoteView(params) {
+        if (!this._trtcCloud || typeof this._trtcCloud.stopRemoteView !== 'function') {
+            return undefined;
+        }
+        const { userId, streamType = 0 } = params || {};
+        return this._trtcCloud.stopRemoteView(userId, streamType);
+    }
+    // ============================ internal ==========================
+    _bindChatListenersOnce() {
+        if (this._chatListenersBound || !this._chat || typeof this._chat.on !== 'function')
+            return;
+        const readyName = getChatEventName('SDK_READY');
+        const kickName = getChatEventName('KICKED_OUT');
+        const sigExpName = getChatEventName('USER_SIG_EXPIRED');
+        const roomCustomDataReceivedName = getChatEventName('ROOM_CUSTOM_DATA_RECEIVED');
+        this._onChatReady = () => {
+            this._chatReadyFired = true;
+            this._emitOnceReady();
+        };
+        this._onChatKickedOut = (payload) => {
+            this._emitter.emit(TUICallEvent.KICKED_OUT, payload || {});
+        };
+        this._onChatUserSigExpired = () => {
+            this._emitter.emit(TUICallEvent.onUserSigExpired, {});
+        };
+        this._onChatRoomCustomDataReceived = (payload) => {
+            const { Data: data = {}, Head = {} } = JSON.parse(payload.data);
+            if (Head?.Command === 'call_engine_srv.invite_user_notify') {
+                const { CallInfo: callInfo = {} } = data;
+                let roomId = { intRoomId: 0, strRoomId: '' };
+                if (callInfo.RoomIdType === 1) {
+                    roomId.intRoomId = Number(callInfo.RoomId);
+                }
+                else if (callInfo.RoomIdType === 2) {
+                    roomId.strRoomId = callInfo.RoomId;
+                }
+                else {
+                    return;
+                }
+                this._callInfo = generateCallInfo({
+                    userIDList: data?.CalleeList_Account || [],
+                    callId: data?.CallInfo?.CallId || '',
+                    inviter: data?.Caller_Account || '',
+                    roomId: roomId.intRoomId || 0,
+                    strRoomId: roomId.strRoomId || '',
+                    groupId: data?.CallInfo?.GroupId || '',
+                    type: data?.CallInfo?.CallMediaType,
+                    status: CallStatus.WAITING,
+                    role: CallRole.CALLEE,
+                });
+                this._emitter.emit(TUICallEvent.ON_CALL_RECEIVED, {
+                    callId: this._callInfo.callId,
+                    inviter: this._callInfo.inviter,
+                    inviteeList: this._callInfo.inviteeList,
+                    groupId: this._callInfo.groupId,
+                    mediaType: this._callInfo.mediaType,
+                    roomId: this._callInfo.roomId,
+                    userData: data?.UserData || '',
+                    callInfo: { ...this._callInfo },
+                });
+            }
+        };
+        if (readyName)
+            this._chat.on(readyName, this._onChatReady);
+        if (kickName)
+            this._chat.on(kickName, this._onChatKickedOut);
+        if (sigExpName)
+            this._chat.on(sigExpName, this._onChatUserSigExpired);
+        if (roomCustomDataReceivedName)
+            this._chat.on(roomCustomDataReceivedName, this._onChatRoomCustomDataReceived);
+        this._chatListenersBound = true;
+    }
+    _unbindChatListeners() {
+        if (!this._chatListenersBound || !this._chat || typeof this._chat.off !== 'function')
+            return;
+        const readyName = getChatEventName('SDK_READY');
+        const kickName = getChatEventName('KICKED_OUT');
+        const sigExpName = getChatEventName('USER_SIG_EXPIRED');
+        const roomCustomDataReceivedName = getChatEventName('ROOM_CUSTOM_DATA_RECEIVED');
+        try {
+            if (readyName && this._onChatReady)
+                this._chat.off(readyName, this._onChatReady);
+        }
+        catch (_) { /* ignore */ }
+        try {
+            if (kickName && this._onChatKickedOut)
+                this._chat.off(kickName, this._onChatKickedOut);
+        }
+        catch (_) { /* ignore */ }
+        try {
+            if (sigExpName && this._onChatUserSigExpired)
+                this._chat.off(sigExpName, this._onChatUserSigExpired);
+        }
+        catch (_) { /* ignore */ }
+        try {
+            if (roomCustomDataReceivedName && this._onChatRoomCustomDataReceived)
+                this._chat.off(roomCustomDataReceivedName, this._onChatRoomCustomDataReceived);
+        }
+        catch (_) { /* ignore */ }
+        this._chatListenersBound = false;
+    }
+    // ============================ TRTC events ========================
+    _bindTRTCListenersOnce() {
+        if (this._trtcListenersBound || !this._trtcCloud)
+            return;
+        const trtc = this._trtcCloud;
+        if (typeof trtc.on !== 'function')
+            return;
+        /** @type {Record<string, (...args: any[]) => void>} */
+        const handlers = {};
+        const make = (name) => (...args) => {
+            try {
+                this._emitter.emit(name, ...args);
+            }
+            catch (e) {
+                // eslint-disable-next-line no-console
+                console.warn('[call-engine-wx] listener for', name, 'threw:', e);
+            }
+        };
+        for (const name of TRTC_EVENT_NAMES) {
+            let fn;
+            if (name === 'onRemoteUserEnterRoom') {
+                const forward = make(name);
+                fn = (...args) => {
+                    try {
+                        if (this._callInfo &&
+                            this._callInfo.callId &&
+                            this._callInfo.status === CallStatus.WAITING) {
+                            this._callInfo.status = CallStatus.CALLING;
+                            if (!this._callInfo.callStartTime) {
+                                this._callInfo.callStartTime = Date.now();
+                            }
+                            this._emitter.emit(TUICallEvent.ON_CALL_BEGIN, {
+                                callInfo: { ...this._callInfo },
+                            });
+                        }
+                    }
+                    catch (e) {
+                        // eslint-disable-next-line no-console
+                        console.warn('[call-engine-wx] ON_CALL_BEGIN gate threw:', e);
+                    }
+                    forward(...args);
+                };
+            }
+            else {
+                fn = make(name);
+            }
+            handlers[name] = fn;
+            try {
+                trtc.on(name, fn);
+            }
+            catch (_) { /* ignore */ }
+        }
+        this._trtcListenerHandlers = handlers;
+        this._trtcListenersBound = true;
+    }
+    _unbindTRTCListeners() {
+        if (!this._trtcListenersBound)
+            return;
+        const trtc = this._trtcCloud;
+        const handlers = this._trtcListenerHandlers || {};
+        if (trtc && typeof trtc.off === 'function') {
+            for (const name of Object.keys(handlers)) {
+                try {
+                    trtc.off(name, handlers[name]);
+                }
+                catch (_) { /* ignore */ }
+            }
+        }
+        this._trtcListenerHandlers = null;
+        this._trtcListenersBound = false;
+    }
+    _emitOnceReady() {
+        if (this._readyEmitted)
+            return;
+        this._readyEmitted = true;
+        this._emitter.emit(TUICallEvent.SDK_READY, { name: 'sdk_ready' });
+        this._fetchPendingInvitation().catch((err) => {
+            // eslint-disable-next-line no-console
+            console.warn('[call-engine-wx] _fetchPendingInvitation: unexpected error', err);
+        });
+    }
+    // 登录后拉取通话信息, 避免登录前收到邀请
+    async _fetchPendingInvitation() {
+        if (!this._chat || !this._isLogined())
+            return;
+        if (this._callInfo && this._callInfo.callId)
+            return; // already in a call
+        const userId = this._getLoginUserId();
+        if (!userId)
+            return;
+        let resp;
+        try {
+            resp = await SSOChannel.getInvitation({ chat: this._chat, userId });
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn('[call-engine-wx] getInvitation request threw:', err);
+            return;
+        }
+        if (!resp || resp.errCode !== 0)
+            return;
+        if (!resp.data)
+            return;
+        try {
+            const replayed = {
+                data: JSON.stringify({
+                    Data: resp.data,
+                    Head: { Command: 'call_engine_srv.invite_user_notify' },
+                }),
+            };
+            if (isFunction(this._onChatRoomCustomDataReceived)) {
+                this._onChatRoomCustomDataReceived(replayed);
+            }
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn('[call-engine-wx] replay pending invitation failed:', err);
+        }
+    }
+    _isLogined() {
+        try {
+            if (!this._chat)
+                return false;
+            if (typeof this._chat.getLoginUser === 'function') {
+                return !!this._chat.getLoginUser();
+            }
+        }
+        catch (_) { /* ignore */ }
+        return false;
+    }
+    _getLoginUserId() {
+        if (this._userId)
+            return this._userId;
+        if (isFunction(this?._chat?.getLoginUser))
+            return this._chat.getLoginUser() || '';
+        return '';
+    }
+    // 支持数字和字符串房间号进房, 数字房间号进房为了和低版本互通
+    async _enterTRTCRoom() {
+        try {
+            SSOChannel.stopHeartBeat();
+        }
+        catch (_) { /* ignore */ }
+        if (this._callInfo.callType === CallMediaType.UNKNOWN)
+            throw makeError(-1, 'call type is none');
+        const { roomId } = this._callInfo;
+        if (roomId.intRoomId === 0 && roomId.strRoomId === '')
+            throw makeError(-1, 'room id is empty');
+        const params = {
+            sdkAppId: this._sdkAppId,
+            userId: this._getLoginUserId(),
+            userSig: this._userSig,
+            role: 20, // call 都是主播角色
+        };
+        if (roomId.intRoomId > 0) {
+            params.roomId = roomId.intRoomId;
+        }
+        else {
+            params.strRoomId = roomId.strRoomId;
+        }
+        const scene = this._callInfo.mediaType === CallMediaType.VIDEO ? 0 : 2; // 0 - video; 2 - audio
+        const trtc = this.getTRTCCloudInstance();
+        const ENTER_ROOM_TIMEOUT_MS = 10000;
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            let timer = null;
+            const cleanup = () => {
+                if (timer) {
+                    clearTimeout(timer);
+                    timer = null;
+                }
+                try {
+                    this._emitter.off('onEnterRoom', onEnterRoom);
+                }
+                catch (_) { /* ignore */ }
+            };
+            const onEnterRoom = (result) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (typeof result === 'number' && result > 0) {
+                    resolve();
+                }
+                else {
+                    reject(makeError(typeof result === 'number' ? result : -1, `enterRoom failed: ${result}`));
+                }
+            };
+            this._emitter.on('onEnterRoom', onEnterRoom);
+            timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(makeError(-1, 'enterRoom timeout'));
+            }, ENTER_ROOM_TIMEOUT_MS);
+            try {
+                const ret = trtc.enterRoom(params, scene);
+                if (ret && typeof ret.catch === 'function') {
+                    ret.catch((err) => {
+                        if (settled)
+                            return;
+                        settled = true;
+                        cleanup();
+                        reject(err);
+                    });
+                }
+            }
+            catch (err) {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                reject(err);
+            }
+        });
+    }
+    _safeLeaveTRTCRoom() {
+        try {
+            if (this._trtcCloud && typeof this._trtcCloud.exitRoom === 'function') {
+                this._trtcCloud.exitRoom();
+            }
+        }
+        catch (_) { /* ignore */ }
+    }
+    _clearCallInfo() {
+        try {
+            SSOChannel.stopHeartBeat();
+        }
+        catch (_) { /* ignore */ }
+        this._callInfo = generateCallInfo();
+    }
+    // Return a stable per-engine terminal id, generating it on first use.
+    _getOrCreateTerminalId() {
+        if (!this._terminalId) {
+            this._terminalId = generateTerminalId();
+        }
+        return this._terminalId;
+    }
+}
+TUICallEngine.instance = null;
+// ---------------------- module-private helpers ---------------------
+function makeError(code, message) {
+    const err = new Error(message);
+    err.code = code;
+    return err;
+}
+
+export { AudioPlayBackDevice, CallEndReason, CallInvitationRespondedType, CallInvitationResultCodeType, CallMediaType, CallRole, CallScene, CallStatus, CameraPosition, IOSOfflinePushType, LOG_LEVEL, LayoutTemplate, TUICallEngine, TUICallEvent, TUIErrorCode, TUICallEngine as default };
+//# sourceMappingURL=index.esm.mjs.map