@xmaxai/web-sdk 1.0.2 → 1.0.3

package/dist/{chunk-6RIEDVRQ.js → chunk-YMLRUDAO.js}

@@ -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.3";
 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),
+        ...options?.keepalive ? { keepalive: true } : {}
       }
     };
   }
@@ -1006,6 +1009,68 @@ var CameraPosition = /* @__PURE__ */ ((CameraPosition3) => {
   return CameraPosition3;
 })(CameraPosition || {});
 
+// src/Foundation/Permissions/MediaPermissionWatch.ts
+var PERMISSION_POLL_INTERVAL_MS = 100;
+async function watchMediaPermissionPrompt(includeMicrophone) {
+  if (typeof navigator === "undefined" || !navigator.permissions?.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 {
+        return "prompt";
+      }
+    })
+  );
+  let states;
+  try {
+    states = await queryOnce();
+  } catch {
+    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/RtcEngineManager.ts
 var RtcEngineLease = class {
   /**
@@ -1239,6 +1304,33 @@ var RtcStatsLogger = class {
   }
 };
 
+// src/Foundation/RTC/RtcVideoOrientation.ts
+function shouldTransposeRtcVideoSize(environment) {
+  const userAgent = environment?.userAgent ?? (typeof navigator === "undefined" ? "" : navigator.userAgent);
+  const maxTouchPoints = environment?.maxTouchPoints ?? (typeof navigator === "undefined" ? 0 : 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 = environment?.orientationType ?? (typeof window === "undefined" ? void 0 : window.screen?.orientation?.type);
+  if (orientationType !== void 0) {
+    return orientationType.includes("portrait");
+  }
+  const degrees = environment?.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/RemoteAudioVolumeControl.ts
+function canControlRemoteAudioVolume(environment) {
+  const userAgent = environment?.userAgent ?? (typeof navigator === "undefined" ? "" : navigator.userAgent);
+  const maxTouchPoints = environment?.maxTouchPoints ?? (typeof navigator === "undefined" ? 0 : navigator.maxTouchPoints ?? 0);
+  const ios = /iPhone|iPad|iPod/i.test(userAgent) || /Macintosh/i.test(userAgent) && maxTouchPoints > 1;
+  return !ios;
+}
+
 // src/Foundation/RTC/RtcManager.ts
 var RTC_EVENT = {
   remoteVideoAvailable: "remote-video-available",
@@ -1343,13 +1435,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
           }
@@ -1469,7 +1565,7 @@ var RtcManager = class {
   /**
    * 配置本地视频编码参数。
    *
-   * TRTC 只接受单一目标码率，以 `maximumBitrate` 作为目标码率；
+   * TRTC 只接受单一目标码率，以 `minimumBitrate`（流畅优先档）作为目标码率；
    * 编码策略偏好映射为 TRTC 弱网偏好。
    *
    * @throws 摄像头采集未启动或编码参数配置失败时抛出错误。
@@ -1483,13 +1579,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]
         }
@@ -1607,14 +1707,34 @@ var RtcManager = class {
       throw this.mapError(error);
     }
   }
+  /**
+   * 当前平台是否支持远端音量控制（iOS Safari/WKWebView 不支持）。
+   */
+  get supportsRemoteAudioVolumeControl() {
+    return canControlRemoteAudioVolume();
+  }
   /**
    * 设置指定远端用户的音频播放音量。
    *
+   * 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 (!canControlRemoteAudioVolume()) {
+      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);
   }
   /**
@@ -1766,74 +1886,25 @@ var RtcManager = class {
 };
 
 // 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;
-  }
-};
+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 +1915,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);
   });
 }
 
@@ -2144,13 +2152,13 @@ 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;
@@ -2160,7 +2168,7 @@ var _CameraController = class _CameraController {
     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 +2187,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 已有活动相机流、格式无效、权限不足或采集启动失败时抛出错误。
    */
@@ -2528,12 +2536,13 @@ var RealtimeSessionService = class _RealtimeSessionService {
     this.heartbeatVersion += 1;
   }
   /**
-   * 关闭指定实时会话。
+   * 关闭指定实时会话；请求带 keepalive，页面卸载后仍能发出。
    */
   async closeSession(sessionID) {
     try {
       await this.apiService.delete(
-        `/session/${sessionID}`
+        `/session/${sessionID}`,
+        { keepalive: true }
       );
     } catch (error) {
       throw XmaxError.from(error);
@@ -3993,14 +4002,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);
   }
   /**
@@ -4588,17 +4606,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());
   }
   /**
    * 开始等待远端显示首帧；完成回调同时记录首帧耗时和实际总耗时。
@@ -4674,7 +4700,8 @@ var XmaxRealtimeConnectionManager = class {
   }
   /**
    * 创建会话、配置编码、进房并发布本地媒体，启动心跳后返回远端占位流。
-   * 进房结束即记录连接耗时；可选 beforePublish 检查只阻塞发布，不计入连接耗时。
+   * 进房结束即记录连接耗时；可选 beforePublish 检查阻塞发布，计入连接耗时；
+   * 发布本地流单独计时。
    * @throws 会话、进房、发布失败或操作租约已失效时抛出错误，由上层统一清理。
    */
   async connect(options) {
@@ -4701,15 +4728,17 @@ var XmaxRealtimeConnectionManager = class {
     }
     await streamController.setVideoEncoderConfig(videoFormat);
     options.ensureCurrent();
+    let completePublish;
     await streamController.connect(connection, options.includeLocalAudio, () => {
       options.ensureCurrent();
     }, async () => {
-      options.ensureCurrent();
-      completeConnection();
       options.ensureCurrent();
       await options.beforePublish?.();
+      completeConnection();
+      completePublish = this.dependencies.timing.startPublish();
     });
     options.ensureCurrent();
+    completePublish?.();
     options.onPublished();
     sessionService.startHeartbeat(session.id, {
       onFailure: (sessionID, error) => {
@@ -5098,6 +5127,10 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
      */
     __publicField(this, "launchTimer", new RealtimeLaunchTimer());
     __publicField(this, "remoteFrameDisplayHandler");
+    /**
+     * 媒体权限弹窗观察
+     */
+    __publicField(this, "permissionWatchDispose");
     /**
      * 本地、远端和网络统计快照及观察者
      */
@@ -5416,7 +5449,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    *
    * 将返回的轨道绑定到预览视图；收到有效帧且视图已绑定后进入 `ready`。
    *
-   * @param options.enableFrameValidation 是否在发布前检测帧亮度，默认 true；false 跳过检测及其等待。
+   * @param options.enableFrameValidation 是否在发布前等待相机预热（固定 200ms），默认 true；false 跳过等待。
    * @returns 包含本地相机视频轨道的媒体流。
    * @throws 模型不支持相机输入、配置无效、权限或采集启动失败时抛出错误。
    */
@@ -5434,11 +5467,20 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         token.ensureCurrent();
         const completeCamera = this.launchTimer.startCamera();
         this.clearVideoStatistics();
+        this.disposePermissionWatch();
+        const permissionWatch = await watchMediaPermissionPrompt(options?.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;
         }
@@ -5451,6 +5493,13 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       }
     );
   }
+  /**
+   * 移除媒体权限弹窗观察；授权决定已记录或不再需要观察时调用。
+   */
+  disposePermissionWatch() {
+    this.permissionWatchDispose?.();
+    this.permissionWatchDispose = void 0;
+  }
   /**
    * 停止本地相机流并释放本地预览与 RTC 资源。
    */
@@ -5461,6 +5510,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       async (token) => {
         this.launchTimer.cancel();
         this.clearVideoStatistics();
+        this.disposePermissionWatch();
         await this.cameraController.stopLocalCameraStream();
         token.ensureCurrent();
         await this.coordinator.commit(
@@ -5494,8 +5544,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    * 使用当前 Manager 创建的本地流建立实时连接。
    *
    * 创建实时会话、加入 RTC 房间并发布本地流，成功后启动会话心跳。
-   * 启用帧检测时，发布前并行检查相机亮度，首张合格帧即放行；2 秒内未通过检查则
-   * 记录警告并按当前画面继续发布，不因环境较暗而阻断连接。
+   * 启用帧检测时，发布前并行等待相机预热（固定 200ms），避免把黑帧推给 RTC。
    * 返回的远端媒体流在生成开始后承载远端生成画面。
    *
    * @param localStream 由 `createLocalCameraStream` 创建的本地媒体流。
@@ -5604,17 +5653,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(() => {
         });
@@ -5639,8 +5686,8 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       );
       return remote;
     } finally {
-      token.signal.removeEventListener("abort", abortExposure);
-      abortExposure();
+      token.signal.removeEventListener("abort", abortWarmup);
+      abortWarmup();
     }
   }
   /**
@@ -5697,6 +5744,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     await this.generationManager.reset(taskID);
     const sessionID = await this.connectionManager.disconnect();
     if (scope === 1 /* all */) {
+      this.disposePermissionWatch();
       try {
         await this.cameraController.stopLocalCameraStream();
       } catch (error) {
@@ -8715,4 +8763,4 @@ export {
   XmaxVideoView,
   XmaxRealtimeVideoView
 };
-//# sourceMappingURL=chunk-6RIEDVRQ.js.map
+//# sourceMappingURL=chunk-YMLRUDAO.js.map