@xmaxai/web-sdk 1.0.2 → 1.0.4

package/dist/{chunk-5NIEZJP5.cjs → chunk-FEL5MJMJ.cjs}

@@ -3,10 +3,10 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/Foundation/Runtime/XmaxEnvironment.ts
-var XmaxEnvironment = /* @__PURE__ */ ((XmaxEnvironment2) => {
-  XmaxEnvironment2["china"] = "china";
-  XmaxEnvironment2["global"] = "global";
-  return XmaxEnvironment2;
+var XmaxEnvironment = /* @__PURE__ */ ((XmaxEnvironment3) => {
+  XmaxEnvironment3["china"] = "china";
+  XmaxEnvironment3["global"] = "global";
+  return XmaxEnvironment3;
 })(XmaxEnvironment || {});
 var API_BASE_URLS = {
   ["china" /* china */]: "https://cloud.xmax.22duck.cn/open/api/v1",
@@ -198,7 +198,7 @@ var XmaxError = class _XmaxError extends Error {
 };
 
 // src/Foundation/Runtime/RuntimeInfo.ts
-var XMAX_SDK_VERSION = "1.0.2";
+var XMAX_SDK_VERSION = "1.0.4";
 var _RuntimeInfo = class _RuntimeInfo {
   /**
    * 序列化为接口传输使用的 snake_case 字段。
@@ -263,10 +263,12 @@ var _ApiService = class _ApiService {
   }
   /**
    * 发送请求并返回统一响应中的数据。
+   *
+   * @param options.keepalive 为 true 时请求可存活于页面卸载之后。
    */
-  async request(method, path, body) {
+  async request(method, path, body, options) {
     this.validateConfiguration();
-    const request = this.makeRequest(method, path, body);
+    const request = this.makeRequest(method, path, body, options);
     const startedAt = Date.now();
     let status;
     let text;
@@ -313,8 +315,8 @@ var _ApiService = class _ApiService {
   /**
    * 发送 DELETE 请求。
    */
-  delete(path) {
-    return this.request("DELETE" /* delete */, path);
+  delete(path, options) {
+    return this.request("DELETE" /* delete */, path, void 0, options);
   }
   /**
    * 校验 API Key 与 Base URL 配置。
@@ -344,7 +346,7 @@ var _ApiService = class _ApiService {
   /**
    * 构造请求地址、请求头与请求体；路径必须相对且与 Base URL 同源。
    */
-  makeRequest(method, path, body) {
+  makeRequest(method, path, body, options) {
     const normalizedPath = path.trim();
     if (normalizedPath.length === 0 || normalizedPath.includes("://") || normalizedPath.startsWith("//")) {
       throw new XmaxError(
@@ -385,7 +387,8 @@ var _ApiService = class _ApiService {
           "X-SDK-Version": XMAX_SDK_VERSION
         },
         body: encodedBody,
-        signal: AbortSignal.timeout(this.timeoutMs)
+        signal: AbortSignal.timeout(this.timeoutMs),
+        ..._optionalChain([options, 'optionalAccess', _4 => _4.keepalive]) ? { keepalive: true } : {}
       }
     };
   }
@@ -403,7 +406,7 @@ var _ApiService = class _ApiService {
     }
     const ok = status >= 200 && status < 300;
     if (!ok || envelope.success !== true) {
-      const message = _optionalChain([envelope, 'access', _4 => _4.message, 'optionalAccess', _5 => _5.trim, 'call', _6 => _6()]);
+      const message = _optionalChain([envelope, 'access', _5 => _5.message, 'optionalAccess', _6 => _6.trim, 'call', _7 => _7()]);
       throw new XmaxError(
         "API_ERROR" /* apiError */,
         message || "Xmax API request failed",
@@ -518,22 +521,22 @@ var RealtimeVideoFormat = class _RealtimeVideoFormat {
    * @throws 尺寸、帧率或码率配置无效时抛出错误。
    */
   validate() {
-    if (this.width <= 0 || this.height <= 0 || this.fps <= 0 || this.width % 2 !== 0 || this.height % 2 !== 0) {
+    if (this.width <= 0 || this.height <= 0 || !Number.isFinite(this.fps) || this.fps <= 0 || this.width % 2 !== 0 || this.height % 2 !== 0) {
       throw new XmaxError(
         "INVALID_CONFIGURATION" /* invalidConfiguration */,
         "Realtime video width and height must be positive even numbers, and fps must be greater than zero"
       );
     }
-    if (this.minimumBitrate !== void 0 && this.minimumBitrate < 0) {
+    if (this.minimumBitrate !== void 0 && (!Number.isFinite(this.minimumBitrate) || this.minimumBitrate < 0)) {
       throw new XmaxError(
         "INVALID_CONFIGURATION" /* invalidConfiguration */,
-        "Minimum bitrate must not be negative"
+        "Minimum bitrate must be finite and not negative"
       );
     }
-    if (this.maximumBitrate !== void 0 && this.maximumBitrate <= 0) {
+    if (this.maximumBitrate !== void 0 && (!Number.isFinite(this.maximumBitrate) || this.maximumBitrate <= 0)) {
       throw new XmaxError(
         "INVALID_CONFIGURATION" /* invalidConfiguration */,
-        "Maximum bitrate must be greater than zero"
+        "Maximum bitrate must be finite and greater than zero"
       );
     }
     if (this.minimumBitrate !== void 0 && this.maximumBitrate !== void 0 && this.minimumBitrate > this.maximumBitrate) {
@@ -561,26 +564,39 @@ var RealtimeVideoFormat = class _RealtimeVideoFormat {
 // src/Service/Realtime/RealtimeModel.ts
 var RealtimeModel = /* @__PURE__ */ ((RealtimeModel2) => {
   RealtimeModel2["x2_0"] = "x2.0";
-  RealtimeModel2["x2_0_pro"] = "x2.0-pro";
   RealtimeModel2["x2_0_trtc"] = "x2.0-trtc";
+  RealtimeModel2["x2_0_agora"] = "x2.0-agora";
+  RealtimeModel2["x2_1_preview"] = "x2.1-preview";
   return RealtimeModel2;
 })(RealtimeModel || {});
+var MODEL_BASE_URLS = {
+  ["x2.0-agora" /* x2_0_agora */]: "https://dev.xmaxai.com/open/api/v1",
+  ["x2.1-preview" /* x2_1_preview */]: "https://dev.xmaxai.com/open/api/v1"
+};
 var RESOLUTION_BUCKETS = {
-  ["x2.0" /* x2_0 */]: [],
-  ["x2.0-pro" /* x2_0_pro */]: [
+  ["x2.1-preview" /* x2_1_preview */]: [
     { width: 1024, height: 1920 },
     { width: 1920, height: 1024 }
   ],
+  ["x2.0-agora" /* x2_0_agora */]: [
+    { width: 1024, height: 1920 },
+    { width: 1920, height: 1024 }
+  ],
+  ["x2.0" /* x2_0 */]: [],
   ["x2.0-trtc" /* x2_0_trtc */]: [
     { width: 1024, height: 1920 },
     { width: 1920, height: 1024 }
   ]
 };
 var MAXIMUM_INPUT_PIXELS = {
+  ["x2.1-preview" /* x2_1_preview */]: 21e5,
+  ["x2.0-agora" /* x2_0_agora */]: 21e5,
   ["x2.0" /* x2_0 */]: 128e4,
-  ["x2.0-pro" /* x2_0_pro */]: 21e5,
   ["x2.0-trtc" /* x2_0_trtc */]: 21e5
 };
+function modelBaseURL(model) {
+  return MODEL_BASE_URLS[model];
+}
 function resolutionBuckets(model) {
   return RESOLUTION_BUCKETS[model];
 }
@@ -609,7 +625,7 @@ async function frameInterpolationAdapter(size) {
   if (size && (!Number.isSafeInteger(size.width) || !Number.isSafeInteger(size.height) || size.width <= 0 || size.height <= 0)) return null;
   try {
     const adapter = await navigator.gpu.requestAdapter();
-    if (!_optionalChain([adapter, 'optionalAccess', _7 => _7.features, 'access', _8 => _8.has, 'call', _9 => _9("shader-f16")])) return null;
+    if (!_optionalChain([adapter, 'optionalAccess', _8 => _8.features, 'access', _9 => _9.has, 'call', _10 => _10("shader-f16")])) return null;
     if (size && (Math.ceil(size.width / 16) * 16 > adapter.limits.maxTextureDimension2D || Math.ceil(size.height / 16) * 16 > adapter.limits.maxTextureDimension2D)) return null;
     return adapter;
   } catch (e5) {
@@ -823,7 +839,7 @@ var StorageService = class _StorageService {
     const startedAt = Date.now();
     try {
       const safeName = _StorageService.validateFileName(options.fileName);
-      const contentType = _optionalChain([options, 'access', _10 => _10.contentType, 'optionalAccess', _11 => _11.trim, 'call', _12 => _12()]) || _StorageService.inferContentType(safeName);
+      const contentType = _optionalChain([options, 'access', _11 => _11.contentType, 'optionalAccess', _12 => _12.trim, 'call', _13 => _13()]) || _StorageService.inferContentType(safeName);
       const body = _StorageService.makeBody(options.data, contentType);
       if (body.size === 0) {
         throw new XmaxError(
@@ -845,7 +861,7 @@ var StorageService = class _StorageService {
         Key: objectKey,
         Body: body,
         ContentType: contentType,
-        onProgress: options.onProgress ? (info) => _optionalChain([options, 'access', _13 => _13.onProgress, 'optionalCall', _14 => _14(info.loaded, info.total)]) : void 0
+        onProgress: options.onProgress ? (info) => _optionalChain([options, 'access', _14 => _14.onProgress, 'optionalCall', _15 => _15(info.loaded, info.total)]) : void 0
       });
       const url = _StorageService.resolveObjectURL(
         uploaded.Location,
@@ -877,9 +893,9 @@ var StorageService = class _StorageService {
     const bucket = _StorageService.nonEmpty(payload.bucket);
     const region = _StorageService.nonEmpty(payload.region);
     const prefix = _StorageService.nonEmpty(payload.prefix);
-    const accessKeyID = _StorageService.nonEmpty(_optionalChain([payload, 'access', _15 => _15.credentials, 'optionalAccess', _16 => _16.accessKeyId]));
-    const secretAccessKey = _StorageService.nonEmpty(_optionalChain([payload, 'access', _17 => _17.credentials, 'optionalAccess', _18 => _18.secretAccessKey]));
-    const sessionToken = _StorageService.nonEmpty(_optionalChain([payload, 'access', _19 => _19.credentials, 'optionalAccess', _20 => _20.sessionToken]));
+    const accessKeyID = _StorageService.nonEmpty(_optionalChain([payload, 'access', _16 => _16.credentials, 'optionalAccess', _17 => _17.accessKeyId]));
+    const secretAccessKey = _StorageService.nonEmpty(_optionalChain([payload, 'access', _18 => _18.credentials, 'optionalAccess', _19 => _19.secretAccessKey]));
+    const sessionToken = _StorageService.nonEmpty(_optionalChain([payload, 'access', _20 => _20.credentials, 'optionalAccess', _21 => _21.sessionToken]));
     if (!bucket || !region || !prefix || !accessKeyID || !secretAccessKey || !sessionToken) {
       throw new XmaxError("API_ERROR" /* apiError */, message);
     }
@@ -920,7 +936,7 @@ var StorageService = class _StorageService {
           reject(
             new XmaxError(
               "UPLOAD_ERROR" /* uploadError */,
-              _optionalChain([error, 'access', _21 => _21.message, 'optionalAccess', _22 => _22.trim, 'call', _23 => _23()]) || "Storage upload failed"
+              _optionalChain([error, 'access', _22 => _22.message, 'optionalAccess', _23 => _23.trim, 'call', _24 => _24()]) || "Storage upload failed"
             )
           );
           return;
@@ -934,14 +950,14 @@ var StorageService = class _StorageService {
    * 其次拼接自定义 endpoint，最后回退到默认 COS 域名。
    */
   static resolveObjectURL(location, configuration, objectKey) {
-    const candidate = _nullishCoalesce(_optionalChain([location, 'optionalAccess', _24 => _24.trim, 'call', _25 => _25()]), () => ( ""));
+    const candidate = _nullishCoalesce(_optionalChain([location, 'optionalAccess', _25 => _25.trim, 'call', _26 => _26()]), () => ( ""));
     if (candidate.startsWith("//")) {
       return `https:${candidate}`;
     }
     if (/^https?:\/\//i.test(candidate)) {
       return candidate;
     }
-    const endpoint = _optionalChain([configuration, 'access', _26 => _26.endpoint, 'optionalAccess', _27 => _27.trim, 'call', _28 => _28()]);
+    const endpoint = _optionalChain([configuration, 'access', _27 => _27.endpoint, 'optionalAccess', _28 => _28.trim, 'call', _29 => _29()]);
     if (endpoint) {
       const normalized = /^https?:\/\//i.test(endpoint) ? endpoint : `https://${endpoint}`;
       return `${normalized.replace(/\/+$/, "")}/${objectKey}`;
@@ -975,7 +991,7 @@ var StorageService = class _StorageService {
    * 按文件名后缀推断内容类型。
    */
   static inferContentType(fileName) {
-    const extension = _nullishCoalesce(_optionalChain([fileName, 'access', _29 => _29.split, 'call', _30 => _30("."), 'access', _31 => _31.pop, 'call', _32 => _32(), 'optionalAccess', _33 => _33.toLowerCase, 'call', _34 => _34()]), () => ( ""));
+    const extension = _nullishCoalesce(_optionalChain([fileName, 'access', _30 => _30.split, 'call', _31 => _31("."), 'access', _32 => _32.pop, 'call', _33 => _33(), 'optionalAccess', _34 => _34.toLowerCase, 'call', _35 => _35()]), () => ( ""));
     return _nullishCoalesce(CONTENT_TYPES[extension], () => ( "application/octet-stream"));
   }
   /**
@@ -994,7 +1010,7 @@ var StorageService = class _StorageService {
    * 归一化可选字符串：去除首尾空白后为空时返回 `undefined`。
    */
   static nonEmpty(value) {
-    const normalized = _optionalChain([value, 'optionalAccess', _35 => _35.trim, 'call', _36 => _36()]);
+    const normalized = _optionalChain([value, 'optionalAccess', _36 => _36.trim, 'call', _37 => _37()]);
     return normalized || void 0;
   }
 };
@@ -1006,7 +1022,780 @@ var CameraPosition = /* @__PURE__ */ ((CameraPosition3) => {
   return CameraPosition3;
 })(CameraPosition || {});
 
-// src/Foundation/RTC/RtcEngineManager.ts
+// src/Foundation/Permissions/MediaPermissionWatch.ts
+var PERMISSION_POLL_INTERVAL_MS = 100;
+async function watchMediaPermissionPrompt(includeMicrophone) {
+  if (typeof navigator === "undefined" || !_optionalChain([navigator, 'access', _38 => _38.permissions, 'optionalAccess', _39 => _39.query])) {
+    return void 0;
+  }
+  const names = ["camera", ...includeMicrophone ? ["microphone"] : []];
+  const queryOnce = () => Promise.all(
+    names.map(async (name) => {
+      const status = await navigator.permissions.query({
+        name
+      });
+      return status.state;
+    })
+  );
+  const queryStates = () => Promise.all(
+    names.map(async (name) => {
+      try {
+        const status = await navigator.permissions.query({
+          name
+        });
+        return status.state;
+      } catch (e6) {
+        return "prompt";
+      }
+    })
+  );
+  let states;
+  try {
+    states = await queryOnce();
+  } catch (e7) {
+    return void 0;
+  }
+  if (states.every((state2) => state2 === "granted")) {
+    return { decided: Promise.resolve(), dispose() {
+    } };
+  }
+  if (!states.includes("prompt")) {
+    return void 0;
+  }
+  let disposed = false;
+  let resolveDecided;
+  const decided = new Promise((resolve) => {
+    resolveDecided = resolve;
+  });
+  const finishIfDecided = (current) => {
+    if (disposed || current.includes("prompt")) {
+      return;
+    }
+    dispose();
+    resolveDecided();
+  };
+  const poll = setInterval(() => {
+    void queryStates().then(finishIfDecided);
+  }, PERMISSION_POLL_INTERVAL_MS);
+  function dispose() {
+    disposed = true;
+    clearInterval(poll);
+  }
+  return { decided, dispose };
+}
+
+// src/Foundation/RTC/Agora/AgoraRtcStatistics.ts
+var AgoraRtcStatistics = class _AgoraRtcStatistics {
+  /**
+   * 采集已发布的视频和已订阅的结果流统计，性能日志不控制回调采集。
+   */
+  static collect(client, listener) {
+    const rtc = client.getRTCStats();
+    const local = client.getLocalVideoStats();
+    const valid = _AgoraRtcStatistics.valid;
+    const loss = _AgoraRtcStatistics.loss;
+    const localVideo = client.localTracks.some((track) => track.trackMediaType === "video") ? {
+      width: valid(local.sendResolutionWidth, 1),
+      height: valid(local.sendResolutionHeight, 1),
+      frameRate: valid(local.sendFrameRate),
+      bitrateKbps: valid(local.sendBitrate / 1e3),
+      uplinkLossPercent: loss(local.currentPacketLossRate)
+    } : void 0;
+    const remote = Object.entries(client.getRemoteVideoStats()).map(([userID, stats]) => ({
+      userID,
+      width: valid(stats.receiveResolutionWidth, 1),
+      height: valid(stats.receiveResolutionHeight, 1),
+      frameRate: valid(stats.receiveFrameRate),
+      bitrateKbps: valid(stats.receiveBitrate / 1e3),
+      rttMs: valid(rtc.RTT),
+      uplinkLossPercent: _optionalChain([localVideo, 'optionalAccess', _40 => _40.uplinkLossPercent]),
+      downlinkLossPercent: loss(stats.currentPacketLossRate),
+      endToEndDelayMs: valid(stats.end2EndDelay)
+    }));
+    _optionalChain([listener, 'optionalAccess', _41 => _41.onLocalVideoStatistics, 'optionalCall', _42 => _42(localVideo && Object.freeze(localVideo))]);
+    _optionalChain([listener, 'optionalAccess', _43 => _43.onRemoteVideoStatistics, 'optionalCall', _44 => _44(Object.freeze(remote.map((item) => Object.freeze(item))))]);
+    XmaxLogger.rtc.info(() => `Agora \u8FD0\u884C\u7EDF\u8BA1 (Agora RTC Statistics)
+${JSON.stringify({
+      rttMs: valid(rtc.RTT),
+      sentBytes: valid(rtc.SendBytes),
+      receivedBytes: valid(rtc.RecvBytes),
+      localVideo,
+      remoteVideo: remote,
+      localAudio: client.getLocalAudioStats(),
+      remoteAudio: client.getRemoteAudioStats()
+    }, null, 2)}`, 2 /* performance */);
+  }
+  /**
+   * 网络质量等级范围与公共枚举一致；不将整体 RTT 冒充上下行独立 RTT。
+   */
+  static network(stats, listener) {
+    const quality = (value) => Number.isInteger(value) && value >= 0 && value <= 6 ? value : void 0;
+    const result = Object.freeze({ uplinkQuality: quality(stats.uplinkNetworkQuality), downlinkQuality: quality(stats.downlinkNetworkQuality) });
+    _optionalChain([listener, 'optionalAccess', _45 => _45.onNetworkStatistics, 'optionalCall', _46 => _46(result)]);
+    XmaxLogger.rtc.info(() => `Agora \u7F51\u7EDC\u8D28\u91CF (Agora Network Quality)
+${JSON.stringify(result, null, 2)}`, 2 /* performance */);
+  }
+  /**
+   * 过滤缺失、非有限或不合理的统计值。
+   */
+  static valid(value, minimum = 0) {
+    return typeof value === "number" && Number.isFinite(value) && value >= minimum ? value : void 0;
+  }
+  /**
+   * 声网丢包率为 0–1 比例，转换为公共百分比。
+   */
+  static loss(value) {
+    return Number.isFinite(value) && value >= 0 && value <= 1 ? value * 100 : void 0;
+  }
+};
+
+// src/Foundation/RTC/RtcVideoOrientation.ts
+function shouldTransposeRtcVideoSize(environment) {
+  const userAgent = _nullishCoalesce(_optionalChain([environment, 'optionalAccess', _47 => _47.userAgent]), () => ( (typeof navigator === "undefined" ? "" : navigator.userAgent)));
+  const maxTouchPoints = _nullishCoalesce(_optionalChain([environment, 'optionalAccess', _48 => _48.maxTouchPoints]), () => ( (typeof navigator === "undefined" ? 0 : _nullishCoalesce(navigator.maxTouchPoints, () => ( 0)))));
+  const mobile = /Android|webOS|iPhone|iPad|iPod|Mobile/i.test(userAgent) || /Macintosh/i.test(userAgent) && maxTouchPoints > 1;
+  if (!mobile) {
+    return false;
+  }
+  const orientationType = _nullishCoalesce(_optionalChain([environment, 'optionalAccess', _49 => _49.orientationType]), () => ( (typeof window === "undefined" ? void 0 : _optionalChain([window, 'access', _50 => _50.screen, 'optionalAccess', _51 => _51.orientation, 'optionalAccess', _52 => _52.type]))));
+  if (orientationType !== void 0) {
+    return orientationType.includes("portrait");
+  }
+  const degrees = _nullishCoalesce(_optionalChain([environment, 'optionalAccess', _53 => _53.orientationDegrees]), () => ( (typeof window === "undefined" ? void 0 : window.orientation)));
+  return degrees === 0 || degrees === 180;
+}
+function rtcOrientedVideoSize(size, environment) {
+  return shouldTransposeRtcVideoSize(environment) ? { width: size.height, height: size.width } : size;
+}
+
+// src/Foundation/RTC/Agora/AgoraRtcManager.ts
+var _AgoraRtcManager = class _AgoraRtcManager {
+  /**
+   * 保存服务环境与加载器，不触发浏览器依赖或设备权限请求。
+   */
+  constructor(options) {
+    /**
+     * 配置与 RTC 资源
+     */
+    __publicField(this, "environment");
+    __publicField(this, "loadSDK");
+    __publicField(this, "sdk");
+    __publicField(this, "client");
+    __publicField(this, "initialization");
+    __publicField(this, "lifecycle", 0);
+    __publicField(this, "camera");
+    __publicField(this, "microphone");
+    __publicField(this, "connection");
+    __publicField(this, "roomVersion", 0);
+    /**
+     * 凭据恢复与发布意图；RTC 自动断开可能清空 localTracks，因此单独保留发布意图。
+     */
+    __publicField(this, "tokenExpired", false);
+    __publicField(this, "rejoinOperation");
+    __publicField(this, "rejoinTask");
+    __publicField(this, "cancelRejoin");
+    __publicField(this, "videoPublishRequested", false);
+    __publicField(this, "audioPublishRequested", false);
+    /**
+     * 事件、统计与音频播放状态
+     */
+    __publicField(this, "listener");
+    __publicField(this, "statisticsTimer");
+    __publicField(this, "audioVolumes", /* @__PURE__ */ new Map());
+    __publicField(this, "requestedAudio", /* @__PURE__ */ new Set());
+    /**
+     * DataStream 串行发送与限速状态；等待中的消息通过房间版本取消。
+     */
+    __publicField(this, "sendTail", Promise.resolve());
+    __publicField(this, "sentPackets", []);
+    __publicField(this, "cancelSendDelay");
+    __publicField(this, "cancelActiveSend");
+    this.environment = options.environment;
+    this.loadSDK = _nullishCoalesce(options.loadSDK, () => ( (async () => (await Promise.resolve().then(() => _interopRequireWildcard(require("agora-rtc-sdk-ng")))).default)));
+  }
+  /**
+   * 当前实例是否已创建声网 client。
+   */
+  get isInitialized() {
+    return this.client !== void 0;
+  }
+  /**
+   * 声网音频轨支持播放前设置音量；零音量额外停止播放以防浏览器差异。
+   */
+  get supportsRemoteAudioVolumeControl() {
+    return true;
+  }
+  /**
+   * 共享本实例的初始化任务，区域完全由接入方环境决定。
+   */
+  async initialize() {
+    if (this.client) return;
+    if (this.initialization) return this.initialization;
+    const version = this.lifecycle;
+    const operation = this.performInitialize(version);
+    this.initialization = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.initialization === operation) this.initialization = void 0;
+    }
+  }
+  /**
+   * 加载模块、锁定区域并注册事件；迟到的初始化不能复活已销毁实例。
+   */
+  async performInitialize(version) {
+    const sdk = await this.loadSDK();
+    if (version !== this.lifecycle) throw this.cancelled();
+    const region = _AgoraRtcManager.regions.get(sdk);
+    if (region && region.environment !== this.environment) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Concurrent Agora clients must use the same XmaxEnvironment");
+    }
+    sdk.setLogLevel(4);
+    if (!region) sdk.setArea([this.environment === "china" /* china */ ? "CHINA" : "GLOBAL"]);
+    const client = sdk.createClient({ mode: "rtc", codec: "h264" });
+    if (typeof client.sendStreamMessage !== "function") {
+      throw new XmaxError("RTC_ERROR" /* rtcError */, "Agora DataStream is unavailable in this SDK version");
+    }
+    _AgoraRtcManager.regions.set(sdk, { environment: this.environment, count: (_nullishCoalesce(_optionalChain([region, 'optionalAccess', _54 => _54.count]), () => ( 0))) + 1 });
+    this.sdk = sdk;
+    this.client = client;
+    this.registerEvents(client);
+  }
+  /**
+   * 先失效全部异步工作，再释放房间、采集、监听和区域引用。
+   */
+  async destroy() {
+    this.lifecycle++;
+    const client = this.client;
+    this.listener = void 0;
+    this.clearRoom();
+    this.client = void 0;
+    _optionalChain([client, 'optionalAccess', _55 => _55.removeAllListeners, 'call', _56 => _56()]);
+    _optionalChain([this, 'access', _57 => _57.camera, 'optionalAccess', _58 => _58.close, 'call', _59 => _59()]);
+    _optionalChain([this, 'access', _60 => _60.microphone, 'optionalAccess', _61 => _61.close, 'call', _62 => _62()]);
+    this.camera = void 0;
+    this.microphone = void 0;
+    const sdk = this.sdk;
+    this.sdk = void 0;
+    try {
+      await _optionalChain([client, 'optionalAccess', _63 => _63.leave, 'call', _64 => _64()]);
+    } catch (e8) {
+      XmaxLogger.rtc.warning(() => "Agora \u9000\u623F\u5931\u8D25\uFF0C\u5DF2\u91CA\u653E\u672C\u5730\u8D44\u6E90 (Agora Leave Failed)");
+    } finally {
+      const region = sdk && _AgoraRtcManager.regions.get(sdk);
+      if (sdk && region && --region.count === 0) _AgoraRtcManager.regions.delete(sdk);
+    }
+  }
+  /**
+   * 通过声网采集相机但不发布，返回原生轨道供公共渲染层使用。
+   */
+  async startCameraCapture(options) {
+    const client = this.requireClient();
+    if (this.camera) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Camera capture is already running");
+    try {
+      const captureSize = rtcOrientedVideoSize(options);
+      const camera = await this.sdk.createCameraVideoTrack({
+        facingMode: options.position === "front" /* front */ ? "user" : "environment",
+        encoderConfig: { width: captureSize.width, height: captureSize.height, frameRate: options.frameRate }
+      });
+      if (this.client !== client) {
+        camera.close();
+        throw this.cancelled();
+      }
+      this.camera = camera;
+      return camera.getMediaStreamTrack();
+    } catch (error) {
+      throw this.mapError(error, "CAMERA_PERMISSION_DENIED" /* cameraPermissionDenied */);
+    }
+  }
+  /**
+   * 切换声网相机设备并返回切换后的原生轨道。
+   */
+  async switchCameraCapture(to) {
+    const camera = this.requireCamera();
+    await this.run(() => camera.setDevice({ facingMode: to === "front" /* front */ ? "user" : "environment" }));
+    if (this.camera !== camera) throw this.cancelled();
+    return camera.getMediaStreamTrack();
+  }
+  /**
+   * 停止采集并释放摄像头。
+   */
+  async stopCameraCapture() {
+    const camera = this.camera;
+    this.camera = void 0;
+    _optionalChain([camera, 'optionalAccess', _65 => _65.close, 'call', _66 => _66()]);
+  }
+  /**
+   * 应用公共编码配置，补偿移动端竖屏的宽高转置。
+   */
+  async configureVideoEncoding(config) {
+    const camera = this.requireCamera();
+    const encodingSize = rtcOrientedVideoSize(config);
+    await this.run(async () => {
+      await camera.setEncoderConfiguration({
+        width: encodingSize.width,
+        height: encodingSize.height,
+        frameRate: config.frameRate,
+        bitrateMin: config.minimumBitrate,
+        bitrateMax: config.maximumBitrate
+      });
+      await camera.setOptimizationMode(config.encoderPreference === "maintainFramerate" /* maintainFramerate */ ? "motion" : "detail");
+    });
+  }
+  /**
+   * 使用会话下发的字符串频道与 UID 入房；不采信后端区域覆盖。
+   */
+  async joinRoom(configuration) {
+    await _optionalChain([this, 'access', _67 => _67.rejoinTask, 'optionalAccess', _68 => _68.catch, 'call', _69 => _69(() => {
+    })]);
+    const client = this.requireClient();
+    if (configuration.provider !== "agora" || this.connection) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Agora credentials and an idle room are required");
+    }
+    const version = ++this.roomVersion;
+    await this.run(() => client.join(configuration.appID, configuration.roomID, configuration.roomToken, configuration.userID));
+    if (client !== this.client || version !== this.roomVersion) {
+      await client.leave();
+      throw this.cancelled();
+    }
+    this.connection = configuration;
+    for (const user of client.remoteUsers) {
+      if (user.hasVideo) _optionalChain([this, 'access', _70 => _70.listener, 'optionalAccess', _71 => _71.onRemoteVideoPublished, 'call', _72 => _72(String(user.uid), true)]);
+    }
+    this.statisticsTimer = setInterval(() => {
+      if (this.client !== client || !this.connection || this.tokenExpired || this.rejoinOperation) return;
+      try {
+        AgoraRtcStatistics.collect(client, this.listener);
+      } catch (e9) {
+        XmaxLogger.rtc.warning(() => "Agora \u7EDF\u8BA1\u91C7\u6837\u5931\u8D25 (Agora Statistics Failed)");
+      }
+    }, 2e3);
+  }
+  /**
+   * 退房前取消排队消息、统计与音频播放；本地相机预览保持运行。
+   */
+  async leaveRoom() {
+    this.clearRoom();
+    if (this.client) await this.run(() => this.client.leave());
+  }
+  /**
+   * 应用同一频道的新 Token；即将过期时续签，已经过期时重新进房并恢复媒体。
+   */
+  async updateCredentials(config, signal) {
+    if (_optionalChain([signal, 'optionalAccess', _73 => _73.aborted])) throw this.cancelled();
+    const current = this.connection;
+    const client = this.requireClient();
+    if (!current || config.provider !== "agora" || config.appID !== current.appID || config.roomID !== current.roomID || config.userID !== current.userID) {
+      throw new XmaxError("SESSION_ERROR" /* sessionError */, "Agora session binding changed");
+    }
+    const version = this.roomVersion;
+    if (!this.tokenExpired) {
+      try {
+        await this.run(() => client.renewToken(config.roomToken));
+      } catch (error) {
+        this.ensureRoomCurrent(client, version);
+        if (!this.tokenExpired) throw error;
+      }
+    }
+    this.ensureRoomCurrent(client, version);
+    if (_optionalChain([signal, 'optionalAccess', _74 => _74.aborted])) throw this.cancelled();
+    if (this.tokenExpired) await this.rejoinRoom(client, config, signal);
+    else this.connection = config;
+  }
+  /**
+   * 串行恢复同一 RTC 房间，不创建业务会话或重新发送生成开始指令。
+   */
+  async rejoinRoom(client, config, signal) {
+    if (this.rejoinOperation) return this.rejoinOperation;
+    const version = ++this.roomVersion;
+    const task = Promise.resolve().then(() => this.performRejoin(client, config, version));
+    this.rejoinTask = task;
+    void task.finally(() => {
+      if (this.rejoinTask === task) this.rejoinTask = void 0;
+    }).catch(() => {
+    });
+    let cancel;
+    const operation = new Promise((resolve, reject) => {
+      cancel = () => {
+        if (this.isRoomCurrent(client, version)) this.roomVersion++;
+        reject(this.cancelled());
+      };
+      this.cancelRejoin = cancel;
+      _optionalChain([signal, 'optionalAccess', _75 => _75.addEventListener, 'call', _76 => _76("abort", cancel, { once: true })]);
+      task.then(resolve, reject);
+      if (_optionalChain([signal, 'optionalAccess', _77 => _77.aborted])) cancel();
+    });
+    this.rejoinOperation = operation;
+    try {
+      await operation;
+    } finally {
+      _optionalChain([signal, 'optionalAccess', _78 => _78.removeEventListener, 'call', _79 => _79("abort", cancel)]);
+      if (this.cancelRejoin === cancel) this.cancelRejoin = void 0;
+      if (this.rejoinOperation === operation) this.rejoinOperation = void 0;
+    }
+    this.ensureRoomCurrent(client, version);
+    for (const user of client.remoteUsers) {
+      if (user.hasVideo) _optionalChain([this, 'access', _80 => _80.listener, 'optionalAccess', _81 => _81.onRemoteVideoPublished, 'call', _82 => _82(String(user.uid), true)]);
+    }
+  }
+  /**
+   * 使用新 Token 重建 RTC 连接，复用采集轨道并恢复远端音频订阅。
+   */
+  async performRejoin(client, config, version) {
+    this.ensureRoomCurrent(client, version);
+    _optionalChain([this, 'access', _83 => _83.cancelSendDelay, 'optionalCall', _84 => _84()]);
+    _optionalChain([this, 'access', _85 => _85.cancelActiveSend, 'optionalCall', _86 => _86()]);
+    _optionalChain([this, 'access', _87 => _87.listener, 'optionalAccess', _88 => _88.onRoomRejoining, 'optionalCall', _89 => _89()]);
+    for (const user of client.remoteUsers) _optionalChain([user, 'access', _90 => _90.audioTrack, 'optionalAccess', _91 => _91.stop, 'call', _92 => _92()]);
+    await this.run(() => client.leave());
+    this.ensureRoomCurrent(client, version);
+    await this.run(() => client.join(config.appID, config.roomID, config.roomToken, config.userID));
+    if (!this.isRoomCurrent(client, version)) {
+      await this.run(() => client.leave());
+      throw this.cancelled();
+    }
+    if (this.videoPublishRequested && this.camera) {
+      await this.run(() => client.publish(this.camera));
+      this.ensureRoomCurrent(client, version);
+    }
+    if (this.audioPublishRequested && this.microphone) {
+      await this.run(() => client.publish(this.microphone));
+      this.ensureRoomCurrent(client, version);
+    }
+    for (const user of client.remoteUsers) {
+      if (!user.hasAudio || !this.requestedAudio.has(String(user.uid))) continue;
+      const track = await this.run(() => client.subscribe(user, "audio"));
+      if (!this.isRoomCurrent(client, version)) {
+        track.stop();
+        throw this.cancelled();
+      }
+      this.applyAudioVolume(user);
+    }
+    this.connection = config;
+    this.tokenExpired = false;
+    this.sentPackets = [];
+  }
+  /**
+   * 发布已采集的视频轨道。
+   */
+  async publishLocalVideo() {
+    const client = this.requireClient();
+    const camera = this.requireCamera();
+    this.videoPublishRequested = true;
+    await this.rejoinOperation;
+    if (client !== this.client || !this.videoPublishRequested) throw this.cancelled();
+    if (client.localTracks.includes(camera)) return;
+    await this.run(() => client.publish(camera));
+  }
+  /**
+   * 停止视频发布但保留采集与预览。
+   */
+  async unpublishLocalVideo() {
+    this.videoPublishRequested = false;
+    if (this.rejoinTask || this.tokenExpired) return;
+    if (this.client && this.camera) await this.run(() => this.client.unpublish(this.camera));
+  }
+  /**
+   * 首次发布时申请麦克风；取消后的迟到采集立即释放。
+   */
+  async publishLocalAudio() {
+    const client = this.requireClient();
+    this.audioPublishRequested = true;
+    await this.rejoinOperation;
+    const version = this.roomVersion;
+    if (client !== this.client || !this.audioPublishRequested) throw this.cancelled();
+    try {
+      if (!this.microphone) {
+        const track = await this.sdk.createMicrophoneAudioTrack();
+        if (client !== this.client || version !== this.roomVersion) {
+          track.close();
+          throw this.cancelled();
+        }
+        this.microphone = track;
+      }
+      if (!client.localTracks.includes(this.microphone)) await client.publish(this.microphone);
+    } catch (error) {
+      throw this.mapError(error, "MICROPHONE_PERMISSION_DENIED" /* microphonePermissionDenied */);
+    }
+  }
+  /**
+   * 停止音频发布，采集交给关闭流程释放。
+   */
+  async unpublishLocalAudio() {
+    this.audioPublishRequested = false;
+    if (this.rejoinTask || this.tokenExpired) return;
+    if (this.client && this.microphone) await this.run(() => this.client.unpublish(this.microphone));
+  }
+  /**
+   * 订阅远端主视频并返回原生轨道，不创建额外播放视图。
+   */
+  async subscribeRemoteVideo(userID, subscribe) {
+    if (!subscribe && this.rejoinTask) return;
+    await this.rejoinOperation;
+    const client = this.requireClient();
+    const user = client.remoteUsers.find((user2) => String(user2.uid) === userID);
+    if (!user && !subscribe) return;
+    if (!user) throw new XmaxError("RTC_ERROR" /* rtcError */, "Agora remote video user is unavailable");
+    if (!subscribe) {
+      await this.run(() => client.unsubscribe(user, "video"));
+      return;
+    }
+    const version = this.roomVersion;
+    const track = await this.run(() => client.subscribe(user, "video"));
+    if (client !== this.client || version !== this.roomVersion) throw this.cancelled();
+    return track.getMediaStreamTrack();
+  }
+  /**
+   * 保存音频订阅意图；音频稍后发布时自动订阅，播放前应用音量。
+   */
+  async subscribeRemoteAudio(userID, subscribe) {
+    const client = this.requireClient();
+    const user = client.remoteUsers.find((user2) => String(user2.uid) === userID);
+    if (!subscribe) {
+      this.requestedAudio.delete(userID);
+      _optionalChain([user, 'optionalAccess', _93 => _93.audioTrack, 'optionalAccess', _94 => _94.stop, 'call', _95 => _95()]);
+      if (_optionalChain([user, 'optionalAccess', _96 => _96.audioTrack]) && !this.rejoinTask) await this.run(() => client.unsubscribe(user, "audio"));
+      return;
+    }
+    this.requestedAudio.add(userID);
+    if (this.rejoinOperation) {
+      const version2 = this.roomVersion;
+      await this.rejoinOperation;
+      this.ensureRoomCurrent(client, version2);
+      if (this.requestedAudio.has(userID)) await this.subscribeRemoteAudio(userID, true);
+      return;
+    }
+    if (!_optionalChain([user, 'optionalAccess', _97 => _97.hasAudio])) return;
+    const version = this.roomVersion;
+    const track = await this.run(() => client.subscribe(user, "audio"));
+    if (client !== this.client || version !== this.roomVersion || !this.requestedAudio.has(userID)) {
+      track.stop();
+      return;
+    }
+    this.applyAudioVolume(user);
+  }
+  /**
+   * 缓存音量，订阅前可调用；零音量不调用 play，防止初始短暂漏声。
+   */
+  setRemoteAudioVolume(volume, userID) {
+    this.audioVolumes.set(userID, Math.max(0, Math.min(100, Number.isFinite(volume) ? Math.round(volume) : 0)));
+    const user = _optionalChain([this, 'access', _98 => _98.client, 'optionalAccess', _99 => _99.remoteUsers, 'access', _100 => _100.find, 'call', _101 => _101((user2) => String(user2.uid) === userID)]);
+    if (this.rejoinTask || this.tokenExpired) {
+      _optionalChain([user, 'optionalAccess', _102 => _102.audioTrack, 'optionalAccess', _103 => _103.stop, 'call', _104 => _104()]);
+      return;
+    }
+    if (user) this.applyAudioVolume(user);
+  }
+  /**
+   * 应用当前用户的播放状态，保留声网对浏览器自动播放限制的处理。
+   */
+  applyAudioVolume(user) {
+    const track = user.audioTrack;
+    if (!track) return;
+    const volume = _nullishCoalesce(this.audioVolumes.get(String(user.uid)), () => ( 0));
+    track.setVolume(volume);
+    if (volume > 0 && this.requestedAudio.has(String(user.uid))) track.play();
+    else track.stop();
+  }
+  /**
+   * 按房间顺序发送消息，限制每秒包数与总字节；失败返回给原业务调用。
+   */
+  sendRoomMessage(message) {
+    const version = this.roomVersion;
+    const client = this.client;
+    const bytes = new TextEncoder().encode(message).byteLength;
+    const operation = this.sendTail.then(async () => {
+      await this.rejoinOperation;
+      if (!client || client !== this.client || !this.connection || version !== this.roomVersion || this.tokenExpired) throw this.cancelled();
+      if (bytes > 1e3) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Room message exceeds the 1000-byte limit");
+      await this.waitForSendBudget(bytes, version);
+      await this.rejoinOperation;
+      if (client !== this.client || version !== this.roomVersion || !this.connection || this.tokenExpired) throw this.cancelled();
+      this.sentPackets.push({ time: Date.now(), bytes });
+      await this.sendWithTimeout(client, message);
+    });
+    this.sendTail = operation.catch(() => {
+    });
+    return operation;
+  }
+  /**
+   * 发送超过五秒视为失败；退房立即取消等待，底层迟到结果不影响新房间。
+   */
+  async sendWithTimeout(client, message) {
+    await new Promise((resolve, reject) => {
+      const finish = (error) => {
+        clearTimeout(timer);
+        if (this.cancelActiveSend === cancel) this.cancelActiveSend = void 0;
+        if (error) reject(this.mapError(error));
+        else resolve();
+      };
+      const cancel = () => finish(this.cancelled());
+      const timer = setTimeout(() => finish(new XmaxError("TIMEOUT" /* timeout */, "Agora room message send timed out")), 5e3);
+      this.cancelActiveSend = cancel;
+      void this.run(() => client.sendStreamMessage(message, false)).then(() => finish(), finish);
+    });
+  }
+  /**
+   * 按滑动时间窗限速，退房立即唤醒等待并取消，不遗留计时器。
+   */
+  async waitForSendBudget(bytes, version) {
+    while (version === this.roomVersion) {
+      const now = Date.now();
+      this.sentPackets = this.sentPackets.filter((packet) => now - packet.time < 1e3);
+      if (this.sentPackets.length < 30 && this.sentPackets.reduce((sum, packet) => sum + packet.bytes, bytes) <= 6e3) return;
+      await new Promise((resolve) => {
+        const finish = () => {
+          clearTimeout(timer);
+          this.cancelSendDelay = void 0;
+          resolve();
+        };
+        const timer = setTimeout(finish, Math.max(1, this.sentPackets[0].time + 1e3 - now));
+        this.cancelSendDelay = finish;
+      });
+    }
+    throw this.cancelled();
+  }
+  /**
+   * 设置公共 RTC 监听器。
+   */
+  setEventListener(listener) {
+    this.listener = listener;
+  }
+  /**
+   * 将声网发布、DataStream、网络质量与 Token 事件桥接到公共传输层。
+   */
+  registerEvents(client) {
+    const active = () => this.client === client && this.connection !== void 0 && !this.rejoinTask;
+    const mediaActive = () => active() && !this.tokenExpired;
+    const handleExpired = () => {
+      if (!active() || this.tokenExpired) return;
+      this.tokenExpired = true;
+      _optionalChain([this, 'access', _105 => _105.listener, 'optionalAccess', _106 => _106.onTokenExpired, 'optionalCall', _107 => _107()]);
+    };
+    client.on("user-published", (user, kind) => {
+      if (!mediaActive()) return;
+      if (kind === "video") _optionalChain([this, 'access', _108 => _108.listener, 'optionalAccess', _109 => _109.onRemoteVideoPublished, 'call', _110 => _110(String(user.uid), true)]);
+      if (kind === "audio" && this.requestedAudio.has(String(user.uid))) {
+        void this.subscribeRemoteAudio(String(user.uid), true).catch((error) => {
+          if (active()) _optionalChain([this, 'access', _111 => _111.listener, 'optionalAccess', _112 => _112.onError, 'optionalCall', _113 => _113(this.mapError(error))]);
+        });
+      }
+    });
+    client.on("user-unpublished", (user, kind) => {
+      if (!mediaActive()) return;
+      if (kind === "video") _optionalChain([this, 'access', _114 => _114.listener, 'optionalAccess', _115 => _115.onRemoteVideoPublished, 'call', _116 => _116(String(user.uid), false)]);
+      if (kind === "audio") _optionalChain([user, 'access', _117 => _117.audioTrack, 'optionalAccess', _118 => _118.stop, 'call', _119 => _119()]);
+    });
+    client.on("user-left", (user) => {
+      if (mediaActive()) _optionalChain([this, 'access', _120 => _120.listener, 'optionalAccess', _121 => _121.onRemoteVideoPublished, 'call', _122 => _122(String(user.uid), false)]);
+    });
+    client.on("stream-message", (uid, data) => {
+      if (mediaActive()) _optionalChain([this, 'access', _123 => _123.listener, 'optionalAccess', _124 => _124.onCustomMessageReceived, 'call', _125 => _125(String(uid), typeof data === "string" ? data : new TextDecoder().decode(data))]);
+    });
+    client.on("network-quality", (quality) => {
+      if (mediaActive()) AgoraRtcStatistics.network(quality, this.listener);
+    });
+    client.on("token-privilege-will-expire", () => {
+      if (active() && !this.tokenExpired) _optionalChain([this, 'access', _126 => _126.listener, 'optionalAccess', _127 => _127.onTokenWillExpire, 'optionalCall', _128 => _128()]);
+    });
+    client.on("token-privilege-did-expire", handleExpired);
+    client.on("connection-state-change", (state2, previous, reason) => {
+      if (state2 === "DISCONNECTED" && reason === "TOKEN_EXPIRE") {
+        handleExpired();
+        return;
+      }
+      if (active() && !this.tokenExpired && state2 === "DISCONNECTED" && previous !== "DISCONNECTED") {
+        _optionalChain([this, 'access', _129 => _129.listener, 'optionalAccess', _130 => _130.onError, 'optionalCall', _131 => _131(new XmaxError("RTC_ERROR" /* rtcError */, `Agora connection disconnected: ${_nullishCoalesce(reason, () => ( "unknown"))}`))]);
+      }
+    });
+  }
+  /**
+   * 清理房间状态、播放和发送队列，不释放本地视频采集。
+   */
+  clearRoom() {
+    this.roomVersion++;
+    _optionalChain([this, 'access', _132 => _132.cancelRejoin, 'optionalCall', _133 => _133()]);
+    this.connection = void 0;
+    this.tokenExpired = false;
+    this.videoPublishRequested = false;
+    this.audioPublishRequested = false;
+    clearInterval(this.statisticsTimer);
+    this.statisticsTimer = void 0;
+    _optionalChain([this, 'access', _134 => _134.cancelSendDelay, 'optionalCall', _135 => _135()]);
+    _optionalChain([this, 'access', _136 => _136.cancelActiveSend, 'optionalCall', _137 => _137()]);
+    this.sentPackets = [];
+    this.sendTail = Promise.resolve();
+    this.requestedAudio.clear();
+    this.audioVolumes.clear();
+    for (const user of _nullishCoalesce(_optionalChain([this, 'access', _138 => _138.client, 'optionalAccess', _139 => _139.remoteUsers]), () => ( []))) _optionalChain([user, 'access', _140 => _140.audioTrack, 'optionalAccess', _141 => _141.stop, 'call', _142 => _142()]);
+  }
+  /**
+   * 判断异步恢复工作是否仍属于当前房间生命周期。
+   */
+  isRoomCurrent(client, version) {
+    return this.client === client && this.connection !== void 0 && this.roomVersion === version;
+  }
+  /**
+   * 退房、销毁或换房后停止后续恢复步骤。
+   */
+  ensureRoomCurrent(client, version) {
+    if (!this.isRoomCurrent(client, version)) throw this.cancelled();
+  }
+  /**
+   * 获取已初始化的 client。
+   */
+  requireClient() {
+    if (!this.client) throw new XmaxError("RTC_ERROR" /* rtcError */, "Agora is not initialized");
+    return this.client;
+  }
+  /**
+   * 获取已启动的相机采集。
+   */
+  requireCamera() {
+    if (!this.camera) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Camera capture is not running");
+    return this.camera;
+  }
+  /**
+   * 执行声网操作并统一错误类型。
+   */
+  async run(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      throw this.mapError(error);
+    }
+  }
+  /**
+   * 只传递错误码，不回显可能包含 Token 的厂商原始错误消息。
+   */
+  mapError(error, permissionCode) {
+    if (error instanceof XmaxError) return error;
+    const code = typeof error === "object" && error !== null && "code" in error ? String(error.code) : "UNKNOWN";
+    const safeCode = /^[A-Z_0-9-]+$/.test(code) ? code : "UNKNOWN";
+    return new XmaxError(permissionCode && safeCode === "PERMISSION_DENIED" ? permissionCode : "RTC_ERROR" /* rtcError */, `Agora operation failed (${safeCode})`);
+  }
+  /**
+   * 构造异步操作失效错误。
+   */
+  cancelled() {
+    return new XmaxError("CANCELLED" /* cancelled */, "Agora operation was cancelled");
+  }
+};
+/**
+ * 模块级区域约束：setArea 是全局设置，拒绝同时运行不同区域，避免静默覆盖。
+ */
+__publicField(_AgoraRtcManager, "regions", /* @__PURE__ */ new Map());
+var AgoraRtcManager = _AgoraRtcManager;
+
+// src/Foundation/RTC/RtcProvider.ts
+var RtcProvider = /* @__PURE__ */ ((RtcProvider2) => {
+  RtcProvider2["trtc"] = "trtc";
+  RtcProvider2["agora"] = "agora";
+  RtcProvider2["vertc"] = "vertc";
+  return RtcProvider2;
+})(RtcProvider || {});
+
+// src/Foundation/RTC/TRTC/RtcEngineManager.ts
 var RtcEngineLease = class {
   /**
    * 为已创建的引擎生成独占租约标识，供引擎管理器核对释放请求。
@@ -1074,13 +1863,13 @@ var _RtcEngineManager = class _RtcEngineManager {
    * 释放有效租约、销毁 Engine，并把独占权交给下一个等待者。
    */
   release(lease) {
-    if (_optionalChain([this, 'access', _37 => _37.activeLease, 'optionalAccess', _38 => _38.id]) !== lease.id) {
+    if (_optionalChain([this, 'access', _143 => _143.activeLease, 'optionalAccess', _144 => _144.id]) !== lease.id) {
       return;
     }
     this.activeLease = void 0;
     try {
       lease.engine.destroy();
-    } catch (e6) {
+    } catch (e10) {
     }
     void this.fulfillNextRequest();
   }
@@ -1148,10 +1937,10 @@ var RtcStatsLogger = class {
         `${XmaxLogger.localized("\u7D2F\u8BA1\u63A5\u6536\uFF1A", "Bytes Received: ")}${this.value(stats.bytesReceived, "bytes")}`
       ])];
       const local = stats.localStatistics;
-      if (_optionalChain([local, 'optionalAccess', _39 => _39.audio])) {
+      if (_optionalChain([local, 'optionalAccess', _145 => _145.audio])) {
         blocks.push(this.audioBlock("\u672C\u5730\u97F3\u9891\u53D1\u9001 (Local Audio Uplink)", local.audio, false));
       }
-      for (const video of _nullishCoalesce(_optionalChain([local, 'optionalAccess', _40 => _40.video]), () => ( []))) {
+      for (const video of _nullishCoalesce(_optionalChain([local, 'optionalAccess', _146 => _146.video]), () => ( []))) {
         blocks.push(this.videoBlock("\u672C\u5730\u89C6\u9891\u53D1\u9001 (Local Video Uplink)", video, false));
       }
       for (const remote of _nullishCoalesce(stats.remoteStatistics, () => ( []))) {
@@ -1239,7 +2028,15 @@ var RtcStatsLogger = class {
   }
 };
 
-// src/Foundation/RTC/RtcManager.ts
+// src/Foundation/RTC/TRTC/TrtcAudioVolumeSupport.ts
+function canControlTrtcRemoteAudioVolume(environment) {
+  const userAgent = _nullishCoalesce(_optionalChain([environment, 'optionalAccess', _147 => _147.userAgent]), () => ( (typeof navigator === "undefined" ? "" : navigator.userAgent)));
+  const maxTouchPoints = _nullishCoalesce(_optionalChain([environment, 'optionalAccess', _148 => _148.maxTouchPoints]), () => ( (typeof navigator === "undefined" ? 0 : _nullishCoalesce(navigator.maxTouchPoints, () => ( 0)))));
+  const ios = /iPhone|iPad|iPod/i.test(userAgent) || /Macintosh/i.test(userAgent) && maxTouchPoints > 1;
+  return !ios;
+}
+
+// src/Foundation/RTC/TRTC/TrtcRtcManager.ts
 var RTC_EVENT = {
   remoteVideoAvailable: "remote-video-available",
   remoteVideoUnavailable: "remote-video-unavailable",
@@ -1255,7 +2052,7 @@ var QOS_PREFERENCE_MAP = {
   ["maintainFramerate" /* maintainFramerate */]: "smooth",
   ["maintainQuality" /* maintainQuality */]: "clear"
 };
-var RtcManager = class {
+var TrtcRtcManager = class {
   /**
    * 创建 RTC 管理器。
    *
@@ -1313,18 +2110,18 @@ var RtcManager = class {
     this.isCapturing = false;
     this.isAudioCapturing = false;
     this.isInRoom = false;
-    _optionalChain([this, 'access', _41 => _41.removeStatsListeners, 'optionalCall', _42 => _42()]);
+    _optionalChain([this, 'access', _149 => _149.removeStatsListeners, 'optionalCall', _150 => _150()]);
     this.removeStatsListeners = void 0;
     if (!lease) {
       return;
     }
     try {
       await lease.engine.stopLocalAudio();
-    } catch (e7) {
+    } catch (e11) {
     }
     try {
       await lease.engine.stopLocalVideo();
-    } catch (e8) {
+    } catch (e12) {
     }
     this.engineManager.release(lease);
   }
@@ -1343,13 +2140,17 @@ var RtcManager = class {
       );
     }
     try {
+      const captureSize = rtcOrientedVideoSize({
+        width: options.width,
+        height: options.height
+      });
       await engine.startLocalVideo({
         publish: false,
         option: {
           useFrontCamera: options.position === "front" /* front */,
           profile: {
-            width: options.width,
-            height: options.height,
+            width: captureSize.width,
+            height: captureSize.height,
             frameRate: options.frameRate,
             bitrate: CAPTURE_PLACEHOLDER_BITRATE
           }
@@ -1402,7 +2203,7 @@ var RtcManager = class {
    * 停止摄像头采集；引擎未初始化或采集未启动时不产生效果。
    */
   async stopCameraCapture() {
-    const engine = _optionalChain([this, 'access', _43 => _43.lease, 'optionalAccess', _44 => _44.engine]);
+    const engine = _optionalChain([this, 'access', _151 => _151.lease, 'optionalAccess', _152 => _152.engine]);
     this.isCapturing = false;
     if (!engine) {
       return;
@@ -1419,6 +2220,9 @@ var RtcManager = class {
    * @throws 引擎未初始化、进房参数无效或进房失败时抛出错误。
    */
   async joinRoom(configuration) {
+    if (configuration.provider !== "trtc") {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "TRTC credentials required");
+    }
     const engine = this.requireEngine();
     const sdkAppId = Number(configuration.sdkAppID);
     if (!Number.isInteger(sdkAppId) || sdkAppId <= 0) {
@@ -1452,7 +2256,7 @@ var RtcManager = class {
    * 离开当前 RTC 房间；未在房间中或引擎未初始化时不产生效果，退房失败仅记录日志。
    */
   async leaveRoom() {
-    const engine = _optionalChain([this, 'access', _45 => _45.lease, 'optionalAccess', _46 => _46.engine]);
+    const engine = _optionalChain([this, 'access', _153 => _153.lease, 'optionalAccess', _154 => _154.engine]);
     if (!engine || !this.isInRoom) {
       return;
     }
@@ -1469,7 +2273,7 @@ var RtcManager = class {
   /**
    * 配置本地视频编码参数。
    *
-   * TRTC 只接受单一目标码率，以 `maximumBitrate` 作为目标码率；
+   * TRTC 只接受单一目标码率，以 `minimumBitrate`（流畅优先档）作为目标码率；
    * 编码策略偏好映射为 TRTC 弱网偏好。
    *
    * @throws 摄像头采集未启动或编码参数配置失败时抛出错误。
@@ -1483,13 +2287,17 @@ var RtcManager = class {
       );
     }
     try {
+      const encodingSize = rtcOrientedVideoSize({
+        width: configuration.width,
+        height: configuration.height
+      });
       await engine.updateLocalVideo({
         option: {
           profile: {
-            width: configuration.width,
-            height: configuration.height,
+            width: encodingSize.width,
+            height: encodingSize.height,
             frameRate: configuration.frameRate,
-            bitrate: configuration.maximumBitrate
+            bitrate: configuration.minimumBitrate
           },
           qosPreference: QOS_PREFERENCE_MAP[configuration.encoderPreference]
         }
@@ -1521,7 +2329,7 @@ var RtcManager = class {
    * 停止发布本地视频流；采集保持运行，本地预览不受影响。
    */
   async unpublishLocalVideo() {
-    const engine = _optionalChain([this, 'access', _47 => _47.lease, 'optionalAccess', _48 => _48.engine]);
+    const engine = _optionalChain([this, 'access', _155 => _155.lease, 'optionalAccess', _156 => _156.engine]);
     if (!engine || !this.isCapturing) {
       return;
     }
@@ -1553,7 +2361,7 @@ var RtcManager = class {
    * 停止发布本地音频流；麦克风采集保持运行。
    */
   async unpublishLocalAudio() {
-    const engine = _optionalChain([this, 'access', _49 => _49.lease, 'optionalAccess', _50 => _50.engine]);
+    const engine = _optionalChain([this, 'access', _157 => _157.lease, 'optionalAccess', _158 => _158.engine]);
     if (!engine || !this.isAudioCapturing) {
       return;
     }
@@ -1607,14 +2415,34 @@ var RtcManager = class {
       throw this.mapError(error);
     }
   }
+  /**
+   * 当前平台是否支持远端音量控制（iOS Safari/WKWebView 不支持）。
+   */
+  get supportsRemoteAudioVolumeControl() {
+    return canControlTrtcRemoteAudioVolume();
+  }
   /**
    * 设置指定远端用户的音频播放音量。
    *
+   * iOS Safari/WKWebView 不允许 JS 修改媒体元素音量（TRTC 官方标注
+   * `setRemoteAudioVolume` 不支持 iOS Safari），该平台上降级为
+   * 播放/静音二值控制：音量为 0 时停止播放该路音频，非 0 时恢复播放；
+   * 恢复播放需要重新拉流，会有短暂缓冲。
+   *
    * @param volume 音量，取值范围为 `0...100`，越界时收敛到边界。
    */
   setRemoteAudioVolume(volume, userID) {
     const engine = this.requireEngine();
     const normalized = Math.min(Math.max(Math.round(volume), 0), 100);
+    if (!canControlTrtcRemoteAudioVolume()) {
+      void engine.muteRemoteAudio(userID, normalized === 0).catch((error) => {
+        XmaxLogger.rtc.warning(
+          () => `\u8FDC\u7AEF\u97F3\u9891\u64AD\u653E\u72B6\u6001\u5207\u6362\u5931\u8D25 (Failed to Toggle Remote Audio Playback)
+\u2514\u2500 ${XmaxLogger.localized("\u539F\u56E0\uFF1A", "Reason: ")}${XmaxError.from(error).message}`
+        );
+      });
+      return;
+    }
     engine.setRemoteAudioVolume(userID, normalized);
   }
   /**
@@ -1622,7 +2450,7 @@ var RtcManager = class {
    *
    * @throws 未在房间中或消息编码后超过 1000 字节时抛出错误。
    */
-  sendRoomMessage(message) {
+  async sendRoomMessage(message) {
     const engine = this.requireEngine();
     if (!this.isInRoom) {
       throw new XmaxError(
@@ -1642,6 +2470,11 @@ var RtcManager = class {
       data: encoded.buffer
     });
   }
+  /**
+   * TRTC 凭据由会话层缓存，保持现有进房鉴权行为。
+   */
+  async updateCredentials(_configuration) {
+  }
   /**
    * 设置 RTC 事件监听器，传入空值时清除监听器。
    */
@@ -1654,19 +2487,19 @@ var RtcManager = class {
   registerEventBridge(engine) {
     const source = engine;
     const onStatistics = (stats) => {
-      if (this.isInRoom && _optionalChain([this, 'access', _51 => _51.lease, 'optionalAccess', _52 => _52.engine]) === engine) {
+      if (this.isInRoom && _optionalChain([this, 'access', _159 => _159.lease, 'optionalAccess', _160 => _160.engine]) === engine) {
         RtcStatsLogger.logStatistics(stats);
-        const video = _optionalChain([stats, 'access', _53 => _53.localStatistics, 'optionalAccess', _54 => _54.video, 'optionalAccess', _55 => _55.find, 'call', _56 => _56((item) => item.videoType === "big")]);
+        const video = _optionalChain([stats, 'access', _161 => _161.localStatistics, 'optionalAccess', _162 => _162.video, 'optionalAccess', _163 => _163.find, 'call', _164 => _164((item) => item.videoType === "big")]);
         const valid = (value, minimum) => typeof value === "number" && Number.isFinite(value) && value >= minimum ? value : void 0;
-        _optionalChain([this, 'access', _57 => _57.eventListener, 'optionalAccess', _58 => _58.onLocalVideoStatistics, 'optionalCall', _59 => _59(video ? Object.freeze({
+        _optionalChain([this, 'access', _165 => _165.eventListener, 'optionalAccess', _166 => _166.onLocalVideoStatistics, 'optionalCall', _167 => _167(video ? Object.freeze({
           width: valid(video.width, 1),
           height: valid(video.height, 1),
           frameRate: valid(video.frameRate, 0),
           bitrateKbps: valid(video.bitrate, 0)
         }) : void 0)]);
-        _optionalChain([this, 'access', _60 => _60.eventListener, 'optionalAccess', _61 => _61.onRemoteVideoStatistics, 'optionalCall', _62 => _62(Object.freeze(
+        _optionalChain([this, 'access', _168 => _168.eventListener, 'optionalAccess', _169 => _169.onRemoteVideoStatistics, 'optionalCall', _170 => _170(Object.freeze(
           (_nullishCoalesce(stats.remoteStatistics, () => ( []))).flatMap((remote) => {
-            const video2 = _optionalChain([remote, 'access', _63 => _63.video, 'optionalAccess', _64 => _64.find, 'call', _65 => _65((item) => item.videoType === "big")]);
+            const video2 = _optionalChain([remote, 'access', _171 => _171.video, 'optionalAccess', _172 => _172.find, 'call', _173 => _173((item) => item.videoType === "big")]);
             if (!video2) {
               return [];
             }
@@ -1688,11 +2521,11 @@ var RtcManager = class {
       }
     };
     const onNetworkQuality = (stats) => {
-      if (this.isInRoom && _optionalChain([this, 'access', _66 => _66.lease, 'optionalAccess', _67 => _67.engine]) === engine) {
+      if (this.isInRoom && _optionalChain([this, 'access', _174 => _174.lease, 'optionalAccess', _175 => _175.engine]) === engine) {
         RtcStatsLogger.logNetworkQuality(stats);
         const quality = (value) => Number.isInteger(value) && value >= 0 && value <= 6 ? value : void 0;
         const rtt = (value) => Number.isFinite(value) && value >= 0 ? value : void 0;
-        _optionalChain([this, 'access', _68 => _68.eventListener, 'optionalAccess', _69 => _69.onNetworkStatistics, 'optionalCall', _70 => _70(Object.freeze({
+        _optionalChain([this, 'access', _176 => _176.eventListener, 'optionalAccess', _177 => _177.onNetworkStatistics, 'optionalCall', _178 => _178(Object.freeze({
           uplinkQuality: quality(stats.uplinkNetworkQuality),
           downlinkQuality: quality(stats.downlinkNetworkQuality),
           uplinkRttMs: rtt(stats.uplinkRTT),
@@ -1710,13 +2543,13 @@ var RtcManager = class {
       if (event.streamType !== STREAM_TYPE_MAIN) {
         return;
       }
-      _optionalChain([this, 'access', _71 => _71.eventListener, 'optionalAccess', _72 => _72.onRemoteVideoPublished, 'call', _73 => _73(event.userId, true)]);
+      _optionalChain([this, 'access', _179 => _179.eventListener, 'optionalAccess', _180 => _180.onRemoteVideoPublished, 'call', _181 => _181(event.userId, true)]);
     });
     source.on(RTC_EVENT.remoteVideoUnavailable, (event) => {
       if (event.streamType !== STREAM_TYPE_MAIN) {
         return;
       }
-      _optionalChain([this, 'access', _74 => _74.eventListener, 'optionalAccess', _75 => _75.onRemoteVideoPublished, 'call', _76 => _76(event.userId, false)]);
+      _optionalChain([this, 'access', _182 => _182.eventListener, 'optionalAccess', _183 => _183.onRemoteVideoPublished, 'call', _184 => _184(event.userId, false)]);
     });
     source.on(RTC_EVENT.customMessage, (event) => {
       if (event.cmdId !== CUSTOM_MESSAGE_CMD_ID) {
@@ -1725,18 +2558,18 @@ var RtcManager = class {
       let message;
       try {
         message = new TextDecoder().decode(event.data);
-      } catch (e9) {
+      } catch (e13) {
         XmaxLogger.rtc.warning(() => "\u81EA\u5B9A\u4E49\u6D88\u606F\u89E3\u7801\u5931\u8D25 (Failed to Decode Custom Message)");
         return;
       }
-      _optionalChain([this, 'access', _77 => _77.eventListener, 'optionalAccess', _78 => _78.onCustomMessageReceived, 'call', _79 => _79(event.userId, message)]);
+      _optionalChain([this, 'access', _185 => _185.eventListener, 'optionalAccess', _186 => _186.onCustomMessageReceived, 'call', _187 => _187(event.userId, message)]);
     });
   }
   /**
    * 返回当前引擎实例；未初始化时抛出错误。
    */
   requireEngine() {
-    const engine = _optionalChain([this, 'access', _80 => _80.lease, 'optionalAccess', _81 => _81.engine]);
+    const engine = _optionalChain([this, 'access', _188 => _188.lease, 'optionalAccess', _189 => _189.engine]);
     if (!engine) {
       throw new XmaxError(
         "RTC_ERROR" /* rtcError */,
@@ -1745,95 +2578,672 @@ var RtcManager = class {
     }
     return engine;
   }
-  /**
-   * 将 TRTC 错误映射为 SDK 统一错误。
-   */
-  mapError(error) {
-    if (error instanceof XmaxError) {
-      return error;
-    }
-    const rtcError = error;
-    const originName = _nullishCoalesce(_optionalChain([rtcError, 'optionalAccess', _82 => _82.originError, 'optionalAccess', _83 => _83.name]), () => ( ""));
-    const message = typeof _optionalChain([rtcError, 'optionalAccess', _84 => _84.message]) === "string" && rtcError.message.trim().length > 0 ? rtcError.message.trim() : String(error);
-    if (originName === "NotAllowedError" || originName === "SecurityError" || /NotAllowed/i.test(message)) {
-      return new XmaxError("CAMERA_PERMISSION_DENIED" /* cameraPermissionDenied */, message);
-    }
-    if (originName) {
-      return new XmaxError("MEDIA_ERROR" /* mediaError */, message);
+  /**
+   * 将 TRTC 错误映射为 SDK 统一错误。
+   */
+  mapError(error) {
+    if (error instanceof XmaxError) {
+      return error;
+    }
+    const rtcError = error;
+    const originName = _nullishCoalesce(_optionalChain([rtcError, 'optionalAccess', _190 => _190.originError, 'optionalAccess', _191 => _191.name]), () => ( ""));
+    const message = typeof _optionalChain([rtcError, 'optionalAccess', _192 => _192.message]) === "string" && rtcError.message.trim().length > 0 ? rtcError.message.trim() : String(error);
+    if (originName === "NotAllowedError" || originName === "SecurityError" || /NotAllowed/i.test(message)) {
+      return new XmaxError("CAMERA_PERMISSION_DENIED" /* cameraPermissionDenied */, message);
+    }
+    if (originName) {
+      return new XmaxError("MEDIA_ERROR" /* mediaError */, message);
+    }
+    return new XmaxError("RTC_ERROR" /* rtcError */, message);
+  }
+};
+
+// src/Foundation/RTC/VeRTC/VeRtcStatistics.ts
+var VeRtcStatistics = class {
+  static local(stats) {
+    return Object.freeze({
+      width: this.valid(stats.encodedFrameWidth, 1),
+      height: this.valid(stats.encodedFrameHeight, 1),
+      frameRate: this.valid(stats.sentFrameRate),
+      bitrateKbps: this.valid(stats.sentKBitrate),
+      uplinkLossPercent: this.loss(stats.videoLossRate)
+    });
+  }
+  static remote(userID, stats, uplinkLossPercent) {
+    return Object.freeze({
+      userID,
+      width: this.valid(stats.width, 1),
+      height: this.valid(stats.height, 1),
+      frameRate: this.valid(stats.decoderOutputFrameRate),
+      bitrateKbps: this.valid(stats.receivedKBitrate),
+      rttMs: this.valid(stats.rtt),
+      downlinkLossPercent: this.loss(stats.videoLossRate),
+      endToEndDelayMs: this.valid(stats.e2eDelay),
+      uplinkLossPercent
+    });
+  }
+  static quality(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 6 ? value : void 0;
+  }
+  static valid(value, minimum = 0) {
+    return typeof value === "number" && Number.isFinite(value) && value >= minimum ? value : void 0;
+  }
+  static loss(value) {
+    return Number.isFinite(value) && value >= 0 && value <= 1 ? value * 100 : void 0;
+  }
+};
+
+// src/Foundation/RTC/VeRTC/VeRtcManager.ts
+var VERTC_APP_ID = "69a177e226e9b90176a86b96";
+var VeRtcManager = class {
+  constructor(options = {}) {
+    __publicField(this, "loadSDK");
+    __publicField(this, "sdk");
+    __publicField(this, "engine");
+    __publicField(this, "initialization");
+    __publicField(this, "lifecycle", 0);
+    __publicField(this, "captureVersion", 0);
+    __publicField(this, "camera");
+    __publicField(this, "microphone", false);
+    __publicField(this, "connection");
+    __publicField(this, "joined", false);
+    __publicField(this, "roomVersion", 0);
+    __publicField(this, "roomAbort", new AbortController());
+    __publicField(this, "recovery");
+    __publicField(this, "joining");
+    __publicField(this, "tokenExpired", false);
+    __publicField(this, "publishPrivilegeExpired", false);
+    __publicField(this, "subscribePrivilegeExpired", false);
+    __publicField(this, "videoRequested", false);
+    __publicField(this, "audioRequested", false);
+    __publicField(this, "listener");
+    __publicField(this, "publishedVideo", /* @__PURE__ */ new Set());
+    __publicField(this, "publishedAudio", /* @__PURE__ */ new Set());
+    __publicField(this, "requestedVideo", /* @__PURE__ */ new Set());
+    __publicField(this, "requestedAudio", /* @__PURE__ */ new Set());
+    __publicField(this, "audioVolumes", /* @__PURE__ */ new Map());
+    __publicField(this, "audioPlayers", /* @__PURE__ */ new Map());
+    __publicField(this, "audioSubscriptions", /* @__PURE__ */ new Map());
+    __publicField(this, "remoteStatistics", /* @__PURE__ */ new Map());
+    __publicField(this, "uplinkLossPercent");
+    this.loadSDK = _nullishCoalesce(options.loadSDK, () => ( (() => Promise.resolve().then(() => _interopRequireWildcard(require("@volcengine/rtc"))))));
+  }
+  get isInitialized() {
+    return this.engine !== void 0;
+  }
+  get supportsRemoteAudioVolumeControl() {
+    if (typeof navigator === "undefined") return true;
+    return !(/iPad|iPhone|iPod/.test(navigator.userAgent) || /Macintosh/.test(navigator.userAgent) && navigator.maxTouchPoints > 1);
+  }
+  async initialize() {
+    if (this.engine) return;
+    if (this.initialization) return this.initialization;
+    const version = this.lifecycle;
+    const operation = (async () => {
+      const sdk = await this.loadSDK();
+      if (version !== this.lifecycle) throw this.cancelled();
+      sdk.default.setLogConfig({ logLevel: "none" });
+      const engine = sdk.default.createEngine(VERTC_APP_ID, { autoPlayPolicy: sdk.RTCAutoPlayPolicy.PLAY_MANUALLY });
+      this.sdk = sdk;
+      this.engine = engine;
+      this.registerEvents(engine);
+    })();
+    this.initialization = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.initialization === operation) this.initialization = void 0;
+    }
+  }
+  async destroy() {
+    this.lifecycle++;
+    this.captureVersion++;
+    const engine = this.engine;
+    const sdk = this.sdk;
+    this.listener = void 0;
+    this.clearRoom();
+    this.engine = void 0;
+    this.sdk = void 0;
+    this.camera = void 0;
+    this.microphone = false;
+    _optionalChain([engine, 'optionalAccess', _193 => _193.removeAllListeners, 'call', _194 => _194()]);
+    if (engine && sdk) sdk.default.destroyEngine(engine);
+  }
+  async startCameraCapture(options) {
+    const engine = this.requireEngine();
+    if (this.camera) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Camera capture is already running");
+    const version = ++this.captureVersion;
+    await this.run(() => engine.setVideoEncoderConfig({
+      ...rtcOrientedVideoSize({ width: options.width, height: options.height }),
+      frameRate: options.frameRate,
+      maxKbps: 1e3,
+      preferCodecName: this.sdk.VideoCodecType.H264,
+      contentHint: "motion"
+    }));
+    if (engine !== this.engine || version !== this.captureVersion) throw this.cancelled();
+    try {
+      await engine.startVideoCapture(options.position === "front" /* front */ ? "user" : "environment");
+      if (engine !== this.engine || version !== this.captureVersion) {
+        await engine.stopVideoCapture().catch(() => {
+        });
+        throw this.cancelled();
+      }
+      const track = engine.getLocalStreamTrack(this.sdk.StreamIndex.STREAM_INDEX_MAIN, "video");
+      if (!track) {
+        await engine.stopVideoCapture();
+        throw new XmaxError("RTC_ERROR" /* rtcError */, "VeRTC camera track is unavailable");
+      }
+      this.camera = track;
+      return track;
+    } catch (error) {
+      throw this.mapError(error, "CAMERA_PERMISSION_DENIED" /* cameraPermissionDenied */);
+    }
+  }
+  async switchCameraCapture(to) {
+    const engine = this.requireEngine();
+    this.requireCamera();
+    const version = this.captureVersion;
+    await this.run(() => engine.setVideoCaptureDevice(to === "front" /* front */ ? "user" : "environment"));
+    if (engine !== this.engine || version !== this.captureVersion) throw this.cancelled();
+    const track = engine.getLocalStreamTrack(this.sdk.StreamIndex.STREAM_INDEX_MAIN, "video");
+    if (!track) throw new XmaxError("RTC_ERROR" /* rtcError */, "VeRTC camera track is unavailable");
+    this.camera = track;
+    return track;
+  }
+  async stopCameraCapture() {
+    this.captureVersion++;
+    this.camera = void 0;
+    if (this.engine) await this.run(() => this.engine.stopVideoCapture());
+  }
+  async configureVideoEncoding(config) {
+    const engine = this.requireEngine();
+    this.requireCamera();
+    await this.run(() => engine.setVideoEncoderConfig({
+      ...rtcOrientedVideoSize({ width: config.width, height: config.height }),
+      frameRate: config.frameRate,
+      maxKbps: config.maximumBitrate,
+      contentHint: config.encoderPreference === "maintainFramerate" /* maintainFramerate */ ? "motion" : "detail",
+      preferCodecName: this.sdk.VideoCodecType.H264
+    }));
+  }
+  async joinRoom(config) {
+    await _optionalChain([this, 'access', _195 => _195.joining, 'optionalAccess', _196 => _196.catch, 'call', _197 => _197(() => {
+    })]);
+    await _optionalChain([this, 'access', _198 => _198.recovery, 'optionalAccess', _199 => _199.catch, 'call', _200 => _200(() => {
+    })]);
+    const engine = this.requireEngine();
+    if (config.provider !== "vertc" || config.appID !== VERTC_APP_ID || this.connection) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "VeRTC credentials for the configured AppID and an idle room are required");
+    }
+    this.clearRoom();
+    this.connection = config;
+    const version = this.roomVersion;
+    const task = this.performJoin(engine, config, version);
+    this.joining = task;
+    try {
+      await task;
+    } finally {
+      if (this.joining === task) this.joining = void 0;
+    }
+  }
+  async performJoin(engine, config, version) {
+    try {
+      await this.enter(engine, config);
+      if (!this.isCurrent(engine, version)) {
+        await engine.leaveRoom().catch(() => {
+        });
+        throw this.cancelled();
+      }
+      this.joined = true;
+      this.replayVideo();
+    } catch (error) {
+      if (this.isCurrent(engine, version)) this.clearRoom();
+      throw this.mapError(error);
+    }
+  }
+  enter(engine, config) {
+    return this.run(() => engine.joinRoom(config.roomToken, config.roomID, { userId: config.userID }, {
+      isAutoPublish: false,
+      isAutoSubscribeAudio: false,
+      isAutoSubscribeVideo: false,
+      roomProfileType: this.sdk.RoomProfileType.communication
+    }));
+  }
+  async leaveRoom() {
+    const engine = this.engine;
+    this.clearRoom();
+    if (engine) await this.run(() => engine.leaveRoom());
+  }
+  /** 正常续签仅 updateToken；被移出房间后重进，恢复发布与订阅意图。 */
+  async updateCredentials(config, signal) {
+    const engine = this.requireEngine();
+    const current = this.connection;
+    if (_optionalChain([signal, 'optionalAccess', _201 => _201.aborted])) throw this.cancelled();
+    if (!current || config.provider !== "vertc" || config.appID !== current.appID || config.roomID !== current.roomID || config.userID !== current.userID) {
+      throw new XmaxError("SESSION_ERROR" /* sessionError */, "VeRTC session binding changed");
+    }
+    const version = this.roomVersion;
+    if (this.recovery) await this.cancellable(this.recovery, signal);
+    if (!this.isCurrent(engine, version)) throw this.cancelled();
+    const task = this.renew(engine, config, version);
+    this.recovery = task;
+    void task.finally(() => {
+      if (this.recovery === task) this.recovery = void 0;
+    }).catch(() => {
+    });
+    await this.cancellable(task, signal);
+  }
+  async renew(engine, config, version) {
+    if (!this.tokenExpired) {
+      try {
+        await this.run(() => engine.updateToken(config.roomToken));
+      } catch (error) {
+        this.ensureCurrent(engine, version);
+        if (!this.tokenExpired) throw error;
+      }
+    }
+    this.ensureCurrent(engine, version);
+    const restore = this.tokenExpired || this.publishPrivilegeExpired || this.subscribePrivilegeExpired;
+    if (restore) {
+      this.joined = false;
+      _optionalChain([this, 'access', _202 => _202.listener, 'optionalAccess', _203 => _203.onRoomRejoining, 'optionalCall', _204 => _204()]);
+      this.clearPlayers();
+      this.clearStatistics();
+      if (this.tokenExpired) {
+        this.publishedVideo.clear();
+        this.publishedAudio.clear();
+        await this.run(() => engine.leaveRoom());
+        this.ensureCurrent(engine, version);
+        await this.enter(engine, config);
+        if (!this.isCurrent(engine, version)) {
+          await engine.leaveRoom().catch(() => {
+          });
+          throw this.cancelled();
+        }
+      }
+      if ((this.tokenExpired || this.publishPrivilegeExpired) && this.videoRequested && this.camera) {
+        await this.run(() => engine.publishStream(this.sdk.MediaType.VIDEO));
+        this.ensureCurrent(engine, version);
+        if (!this.videoRequested) {
+          await this.run(() => engine.unpublishStream(this.sdk.MediaType.VIDEO));
+          this.ensureCurrent(engine, version);
+        }
+      }
+      if ((this.tokenExpired || this.publishPrivilegeExpired) && this.audioRequested && this.microphone) {
+        await this.run(() => engine.publishStream(this.sdk.MediaType.AUDIO));
+        this.ensureCurrent(engine, version);
+        if (!this.audioRequested) {
+          await this.run(() => engine.unpublishStream(this.sdk.MediaType.AUDIO));
+          this.ensureCurrent(engine, version);
+        }
+      }
+    }
+    this.connection = config;
+    this.tokenExpired = false;
+    this.publishPrivilegeExpired = false;
+    this.subscribePrivilegeExpired = false;
+    this.joined = true;
+    if (restore) {
+      this.replayVideo();
+      for (const userID of this.requestedAudio) {
+        if (this.publishedAudio.has(userID)) await this.subscribeRemoteAudio(userID, true);
+        this.ensureCurrent(engine, version);
+      }
+    }
+  }
+  async publishLocalVideo() {
+    const engine = this.requireEngine();
+    this.requireCamera();
+    this.videoRequested = true;
+    const version = this.roomVersion;
+    await this.recovery;
+    this.ensureCurrent(engine, version);
+    if (!this.videoRequested) throw this.cancelled();
+    await this.run(() => engine.publishStream(this.sdk.MediaType.VIDEO));
+  }
+  async unpublishLocalVideo() {
+    this.videoRequested = false;
+    if (this.joined && !this.tokenExpired) await this.run(() => this.requireEngine().unpublishStream(this.sdk.MediaType.VIDEO));
+  }
+  async publishLocalAudio() {
+    const engine = this.requireEngine();
+    this.audioRequested = true;
+    const version = this.roomVersion;
+    await this.recovery;
+    this.ensureCurrent(engine, version);
+    try {
+      if (!this.microphone) {
+        await engine.startAudioCapture();
+        if (!this.isCurrent(engine, version)) {
+          await engine.stopAudioCapture().catch(() => {
+          });
+          throw this.cancelled();
+        }
+        this.microphone = true;
+      }
+      if (!this.audioRequested) throw this.cancelled();
+      await engine.publishStream(this.sdk.MediaType.AUDIO);
+    } catch (error) {
+      throw this.mapError(error, "MICROPHONE_PERMISSION_DENIED" /* microphonePermissionDenied */);
+    }
+  }
+  async unpublishLocalAudio() {
+    this.audioRequested = false;
+    if (this.joined && !this.tokenExpired) await this.run(() => this.requireEngine().unpublishStream(this.sdk.MediaType.AUDIO));
+  }
+  async subscribeRemoteVideo(userID, subscribe) {
+    const engine = this.requireEngine();
+    const version = this.roomVersion;
+    if (!subscribe) {
+      this.requestedVideo.delete(userID);
+      this.remoteStatistics.delete(userID);
+      this.emitRemoteStatistics();
+      if (this.joined && !this.tokenExpired) await this.run(() => engine.unsubscribeStream(userID, this.sdk.MediaType.VIDEO));
+      return;
+    }
+    this.requestedVideo.add(userID);
+    await this.run(() => engine.subscribeStream(userID, this.sdk.MediaType.VIDEO));
+    this.ensureCurrent(engine, version);
+    if (!this.requestedVideo.has(userID)) return;
+    const track = engine.getRemoteStreamTrack(userID, this.sdk.StreamIndex.STREAM_INDEX_MAIN, "video");
+    if (!track) throw new XmaxError("RTC_ERROR" /* rtcError */, "VeRTC remote video track is unavailable");
+    return track;
+  }
+  async subscribeRemoteAudio(userID, subscribe) {
+    const engine = this.requireEngine();
+    const version = this.roomVersion;
+    if (!subscribe) {
+      this.requestedAudio.delete(userID);
+      this.clearPlayer(userID);
+      if (this.joined && !this.tokenExpired && this.publishedAudio.has(userID)) await this.run(() => engine.unsubscribeStream(userID, this.sdk.MediaType.AUDIO));
+      return;
+    }
+    this.requestedAudio.add(userID);
+    if (!this.joined || this.tokenExpired || !this.publishedAudio.has(userID)) return;
+    const subscription = {};
+    this.audioSubscriptions.set(userID, subscription);
+    await this.run(() => engine.subscribeStream(userID, this.sdk.MediaType.AUDIO));
+    if (!this.isCurrent(engine, version) || !this.joined || this.tokenExpired || this.audioSubscriptions.get(userID) !== subscription || !this.requestedAudio.has(userID) || !this.publishedAudio.has(userID)) return;
+    const track = engine.getRemoteStreamTrack(userID, this.sdk.StreamIndex.STREAM_INDEX_MAIN, "audio");
+    if (!track) return;
+    this.clearPlayer(userID);
+    const player = document.createElement("audio");
+    player.srcObject = new MediaStream([track]);
+    this.audioPlayers.set(userID, player);
+    this.applyAudioVolume(userID);
+  }
+  setRemoteAudioVolume(volume, userID) {
+    this.audioVolumes.set(userID, Number.isFinite(volume) ? Math.max(0, Math.min(100, Math.round(volume))) : 0);
+    this.applyAudioVolume(userID);
+  }
+  applyAudioVolume(userID) {
+    const player = this.audioPlayers.get(userID);
+    if (!player) return;
+    const volume = _nullishCoalesce(this.audioVolumes.get(userID), () => ( 0));
+    player.muted = volume === 0 || !this.requestedAudio.has(userID);
+    if (this.supportsRemoteAudioVolumeControl) player.volume = volume / 100;
+    if (player.muted) player.pause();
+    else void player.play().catch(() => {
+      XmaxLogger.rtc.warning(() => "VeRTC audio playback requires a user interaction");
+    });
+  }
+  async sendRoomMessage(message) {
+    const engine = this.requireEngine();
+    const version = this.roomVersion;
+    if (!this.joined || this.tokenExpired) throw this.cancelled();
+    if (new TextEncoder().encode(message).byteLength > 64 * 1024) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "VeRTC room message exceeds the 64-KiB limit");
+    }
+    await this.cancellable(this.run(async () => {
+      const sent = engine.sendRoomMessage(message);
+      if (!sent) throw new XmaxError("RTC_ERROR" /* rtcError */, "VeRTC room message was not sent");
+      await sent;
+    }), void 0, 5e3);
+    this.ensureCurrent(engine, version);
+  }
+  setEventListener(listener) {
+    this.listener = listener;
+  }
+  registerEvents(engine) {
+    const events = this.sdk.default.events;
+    const active = () => engine === this.engine && this.connection !== void 0;
+    const mediaActive = () => active() && this.joined && !this.tokenExpired;
+    const video = (mediaType) => (mediaType & this.sdk.MediaType.VIDEO) !== 0;
+    const audio = (mediaType) => (mediaType & this.sdk.MediaType.AUDIO) !== 0;
+    engine.on(events.onUserPublishStream, ({ userId, mediaType }) => {
+      if (!active()) return;
+      if (video(mediaType)) {
+        this.publishedVideo.add(userId);
+        if (mediaActive()) _optionalChain([this, 'access', _205 => _205.listener, 'optionalAccess', _206 => _206.onRemoteVideoPublished, 'call', _207 => _207(userId, true)]);
+      }
+      if (audio(mediaType)) {
+        this.publishedAudio.add(userId);
+        if (mediaActive() && this.requestedAudio.has(userId)) {
+          void this.subscribeRemoteAudio(userId, true).catch((error) => {
+            if (mediaActive()) _optionalChain([this, 'access', _208 => _208.listener, 'optionalAccess', _209 => _209.onError, 'optionalCall', _210 => _210(this.mapError(error))]);
+          });
+        }
+      }
+    });
+    engine.on(events.onUserUnpublishStream, ({ userId, mediaType }) => {
+      if (!active()) return;
+      if (video(mediaType)) this.removeVideo(userId);
+      if (audio(mediaType)) {
+        this.publishedAudio.delete(userId);
+        this.clearPlayer(userId);
+      }
+    });
+    engine.on(events.onUserLeave, ({ userInfo }) => {
+      if (!active()) return;
+      this.removeVideo(userInfo.userId);
+      this.publishedAudio.delete(userInfo.userId);
+      this.clearPlayer(userInfo.userId);
+    });
+    engine.on(events.onRoomMessageReceived, ({ userId, message }) => {
+      if (mediaActive() && typeof message === "string") _optionalChain([this, 'access', _211 => _211.listener, 'optionalAccess', _212 => _212.onCustomMessageReceived, 'call', _213 => _213(userId, message)]);
+    });
+    const willExpire = () => {
+      if (active()) _optionalChain([this, 'access', _214 => _214.listener, 'optionalAccess', _215 => _215.onTokenWillExpire, 'optionalCall', _216 => _216()]);
+    };
+    engine.on(events.onTokenWillExpire, willExpire);
+    engine.on(events.onTokenPublishPrivilegeWillExpire, willExpire);
+    engine.on(events.onTokenSubscribePrivilegeWillExpire, willExpire);
+    engine.on(events.onTokenPublishPrivilegeDidExpired, () => {
+      if (!active() || this.publishPrivilegeExpired) return;
+      this.publishPrivilegeExpired = true;
+      _optionalChain([this, 'access', _217 => _217.listener, 'optionalAccess', _218 => _218.onTokenExpired, 'optionalCall', _219 => _219()]);
+    });
+    engine.on(events.onTokenSubscribePrivilegeDidExpired, () => {
+      if (!active() || this.subscribePrivilegeExpired) return;
+      this.subscribePrivilegeExpired = true;
+      this.clearPlayers();
+      _optionalChain([this, 'access', _220 => _220.listener, 'optionalAccess', _221 => _221.onTokenExpired, 'optionalCall', _222 => _222()]);
+    });
+    engine.on(events.onError, ({ errorCode }) => {
+      if (!active()) return;
+      if (errorCode === "TOKEN_EXPIRED") {
+        if (this.tokenExpired) return;
+        this.tokenExpired = true;
+        this.clearPlayers();
+        _optionalChain([this, 'access', _223 => _223.listener, 'optionalAccess', _224 => _224.onTokenExpired, 'optionalCall', _225 => _225()]);
+      } else _optionalChain([this, 'access', _226 => _226.listener, 'optionalAccess', _227 => _227.onError, 'optionalCall', _228 => _228(this.mapError({ code: errorCode }))]);
+    });
+    engine.on(events.onConnectionStateChanged, ({ state: state2 }) => {
+      if (!mediaActive() || state2 !== this.sdk.ConnectionState.CONNECTION_STATE_RECONNECTED) return;
+      _optionalChain([this, 'access', _229 => _229.listener, 'optionalAccess', _230 => _230.onRoomRejoining, 'optionalCall', _231 => _231()]);
+      this.clearPlayers();
+      this.clearStatistics();
+      this.replayVideo();
+      for (const userID of this.requestedAudio) {
+        void this.subscribeRemoteAudio(userID, true).catch((error) => {
+          if (mediaActive()) _optionalChain([this, 'access', _232 => _232.listener, 'optionalAccess', _233 => _233.onError, 'optionalCall', _234 => _234(this.mapError(error))]);
+        });
+      }
+    });
+    engine.on(events.onNetworkQuality, (up, down) => {
+      if (mediaActive()) _optionalChain([this, 'access', _235 => _235.listener, 'optionalAccess', _236 => _236.onNetworkStatistics, 'optionalCall', _237 => _237(Object.freeze({
+        uplinkQuality: VeRtcStatistics.quality(up),
+        downlinkQuality: VeRtcStatistics.quality(down)
+      }))]);
+    });
+    engine.on(events.onLocalStreamStats, (stats) => {
+      if (!mediaActive() || stats.isScreen || !this.videoRequested) return;
+      const result = VeRtcStatistics.local(stats.videoStats);
+      this.uplinkLossPercent = result.uplinkLossPercent;
+      _optionalChain([this, 'access', _238 => _238.listener, 'optionalAccess', _239 => _239.onLocalVideoStatistics, 'optionalCall', _240 => _240(result)]);
+      XmaxLogger.rtc.info(() => `VeRTC local video statistics: ${JSON.stringify(result)}`, 2 /* performance */);
+    });
+    engine.on(events.onRemoteStreamStats, (stats) => {
+      if (!mediaActive() || stats.isScreen || !this.requestedVideo.has(stats.userId)) return;
+      this.remoteStatistics.set(stats.userId, VeRtcStatistics.remote(stats.userId, stats.videoStats, this.uplinkLossPercent));
+      this.emitRemoteStatistics();
+    });
+  }
+  replayVideo() {
+    for (const userID of this.publishedVideo) _optionalChain([this, 'access', _241 => _241.listener, 'optionalAccess', _242 => _242.onRemoteVideoPublished, 'call', _243 => _243(userID, true)]);
+  }
+  removeVideo(userID) {
+    this.publishedVideo.delete(userID);
+    this.remoteStatistics.delete(userID);
+    this.emitRemoteStatistics();
+    if (this.joined && !this.tokenExpired) _optionalChain([this, 'access', _244 => _244.listener, 'optionalAccess', _245 => _245.onRemoteVideoPublished, 'call', _246 => _246(userID, false)]);
+  }
+  emitRemoteStatistics() {
+    _optionalChain([this, 'access', _247 => _247.listener, 'optionalAccess', _248 => _248.onRemoteVideoStatistics, 'optionalCall', _249 => _249(Object.freeze([...this.remoteStatistics.values()]))]);
+  }
+  clearStatistics() {
+    this.remoteStatistics.clear();
+    this.uplinkLossPercent = void 0;
+    _optionalChain([this, 'access', _250 => _250.listener, 'optionalAccess', _251 => _251.onLocalVideoStatistics, 'optionalCall', _252 => _252(void 0)]);
+    this.emitRemoteStatistics();
+  }
+  clearPlayer(userID) {
+    this.audioSubscriptions.delete(userID);
+    const player = this.audioPlayers.get(userID);
+    if (player) {
+      player.pause();
+      player.srcObject = null;
+    }
+    this.audioPlayers.delete(userID);
+  }
+  clearPlayers() {
+    this.audioSubscriptions.clear();
+    for (const userID of this.audioPlayers.keys()) this.clearPlayer(userID);
+  }
+  clearRoom() {
+    this.roomVersion++;
+    this.roomAbort.abort();
+    this.roomAbort = new AbortController();
+    this.connection = void 0;
+    this.joined = false;
+    this.tokenExpired = false;
+    this.publishPrivilegeExpired = false;
+    this.subscribePrivilegeExpired = false;
+    this.videoRequested = false;
+    this.audioRequested = false;
+    this.publishedVideo.clear();
+    this.publishedAudio.clear();
+    this.requestedVideo.clear();
+    this.requestedAudio.clear();
+    this.audioVolumes.clear();
+    this.clearPlayers();
+    this.clearStatistics();
+  }
+  /** 业务取消立即结束等待；底层迟到结果由版本检查清理。 */
+  async cancellable(task, signal, timeoutMs) {
+    const roomSignal = this.roomAbort.signal;
+    return new Promise((resolve, reject) => {
+      const timer = timeoutMs === void 0 ? void 0 : setTimeout(() => {
+        cleanup();
+        reject(new XmaxError("TIMEOUT" /* timeout */, "VeRTC room message send timed out"));
+      }, timeoutMs);
+      const cleanup = () => {
+        clearTimeout(timer);
+        roomSignal.removeEventListener("abort", cancel);
+        _optionalChain([signal, 'optionalAccess', _253 => _253.removeEventListener, 'call', _254 => _254("abort", cancel)]);
+      };
+      const cancel = () => {
+        if (_optionalChain([signal, 'optionalAccess', _255 => _255.aborted]) && !roomSignal.aborted) this.roomVersion++;
+        cleanup();
+        reject(this.cancelled());
+      };
+      roomSignal.addEventListener("abort", cancel, { once: true });
+      _optionalChain([signal, 'optionalAccess', _256 => _256.addEventListener, 'call', _257 => _257("abort", cancel, { once: true })]);
+      task.then((value) => {
+        cleanup();
+        resolve(value);
+      }, (error) => {
+        cleanup();
+        reject(error);
+      });
+      if (roomSignal.aborted || _optionalChain([signal, 'optionalAccess', _258 => _258.aborted])) cancel();
+    });
+  }
+  isCurrent(engine, version) {
+    return this.engine === engine && this.connection !== void 0 && this.roomVersion === version;
+  }
+  ensureCurrent(engine, version) {
+    if (!this.isCurrent(engine, version)) throw this.cancelled();
+  }
+  requireEngine() {
+    if (!this.engine) throw new XmaxError("RTC_ERROR" /* rtcError */, "VeRTC is not initialized");
+    return this.engine;
+  }
+  requireCamera() {
+    if (!this.camera) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Camera capture is not running");
+    return this.camera;
+  }
+  async run(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      throw this.mapError(error);
     }
-    return new XmaxError("RTC_ERROR" /* rtcError */, message);
+  }
+  mapError(error, permissionCode) {
+    if (error instanceof XmaxError) return error;
+    const value = error;
+    const code = typeof _optionalChain([value, 'optionalAccess', _259 => _259.code]) === "string" && /^[A-Z_0-9-]{1,64}$/.test(value.code) ? value.code : "UNKNOWN";
+    const denied = _optionalChain([value, 'optionalAccess', _260 => _260.name]) === "NotAllowedError" || code === "PERMISSION_DENIED" || code === "DEVICE_PERMISSION_DENIED";
+    return new XmaxError(permissionCode && denied ? permissionCode : "RTC_ERROR" /* rtcError */, `VeRTC operation failed (${code})`);
+  }
+  cancelled() {
+    return new XmaxError("CANCELLED" /* cancelled */, "VeRTC operation was cancelled");
   }
 };
 
-// src/Foundation/Media/Camera/CameraFrameValidator.ts
-var FALLBACK_POLL_INTERVAL_MS = 16;
-var TIMEOUT_MS = 2e3;
-var CameraFrameValidator = class {
-  /**
-   * 单帧中央区域亮度达标即放行，不等待连续帧或曝光稳定。
-   */
-  accept(pixels) {
-    const size = pixels.length / 4;
-    if (!size || !Number.isInteger(size)) return false;
-    const histogram = new Uint32Array(256);
-    let total = 0;
-    let dark = 0;
-    for (let i = 0; i < pixels.length; i += 4) {
-      const luminance = Math.round(0.2126 * pixels[i] + 0.7152 * pixels[i + 1] + 0.0722 * pixels[i + 2]);
-      histogram[luminance] = histogram[luminance] + 1;
-      total += luminance;
-      if (luminance < 12) dark++;
-    }
-    let median = 0;
-    let accumulated = 0;
-    for (; median < 255; median++) {
-      accumulated += histogram[median];
-      if (accumulated >= size / 2) break;
-    }
-    const mean = total / size;
-    return mean >= 24 && median >= 18 && dark / size <= 0.75;
+// src/Foundation/RTC/RtcFactory.ts
+function createRtcManager(provider, environment) {
+  switch (provider) {
+    case "agora" /* agora */:
+      return new AgoraRtcManager({ environment });
+    case "vertc" /* vertc */:
+      return new VeRtcManager();
+    default:
+      return new TrtcRtcManager();
   }
-};
+}
+
+// src/Foundation/Media/Camera/CameraFrameValidator.ts
+var CAMERA_WARMUP_MS = 200;
 function waitForValidCameraFrame(track, signal) {
   return new Promise((resolve, reject) => {
-    let video;
-    let timeout;
-    let poll;
-    let frameCallback;
-    let finished = false;
-    const started = performance.now();
-    const gate = new CameraFrameValidator();
-    const finish = (result = "valid") => {
-      if (finished) return;
-      finished = true;
-      clearTimeout(timeout);
-      clearTimeout(poll);
-      if (video) {
-        if (frameCallback !== void 0) video.cancelVideoFrameCallback(frameCallback);
-        video.pause();
-        video.srcObject = null;
-        video.remove();
-      }
+    let timer;
+    let settled = false;
+    const finish = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
       signal.removeEventListener("abort", abort);
       track.removeEventListener("ended", ended);
-      if (result instanceof XmaxError) {
-        if (result.code !== "CANCELLED" /* cancelled */) XmaxLogger.media.warning(() => result.message);
-        reject(result);
+      if (error) {
+        reject(error);
       } else {
-        if (result === "timeout") {
-          XmaxLogger.media.warning(() => XmaxLogger.localized(
-            "\u76F8\u673A\u4EAE\u5EA6\u68C0\u67E5\u8D85\u65F6\uFF0C\u6309\u5F53\u524D\u753B\u9762\u7EE7\u7EED\u751F\u6210 (Camera Frame Validation Timed Out; Continuing)\n\u2514\u2500 \u672A\u83B7\u5F97\u4EAE\u5EA6\u5408\u683C\u5E27\uFF0C\u4E0D\u518D\u7B49\u5F85\u3002",
-            "Camera Frame Validation Timed Out; Continuing\n\u2514\u2500 No sufficiently bright frame received; proceeding without further waiting."
-          ));
-        } else {
-          XmaxLogger.media.info(() => `\u76F8\u673A\u66DD\u5149\u68C0\u67E5\u901A\u8FC7 (Camera Exposure Ready)
-\u2514\u2500 ${Math.round(performance.now() - started)} ms`);
-        }
         resolve();
       }
     };
-    const abort = () => finish(new XmaxError("CANCELLED" /* cancelled */, "Camera exposure check cancelled"));
-    const ended = () => finish(new XmaxError("MEDIA_ERROR" /* mediaError */, "Camera track ended before exposure was ready"));
+    const abort = () => finish(new XmaxError("CANCELLED" /* cancelled */, "Camera warmup cancelled"));
+    const ended = () => finish(new XmaxError("MEDIA_ERROR" /* mediaError */, "Camera track ended before warmup completed"));
     signal.addEventListener("abort", abort, { once: true });
     track.addEventListener("ended", ended, { once: true });
     if (signal.aborted) {
@@ -1844,70 +3254,7 @@ function waitForValidCameraFrame(track, signal) {
       ended();
       return;
     }
-    try {
-      video = document.createElement("video");
-      video.muted = true;
-      video.autoplay = true;
-      video.playsInline = true;
-      video.setAttribute("aria-hidden", "true");
-      video.style.cssText = "position:fixed;left:0;top:0;width:1px;height:1px;opacity:0;pointer-events:none;";
-      const canvas = document.createElement("canvas");
-      canvas.width = 64;
-      canvas.height = 48;
-      const context = canvas.getContext("2d", { willReadFrequently: true });
-      if (!context) throw new Error("Camera exposure sampling requires a 2D canvas");
-      video.srcObject = new MediaStream([track]);
-      document.body.appendChild(video);
-      const source = video;
-      let lastFrameTime = -Infinity;
-      const sample = (mediaTime) => {
-        if (source.readyState < 2 || !source.videoWidth || !source.videoHeight || track.muted || !track.enabled) {
-          return;
-        }
-        if (mediaTime === lastFrameTime) return;
-        lastFrameTime = mediaTime;
-        const width = source.videoWidth;
-        const height = source.videoHeight;
-        context.drawImage(source, width * 0.2, height * 0.2, width * 0.6, height * 0.6, 0, 0, 64, 48);
-        if (gate.accept(context.getImageData(0, 0, 64, 48).data)) finish();
-      };
-      const fail = (error) => finish(new XmaxError(
-        "MEDIA_ERROR" /* mediaError */,
-        `Camera exposure check failed: ${error instanceof Error ? error.message : String(error)}`
-      ));
-      const schedule = () => {
-        if (finished) return;
-        if (typeof source.requestVideoFrameCallback === "function") {
-          frameCallback = source.requestVideoFrameCallback((_now, metadata) => {
-            frameCallback = void 0;
-            try {
-              sample(metadata.mediaTime);
-              schedule();
-            } catch (error) {
-              fail(error);
-            }
-          });
-        } else {
-          poll = setTimeout(() => {
-            try {
-              const frameTime = typeof source.getVideoPlaybackQuality === "function" ? source.getVideoPlaybackQuality().totalVideoFrames : source.currentTime;
-              sample(frameTime);
-              schedule();
-            } catch (error) {
-              fail(error);
-            }
-          }, FALLBACK_POLL_INTERVAL_MS);
-        }
-      };
-      timeout = setTimeout(() => finish("timeout"), TIMEOUT_MS);
-      XmaxLogger.media.info(() => "\u7B49\u5F85\u9996\u5F20\u4EAE\u5EA6\u5408\u683C\u5E27 (Waiting for the First Sufficiently Bright Frame)");
-      void source.play().then(schedule, fail);
-    } catch (error) {
-      finish(new XmaxError(
-        "MEDIA_ERROR" /* mediaError */,
-        `Camera exposure check failed: ${error instanceof Error ? error.message : String(error)}`
-      ));
-    }
+    timer = setTimeout(() => finish(), CAMERA_WARMUP_MS);
   });
 }
 
@@ -1937,7 +3284,7 @@ var PermissionManager = class {
    * @param deniedCode 权限被拒绝时抛出的错误码。
    */
   async ensurePermission(name, deniedCode) {
-    if (typeof navigator === "undefined" || !_optionalChain([navigator, 'access', _85 => _85.mediaDevices, 'optionalAccess', _86 => _86.getUserMedia])) {
+    if (typeof navigator === "undefined" || !_optionalChain([navigator, 'access', _261 => _261.mediaDevices, 'optionalAccess', _262 => _262.getUserMedia])) {
       throw new XmaxError(
         deniedCode,
         "This browser does not support media capture (getUserMedia)"
@@ -1945,7 +3292,7 @@ var PermissionManager = class {
     }
     try {
       const permissions = navigator.permissions;
-      if (!_optionalChain([permissions, 'optionalAccess', _87 => _87.query])) {
+      if (!_optionalChain([permissions, 'optionalAccess', _263 => _263.query])) {
         return;
       }
       const status = await permissions.query({
@@ -2125,10 +3472,10 @@ var _CameraController = class _CameraController {
      */
     __publicField(this, "storedUseMicrophone", false);
     __publicField(this, "storedFrameValidationEnabled", true);
-    this.permissionManager = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _88 => _88.permissionManager]), () => ( new PermissionManager()));
-    this.rtcManager = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _89 => _89.rtcManager]), () => ( new RtcManager()));
-    this.mediaService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _90 => _90.mediaService]), () => ( new MediaService()));
-    this.errorListener = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _91 => _91.errorListener]), () => ( (() => {
+    this.permissionManager = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _264 => _264.permissionManager]), () => ( new PermissionManager()));
+    this.rtcManager = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _265 => _265.rtcManager]), () => ( new TrtcRtcManager()));
+    this.mediaService = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _266 => _266.mediaService]), () => ( new MediaService()));
+    this.errorListener = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _267 => _267.errorListener]), () => ( (() => {
     })));
   }
   /**
@@ -2144,23 +3491,23 @@ var _CameraController = class _CameraController {
     return this.activeTrack !== void 0 && this.storedUseMicrophone;
   }
   /**
-   * 当前活动相机流是否启用发布前亮度检测；没有活动流时为 false。
+   * 当前活动相机流是否启用发布前预热等待；没有活动流时为 false。
    */
   get isFrameValidationEnabled() {
     return this.activeTrack !== void 0 && this.storedFrameValidationEnabled;
   }
   /**
-   * 等待当前轨道首张合格帧或超时放行；禁用时跳过，取消或轨道被替换时拒绝。
+   * 等待当前轨道预热完成（固定 200ms）；禁用时跳过，取消或轨道被替换时拒绝。
    */
   async waitForValidCameraFrame(signal) {
     const track = this.activeTrack;
-    const mediaTrack = _optionalChain([track, 'optionalAccess', _92 => _92.mediaStreamTrack]);
+    const mediaTrack = _optionalChain([track, 'optionalAccess', _268 => _268.mediaStreamTrack]);
     if (!mediaTrack) throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Camera capture is not running");
     if (signal.aborted) throw new XmaxError("CANCELLED" /* cancelled */, "Camera frame validation cancelled");
     if (!this.isFrameValidationEnabled) return;
     await waitForValidCameraFrame(mediaTrack, signal);
     if (this.activeTrack !== track || track.mediaStreamTrack !== mediaTrack) {
-      throw new XmaxError("CANCELLED" /* cancelled */, "Camera track changed during exposure check");
+      throw new XmaxError("CANCELLED" /* cancelled */, "Camera track changed during warmup");
     }
   }
   /**
@@ -2179,7 +3526,7 @@ var _CameraController = class _CameraController {
    * @param options.videoFormat 期望的输出尺寸、帧率和编码配置；尺寸按模型规则调整。
    * @param options.position 首次启动时使用的摄像头位置。
    * @param options.useMicrophone 是否申请麦克风权限并允许实时连接时启动音频采集。
-   * @param options.enableFrameValidation 是否在发布前检测帧亮度，默认 true；false 跳过检测及其等待。
+   * @param options.enableFrameValidation 是否在发布前等待相机预热（固定 200ms），默认 true；false 跳过等待。
    * @returns 包含本地相机视频轨道的媒体流。
    * @throws 已有活动相机流、格式无效、权限不足或采集启动失败时抛出错误。
    */
@@ -2254,7 +3601,7 @@ var _CameraController = class _CameraController {
    */
   async switchCamera() {
     const track = this.activeTrack;
-    const position = _optionalChain([track, 'optionalAccess', _93 => _93.position]);
+    const position = _optionalChain([track, 'optionalAccess', _269 => _269.position]);
     if (!track || !position) {
       throw new XmaxError(
         "RTC_ERROR" /* rtcError */,
@@ -2272,7 +3619,7 @@ var _CameraController = class _CameraController {
       }
       this.previewStream.addTrack(mediaTrack);
     }
-    _optionalChain([this, 'access', _94 => _94.previewMirrorApplier, 'optionalCall', _95 => _95(nextPosition === "front" /* front */)]);
+    _optionalChain([this, 'access', _270 => _270.previewMirrorApplier, 'optionalCall', _271 => _271(nextPosition === "front" /* front */)]);
     this.observeMediaTrack(track, mediaTrack);
     return new RealtimeMediaStream({ id: "stream0" /* local */, videoTrack: track });
   }
@@ -2417,6 +3764,53 @@ var RealtimeSession = class {
   }
 };
 
+// src/Foundation/RTC/RoomJoinConfiguration.ts
+var RoomJoinConfiguration = class {
+  /**
+   * 创建房间加入参数。
+   *
+   * @param init.roomID TRTC 房间号。
+   * @param init.userID TRTC 登录身份。
+   * @param init.sdkAppID TRTC SDKAppID（字符串形式）。
+   * @param init.userSig TRTC 登录签名。
+   * @param init.privateMapKey TRTC 进房鉴权字段。
+   */
+  constructor(init) {
+    /**
+     * RTC 提供方。
+     */
+    __publicField(this, "provider", "trtc");
+    /**
+     * 进房参数
+     */
+    /**
+     * TRTC 房间号（字符串房间号）。
+     */
+    __publicField(this, "roomID");
+    /**
+     * TRTC 登录身份（`rtc_user_id`）。
+     */
+    __publicField(this, "userID");
+    /**
+     * TRTC SDKAppID（字符串形式，进房时转换为数值）。
+     */
+    __publicField(this, "sdkAppID");
+    /**
+     * TRTC 登录签名。
+     */
+    __publicField(this, "userSig");
+    /**
+     * TRTC 进房鉴权字段（字符串房间号对应的 privateMapKey）。
+     */
+    __publicField(this, "privateMapKey");
+    this.roomID = init.roomID;
+    this.userID = init.userID;
+    this.sdkAppID = init.sdkAppID;
+    this.userSig = init.userSig;
+    this.privateMapKey = init.privateMapKey;
+  }
+};
+
 // src/Service/Realtime/RealtimeSessionConnection.ts
 var RealtimeSessionConnection = class {
   /**
@@ -2435,7 +3829,7 @@ var RealtimeSessionConnection = class {
      * RTC 提供方
      */
     /**
-     * RTC 提供方标识（当前仅支持 `trtc`）。
+     * TRTC 凭据的提供方判别字段。
      */
     __publicField(this, "provider");
     /**
@@ -2477,6 +3871,12 @@ var RealtimeSessionConnection = class {
     this.botID = init.botID;
   }
 };
+function toRoomJoinConfiguration(connection) {
+  return connection.provider === "trtc" ? new RoomJoinConfiguration(connection) : connection;
+}
+function connectionAppID(connection) {
+  return connection.provider === "trtc" ? connection.sdkAppID : connection.appID;
+}
 
 // src/Service/Realtime/RealtimeSessionService.ts
 var RealtimeSessionService = class _RealtimeSessionService {
@@ -2492,6 +3892,7 @@ var RealtimeSessionService = class _RealtimeSessionService {
      * 服务层组件
      */
     __publicField(this, "apiService");
+    __publicField(this, "provider");
     /**
      * 心跳配置
      */
@@ -2501,7 +3902,16 @@ var RealtimeSessionService = class _RealtimeSessionService {
      * 运行状态
      */
     __publicField(this, "heartbeatVersion", 0);
+    /**
+     * 会话凭证缓存，支持心跳仅返回变更字段；关闭后清除。
+     */
+    __publicField(this, "credentials", /* @__PURE__ */ new Map());
+    __publicField(this, "refreshes", /* @__PURE__ */ new Map());
     this.apiService = options.apiService;
+    this.provider = _nullishCoalesce(options.provider, () => ( "trtc")) /* trtc */;
+    if (!Object.values(RtcProvider).includes(this.provider)) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Unsupported RTC provider");
+    }
     this.heartbeatIntervalMs = _nullishCoalesce(options.heartbeatIntervalMs, () => ( 1e4));
     this.sleep = _nullishCoalesce(options.sleep, () => ( ((ms) => new Promise((resolve) => setTimeout(resolve, ms)))));
   }
@@ -2512,7 +3922,18 @@ var RealtimeSessionService = class _RealtimeSessionService {
     const payload = await this.apiService.post("/session", {
       model
     });
-    return _RealtimeSessionService.makeSession(payload, true);
+    try {
+      const session = this.makeSession(payload, true);
+      _RealtimeSessionService.ensureSessionActive(session);
+      const credentials = _RealtimeSessionService.decodeConnectionPayload(payload.modelExtra);
+      this.credentials.set(session.id, this.provider === "vertc" /* vertc */ ? { ...credentials, user_id: session.connection.userID } : credentials);
+      return session;
+    } catch (error) {
+      const sessionID = _RealtimeSessionService.nonEmpty(payload.sessionUid);
+      if (sessionID) await this.closeSession(sessionID).catch(() => {
+      });
+      throw error;
+    }
   }
   /**
    * 启动指定会话的周期心跳；重复启动会替换当前心跳。
@@ -2528,12 +3949,15 @@ var RealtimeSessionService = class _RealtimeSessionService {
     this.heartbeatVersion += 1;
   }
   /**
-   * 关闭指定实时会话。
+   * 关闭指定实时会话；请求带 keepalive，页面卸载后仍能发出。
    */
   async closeSession(sessionID) {
+    this.credentials.delete(sessionID);
+    this.refreshes.delete(sessionID);
     try {
       await this.apiService.delete(
-        `/session/${sessionID}`
+        `/session/${sessionID}`,
+        { keepalive: true }
       );
     } catch (error) {
       throw XmaxError.from(error);
@@ -2554,7 +3978,7 @@ var RealtimeSessionService = class _RealtimeSessionService {
           return;
         }
         _RealtimeSessionService.ensureSessionActive(session);
-        _optionalChain([handlers, 'access', _96 => _96.onRefresh, 'optionalCall', _97 => _97(session)]);
+        await _optionalChain([handlers, 'access', _272 => _272.onRefresh, 'optionalCall', _273 => _273(session)]);
       } catch (error) {
         if (this.heartbeatVersion !== version) {
           return;
@@ -2568,11 +3992,35 @@ var RealtimeSessionService = class _RealtimeSessionService {
   /**
    * 发送一次心跳请求并解析会话数据（不要求携带完整连接参数）。
    */
-  async heartbeatSession(sessionID) {
+  heartbeatSession(sessionID) {
+    const pending = this.refreshes.get(sessionID);
+    if (pending) return pending;
+    const operation = this.performHeartbeat(sessionID);
+    this.refreshes.set(sessionID, operation);
+    void operation.finally(() => {
+      if (this.refreshes.get(sessionID) === operation) this.refreshes.delete(sessionID);
+    }).catch(() => {
+    });
+    return operation;
+  }
+  /**
+   * 合并心跳部分凭据；已关闭会话的迟到响应不重建缓存。
+   */
+  async performHeartbeat(sessionID) {
+    const previous = this.credentials.get(sessionID);
     const payload = await this.apiService.put(
       `/session/${sessionID}/heartbeat`
     );
-    return _RealtimeSessionService.makeSession(payload, false);
+    const incoming = _RealtimeSessionService.decodeConnectionPayload(payload.modelExtra);
+    if (payload.modelExtra != null && !incoming) {
+      throw new XmaxError("SESSION_ERROR" /* sessionError */, "Invalid heartbeat RTC credentials");
+    }
+    const merged = incoming ? { ...previous, ...incoming } : previous;
+    const session = this.makeSession({ ...payload, modelExtra: merged }, merged !== void 0);
+    if (session.id !== sessionID) throw new XmaxError("SESSION_ERROR" /* sessionError */, "Heartbeat session identity changed");
+    _RealtimeSessionService.ensureSessionActive(session);
+    if (previous && this.credentials.get(sessionID) === previous && merged) this.credentials.set(sessionID, merged);
+    return session;
   }
   /**
    * 校验会话仍处于活跃状态；状态明确非 ACTIVE 时抛出会话错误。
@@ -2589,12 +4037,12 @@ var RealtimeSessionService = class _RealtimeSessionService {
   /**
    * 由会话接口数据构造会话模型；`requiresConnection` 要求携带完整 RTC 连接参数。
    */
-  static makeSession(payload, requiresConnection) {
+  makeSession(payload, requiresConnection) {
     const sessionID = _RealtimeSessionService.nonEmpty(payload.sessionUid);
     if (!sessionID) {
       throw new XmaxError("SESSION_ERROR" /* sessionError */, "Invalid session response");
     }
-    const connection = _RealtimeSessionService.makeConnection(payload.modelExtra);
+    const connection = this.makeConnection(payload.modelExtra, payload.userUid);
     if (requiresConnection && !connection) {
       throw new XmaxError(
         "SESSION_ERROR" /* sessionError */,
@@ -2610,19 +4058,30 @@ var RealtimeSessionService = class _RealtimeSessionService {
     });
   }
   /**
-   * 解析 `modelExtra` 中的 TRTC 连接参数；字段不完整或提供方不支持时返回空。
+   * 解析 `modelExtra` 中的 RTC 连接参数；字段不完整或提供方不支持时返回空。
    */
-  static makeConnection(modelExtra) {
+  makeConnection(modelExtra, fallbackUserID) {
     const payload = _RealtimeSessionService.decodeConnectionPayload(modelExtra);
     if (!payload) {
       return void 0;
     }
-    if (_RealtimeSessionService.nonEmpty(payload.provider) !== "trtc") {
-      return void 0;
-    }
+    const provider = this.provider;
     const roomID = _RealtimeSessionService.nonEmpty(payload.room_id);
     const sdkAppID = _RealtimeSessionService.nonEmpty(payload.rtc_app_id);
-    const userID = _RealtimeSessionService.nonEmpty(payload.rtc_user_id);
+    const userID = provider === "vertc" /* vertc */ ? _nullishCoalesce(_RealtimeSessionService.nonEmpty(payload.user_id), () => ( _RealtimeSessionService.nonEmpty(fallbackUserID))) : _RealtimeSessionService.nonEmpty(payload.rtc_user_id);
+    if (!roomID || !sdkAppID || !userID) return void 0;
+    if (provider === "agora" /* agora */ || provider === "vertc" /* vertc */) {
+      const roomToken = _RealtimeSessionService.nonEmpty(payload.room_token);
+      if (!roomToken) return void 0;
+      return Object.freeze({
+        provider,
+        roomID,
+        appID: sdkAppID,
+        userID,
+        roomToken,
+        botID: _RealtimeSessionService.nonEmpty(provider === "vertc" /* vertc */ ? payload.bot_name : payload.rtc_bot_id)
+      });
+    }
     const userSig = _RealtimeSessionService.nonEmpty(payload.user_sig);
     const privateMapKey = _RealtimeSessionService.nonEmpty(
       payload.private_map_key_with_string_room_id
@@ -2646,12 +4105,12 @@ var RealtimeSessionService = class _RealtimeSessionService {
   static decodeConnectionPayload(modelExtra) {
     if (typeof modelExtra === "string") {
       try {
-        return JSON.parse(modelExtra);
-      } catch (e10) {
+        return _RealtimeSessionService.decodeConnectionPayload(JSON.parse(modelExtra));
+      } catch (e14) {
         return void 0;
       }
     }
-    if (typeof modelExtra === "object" && modelExtra !== null) {
+    if (typeof modelExtra === "object" && modelExtra !== null && !Array.isArray(modelExtra)) {
       return modelExtra;
     }
     return void 0;
@@ -2660,7 +4119,7 @@ var RealtimeSessionService = class _RealtimeSessionService {
    * 归一化可选字符串：去除首尾空白后为空时返回 `undefined`。
    */
   static nonEmpty(value) {
-    const normalized = _optionalChain([value, 'optionalAccess', _98 => _98.trim, 'call', _99 => _99()]);
+    const normalized = typeof value === "string" ? value.trim() : void 0;
     return normalized || void 0;
   }
 };
@@ -2732,7 +4191,7 @@ var RealtimeState = class {
    * @param other 待比较的状态。
    */
   equals(other) {
-    return this.connectionState === other.connectionState && this.sessionID === other.sessionID && this.taskID === other.taskID && _optionalChain([this, 'access', _100 => _100.reason, 'optionalAccess', _101 => _101.kind]) === _optionalChain([other, 'access', _102 => _102.reason, 'optionalAccess', _103 => _103.kind]);
+    return this.connectionState === other.connectionState && this.sessionID === other.sessionID && this.taskID === other.taskID && _optionalChain([this, 'access', _274 => _274.reason, 'optionalAccess', _275 => _275.kind]) === _optionalChain([other, 'access', _276 => _276.reason, 'optionalAccess', _277 => _277.kind]);
   }
 };
 
@@ -2767,49 +4226,6 @@ var RemoteStream = class {
   }
 };
 
-// src/Foundation/RTC/RoomJoinConfiguration.ts
-var RoomJoinConfiguration = class {
-  /**
-   * 创建房间加入参数。
-   *
-   * @param init.roomID TRTC 房间号。
-   * @param init.userID TRTC 登录身份。
-   * @param init.sdkAppID TRTC SDKAppID（字符串形式）。
-   * @param init.userSig TRTC 登录签名。
-   * @param init.privateMapKey TRTC 进房鉴权字段。
-   */
-  constructor(init) {
-    /**
-     * 进房参数
-     */
-    /**
-     * TRTC 房间号（字符串房间号）。
-     */
-    __publicField(this, "roomID");
-    /**
-     * TRTC 登录身份（`rtc_user_id`）。
-     */
-    __publicField(this, "userID");
-    /**
-     * TRTC SDKAppID（字符串形式，进房时转换为数值）。
-     */
-    __publicField(this, "sdkAppID");
-    /**
-     * TRTC 登录签名。
-     */
-    __publicField(this, "userSig");
-    /**
-     * TRTC 进房鉴权字段（字符串房间号对应的 privateMapKey）。
-     */
-    __publicField(this, "privateMapKey");
-    this.roomID = init.roomID;
-    this.userID = init.userID;
-    this.sdkAppID = init.sdkAppID;
-    this.userSig = init.userSig;
-    this.privateMapKey = init.privateMapKey;
-  }
-};
-
 // src/Stream/Room/RoomEvent.ts
 var RoomEvent = class _RoomEvent {
   /**
@@ -2901,7 +4317,7 @@ var RoomEvent = class _RoomEvent {
   static encode(payload) {
     try {
       return JSON.stringify({ ...payload, runtime: RuntimeInfo.toJSON() });
-    } catch (e11) {
+    } catch (e15) {
       throw new XmaxError(
         "INTERNAL_ERROR" /* internalError */,
         "Failed to encode RTC room event"
@@ -2960,7 +4376,7 @@ var RoomHeartbeat = class {
         return;
       }
       try {
-        this.rtcManager.sendRoomMessage(RoomEvent.heartbeat({ userID }));
+        await this.rtcManager.sendRoomMessage(RoomEvent.heartbeat({ userID }));
       } catch (error) {
         if (this.cycleVersion !== version) {
           return;
@@ -2977,7 +4393,11 @@ var RoomHeartbeat = class {
 // src/Stream/Room/RoomMessageCodec.ts
 var CHUNK_EVENT = "__trtc_chunk__";
 var _RoomMessageCodec = class _RoomMessageCodec {
-  constructor() {
+  /**
+   * 创建厂商协议编解码器；TRTC 保持原事件名，Agora 使用 __agora_chunk__；null 表示不拆包。
+   */
+  constructor(chunkEvent = CHUNK_EVENT) {
+    __publicField(this, "chunkEvent", chunkEvent);
     /**
      * 接收缓存
      */
@@ -2987,10 +4407,10 @@ var _RoomMessageCodec = class _RoomMessageCodec {
    * 编码出站消息。
    *
    * @returns 不超过阈值时返回仅含原消息的单元素数组；
-   * 否则返回按 `__trtc_chunk__` 协议包装的分片 JSON 数组。
+   * 否则返回按当前提供方分片协议包装的 JSON 数组。
    */
   encodeOutgoing(message) {
-    if (_RoomMessageCodec.byteLength(message) <= _RoomMessageCodec.chunkThresholdBytes) {
+    if (this.chunkEvent === null || _RoomMessageCodec.byteLength(message) <= _RoomMessageCodec.chunkThresholdBytes) {
       return [message];
     }
     const eventId = _RoomMessageCodec.makeEventId();
@@ -3005,7 +4425,7 @@ var _RoomMessageCodec = class _RoomMessageCodec {
     );
     return slices.map(
       (data, index) => JSON.stringify({
-        event: CHUNK_EVENT,
+        event: this.chunkEvent,
         eventId,
         index,
         count,
@@ -3023,11 +4443,11 @@ var _RoomMessageCodec = class _RoomMessageCodec {
     let parsed;
     try {
       parsed = JSON.parse(message);
-    } catch (e12) {
+    } catch (e16) {
       XmaxLogger.room.warning(() => "\u623F\u95F4\u6D88\u606F\u4E0D\u662F\u5408\u6CD5 JSON (Room Message Is Not Valid JSON)");
       return void 0;
     }
-    const chunk = _RoomMessageCodec.parseChunk(parsed);
+    const chunk = this.parseChunk(parsed);
     if (!chunk) {
       return parsed;
     }
@@ -3054,7 +4474,7 @@ var _RoomMessageCodec = class _RoomMessageCodec {
     const joined = parts.join("");
     try {
       return JSON.parse(joined);
-    } catch (e13) {
+    } catch (e17) {
       XmaxLogger.room.warning(
         () => `\u623F\u95F4\u6D88\u606F\u7EC4\u5305\u540E\u4E0D\u662F\u5408\u6CD5 JSON (Reassembled Message Is Not Valid JSON)
 \u2514\u2500 eventId: ${chunk.eventId}`
@@ -3071,12 +4491,12 @@ var _RoomMessageCodec = class _RoomMessageCodec {
   /**
    * 从已解析的值识别分片消息；字段不完整时按普通业务消息处理。
    */
-  static parseChunk(parsed) {
-    if (typeof parsed !== "object" || parsed === null) {
+  parseChunk(parsed) {
+    if (this.chunkEvent === null || typeof parsed !== "object" || parsed === null) {
       return void 0;
     }
     const record = parsed;
-    if (record.event !== CHUNK_EVENT || typeof record.eventId !== "string" || !Number.isInteger(record.index) || !Number.isInteger(record.count) || typeof record.data !== "string") {
+    if (record.event !== this.chunkEvent || typeof record.eventId !== "string" || record.eventId.length === 0 || !Number.isInteger(record.index) || !Number.isInteger(record.count) || typeof record.data !== "string") {
       return void 0;
     }
     const index = record.index;
@@ -3106,7 +4526,7 @@ var _RoomMessageCodec = class _RoomMessageCodec {
     let current = "";
     let currentBytes = 0;
     for (const char of message) {
-      const bytes = _RoomMessageCodec.byteLength(char);
+      const bytes = _RoomMessageCodec.byteLength(JSON.stringify(char)) - 2;
       if (currentBytes + bytes > budget && current.length > 0) {
         slices.push(current);
         current = "";
@@ -3175,6 +4595,8 @@ var RoomController = class {
      */
     __publicField(this, "heartbeat");
     __publicField(this, "codec");
+    __publicField(this, "customCodec");
+    __publicField(this, "sendTail", Promise.resolve());
     /**
      * 事件监听
      */
@@ -3187,6 +4609,7 @@ var RoomController = class {
     this.rtcManager = options.rtcManager;
     this.heartbeat = _nullishCoalesce(options.heartbeat, () => ( new RoomHeartbeat({ rtcManager: options.rtcManager })));
     this.codec = _nullishCoalesce(options.codec, () => ( new RoomMessageCodec()));
+    this.customCodec = options.codec !== void 0;
   }
   /**
    * 加入实时房间，并在异步边界前后确认连接操作仍然有效。
@@ -3209,15 +4632,10 @@ var RoomController = class {
     this.state = { kind: "joining", operationID };
     this.heartbeat.stop();
     try {
-      await this.rtcManager.joinRoom(
-        new RoomJoinConfiguration({
-          roomID: connection.roomID,
-          userID: connection.userID,
-          sdkAppID: connection.sdkAppID,
-          userSig: connection.userSig,
-          privateMapKey: connection.privateMapKey
-        })
+      if (!this.customCodec) this.codec = new RoomMessageCodec(
+        connection.provider === "vertc" ? null : connection.provider === "agora" ? "__agora_chunk__" : "__trtc_chunk__"
       );
+      await this.rtcManager.joinRoom(toRoomJoinConfiguration(connection));
       ensureActive();
       if (this.state.kind !== "joining" || this.state.operationID !== operationID || this.leaveOperation) {
         throw new XmaxError("CANCELLED" /* cancelled */, "RTC room join was cancelled");
@@ -3257,7 +4675,7 @@ var RoomController = class {
    * @throws 房间未就绪或信令发送失败时抛出错误。
    */
   startGeneration(options) {
-    this.send(
+    return this.send(
       RoomEvent.start({
         userID: this.requireUserID(),
         taskID: options.taskID,
@@ -3273,7 +4691,7 @@ var RoomController = class {
    * @throws 房间未就绪或信令发送失败时抛出错误。
    */
   changeGenerationCondition(options) {
-    this.send(
+    return this.send(
       RoomEvent.changeCondition({
         userID: this.requireUserID(),
         taskID: options.taskID,
@@ -3290,7 +4708,7 @@ var RoomController = class {
    */
   changeTargetSize(options) {
     options.ensureActive();
-    this.send(
+    return this.send(
       RoomEvent.changeTargetSize({
         userID: this.requireUserID(),
         taskID: options.taskID,
@@ -3303,18 +4721,18 @@ var RoomController = class {
    */
   stopGeneration(taskID) {
     if (!taskID || this.state.kind !== "joined") {
-      return;
+      return Promise.resolve();
     }
-    this.send(RoomEvent.stop({ userID: this.state.userID, taskID }));
+    return this.send(RoomEvent.stop({ userID: this.state.userID, taskID }));
   }
   /**
    * 发送生成任务的交互轨迹；任务标识或轨迹为空时忽略。
    */
   sendTracks(taskID, points) {
     if (!taskID || points.length === 0) {
-      return;
+      return Promise.resolve();
     }
-    this.send(
+    return this.send(
       RoomEvent.tracks({
         userID: this.requireUserID(),
         taskID,
@@ -3335,8 +4753,12 @@ var RoomController = class {
     this.state = { kind: "idle" };
     this.heartbeat.stop();
     this.codec.reset();
-    await this.rtcManager.leaveRoom();
-    this.leaveOperation = void 0;
+    this.sendTail = Promise.resolve();
+    try {
+      await this.rtcManager.leaveRoom();
+    } finally {
+      this.leaveOperation = void 0;
+    }
   }
   /**
    * 组包入站消息并按目标用户过滤后分发完整业务消息。
@@ -3352,24 +4774,32 @@ var RoomController = class {
     if (targetUserID && ownUserID && targetUserID !== ownUserID) {
       return;
     }
-    _optionalChain([this, 'access', _104 => _104.listener, 'optionalAccess', _105 => _105.onRoomMessage, 'call', _106 => _106(senderUserID, message)]);
+    _optionalChain([this, 'access', _278 => _278.listener, 'optionalAccess', _279 => _279.onRoomMessage, 'call', _280 => _280(senderUserID, message)]);
   }
   /**
    * 发送房间信令并输出日志。
    */
   send(message) {
-    for (const packet of this.codec.encodeOutgoing(message)) {
-      try {
-        this.rtcManager.sendRoomMessage(packet);
-      } catch (error) {
-        throw XmaxError.from(error);
+    const state2 = this.state;
+    const packets = this.codec.encodeOutgoing(message);
+    const operation = this.sendTail.then(async () => {
+      for (const packet of packets) {
+        if (state2 !== this.state || state2.kind !== "joined") {
+          throw new XmaxError("CANCELLED" /* cancelled */, "Room message was cancelled");
+        }
+        await this.rtcManager.sendRoomMessage(packet);
       }
-    }
-    XmaxLogger.room.info(
-      () => `\u53D1\u9001\u623F\u95F4\u4FE1\u4EE4 (Outbound Room Signaling)
+      XmaxLogger.room.info(
+        () => `\u53D1\u9001\u623F\u95F4\u4FE1\u4EE4 (Outbound Room Signaling)
 \u2514\u2500 ${XmaxLogger.localized("\u5185\u5BB9\uFF1A", "Content:")}
 ${JSON.stringify(JSON.parse(message), null, 2)}`
-    );
+      );
+    }).catch((error) => {
+      throw XmaxError.from(error);
+    });
+    this.sendTail = operation.catch(() => {
+    });
+    return operation;
   }
   /**
    * 返回当前房间中的用户标识；未进房时抛出错误。
@@ -3542,6 +4972,9 @@ function makeInitialState() {
     localVideoPublished: false,
     localAudioPublished: false,
     subscribedRemoteUserIDs: /* @__PURE__ */ new Set(),
+    publishedRemoteUserIDs: /* @__PURE__ */ new Set(),
+    remoteVideoTracks: /* @__PURE__ */ new Map(),
+    remoteVideoSubscriptions: /* @__PURE__ */ new Map(),
     subscribedRemoteAudioUserIDs: /* @__PURE__ */ new Set()
   };
 }
@@ -3595,20 +5028,24 @@ var StreamController = class {
     })));
     this.generationTimeoutMs = _nullishCoalesce(options.generationTimeoutMs, () => ( 3e4));
     this.rtcManager.setEventListener({
+      onTokenWillExpire: options.onCredentialsRequired,
+      onTokenExpired: options.onCredentialsRequired,
+      onRoomRejoining: () => this.handleRoomRejoining(),
+      onError: (error) => this.errorListener(error),
       onNetworkStatistics: (statistics) => {
         if (this.state.localVideoPublished) {
-          _optionalChain([this, 'access', _107 => _107.networkStatisticsListener, 'optionalCall', _108 => _108(statistics)]);
+          _optionalChain([this, 'access', _281 => _281.networkStatisticsListener, 'optionalCall', _282 => _282(statistics)]);
         }
       },
       onRemoteVideoStatistics: (statistics) => {
-        const userID = _optionalChain([this, 'access', _109 => _109.state, 'access', _110 => _110.activeRemoteStream, 'optionalAccess', _111 => _111.userID]);
-        _optionalChain([this, 'access', _112 => _112.remoteVideoStatisticsListener, 'optionalCall', _113 => _113(
+        const userID = _optionalChain([this, 'access', _283 => _283.state, 'access', _284 => _284.activeRemoteStream, 'optionalAccess', _285 => _285.userID]);
+        _optionalChain([this, 'access', _286 => _286.remoteVideoStatisticsListener, 'optionalCall', _287 => _287(
           userID ? statistics.find((item) => item.userID === userID) : void 0
         )]);
       },
       onLocalVideoStatistics: (statistics) => {
         if (this.state.localVideoPublished) {
-          _optionalChain([this, 'access', _114 => _114.localVideoStatisticsListener, 'optionalCall', _115 => _115(statistics)]);
+          _optionalChain([this, 'access', _288 => _288.localVideoStatisticsListener, 'optionalCall', _289 => _289(statistics)]);
         }
       },
       onCustomMessageReceived: (senderUserID, message) => {
@@ -3673,14 +5110,14 @@ var StreamController = class {
    * @throws 连接已取消，或 RTC 进房、房间配置与本地流发布失败时抛出错误。
    */
   async connect(connection, includeLocalAudio, ensureActive, beforePublish) {
+    this.configureRoom({ roomID: connection.roomID, botID: connection.botID });
     await this.roomController.join(connection, ensureActive);
     ensureActive();
-    this.configureRoom({ roomID: connection.roomID, botID: connection.botID });
     XmaxLogger.stream.info(
       () => `RTC \u623F\u95F4\u5DF2\u914D\u7F6E (RTC Room Configured)
 \u2514\u2500 roomID: ${connection.roomID}, botID: ${_nullishCoalesce(connection.botID, () => ( "(\u672A\u8BBE\u7F6E)"))}`
     );
-    await _optionalChain([beforePublish, 'optionalCall', _116 => _116()]);
+    await _optionalChain([beforePublish, 'optionalCall', _290 => _290()]);
     ensureActive();
     await this.publishLocalStream(includeLocalAudio);
   }
@@ -3691,12 +5128,18 @@ var StreamController = class {
     await this.resetStream();
     await this.roomController.leave();
   }
+  /**
+   * 将会话刷新后的凭据应用到当前 RTC 连接。
+   */
+  async updateCredentials(connection, signal) {
+    await this.rtcManager.updateCredentials(toRoomJoinConfiguration(connection), signal);
+  }
   /**
    * 建立生成任务并发送开始信令。
    *
    * @returns 等待远端结果流确认的 Promise。
-   * @throws 任务标识无效、RTC 房间未就绪、已有生成任务，或开始信令
-   * 发送失败时同步抛出错误。
+   * @throws 任务标识无效、RTC 房间未就绪或已有生成任务时同步抛错；
+   * 发送失败或确认超时通过返回的 Promise 拒绝。
    */
   beginGeneration(options) {
     const taskID = options.taskID.trim();
@@ -3738,24 +5181,44 @@ var StreamController = class {
     };
     this.state.generationTaskID = taskID;
     this.state.generationWaiter = waiter;
+    void confirmation.catch(() => {
+    });
     try {
-      this.roomController.startGeneration({
+      const sending = this.roomController.startGeneration({
         taskID,
         videoFormat: options.videoFormat,
         targetSize: options.targetSize,
         context: options.context
       });
+      const state2 = this.state;
+      const sent = Promise.resolve(sending).then(() => {
+        if (this.state !== state2 || state2.generationTaskID !== taskID) return;
+        for (const userID of state2.publishedRemoteUserIDs) {
+          void this.handleRemoteVideoPublished(userID, true);
+        }
+      }).catch((error) => {
+        const mapped = XmaxError.from(error);
+        this.rejectGenerationStart(taskID, mapped);
+        if (this.state.generationTaskID === taskID) {
+          this.state.generationTaskID = void 0;
+          void this.roomController.stopGeneration(taskID).catch(() => {
+          });
+        }
+        throw mapped;
+      });
+      return Promise.all([sent, confirmation]).then(() => {
+      });
     } catch (error) {
       const mapped = XmaxError.from(error);
-      this.state.generationTaskID = void 0;
       this.rejectGenerationStart(taskID, mapped);
+      this.state.generationTaskID = void 0;
       try {
-        this.roomController.stopGeneration(taskID);
-      } catch (e14) {
+        void this.roomController.stopGeneration(taskID).catch(() => {
+        });
+      } catch (e18) {
       }
       throw mapped;
     }
-    return confirmation;
   }
   /**
    * 在远端首帧已经可显示后订阅当前生成流的音频。
@@ -3777,9 +5240,9 @@ var StreamController = class {
    *
    * @throws RTC 房间未就绪或条件变更信令发送失败时抛出错误。
    */
-  updateGeneration(options) {
+  async updateGeneration(options) {
     try {
-      this.roomController.changeGenerationCondition({
+      await this.roomController.changeGenerationCondition({
         taskID: options.taskID,
         videoFormat: options.videoFormat,
         targetSize: options.targetSize,
@@ -3794,9 +5257,9 @@ var StreamController = class {
    *
    * @throws 操作已取消、房间未就绪或信令发送失败时抛出错误。
    */
-  changeTargetSize(taskID, targetSize, ensureActive) {
+  async changeTargetSize(taskID, targetSize, ensureActive) {
     try {
-      this.roomController.changeTargetSize({ taskID, targetSize, ensureActive });
+      await this.roomController.changeTargetSize({ taskID, targetSize, ensureActive });
     } catch (error) {
       throw XmaxError.from(error);
     }
@@ -3812,7 +5275,7 @@ var StreamController = class {
       return;
     }
     try {
-      this.roomController.stopGeneration(stoppedTaskID);
+      await this.roomController.stopGeneration(stoppedTaskID);
     } catch (error) {
       throw XmaxError.from(error);
     }
@@ -3822,9 +5285,9 @@ var StreamController = class {
    *
    * @throws RTC 房间未就绪或轨迹信令发送失败时抛出错误。
    */
-  sendTracks(taskID, points) {
+  async sendTracks(taskID, points) {
     try {
-      this.roomController.sendTracks(taskID, points);
+      await this.roomController.sendTracks(taskID, points);
     } catch (error) {
       throw XmaxError.from(error);
     }
@@ -3840,7 +5303,7 @@ var StreamController = class {
    */
   configureRoom(options) {
     const roomID = options.roomID.trim();
-    const botID = _nullishCoalesce(_optionalChain([options, 'access', _117 => _117.botID, 'optionalAccess', _118 => _118.trim, 'call', _119 => _119()]), () => ( ""));
+    const botID = _nullishCoalesce(_optionalChain([options, 'access', _291 => _291.botID, 'optionalAccess', _292 => _292.trim, 'call', _293 => _293()]), () => ( ""));
     if (!roomID) {
       throw new XmaxError(
         "INVALID_CONFIGURATION" /* invalidConfiguration */,
@@ -3899,6 +5362,12 @@ var StreamController = class {
     if (!this.state.roomID) {
       return;
     }
+    if (published) this.state.publishedRemoteUserIDs.add(trimmedUserID);
+    else {
+      this.state.publishedRemoteUserIDs.delete(trimmedUserID);
+      this.state.remoteVideoSubscriptions.delete(trimmedUserID);
+      this.state.remoteVideoTracks.delete(trimmedUserID);
+    }
     if (this.state.botID && this.state.botID !== trimmedUserID) {
       if (this.state.generationTaskID === void 0) {
         XmaxLogger.stream.warning(
@@ -3917,37 +5386,55 @@ var StreamController = class {
       return;
     }
     this.state.subscribedRemoteUserIDs.delete(trimmedUserID);
-    if (_optionalChain([this, 'access', _120 => _120.state, 'access', _121 => _121.activeRemoteStream, 'optionalAccess', _122 => _122.userID]) === trimmedUserID) {
+    if (_optionalChain([this, 'access', _294 => _294.state, 'access', _295 => _295.activeRemoteStream, 'optionalAccess', _296 => _296.userID]) === trimmedUserID) {
       await this.unsubscribeRemoteAudio(trimmedUserID);
       this.state.activeRemoteStream = void 0;
       this.clearRemoteStream();
     }
   }
+  /**
+   * RTC 重进房时废弃旧媒体绑定；业务任务、音频订阅意图和生成确认等待器继续保留。
+   */
+  handleRoomRejoining() {
+    this.state.publishedRemoteUserIDs.clear();
+    this.state.subscribedRemoteUserIDs.clear();
+    this.state.remoteVideoSubscriptions.clear();
+    this.state.remoteVideoTracks.clear();
+    this.state.activeRemoteStream = void 0;
+    this.clearRemoteStream();
+  }
   /**
    * 订阅远端视频并在成功后就绪或确认生成任务。
    */
   async subscribeRemoteVideo(userID) {
-    if (this.state.subscribedRemoteUserIDs.has(userID)) {
+    const state2 = this.state;
+    const existing = state2.remoteVideoTracks.get(userID);
+    if (existing) {
+      if (state2.generationWaiter) this.confirmOrUpdateRemoteStream(userID, existing);
       return;
     }
+    if (state2.remoteVideoSubscriptions.has(userID)) return;
+    const subscription = {};
+    state2.remoteVideoSubscriptions.set(userID, subscription);
+    const isCurrent = () => this.state === state2 && state2.remoteVideoSubscriptions.get(userID) === subscription;
     try {
       const track = await this.rtcManager.subscribeRemoteVideo(userID, true);
+      if (!isCurrent()) return;
       if (!track) {
         throw new XmaxError(
           "MEDIA_ERROR" /* mediaError */,
           "Remote video track is not available"
         );
       }
-      if (!this.state.roomID) {
-        return;
-      }
-      this.state.subscribedRemoteUserIDs.add(userID);
+      state2.subscribedRemoteUserIDs.add(userID);
+      state2.remoteVideoTracks.set(userID, track);
       XmaxLogger.stream.info(
         () => `\u8FDC\u7AEF\u89C6\u9891\u8BA2\u9605\u6210\u529F (Remote Video Subscribed)
 \u2514\u2500 userID: ${userID}`
       );
       this.confirmOrUpdateRemoteStream(userID, track);
     } catch (error) {
+      if (!isCurrent()) return;
       const mapped = XmaxError.from(error);
       const pendingTaskID = this.state.generationWaiter ? this.state.generationTaskID : void 0;
       if (pendingTaskID) {
@@ -3955,6 +5442,8 @@ var StreamController = class {
       } else {
         this.errorListener(mapped);
       }
+    } finally {
+      if (isCurrent()) state2.remoteVideoSubscriptions.delete(userID);
     }
   }
   /**
@@ -3993,14 +5482,23 @@ var StreamController = class {
     }
   }
   /**
-   * 订阅远端音频：先应用当前音量再订阅。
+   * 订阅远端音频并按平台能力应用当前音量。
+   *
+   * 支持音量控制的平台先设音量再订阅，避免以默认音量短暂出声；
+   * iOS 上音量降级为播放/静音二值控制，必须先完成订阅（恢复播放）
+   * 再按需静音，否则订阅的恢复播放会覆盖音量 0 的静音状态。
    */
   async subscribeRemoteAudio(userID) {
     if (this.state.subscribedRemoteAudioUserIDs.has(userID)) {
       return;
     }
-    this.rtcManager.setRemoteAudioVolume(this.remoteAudioVolumePercentage, userID);
-    await this.rtcManager.subscribeRemoteAudio(userID, true);
+    if (this.rtcManager.supportsRemoteAudioVolumeControl) {
+      this.rtcManager.setRemoteAudioVolume(this.remoteAudioVolumePercentage, userID);
+      await this.rtcManager.subscribeRemoteAudio(userID, true);
+    } else {
+      await this.rtcManager.subscribeRemoteAudio(userID, true);
+      this.rtcManager.setRemoteAudioVolume(this.remoteAudioVolumePercentage, userID);
+    }
     this.state.subscribedRemoteAudioUserIDs.add(userID);
   }
   /**
@@ -4077,7 +5575,7 @@ var StreamController = class {
    */
   resolveGenerationStart(taskID) {
     const waiter = this.state.generationWaiter;
-    if (this.state.generationTaskID !== taskID || _optionalChain([waiter, 'optionalAccess', _123 => _123.taskID]) !== taskID) {
+    if (this.state.generationTaskID !== taskID || _optionalChain([waiter, 'optionalAccess', _297 => _297.taskID]) !== taskID) {
       return;
     }
     this.state.generationWaiter = void 0;
@@ -4089,7 +5587,7 @@ var StreamController = class {
    */
   rejectGenerationStart(taskID, error) {
     const waiter = this.state.generationWaiter;
-    if (this.state.generationTaskID !== taskID || _optionalChain([waiter, 'optionalAccess', _124 => _124.taskID]) !== taskID) {
+    if (this.state.generationTaskID !== taskID || _optionalChain([waiter, 'optionalAccess', _298 => _298.taskID]) !== taskID) {
       return;
     }
     this.state.generationWaiter = void 0;
@@ -4100,7 +5598,7 @@ var StreamController = class {
    * 通知渲染层清理远端生成流；失败仅记录日志。
    */
   clearRemoteStream() {
-    _optionalChain([this, 'access', _125 => _125.remoteVideoStatisticsListener, 'optionalCall', _126 => _126(void 0)]);
+    _optionalChain([this, 'access', _299 => _299.remoteVideoStatisticsListener, 'optionalCall', _300 => _300(void 0)]);
     try {
       this.remoteStreamListener(null);
     } catch (error) {
@@ -4371,7 +5869,7 @@ var RealtimeCoordinator = class _RealtimeCoordinator {
         }
         throw _RealtimeCoordinator.cancelledError();
       }
-      const terminationTask = await _asyncNullishCoalesce(await _asyncNullishCoalesce(operation.terminationTask, async () => ( _optionalChain([this, 'access', _127 => _127.termination, 'optionalAccess', _128 => _128.task]))), async () => ( await this.requestTermination(
+      const terminationTask = await _asyncNullishCoalesce(await _asyncNullishCoalesce(operation.terminationTask, async () => ( _optionalChain([this, 'access', _301 => _301.termination, 'optionalAccess', _302 => _302.task]))), async () => ( await this.requestTermination(
         _nullishCoalesce(operation.lease.failureScope, () => ( 0)) /* connection */,
         void 0,
         RealtimeReason.normal,
@@ -4500,7 +5998,7 @@ var RealtimeCoordinator = class _RealtimeCoordinator {
    * 结束指定操作，释放操作准入场。
    */
   finish(operation) {
-    if (_optionalChain([this, 'access', _129 => _129.activeOperation, 'optionalAccess', _130 => _130.id]) === operation.id) {
+    if (_optionalChain([this, 'access', _303 => _303.activeOperation, 'optionalAccess', _304 => _304.id]) === operation.id) {
       this.activeOperation = void 0;
     }
   }
@@ -4512,7 +6010,7 @@ var RealtimeCoordinator = class _RealtimeCoordinator {
       return;
     }
     this.state = nextState;
-    _optionalChain([this, 'access', _131 => _131.stateListener, 'optionalCall', _132 => _132(nextState)]);
+    _optionalChain([this, 'access', _305 => _305.stateListener, 'optionalCall', _306 => _306(nextState)]);
   }
   /**
    * 构造统一的操作取消错误。
@@ -4588,17 +6086,25 @@ var RealtimeLaunchTimer = class {
     this.notify();
     return complete;
   }
+  /**
+   * 开始等待用户授权系统媒体权限，返回授权决定时调用的记录函数。
+   * 仅在系统弹出授权请求时使用；已授权或未弹窗不记录该阶段。
+   */
+  startPermission() {
+    return this.measure("permissionMs", performance.now());
+  }
   /**
    * 开始会话与进房计时，返回连接阶段完成时调用的记录函数。
+   * 相机预热等待计入连接耗时。
    */
   startConnection() {
     return this.measure("connectionMs", performance.now());
   }
   /**
-   * 开始亮度检测计时；合格帧到达或超时放行时调用返回的记录函数。
+   * 开始发布本地流计时，返回发布完成时调用的记录函数。
    */
-  startFrameValidation() {
-    return this.measure("frameValidationMs", performance.now());
+  startPublish() {
+    return this.measure("publishMs", performance.now());
   }
   /**
    * 开始等待远端显示首帧；完成回调同时记录首帧耗时和实际总耗时。
@@ -4636,9 +6142,9 @@ var RealtimeLaunchTimer = class {
    */
   notify() {
     try {
-      void Promise.resolve(_optionalChain([this, 'access', _133 => _133.listener, 'optionalCall', _134 => _134(this.snapshot)])).catch(() => {
+      void Promise.resolve(_optionalChain([this, 'access', _307 => _307.listener, 'optionalCall', _308 => _308(this.snapshot)])).catch(() => {
       });
-    } catch (e15) {
+    } catch (e19) {
     }
   }
 };
@@ -4654,6 +6160,10 @@ var XmaxRealtimeConnectionManager = class {
      * 会话资源
      */
     __publicField(this, "activeSession");
+    __publicField(this, "refreshVersion", 0);
+    __publicField(this, "credentialRefresh");
+    __publicField(this, "credentialApplication", Promise.resolve());
+    __publicField(this, "credentialController");
     /**
      * 远端轨道与渲染绑定
      */
@@ -4664,7 +6174,7 @@ var XmaxRealtimeConnectionManager = class {
    * 当前活动会话标识；尚未连接或清理完成后为空。
    */
   get currentSessionID() {
-    return _optionalChain([this, 'access', _135 => _135.activeSession, 'optionalAccess', _136 => _136.id]);
+    return _optionalChain([this, 'access', _309 => _309.activeSession, 'optionalAccess', _310 => _310.id]);
   }
   /**
    * 未配置 API 服务时在连接操作开始前报错，不影响本地预览。
@@ -4674,7 +6184,8 @@ var XmaxRealtimeConnectionManager = class {
   }
   /**
    * 创建会话、配置编码、进房并发布本地媒体，启动心跳后返回远端占位流。
-   * 进房结束即记录连接耗时；可选 beforePublish 检查只阻塞发布，不计入连接耗时。
+   * 进房结束即记录连接耗时；可选 beforePublish 检查阻塞发布，计入连接耗时；
+   * 发布本地流单独计时。
    * @throws 会话、进房、发布失败或操作租约已失效时抛出错误，由上层统一清理。
    */
   async connect(options) {
@@ -4692,6 +6203,11 @@ var XmaxRealtimeConnectionManager = class {
         "Session does not contain RTC join information"
       );
     }
+    if (connection.provider !== (_nullishCoalesce(this.dependencies.provider, () => ( "trtc")) /* trtc */)) {
+      throw new XmaxError("SESSION_ERROR" /* sessionError */, "RTC adapter configuration does not match the session service");
+    }
+    const refreshVersion = ++this.refreshVersion;
+    this.credentialController = new AbortController();
     const videoFormat = options.localTrack.videoFormat;
     if (!videoFormat) {
       throw new XmaxError(
@@ -4701,27 +6217,29 @@ var XmaxRealtimeConnectionManager = class {
     }
     await streamController.setVideoEncoderConfig(videoFormat);
     options.ensureCurrent();
+    let completePublish;
     await streamController.connect(connection, options.includeLocalAudio, () => {
       options.ensureCurrent();
     }, async () => {
       options.ensureCurrent();
+      await _optionalChain([options, 'access', _311 => _311.beforePublish, 'optionalCall', _312 => _312()]);
       completeConnection();
-      options.ensureCurrent();
-      await _optionalChain([options, 'access', _137 => _137.beforePublish, 'optionalCall', _138 => _138()]);
+      completePublish = this.dependencies.timing.startPublish();
     });
     options.ensureCurrent();
+    _optionalChain([completePublish, 'optionalCall', _313 => _313()]);
     options.onPublished();
     sessionService.startHeartbeat(session.id, {
       onFailure: (sessionID, error) => {
         this.dependencies.onHeartbeatFailure(sessionID, error);
       },
       onRefresh: (refreshed) => {
-        this.handleSessionRefresh(refreshed);
+        return this.handleSessionRefresh(refreshed, refreshVersion);
       }
     });
     const remoteTrack = new RealtimeVideoTrack({
       id: _nullishCoalesce(connection.botID, () => ( "video-remote")),
-      videoFormat: options.localTrack.videoFormat
+      videoFormat: _nullishCoalesce(options.remoteVideoFormat, () => ( options.localTrack.videoFormat))
     });
     this.activeRemoteTrack = remoteTrack;
     this.registerRemoteBinding(remoteTrack);
@@ -4732,26 +6250,56 @@ var XmaxRealtimeConnectionManager = class {
    * 更新已绑定远端视图的插帧配置；传 undefined 停用插帧。
    */
   setFrameInterpolation(options) {
-    _optionalChain([this, 'access', _139 => _139.remoteTarget, 'optionalAccess', _140 => _140.setFrameInterpolation, 'optionalCall', _141 => _141(options)]);
+    _optionalChain([this, 'access', _314 => _314.remoteTarget, 'optionalAccess', _315 => _315.setFrameInterpolation, 'optionalCall', _316 => _316(options)]);
   }
   /**
    * 清空远端视图的媒体流，保留轨道与视图绑定以供统一清理。
    */
   clearRemoteMedia() {
-    _optionalChain([this, 'access', _142 => _142.remoteTarget, 'optionalAccess', _143 => _143.setMediaStream, 'call', _144 => _144(null)]);
+    _optionalChain([this, 'access', _317 => _317.remoteTarget, 'optionalAccess', _318 => _318.setMediaStream, 'call', _319 => _319(null)]);
   }
   /**
    * 停止会话心跳；未配置会话服务时不执行操作。
    */
   stopHeartbeat() {
-    _optionalChain([this, 'access', _145 => _145.dependencies, 'access', _146 => _146.sessionService, 'optionalAccess', _147 => _147.stopHeartbeat, 'call', _148 => _148()]);
+    this.refreshVersion++;
+    _optionalChain([this, 'access', _320 => _320.credentialController, 'optionalAccess', _321 => _321.abort, 'call', _322 => _322()]);
+    this.credentialController = void 0;
+    this.credentialRefresh = void 0;
+    this.credentialApplication = Promise.resolve();
+    _optionalChain([this, 'access', _323 => _323.dependencies, 'access', _324 => _324.sessionService, 'optionalAccess', _325 => _325.stopHeartbeat, 'call', _326 => _326()]);
+  }
+  /**
+   * RTC Token 过期时复用会话心跳获取新凭据，并合并同一实例的并发请求。
+   */
+  async refreshCredentials() {
+    if (this.credentialRefresh) return this.credentialRefresh;
+    const current = this.activeSession;
+    if (!_optionalChain([current, 'optionalAccess', _327 => _327.connection]) || current.connection.provider === "trtc") return;
+    const version = this.refreshVersion;
+    const operation = (async () => {
+      try {
+        const session = await this.requireSessionService().heartbeatSession(current.id);
+        await this.handleSessionRefresh(session, version, true);
+      } catch (error) {
+        if (version === this.refreshVersion && _optionalChain([this, 'access', _328 => _328.activeSession, 'optionalAccess', _329 => _329.id]) === current.id) {
+          this.dependencies.onHeartbeatFailure(current.id, XmaxError.from(error));
+        }
+      }
+    })();
+    this.credentialRefresh = operation;
+    try {
+      await operation;
+    } finally {
+      if (this.credentialRefresh === operation) this.credentialRefresh = void 0;
+    }
   }
   /**
    * 等待接收轨解除静音；超时只警告，取消必须立即退出并移除监听。
    */
   async waitUntilRemoteTrackReady(timeoutMs, signal) {
     if (signal.aborted) throw RealtimeCoordinator.cancelledError();
-    const mediaTrack = _optionalChain([this, 'access', _149 => _149.activeRemoteTrack, 'optionalAccess', _150 => _150.mediaStreamTrack]);
+    const mediaTrack = _optionalChain([this, 'access', _330 => _330.activeRemoteTrack, 'optionalAccess', _331 => _331.mediaStreamTrack]);
     if (!mediaTrack || !mediaTrack.muted) return;
     await new Promise((resolve, reject) => {
       const cleanup = () => {
@@ -4788,7 +6336,7 @@ var XmaxRealtimeConnectionManager = class {
       if (track) {
         track.mediaStreamTrack = void 0;
       }
-      _optionalChain([this, 'access', _151 => _151.remoteTarget, 'optionalAccess', _152 => _152.setMediaStream, 'call', _153 => _153(null)]);
+      _optionalChain([this, 'access', _332 => _332.remoteTarget, 'optionalAccess', _333 => _333.setMediaStream, 'call', _334 => _334(null)]);
       return;
     }
     if (!track) {
@@ -4798,7 +6346,7 @@ var XmaxRealtimeConnectionManager = class {
       );
     }
     track.mediaStreamTrack = binding.videoTrack;
-    _optionalChain([this, 'access', _154 => _154.remoteTarget, 'optionalAccess', _155 => _155.setMediaStream, 'call', _156 => _156(new MediaStream([binding.videoTrack]))]);
+    _optionalChain([this, 'access', _335 => _335.remoteTarget, 'optionalAccess', _336 => _336.setMediaStream, 'call', _337 => _337(new MediaStream([binding.videoTrack]))]);
   }
   /**
    * 为远端轨道注册渲染绑定：attach 时挂流占位，媒体轨到达后送入画面。
@@ -4811,7 +6359,7 @@ var XmaxRealtimeConnectionManager = class {
         }
       },
       attachHandler: (view) => {
-        _optionalChain([this, 'access', _157 => _157.remoteTarget, 'optionalAccess', _158 => _158.setFrameInterpolation, 'optionalCall', _159 => _159(void 0)]);
+        _optionalChain([this, 'access', _338 => _338.remoteTarget, 'optionalAccess', _339 => _339.setFrameInterpolation, 'optionalCall', _340 => _340(void 0)]);
         view.isMirrored = this.dependencies.isMirrored();
         this.remoteTarget = view;
         this.dependencies.onRenderAttached();
@@ -4823,7 +6371,7 @@ var XmaxRealtimeConnectionManager = class {
           this.dependencies.onRenderDetached();
           this.remoteTarget = void 0;
         }
-        _optionalChain([view, 'access', _160 => _160.setFrameInterpolation, 'optionalCall', _161 => _161(void 0)]);
+        _optionalChain([view, 'access', _341 => _341.setFrameInterpolation, 'optionalCall', _342 => _342(void 0)]);
         view.setMediaStream(null);
       }
     });
@@ -4853,9 +6401,18 @@ var XmaxRealtimeConnectionManager = class {
    * 心跳成功后的凭据刷新：仅凭据变化时覆盖本地缓存；房间绑定信息
    * （提供方、房间、应用、登录身份）变化时当前连接失效，按失败结束。
    */
-  handleSessionRefresh(session) {
+  handleSessionRefresh(session, version, force = false) {
+    const operation = this.credentialApplication.then(() => this.applySessionRefresh(session, version, force));
+    this.credentialApplication = operation.catch(() => {
+    });
+    return operation;
+  }
+  /**
+   * 校验绑定并应用最新凭据，异步刷新期间失效的房间不得恢复缓存。
+   */
+  async applySessionRefresh(session, version, force) {
     const current = this.activeSession;
-    if (!current || current.id !== session.id) {
+    if (version !== this.refreshVersion || !current || current.id !== session.id) {
       return;
     }
     const next = session.connection;
@@ -4863,7 +6420,7 @@ var XmaxRealtimeConnectionManager = class {
       return;
     }
     const previous = current.connection;
-    const bindingChanged = previous !== void 0 && (next.provider !== previous.provider || next.roomID !== previous.roomID || next.sdkAppID !== previous.sdkAppID || next.userID !== previous.userID);
+    const bindingChanged = previous !== void 0 && (next.provider !== previous.provider || next.roomID !== previous.roomID || connectionAppID(next) !== connectionAppID(previous) || next.botID !== previous.botID || next.userID !== previous.userID);
     if (bindingChanged) {
       this.dependencies.onHeartbeatFailure(
         session.id,
@@ -4871,6 +6428,10 @@ var XmaxRealtimeConnectionManager = class {
       );
       return;
     }
+    if (next.provider !== "trtc" && (force || !previous || previous.provider === "trtc" || next.roomToken !== previous.roomToken)) {
+      await this.dependencies.streamController.updateCredentials(next, _optionalChain([this, 'access', _343 => _343.credentialController, 'optionalAccess', _344 => _344.signal]));
+      if (version !== this.refreshVersion || this.activeSession !== current) return;
+    }
     this.activeSession = new RealtimeSession({
       id: session.id,
       userID: _nullishCoalesce(session.userID, () => ( current.userID)),
@@ -4883,7 +6444,7 @@ var XmaxRealtimeConnectionManager = class {
    * 尽力清理全部连接资源，即使退房失败也关闭服务端会话。
    */
   async disconnect() {
-    const sessionID = _optionalChain([this, 'access', _162 => _162.activeSession, 'optionalAccess', _163 => _163.id]);
+    const sessionID = _optionalChain([this, 'access', _345 => _345.activeSession, 'optionalAccess', _346 => _346.id]);
     this.stopHeartbeat();
     this.clearRemoteMedia();
     try {
@@ -4983,16 +6544,17 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
   /**
    * 更新活动任务的生成条件；信令发送成功后才覆盖缓存，无任务或上下文时抛错。
    */
-  update(taskID, options) {
+  async update(taskID, options) {
     const context = _nullishCoalesce(options.context, () => ( this.currentContext));
     if (!taskID || !context) {
       throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "A realtime context is required to update the current generation");
     }
-    this.streamController.updateGeneration({
+    await this.streamController.updateGeneration({
       taskID,
       videoFormat: options.videoFormat,
       context
     });
+    if (this.activeTaskID !== taskID) throw RealtimeCoordinator.cancelledError();
     this.currentContext = context;
   }
   /**
@@ -5016,7 +6578,7 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
     try {
       await completion;
     } finally {
-      if (_optionalChain([this, 'access', _164 => _164.pendingStop, 'optionalAccess', _165 => _165.completion]) === completion) this.pendingStop = void 0;
+      if (_optionalChain([this, 'access', _347 => _347.pendingStop, 'optionalAccess', _348 => _348.completion]) === completion) this.pendingStop = void 0;
     }
   }
   /**
@@ -5080,6 +6642,10 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
      */
     __publicField(this, "options");
     __publicField(this, "mediaService");
+    /**
+     * 本地流创建时的生成格式；上行编码调整不改变模型输入配置与远端插帧尺寸。
+     */
+    __publicField(this, "generationVideoFormat");
     /**
      * 插帧能力、用户配置与渲染版本
      */
@@ -5098,6 +6664,10 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
      */
     __publicField(this, "launchTimer", new RealtimeLaunchTimer());
     __publicField(this, "remoteFrameDisplayHandler");
+    /**
+     * 媒体权限弹窗观察
+     */
+    __publicField(this, "permissionWatchDispose");
     /**
      * 本地、远端和网络统计快照及观察者
      */
@@ -5122,19 +6692,22 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     this.options = options;
     this.mediaService = new MediaService(options.model);
     this.interpolationRequested = options.isFrameInterpolationEnabled;
-    this.supportsInterpolation = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _166 => _166.supportsFrameInterpolation]), () => ( (async (size) => await frameInterpolationAdapter(size) !== null)));
+    this.supportsInterpolation = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _349 => _349.supportsFrameInterpolation]), () => ( (async (size) => await frameInterpolationAdapter(size) !== null)));
     this.errorHandler = new RealtimeErrorHandler();
-    const rtcManager = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _167 => _167.rtcManager]), () => ( new RtcManager()));
-    this.cameraController = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _168 => _168.cameraController]), () => ( new CameraController({
+    const rtcManager = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _350 => _350.rtcManager]), () => ( createRtcManager(options.provider, _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _351 => _351.environment]), () => ( "china")) /* china */)));
+    this.cameraController = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _352 => _352.cameraController]), () => ( new CameraController({
       rtcManager,
       mediaService: this.mediaService,
       errorListener: (error) => {
         void this.errorHandler.report(error);
       }
     })));
-    const sessionService = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _169 => _169.sessionService]), () => ( (_optionalChain([dependencies, 'optionalAccess', _170 => _170.apiService]) ? new RealtimeSessionService({ apiService: dependencies.apiService }) : void 0)));
-    this.streamController = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _171 => _171.streamController]), () => ( new StreamController({
+    const sessionService = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _353 => _353.sessionService]), () => ( (_optionalChain([dependencies, 'optionalAccess', _354 => _354.apiService]) ? new RealtimeSessionService({ apiService: dependencies.apiService, provider: options.provider }) : void 0)));
+    this.streamController = _nullishCoalesce(_optionalChain([dependencies, 'optionalAccess', _355 => _355.streamController]), () => ( new StreamController({
       rtcManager,
+      onCredentialsRequired: () => {
+        void this.connectionManager.refreshCredentials();
+      },
       errorListener: (error) => {
         void this.errorHandler.report(error);
       },
@@ -5144,15 +6717,16 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       }
     })));
     this.connectionManager = new XmaxRealtimeConnectionManager({
+      provider: options.provider,
       sessionService,
       streamController: this.streamController,
       timing: this.launchTimer,
-      isMirrored: () => _optionalChain([this, 'access', _172 => _172.cameraController, 'access', _173 => _173.currentTrack, 'optionalAccess', _174 => _174.position]) === "front" /* front */,
+      isMirrored: () => _optionalChain([this, 'access', _356 => _356.cameraController, 'access', _357 => _357.currentTrack, 'optionalAccess', _358 => _358.position]) === "front" /* front */,
       remoteAudioVolume: () => this.storedRemoteAudioVolume,
       onHeartbeatFailure: (sessionID, error) => {
         void this.handleHeartbeatFailure(sessionID, error);
       },
-      onFrameDisplayed: () => _optionalChain([this, 'access', _175 => _175.remoteFrameDisplayHandler, 'optionalCall', _176 => _176()]),
+      onFrameDisplayed: () => _optionalChain([this, 'access', _359 => _359.remoteFrameDisplayHandler, 'optionalCall', _360 => _360()]),
       onRenderAttached: () => this.applyRemoteInterpolation(),
       onRenderDetached: () => {
         this.interpolationRevision++;
@@ -5199,7 +6773,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   async setFrameInterpolationEnabled(enabled) {
     await this.coordinator.run("configuration" /* configuration */, void 0, async (token) => {
-      const format = _optionalChain([this, 'access', _177 => _177.cameraController, 'access', _178 => _178.currentTrack, 'optionalAccess', _179 => _179.videoFormat]);
+      const format = _nullishCoalesce(this.generationVideoFormat, () => ( _optionalChain([this, 'access', _361 => _361.cameraController, 'access', _362 => _362.currentTrack, 'optionalAccess', _363 => _363.videoFormat])));
       const size = format && enabled ? this.mediaService.resolveFrameInterpolationSize(format) : void 0;
       if (enabled && !await this.checkInterpolationSupport(size, token)) {
         token.ensureCurrent();
@@ -5325,9 +6899,9 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   notifyRemoteVideoStatistics() {
     try {
-      void Promise.resolve(_optionalChain([this, 'access', _180 => _180.remoteVideoStatisticsListener, 'optionalCall', _181 => _181(this.remoteVideoStatistics)])).catch(() => {
+      void Promise.resolve(_optionalChain([this, 'access', _364 => _364.remoteVideoStatisticsListener, 'optionalCall', _365 => _365(this.remoteVideoStatistics)])).catch(() => {
       });
-    } catch (e16) {
+    } catch (e20) {
     }
   }
   /**
@@ -5342,9 +6916,9 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   notifyNetworkStatistics() {
     try {
-      void Promise.resolve(_optionalChain([this, 'access', _182 => _182.networkStatisticsListener, 'optionalCall', _183 => _183(this.networkStatistics)])).catch(() => {
+      void Promise.resolve(_optionalChain([this, 'access', _366 => _366.networkStatisticsListener, 'optionalCall', _367 => _367(this.networkStatistics)])).catch(() => {
       });
-    } catch (e17) {
+    } catch (e21) {
     }
   }
   /**
@@ -5362,9 +6936,9 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   notifyLocalVideoStatistics() {
     try {
-      void Promise.resolve(_optionalChain([this, 'access', _184 => _184.localVideoStatisticsListener, 'optionalCall', _185 => _185(this.localVideoStatistics)])).catch(() => {
+      void Promise.resolve(_optionalChain([this, 'access', _368 => _368.localVideoStatisticsListener, 'optionalCall', _369 => _369(this.localVideoStatistics)])).catch(() => {
       });
-    } catch (e18) {
+    } catch (e22) {
     }
   }
   /**
@@ -5416,7 +6990,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    *
    * 将返回的轨道绑定到预览视图；收到有效帧且视图已绑定后进入 `ready`。
    *
-   * @param options.enableFrameValidation 是否在发布前检测帧亮度，默认 true；false 跳过检测及其等待。
+   * @param options.enableFrameValidation 是否在发布前等待相机预热（固定 200ms），默认 true；false 跳过等待。
    * @returns 包含本地相机视频轨道的媒体流。
    * @throws 模型不支持相机输入、配置无效、权限或采集启动失败时抛出错误。
    */
@@ -5434,15 +7008,25 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         token.ensureCurrent();
         const completeCamera = this.launchTimer.startCamera();
         this.clearVideoStatistics();
+        this.disposePermissionWatch();
+        const permissionWatch = await watchMediaPermissionPrompt(_nullishCoalesce(_optionalChain([options, 'optionalAccess', _370 => _370.useMicrophone]), () => ( false)));
+        if (permissionWatch) {
+          const completePermission = this.launchTimer.startPermission();
+          void permissionWatch.decided.then(() => completePermission()).catch(() => {
+          });
+          this.permissionWatchDispose = permissionWatch.dispose;
+        }
         let stream;
         try {
           token.ensureCurrent();
           stream = await this.cameraController.createLocalCameraStream(options);
         } catch (error) {
+          this.disposePermissionWatch();
           this.launchTimer.cancel();
           throw error;
         }
         token.ensureCurrent();
+        this.generationVideoFormat = _optionalChain([stream, 'access', _371 => _371.videoTrack, 'optionalAccess', _372 => _372.videoFormat]);
         completeCamera();
         this.cameraController.setPreviewReadyHandler((isCurrent) => {
           void this.coordinator.localPreviewDidBecomeReady(isCurrent);
@@ -5451,6 +7035,33 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       }
     );
   }
+  /**
+   * 移除媒体权限弹窗观察；授权决定已记录或不再需要观察时调用。
+   */
+  disposePermissionWatch() {
+    _optionalChain([this, 'access', _373 => _373.permissionWatchDispose, 'optionalCall', _374 => _374()]);
+    this.permissionWatchDispose = void 0;
+  }
+  /**
+   * 应用完整的上行视频格式，成功后更新本地轨道元数据，不改变生成格式或生命周期。
+   * 复用配置操作准入，避免与建连、切换摄像头或其他配置更新并发。
+   *
+   * @throws 无本地相机流、参数无效、操作冲突或底层编码更新失败时抛错。
+   */
+  async updateVideoFormat(videoFormat) {
+    await this.coordinator.run("configuration" /* configuration */, void 0, async (token) => {
+      const track = this.cameraController.currentTrack;
+      const previousFormat = _optionalChain([track, 'optionalAccess', _375 => _375.videoFormat]);
+      if (!track || !previousFormat) {
+        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Local camera stream is not started");
+      }
+      videoFormat.validate();
+      await this.streamController.setVideoEncoderConfig(videoFormat);
+      token.ensureCurrent();
+      _nullishCoalesce(this.generationVideoFormat, () => ( (this.generationVideoFormat = previousFormat)));
+      track.updateVideoFormat(videoFormat);
+    });
+  }
   /**
    * 停止本地相机流并释放本地预览与 RTC 资源。
    */
@@ -5461,8 +7072,10 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       async (token) => {
         this.launchTimer.cancel();
         this.clearVideoStatistics();
+        this.disposePermissionWatch();
         await this.cameraController.stopLocalCameraStream();
         token.ensureCurrent();
+        this.generationVideoFormat = void 0;
         await this.coordinator.commit(
           new RealtimeState({ connectionState: "Idle" /* idle */ }),
           token
@@ -5494,8 +7107,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    * 使用当前 Manager 创建的本地流建立实时连接。
    *
    * 创建实时会话、加入 RTC 房间并发布本地流，成功后启动会话心跳。
-   * 启用帧检测时，发布前并行检查相机亮度，首张合格帧即放行；2 秒内未通过检查则
-   * 记录警告并按当前画面继续发布，不因环境较暗而阻断连接。
+   * 启用帧检测时，发布前并行等待相机预热（固定 200ms），避免把黑帧推给 RTC。
    * 返回的远端媒体流在生成开始后承载远端生成画面。
    *
    * @param localStream 由 `createLocalCameraStream` 创建的本地媒体流。
@@ -5543,7 +7155,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
             "The local stream must be created and started by this realtime manager"
           );
         }
-        const videoFormat = localTrack.videoFormat;
+        const videoFormat = _nullishCoalesce(this.generationVideoFormat, () => ( localTrack.videoFormat));
         if (!videoFormat) {
           throw new XmaxError(
             "INVALID_CONFIGURATION" /* invalidConfiguration */,
@@ -5552,10 +7164,11 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         }
         const currentState = this.coordinator.currentState;
         if (currentState.connectionState === "Generating" /* generating */) {
-          this.generationManager.update(currentState.taskID, {
+          await this.generationManager.update(currentState.taskID, {
             videoFormat,
             context: options.context
           });
+          token.ensureCurrent();
           return this.connectionManager.makeRemoteStream();
         }
         const context = this.generationManager.validateContext(options.context);
@@ -5604,17 +7217,15 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       new RealtimeState({ connectionState: "Connecting" /* connecting */ }),
       token
     );
-    const exposureController = new AbortController();
-    const abortExposure = () => exposureController.abort();
-    token.signal.addEventListener("abort", abortExposure, { once: true });
-    if (token.signal.aborted) abortExposure();
+    const warmupController = new AbortController();
+    const abortWarmup = () => warmupController.abort();
+    token.signal.addEventListener("abort", abortWarmup, { once: true });
+    if (token.signal.aborted) abortWarmup();
     try {
       let beforePublish;
       if (this.cameraController.isFrameValidationEnabled) {
-        const completeFrameValidation = this.launchTimer.startFrameValidation();
-        const cameraReady = this.cameraController.waitForValidCameraFrame(exposureController.signal).then(() => {
+        const cameraReady = this.cameraController.waitForValidCameraFrame(warmupController.signal).then(() => {
           token.ensureCurrent();
-          completeFrameValidation();
         });
         void cameraReady.catch(() => {
         });
@@ -5622,6 +7233,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       }
       const remote = await this.connectionManager.connect({
         localTrack,
+        remoteVideoFormat: this.generationVideoFormat,
         model: this.options.model,
         includeLocalAudio: this.cameraController.useMicrophone,
         ensureCurrent: () => token.ensureCurrent(),
@@ -5639,8 +7251,8 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       );
       return remote;
     } finally {
-      token.signal.removeEventListener("abort", abortExposure);
-      abortExposure();
+      token.signal.removeEventListener("abort", abortWarmup);
+      abortWarmup();
     }
   }
   /**
@@ -5697,6 +7309,8 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     await this.generationManager.reset(taskID);
     const sessionID = await this.connectionManager.disconnect();
     if (scope === 1 /* all */) {
+      this.generationVideoFormat = void 0;
+      this.disposePermissionWatch();
       try {
         await this.cameraController.stopLocalCameraStream();
       } catch (error) {
@@ -5802,12 +7416,18 @@ var XmaxClient = class {
   }
   /**
    * 创建实时媒体 Manager。
+   * 模型专用地址优先于环境默认地址，并用于该 Manager 的整个会话生命周期。
    *
    * @param options 实时生成模型等业务配置。
    * @returns 可用于本地相机预览、实时连接与生成的实时 Manager。
    */
   createRealtimeManager(options) {
-    return new XmaxRealtimeManager(options, { apiService: this.apiService });
+    const baseURL = modelBaseURL(options.model);
+    const apiService = baseURL ? new ApiService({ apiKey: this.configuration.apiKey, baseURL }) : this.apiService;
+    return new XmaxRealtimeManager(options, {
+      apiService,
+      environment: this.configuration.environment
+    });
   }
   /**
    * 创建媒体处理与能力查询 Service。
@@ -5833,10 +7453,15 @@ var RealtimeConfiguration = class {
    * 创建实时业务配置。
    *
    * @param init.model 实时生成业务使用的模型。
+   * @param init.provider RTC 提供方，默认 TRTC；创建后不可切换。
    * @param init.isFrameInterpolationEnabled 是否默认开启远端生成画面的插帧。
    * @param init.frameInterpolation 插帧开关和显示帧率上限的详细配置。
    */
   constructor(init) {
+    /**
+     * RTC 配置
+     */
+    __publicField(this, "provider");
     /**
      * 模型配置
      */
@@ -5855,12 +7480,16 @@ var RealtimeConfiguration = class {
      * 已补全默认值的只读插帧配置。
      */
     __publicField(this, "frameInterpolation");
+    this.provider = _nullishCoalesce(init.provider, () => ( "trtc")) /* trtc */;
+    if (!Object.values(RtcProvider).includes(this.provider)) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Unsupported RTC provider");
+    }
     this.model = init.model;
-    const targetFrameRate = _nullishCoalesce(_optionalChain([init, 'access', _186 => _186.frameInterpolation, 'optionalAccess', _187 => _187.targetFrameRate]), () => ( 60));
+    const targetFrameRate = _nullishCoalesce(_optionalChain([init, 'access', _376 => _376.frameInterpolation, 'optionalAccess', _377 => _377.targetFrameRate]), () => ( 60));
     if (!Number.isFinite(targetFrameRate) || targetFrameRate < 1 || targetFrameRate > 60) {
       throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Interpolation targetFrameRate must be between 1 and 60");
     }
-    this.isFrameInterpolationEnabled = _nullishCoalesce(_nullishCoalesce(_optionalChain([init, 'access', _188 => _188.frameInterpolation, 'optionalAccess', _189 => _189.enabled]), () => ( init.isFrameInterpolationEnabled)), () => ( false));
+    this.isFrameInterpolationEnabled = _nullishCoalesce(_nullishCoalesce(_optionalChain([init, 'access', _378 => _378.frameInterpolation, 'optionalAccess', _379 => _379.enabled]), () => ( init.isFrameInterpolationEnabled)), () => ( false));
     this.frameInterpolation = Object.freeze({ enabled: this.isFrameInterpolationEnabled, targetFrameRate });
   }
 };
@@ -5890,7 +7519,7 @@ var RealtimeContext = class {
      */
     __publicField(this, "referencePath");
     this.prompt = init.prompt.trim();
-    const normalizedReferencePath = _optionalChain([init, 'access', _190 => _190.referencePath, 'optionalAccess', _191 => _191.trim, 'call', _192 => _192()]);
+    const normalizedReferencePath = _optionalChain([init, 'access', _380 => _380.referencePath, 'optionalAccess', _381 => _381.trim, 'call', _382 => _382()]);
     this.referencePath = normalizedReferencePath || void 0;
   }
 };
@@ -8017,11 +9646,11 @@ var _FrameInterpolationManager = class _FrameInterpolationManager {
     if (this.destroyed) return;
     this.destroyed = true;
     this.device.removeEventListener("uncapturederror", this.onGPUError);
-    _optionalChain([this, 'access', _193 => _193.runtime, 'optionalAccess', _194 => _194.destroy, 'call', _195 => _195()]);
+    _optionalChain([this, 'access', _383 => _383.runtime, 'optionalAccess', _384 => _384.destroy, 'call', _385 => _385()]);
     this.runtime = void 0;
     this.textures.forEach((texture) => texture.destroy());
     this.textures = [];
-    _optionalChain([this, 'access', _196 => _196.context, 'optionalAccess', _197 => _197.unconfigure, 'call', _198 => _198()]);
+    _optionalChain([this, 'access', _386 => _386.context, 'optionalAccess', _387 => _387.unconfigure, 'call', _388 => _388()]);
     this.device.destroy();
   }
 };
@@ -8200,7 +9829,7 @@ var RemoteVideoFramePipeline = class {
   setActive(active) {
     if (active === this.active) return;
     this.active = active;
-    _optionalChain([this, 'access', _199 => _199.options, 'access', _200 => _200.onActiveChange, 'optionalCall', _201 => _201(active)]);
+    _optionalChain([this, 'access', _389 => _389.options, 'access', _390 => _390.onActiveChange, 'optionalCall', _391 => _391(active)]);
   }
   resetTimeline() {
     this.generation++;
@@ -8231,7 +9860,7 @@ var RemoteVideoFramePipeline = class {
     this.callback = void 0;
     clearTimeout(this.initializationTimer);
     this.resetTimeline();
-    _optionalChain([this, 'access', _202 => _202.processor, 'optionalAccess', _203 => _203.destroy, 'call', _204 => _204()]);
+    _optionalChain([this, 'access', _392 => _392.processor, 'optionalAccess', _393 => _393.destroy, 'call', _394 => _394()]);
     this.processor = void 0;
   }
 };
@@ -8289,7 +9918,7 @@ var XmaxVideoView = class {
      * DOM 挂载状态
      */
     __publicField(this, "detached", false);
-    this.contentMode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _205 => _205.videoContentMode]), () => ( "fill")) /* fill */;
+    this.contentMode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _395 => _395.videoContentMode]), () => ( "fill")) /* fill */;
     this.element = document.createElement("div");
     this.element.style.position = "relative";
     this.element.style.overflow = "hidden";
@@ -8436,8 +10065,8 @@ var XmaxVideoView = class {
   stopInterpolation() {
     const pipeline = this.interpolationPipeline;
     this.interpolationPipeline = void 0;
-    _optionalChain([pipeline, 'optionalAccess', _206 => _206.stop, 'call', _207 => _207()]);
-    _optionalChain([this, 'access', _208 => _208.interpolationCanvas, 'optionalAccess', _209 => _209.remove, 'call', _210 => _210()]);
+    _optionalChain([pipeline, 'optionalAccess', _396 => _396.stop, 'call', _397 => _397()]);
+    _optionalChain([this, 'access', _398 => _398.interpolationCanvas, 'optionalAccess', _399 => _399.remove, 'call', _400 => _400()]);
     this.interpolationCanvas = void 0;
   }
   /**
@@ -8463,7 +10092,7 @@ var XmaxVideoView = class {
   detachCurrentTrack() {
     const track = this.currentTrack;
     if (track) {
-      _optionalChain([VideoRenderRegistry, 'access', _211 => _211.binding, 'call', _212 => _212(track), 'optionalAccess', _213 => _213.detachHandler, 'call', _214 => _214(this)]);
+      _optionalChain([VideoRenderRegistry, 'access', _401 => _401.binding, 'call', _402 => _402(track), 'optionalAccess', _403 => _403.detachHandler, 'call', _404 => _404(this)]);
     }
     this.setFrameInterpolation(void 0);
     this.cancelFrameDisplayNotification();
@@ -8483,8 +10112,8 @@ var XmaxVideoView = class {
       }
       this.hasNotifiedFrameDisplay = true;
       this.cancelFrameDisplayNotification();
-      _optionalChain([binding, 'optionalAccess', _215 => _215.frameDisplayHandler, 'optionalCall', _216 => _216()]);
-      _optionalChain([this, 'access', _217 => _217.frameDisplayHandler, 'optionalCall', _218 => _218()]);
+      _optionalChain([binding, 'optionalAccess', _405 => _405.frameDisplayHandler, 'optionalCall', _406 => _406()]);
+      _optionalChain([this, 'access', _407 => _407.frameDisplayHandler, 'optionalCall', _408 => _408()]);
     };
     if (typeof this.videoElement.requestVideoFrameCallback === "function") {
       this.videoFrameCallbackID = this.videoElement.requestVideoFrameCallback(notify);
@@ -8554,9 +10183,9 @@ var XmaxRealtimeVideoView = class {
     __publicField(this, "currentLocalTrack");
     __publicField(this, "currentRemoteTrack");
     __publicField(this, "contentMode");
-    this.contentMode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _219 => _219.videoContentMode]), () => ( "fill")) /* fill */;
-    this.currentLocalTrack = _optionalChain([options, 'optionalAccess', _220 => _220.localTrack]);
-    this.currentRemoteTrack = _optionalChain([options, 'optionalAccess', _221 => _221.remoteTrack]);
+    this.contentMode = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _409 => _409.videoContentMode]), () => ( "fill")) /* fill */;
+    this.currentLocalTrack = _optionalChain([options, 'optionalAccess', _410 => _410.localTrack]);
+    this.currentRemoteTrack = _optionalChain([options, 'optionalAccess', _411 => _411.remoteTrack]);
     this.element = document.createElement("div");
     this.element.style.position = "relative";
     this.element.style.overflow = "hidden";
@@ -8714,5 +10343,6 @@ var XmaxRealtimeVideoView = class {
 
 
 
-exports.XmaxEnvironment = XmaxEnvironment; exports.apiBaseURL = apiBaseURL; exports.XmaxLoggerOption = XmaxLoggerOption; exports.XmaxLogger = XmaxLogger; exports.XmaxErrorCode = XmaxErrorCode; exports.XmaxError = XmaxError; exports.RealtimeVideoEncoderPreference = RealtimeVideoEncoderPreference; exports.RealtimeVideoFormat = RealtimeVideoFormat; exports.RealtimeModel = RealtimeModel; exports.defaultFrameRate = defaultFrameRate; exports.defaultCameraVideoFormat = defaultCameraVideoFormat; exports.MediaService = MediaService; exports.StoredFile = StoredFile; exports.StorageService = StorageService; exports.CameraPosition = CameraPosition; exports.RealtimeVideoTrack = RealtimeVideoTrack; exports.RealtimeMediaStream = RealtimeMediaStream; exports.RealtimeConnectionState = RealtimeConnectionState; exports.RealtimeReason = RealtimeReason; exports.RealtimeState = RealtimeState; exports.XmaxConfiguration = XmaxConfiguration; exports.XmaxClient = XmaxClient; exports.RealtimeConfiguration = RealtimeConfiguration; exports.VideoContentMode = VideoContentMode; exports.RealtimeContext = RealtimeContext; exports.XmaxVideoView = XmaxVideoView; exports.XmaxRealtimeVideoView = XmaxRealtimeVideoView;
-//# sourceMappingURL=chunk-5NIEZJP5.cjs.map
+
+exports.XmaxEnvironment = XmaxEnvironment; exports.apiBaseURL = apiBaseURL; exports.XmaxLoggerOption = XmaxLoggerOption; exports.XmaxLogger = XmaxLogger; exports.XmaxErrorCode = XmaxErrorCode; exports.XmaxError = XmaxError; exports.RealtimeVideoEncoderPreference = RealtimeVideoEncoderPreference; exports.RealtimeVideoFormat = RealtimeVideoFormat; exports.RealtimeModel = RealtimeModel; exports.defaultFrameRate = defaultFrameRate; exports.defaultCameraVideoFormat = defaultCameraVideoFormat; exports.MediaService = MediaService; exports.StoredFile = StoredFile; exports.StorageService = StorageService; exports.CameraPosition = CameraPosition; exports.RtcProvider = RtcProvider; exports.RealtimeVideoTrack = RealtimeVideoTrack; exports.RealtimeMediaStream = RealtimeMediaStream; exports.RealtimeConnectionState = RealtimeConnectionState; exports.RealtimeReason = RealtimeReason; exports.RealtimeState = RealtimeState; exports.XmaxConfiguration = XmaxConfiguration; exports.XmaxClient = XmaxClient; exports.RealtimeConfiguration = RealtimeConfiguration; exports.VideoContentMode = VideoContentMode; exports.RealtimeContext = RealtimeContext; exports.XmaxVideoView = XmaxVideoView; exports.XmaxRealtimeVideoView = XmaxRealtimeVideoView;
+//# sourceMappingURL=chunk-FEL5MJMJ.cjs.map