@xmaxai/web-sdk 1.0.8 → 1.0.10

package/dist/{chunk-JGDZ3RD3.js → chunk-LOYJFYQT.js}

@@ -1,6 +1,6 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import {
+  __publicField
+} from "./chunk-V6TY7KAL.js";
 
 // src/Foundation/Runtime/XmaxEnvironment.ts
 var XmaxEnvironment = /* @__PURE__ */ ((XmaxEnvironment3) => {
@@ -205,7 +205,7 @@ var XmaxError = class _XmaxError extends Error {
 };
 
 // src/Foundation/Runtime/RuntimeInfo.ts
-var XMAX_SDK_VERSION = "1.0.8";
+var XMAX_SDK_VERSION = "1.0.10";
 var _RuntimeInfo = class _RuntimeInfo {
   /**
    * 序列化为接口传输使用的 snake_case 字段。
@@ -501,7 +501,7 @@ var RealtimeVideoFormat = class _RealtimeVideoFormat {
    * @param init.width 视频宽度，单位为像素。
    * @param init.height 视频高度，单位为像素。
    * @param init.fps 视频帧率，必须大于 0。
-   * @param init.minimumBitrate 最低上传码率，单位为 kbps；缺省按最终上传尺寸和帧率计算。
+   * @param init.minimumBitrate 最低上传码率，单位为 kbps；缺省为 100，仅支持该参数的 RTC 链路生效。
    * @param init.maximumBitrate 最高上传码率，单位为 kbps；缺省按最终上传尺寸和帧率计算。
    * @param init.encoderPreference 上传编码策略偏好，默认值为 maintainFramerate。
    */
@@ -525,7 +525,7 @@ var RealtimeVideoFormat = class _RealtimeVideoFormat {
      * 上传编码配置
      */
     /**
-     * 最低上传码率，单位为 kbps；未指定时由 SDK 计算，0 表示不设最低码率。
+     * 最低上传码率，单位为 kbps；缺省为 100，0 表示不设最低码率；仅支持该参数的 RTC 链路生效。
      */
     __publicField(this, "minimumBitrate");
     /**
@@ -598,10 +598,8 @@ var RtcProvider = /* @__PURE__ */ ((RtcProvider2) => {
 
 // src/Service/Realtime/RealtimeModel.ts
 var RealtimeModel = /* @__PURE__ */ ((RealtimeModel2) => {
-  RealtimeModel2["x2_0"] = "x2.0";
-  RealtimeModel2["x2_0_trtc"] = "x2.0-trtc";
-  RealtimeModel2["x2_1_preview"] = "x2.1-preview";
-  RealtimeModel2["x2_1_preview_1014"] = "x2.1-preview-1014";
+  RealtimeModel2["x2_1_1_preview_cn"] = "x2.1.1-preview-cn";
+  RealtimeModel2["x2_1_1_preview_us"] = "x2.1.1-preview-us";
   return RealtimeModel2;
 })(RealtimeModel || {});
 function isKnownModel(model) {
@@ -611,38 +609,29 @@ function isKnownModel(model) {
   return Object.values(RealtimeModel).includes(model);
 }
 function modelDefaults(model) {
-  return isKnownModel(model) ? model : "x2.1-preview" /* x2_1_preview */;
+  return isKnownModel(model) ? model : "x2.1.1-preview-cn" /* x2_1_1_preview_cn */;
 }
 var MODEL_DISPLAY_NAMES = {
-  ["x2.0" /* x2_0 */]: "X2.0",
-  ["x2.0-trtc" /* x2_0_trtc */]: "X2.1-preview-trtc",
-  ["x2.1-preview" /* x2_1_preview */]: "X2.1-preview-agora",
-  ["x2.1-preview-1014" /* x2_1_preview_1014 */]: "X2.1-preview-1014"
+  ["x2.1.1-preview-cn" /* x2_1_1_preview_cn */]: "X2.1.1-preview-cn",
+  ["x2.1.1-preview-us" /* x2_1_1_preview_us */]: "X2.1.1-preview-us"
 };
 var MODEL_BASE_URLS = {
-  ["x2.1-preview" /* x2_1_preview */]: "https://cloud.xmax.22duck.cn/open/api/v1",
-  ["x2.1-preview-1014" /* x2_1_preview_1014 */]: "https://dev.xmaxai.com/open/api/v1"
+  ["x2.1.1-preview-cn" /* x2_1_1_preview_cn */]: "https://cloud.xmax.22duck.cn/open/api/v1",
+  ["x2.1.1-preview-us" /* x2_1_1_preview_us */]: "https://api.xmax.ai/open/api/v1"
 };
 var RESOLUTION_BUCKETS = {
-  ["x2.0" /* x2_0 */]: [],
-  ["x2.0-trtc" /* x2_0_trtc */]: [
+  ["x2.1.1-preview-cn" /* x2_1_1_preview_cn */]: [
     { width: 1024, height: 1920 },
     { width: 1920, height: 1024 }
   ],
-  ["x2.1-preview" /* x2_1_preview */]: [
-    { width: 1024, height: 1920 },
-    { width: 1920, height: 1024 }
-  ],
-  ["x2.1-preview-1014" /* x2_1_preview_1014 */]: [
+  ["x2.1.1-preview-us" /* x2_1_1_preview_us */]: [
     { width: 1024, height: 1920 },
     { width: 1920, height: 1024 }
   ]
 };
 var MAXIMUM_INPUT_PIXELS = {
-  ["x2.0" /* x2_0 */]: 128e4,
-  ["x2.0-trtc" /* x2_0_trtc */]: 21e5,
-  ["x2.1-preview" /* x2_1_preview */]: 21e5,
-  ["x2.1-preview-1014" /* x2_1_preview_1014 */]: 21e5
+  ["x2.1.1-preview-cn" /* x2_1_1_preview_cn */]: 21e5,
+  ["x2.1.1-preview-us" /* x2_1_1_preview_us */]: 21e5
 };
 function modelDisplayName(model) {
   return isKnownModel(model) ? MODEL_DISPLAY_NAMES[model] : model;
@@ -666,23 +655,19 @@ function defaultFrameRate(_model) {
   return 30;
 }
 function defaultCameraVideoFormat(model) {
-  if (modelDefaults(model) === "x2.0" /* x2_0 */) {
-    return new RealtimeVideoFormat({ width: 832, height: 1472, fps: 30 });
-  }
+  modelDefaults(model);
   return new RealtimeVideoFormat({ width: 1024, height: 1920, fps: 30 });
 }
 var MODEL_RTC_PROVIDERS = {
-  ["x2.0" /* x2_0 */]: Object.freeze(["vertc" /* vertc */]),
-  ["x2.0-trtc" /* x2_0_trtc */]: Object.freeze(["trtc" /* trtc */]),
-  ["x2.1-preview" /* x2_1_preview */]: Object.freeze(["agora" /* agora */]),
-  ["x2.1-preview-1014" /* x2_1_preview_1014 */]: Object.freeze(["agora" /* agora */])
+  ["x2.1.1-preview-cn" /* x2_1_1_preview_cn */]: Object.freeze(["agora" /* agora */]),
+  ["x2.1.1-preview-us" /* x2_1_1_preview_us */]: Object.freeze(["agora" /* agora */])
 };
 function supportedRtcProviders(model) {
   return isKnownModel(model) ? MODEL_RTC_PROVIDERS[model] : CUSTOM_MODEL_RTC_PROVIDERS;
 }
 var CUSTOM_MODEL_RTC_PROVIDERS = Object.freeze([
-  ...MODEL_RTC_PROVIDERS["x2.1-preview" /* x2_1_preview */],
-  ...Object.values(RtcProvider).filter((provider) => !MODEL_RTC_PROVIDERS["x2.1-preview" /* x2_1_preview */].includes(provider))
+  ...MODEL_RTC_PROVIDERS["x2.1.1-preview-cn" /* x2_1_1_preview_cn */],
+  ...Object.values(RtcProvider).filter((provider) => !MODEL_RTC_PROVIDERS["x2.1.1-preview-cn" /* x2_1_1_preview_cn */].includes(provider))
 ]);
 
 // src/Foundation/Media/Video/FrameInterpolationSupport.ts
@@ -704,9 +689,9 @@ var MediaService = class {
   /**
    * 创建媒体服务。
    *
-   * @param model 媒体输入规则使用的模型，默认为 `x2.0-trtc`。
+   * @param model 媒体输入规则使用的模型，默认为 `x2.1.1-preview-cn`。
    */
-  constructor(model = "x2.0-trtc" /* x2_0_trtc */) {
+  constructor(model = "x2.1.1-preview-cn" /* x2_1_1_preview_cn */) {
     /**
      * 模型约束
      */
@@ -2133,6 +2118,12 @@ var _AgoraRtcManager = class _AgoraRtcManager {
     if (volume > 0 && this.requestedAudio.has(String(user.uid))) track.play();
     else track.stop();
   }
+  /**
+   * 获取原始远端音轨，不依赖声网音频播放器是否处于播放状态。
+   */
+  getRemoteAudioTrack(userID) {
+    return this.client?.remoteUsers.find((user) => String(user.uid) === userID)?.audioTrack?.getMediaStreamTrack();
+  }
   /**
    * 按房间顺序发送消息，限制每秒包数与总字节；失败返回给原业务调用。
    */
@@ -3031,6 +3022,15 @@ var TrtcRtcManager = class {
   get supportsRemoteAudioVolumeControl() {
     return canControlTrtcRemoteAudioVolume();
   }
+  /**
+   * 获取原始远端音轨；不支持独立播放音量的平台暂不开放录制。
+   */
+  getRemoteAudioTrack(userID) {
+    if (!canControlTrtcRemoteAudioVolume()) {
+      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "TRTC recording cannot preserve remote audio while muted on this platform");
+    }
+    return this.requireEngine().getAudioTrack(userID) ?? void 0;
+  }
   /**
    * 设置指定远端用户的音频播放音量。
    *
@@ -3656,6 +3656,12 @@ var VeRtcManager = class {
     this.audioPlayers.set(userID, player);
     this.applyAudioVolume(userID);
   }
+  /**
+   * 获取原始远端音轨，独立于 audio 元素的静音和播放音量。
+   */
+  getRemoteAudioTrack(userID) {
+    return this.requireEngine().getRemoteStreamTrack(userID, this.sdk.StreamIndex.STREAM_INDEX_MAIN, "audio");
+  }
   setRemoteAudioVolume(volume, userID) {
     this.audioVolumes.set(userID, Number.isFinite(volume) ? Math.max(0, Math.min(100, Math.round(volume))) : 0);
     this.applyAudioVolume(userID);
@@ -3919,6 +3925,50 @@ function createRtcManager(provider, environment) {
   }
 }
 
+// src/Service/Realtime/RealtimeExtraParams.ts
+var RESERVED_PARAMS = /* @__PURE__ */ new Set([
+  "model",
+  "face_replace",
+  "size",
+  "target_size",
+  "prompt",
+  "ref_image_path",
+  "mirror",
+  "ref_video_path",
+  "sample_method",
+  "min_bitrate",
+  "max_bitrate"
+]);
+function snapshotExtraParams(params) {
+  if (params === void 0) return void 0;
+  const invalid2 = (message) => {
+    throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, message);
+  };
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return invalid2("extraParams must be a JSON object");
+  }
+  for (const key of Object.keys(params)) {
+    if (RESERVED_PARAMS.has(key)) return invalid2(`extraParams conflicts with SDK parameter: ${key}`);
+  }
+  const ancestors = /* @__PURE__ */ new Set();
+  const validate = (value) => {
+    if (value === null || typeof value === "string" || typeof value === "boolean") return;
+    if (typeof value === "number" && Number.isFinite(value)) return;
+    if (typeof value !== "object" || !value) return invalid2("extraParams must contain only JSON values");
+    if (ancestors.has(value)) return invalid2("extraParams must not contain circular references");
+    const prototype = Object.getPrototypeOf(value);
+    if (!Array.isArray(value) && prototype !== Object.prototype && prototype !== null) {
+      return invalid2("extraParams must contain only JSON objects and arrays");
+    }
+    if (Object.getOwnPropertySymbols(value).length) return invalid2("extraParams must not contain symbol keys");
+    ancestors.add(value);
+    for (const child of Array.isArray(value) ? value : Object.values(value)) validate(child);
+    ancestors.delete(value);
+  };
+  validate(params);
+  return JSON.parse(JSON.stringify(params));
+}
+
 // src/Foundation/Media/Camera/CameraFrameValidator.ts
 var CAMERA_WARMUP_MS = 200;
 function waitForValidCameraFrame(track, signal) {
@@ -4413,121 +4463,26 @@ var _CameraController = class _CameraController {
 __publicField(_CameraController, "localVideoTrackID", "video0");
 var CameraController = _CameraController;
 
-// src/Service/Realtime/RealtimeReferenceVideo.ts
-var RealtimeVideoSampleMethod = /* @__PURE__ */ ((RealtimeVideoSampleMethod2) => {
-  RealtimeVideoSampleMethod2["time"] = "time";
-  RealtimeVideoSampleMethod2["fps"] = "fps";
-  return RealtimeVideoSampleMethod2;
-})(RealtimeVideoSampleMethod || {});
-
-// src/Media/Video/NetworkVideoController.ts
-var NetworkVideoController = class {
-  constructor() {
-    /**
-     * 当前视频源与完成通知
-     */
-    __publicField(this, "currentTrack");
-    __publicField(this, "reference");
-    __publicField(this, "onFinish");
-    /**
-     * 预览进度与视图资源
-     */
-    __publicField(this, "position", 0);
-    __publicField(this, "ended", false);
-    __publicField(this, "bindings", /* @__PURE__ */ new Map());
-  }
-  /**
-   * 创建网络视频源，校验地址、采样方式和模型支持的尺寸；不请求视频下载。
-   */
-  create(options, mediaService) {
-    let url;
-    try {
-      url = new URL(options.url);
-    } catch {
-      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Network video requires an absolute HTTP or HTTPS URL");
-    }
-    if (!["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password) {
-      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Network video requires an HTTP or HTTPS URL without embedded credentials");
-    }
-    const sampleMethod = options.sampleMethod ?? "time" /* time */;
-    if (!Object.values(RealtimeVideoSampleMethod).includes(sampleMethod)) {
-      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Unsupported video sample method");
-    }
-    if (this.currentTrack) {
-      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current network video stream before creating another one");
-    }
-    options.videoFormat.validate();
-    const size = mediaService.resolveModelInputSize(options.videoFormat);
-    const track = new RealtimeVideoTrack({
-      id: "network-video",
-      videoFormat: options.videoFormat.resized(size.width, size.height)
-    });
-    this.currentTrack = track;
-    this.reference = Object.freeze({ path: options.url.trim(), sampleMethod });
-    this.onFinish = options.onFinish;
-    VideoRenderRegistry.register(track, {
-      attachHandler: (view) => this.attach(view),
-      detachHandler: (view) => this.detach(view)
-    });
-    return new RealtimeMediaStream({ id: "stream0" /* local */, videoTrack: track });
-  }
-  /**
-   * 释放全部预览绑定及源信息，不影响其他媒体源。
-   */
-  stop() {
-    for (const view of this.bindings.keys()) {
-      this.detach(view);
-    }
-    if (this.currentTrack) {
-      VideoRenderRegistry.unregister(this.currentTrack);
-    }
-    this.currentTrack = void 0;
-    this.reference = void 0;
-    this.onFinish = void 0;
-    this.position = 0;
-    this.ended = false;
-  }
-  /**
-   * 绑定播放器，恢复预览位置；本地播放错误仅记录，不中断服务端生成。
-   */
-  attach(view) {
-    if (!this.reference || !view.videoElement || !view.setVideoURL) {
-      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "This render target does not support network video preview");
-    }
-    this.detach(view);
-    const video = view.videoElement;
-    video.autoplay = !this.ended;
-    const restore = () => {
-      if (this.position > 0) {
-        video.currentTime = Math.min(this.position, Math.max(0, video.duration - 1e-3) || this.position);
-      }
-      if (this.ended) {
-        video.pause();
+// src/Media/LocalMediaVideoFormat.ts
+function resolveLocalMediaVideoFormat(format, mediaService) {
+  format.validate();
+  const buckets = resolutionBuckets(mediaService.model);
+  let target = buckets.find((size2) => size2.width === format.width && size2.height === format.height);
+  if (!target && buckets.length > 0) {
+    const ratio = format.width / format.height;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const bucket of buckets) {
+      const distance = Math.abs(Math.log(bucket.width / bucket.height / ratio));
+      const tied = Math.abs(distance - bestDistance) < 1e-9;
+      if (distance < bestDistance - 1e-9 || tied && bucket.width >= bucket.height && target && target.width < target.height) {
+        target = bucket;
+        bestDistance = distance;
       }
-    };
-    const fail = () => {
-      XmaxLogger.render.warning(() => "\u7F51\u7EDC\u89C6\u9891\u9884\u89C8\u5931\u8D25 (Network Video Preview Failed)");
-    };
-    video.addEventListener("loadedmetadata", restore);
-    video.addEventListener("error", fail);
-    this.bindings.set(view, () => {
-      this.position = video.currentTime;
-      this.ended = video.ended || this.ended;
-      video.removeEventListener("loadedmetadata", restore);
-      video.removeEventListener("error", fail);
-      view.setVideoURL?.(null);
-    });
-    view.isMirrored = false;
-    view.setVideoURL(this.reference.path);
-  }
-  /**
-   * 保存预览进度并释放该视图的地址和事件监听。
-   */
-  detach(view) {
-    this.bindings.get(view)?.();
-    this.bindings.delete(view);
+    }
   }
-};
+  const size = mediaService.resolveModelInputSize(target ?? format);
+  return format.resized(size.width, size.height);
+}
 
 // src/Media/Video/LocalVideoController.ts
 var LocalVideoController = class {
@@ -4571,7 +4526,7 @@ var LocalVideoController = class {
     if (!(options.file instanceof Blob) || options.file.size === 0) {
       throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Local video requires a non-empty File or Blob");
     }
-    const format = this.resolveVideoFormat(options.videoFormat, mediaService);
+    const format = resolveLocalMediaVideoFormat(options.videoFormat, mediaService);
     if (signal.aborted) {
       throw this.cancelled();
     }
@@ -4798,29 +4753,6 @@ var LocalVideoController = class {
     context.fillRect(0, 0, canvas.width, canvas.height);
     context.drawImage(video, (canvas.width - width) / 2, (canvas.height - height) / 2, width, height);
   }
-  /**
-   * 仅为本地文件选择最接近宽高比的模型档位；比例距离相同时优先横屏。
-   * 无固定档位时保留公共尺寸解析规则，帧率和显式编码配置不变。
-   */
-  resolveVideoFormat(format, mediaService) {
-    format.validate();
-    const buckets = resolutionBuckets(mediaService.model);
-    let target = buckets.find((size2) => size2.width === format.width && size2.height === format.height);
-    if (!target && buckets.length > 0) {
-      const ratio = format.width / format.height;
-      let bestDistance = Number.POSITIVE_INFINITY;
-      for (const bucket of buckets) {
-        const distance = Math.abs(Math.log(bucket.width / bucket.height / ratio));
-        const tied = Math.abs(distance - bestDistance) < 1e-9;
-        if (distance < bestDistance - 1e-9 || tied && bucket.width >= bucket.height && target && target.width < target.height) {
-          target = bucket;
-          bestDistance = distance;
-        }
-      }
-    }
-    const size = mediaService.resolveModelInputSize(target ?? format);
-    return format.resized(size.width, size.height);
-  }
   /**
    * 解码或绘制失败时停止媒体推进，并报告一次运行期错误。
    */
@@ -4842,61 +4774,1299 @@ var LocalVideoController = class {
   }
 };
 
-// src/Media/Video/ExternalVideoController.ts
-var ExternalVideoController = class {
-  constructor(onError) {
-    __publicField(this, "onError", onError);
-    __publicField(this, "track");
-    __publicField(this, "onEnded", () => {
-      this.onError(new XmaxError("MEDIA_ERROR" /* mediaError */, "External video source ended"));
-    });
-  }
-  get currentTrack() {
-    return this.track;
+// src/Service/Realtime/RealtimeReferenceVideo.ts
+var RealtimeVideoSampleMethod = /* @__PURE__ */ ((RealtimeVideoSampleMethod2) => {
+  RealtimeVideoSampleMethod2["time"] = "time";
+  RealtimeVideoSampleMethod2["fps"] = "fps";
+  return RealtimeVideoSampleMethod2;
+})(RealtimeVideoSampleMethod || {});
+
+// src/Media/Video/NetworkVideoController.ts
+var NetworkVideoController = class {
+  constructor() {
+    /**
+     * 当前视频源与完成通知
+     */
+    __publicField(this, "currentTrack");
+    __publicField(this, "reference");
+    __publicField(this, "onFinish");
+    /**
+     * 预览进度与视图资源
+     */
+    __publicField(this, "position", 0);
+    __publicField(this, "ended", false);
+    __publicField(this, "bindings", /* @__PURE__ */ new Map());
   }
+  /**
+   * 创建网络视频源，校验地址、采样方式和模型支持的尺寸；不请求视频下载。
+   */
   create(options, mediaService) {
-    if (this.track) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current external video first");
-    const { videoTrack, videoFormat } = options;
-    if (!videoTrack || videoTrack.kind !== "video" || videoTrack.readyState !== "live" || typeof videoTrack.clone !== "function") {
-      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "External video requires a live video MediaStreamTrack");
+    let url;
+    try {
+      url = new URL(options.url);
+    } catch {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Network video requires an absolute HTTP or HTTPS URL");
     }
-    videoFormat.validate();
-    const size = mediaService.resolveModelInputSize(videoFormat);
-    const format = videoFormat.resized(size.width, size.height);
-    const nativeTrack = videoTrack.clone();
-    if (nativeTrack.readyState !== "live") {
-      nativeTrack.stop();
-      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "External video source ended during setup");
+    if (!["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Network video requires an HTTP or HTTPS URL without embedded credentials");
     }
-    const track = new RealtimeVideoTrack({ id: "external-video", videoFormat: format });
-    track.mediaStreamTrack = nativeTrack;
-    nativeTrack.addEventListener("ended", this.onEnded);
-    this.track = track;
+    const sampleMethod = options.sampleMethod ?? "time" /* time */;
+    if (!Object.values(RealtimeVideoSampleMethod).includes(sampleMethod)) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Unsupported video sample method");
+    }
+    if (this.currentTrack) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current network video stream before creating another one");
+    }
+    options.videoFormat.validate();
+    const size = mediaService.resolveModelInputSize(options.videoFormat);
+    const track = new RealtimeVideoTrack({
+      id: "network-video",
+      videoFormat: options.videoFormat.resized(size.width, size.height)
+    });
+    this.currentTrack = track;
+    this.reference = Object.freeze({ path: options.url.trim(), sampleMethod });
+    this.onFinish = options.onFinish;
+    VideoRenderRegistry.register(track, {
+      attachHandler: (view) => this.attach(view),
+      detachHandler: (view) => this.detach(view)
+    });
     return new RealtimeMediaStream({ id: "stream0" /* local */, videoTrack: track });
   }
+  /**
+   * 释放全部预览绑定及源信息，不影响其他媒体源。
+   */
   stop() {
-    const nativeTrack = this.track?.mediaStreamTrack;
-    this.track = void 0;
-    nativeTrack?.removeEventListener("ended", this.onEnded);
-    nativeTrack?.stop();
+    for (const view of this.bindings.keys()) {
+      this.detach(view);
+    }
+    if (this.currentTrack) {
+      VideoRenderRegistry.unregister(this.currentTrack);
+    }
+    this.currentTrack = void 0;
+    this.reference = void 0;
+    this.onFinish = void 0;
+    this.position = 0;
+    this.ended = false;
   }
-};
-
-// src/Service/Realtime/RealtimeContext.ts
-var RealtimeContext = class {
   /**
-   * 创建实时生成条件并规范化文本和参考路径。
+   * 绑定播放器，恢复预览位置；本地播放错误仅记录，不中断服务端生成。
    */
-  constructor(init) {
-    /**
-     * 服务端直接读取的网络视频。
-     */
-    __publicField(this, "referenceVideo");
-    /**
-     * 生成条件
-     */
-    /**
-     * 实时生成使用的文本条件。
+  attach(view) {
+    if (!this.reference || !view.videoElement || !view.setVideoURL) {
+      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "This render target does not support network video preview");
+    }
+    this.detach(view);
+    const video = view.videoElement;
+    video.autoplay = !this.ended;
+    const restore = () => {
+      if (this.position > 0) {
+        video.currentTime = Math.min(this.position, Math.max(0, video.duration - 1e-3) || this.position);
+      }
+      if (this.ended) {
+        video.pause();
+      }
+    };
+    const fail = () => {
+      XmaxLogger.render.warning(() => "\u7F51\u7EDC\u89C6\u9891\u9884\u89C8\u5931\u8D25 (Network Video Preview Failed)");
+    };
+    video.addEventListener("loadedmetadata", restore);
+    video.addEventListener("error", fail);
+    this.bindings.set(view, () => {
+      this.position = video.currentTime;
+      this.ended = video.ended || this.ended;
+      video.removeEventListener("loadedmetadata", restore);
+      video.removeEventListener("error", fail);
+      view.setVideoURL?.(null);
+    });
+    view.isMirrored = false;
+    view.setVideoURL(this.reference.path);
+  }
+  /**
+   * 保存预览进度并释放该视图的地址和事件监听。
+   */
+  detach(view) {
+    this.bindings.get(view)?.();
+    this.bindings.delete(view);
+  }
+};
+
+// src/Media/Video/ExternalVideoController.ts
+var ExternalVideoController = class {
+  constructor(onError) {
+    __publicField(this, "onError", onError);
+    __publicField(this, "track");
+    __publicField(this, "onEnded", () => {
+      this.onError(new XmaxError("MEDIA_ERROR" /* mediaError */, "External video source ended"));
+    });
+  }
+  get currentTrack() {
+    return this.track;
+  }
+  create(options, mediaService) {
+    if (this.track) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current external video first");
+    const { videoTrack, videoFormat } = options;
+    if (!videoTrack || videoTrack.kind !== "video" || videoTrack.readyState !== "live" || typeof videoTrack.clone !== "function") {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "External video requires a live video MediaStreamTrack");
+    }
+    videoFormat.validate();
+    const size = mediaService.resolveModelInputSize(videoFormat);
+    const format = videoFormat.resized(size.width, size.height);
+    const nativeTrack = videoTrack.clone();
+    if (nativeTrack.readyState !== "live") {
+      nativeTrack.stop();
+      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "External video source ended during setup");
+    }
+    const track = new RealtimeVideoTrack({ id: "external-video", videoFormat: format });
+    track.mediaStreamTrack = nativeTrack;
+    nativeTrack.addEventListener("ended", this.onEnded);
+    this.track = track;
+    return new RealtimeMediaStream({ id: "stream0" /* local */, videoTrack: track });
+  }
+  stop() {
+    const nativeTrack = this.track?.mediaStreamTrack;
+    this.track = void 0;
+    nativeTrack?.removeEventListener("ended", this.onEnded);
+    nativeTrack?.stop();
+  }
+};
+
+// src/Media/Image/LocalImageController.ts
+var LocalImageController = class {
+  /**
+   * 注入运行期错误通知，不创建浏览器资源。
+   */
+  constructor(onError) {
+    __publicField(this, "onError", onError);
+    /**
+     * 当前图片源，包含尚未完成的解码操作。
+     */
+    __publicField(this, "source");
+  }
+  /**
+   * 是否持有正在准备或可用的图片源。
+   */
+  get isActive() {
+    return this.source !== void 0;
+  }
+  /**
+   * 已准备的本地图片视频轨。
+   */
+  get currentTrack() {
+    return this.source?.track;
+  }
+  /**
+   * 解码图片、准备静止画面并持续输出帧；取消或失败时释放本次资源。
+   */
+  async create(options, mediaService, signal) {
+    if (this.source) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current local image before creating another one");
+    }
+    if (!(options.file instanceof Blob) || options.file.size === 0) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Local image requires a non-empty File or Blob");
+    }
+    const format = resolveLocalMediaVideoFormat(options.videoFormat, mediaService);
+    if (signal.aborted) {
+      throw this.cancelled();
+    }
+    if (typeof document === "undefined") {
+      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Local image requires a browser");
+    }
+    const image = document.createElement("img");
+    const canvas = document.createElement("canvas");
+    const context = canvas.getContext("2d");
+    if (!context || typeof canvas.captureStream !== "function") {
+      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Canvas video capture is unavailable");
+    }
+    canvas.width = format.width;
+    canvas.height = format.height;
+    const source = {
+      image,
+      canvas,
+      url: URL.createObjectURL(options.file),
+      abort: new AbortController(),
+      targets: /* @__PURE__ */ new Set()
+    };
+    this.source = source;
+    try {
+      await this.load(source, signal);
+      if (signal.aborted || this.source !== source) {
+        throw this.cancelled();
+      }
+      if (!image.naturalWidth || !image.naturalHeight) {
+        throw new XmaxError("MEDIA_ERROR" /* mediaError */, "The image has no valid dimensions");
+      }
+      const scale = Math.min(canvas.width / image.naturalWidth, canvas.height / image.naturalHeight);
+      const width = image.naturalWidth * scale;
+      const height = image.naturalHeight * scale;
+      context.fillStyle = "black";
+      context.fillRect(0, 0, canvas.width, canvas.height);
+      context.drawImage(image, (canvas.width - width) / 2, (canvas.height - height) / 2, width, height);
+      source.stream = canvas.captureStream(format.fps);
+      const nativeTrack = source.stream.getVideoTracks()[0];
+      if (!nativeTrack || nativeTrack.readyState !== "live") {
+        throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Canvas did not provide a live video track");
+      }
+      const track = new RealtimeVideoTrack({ id: "local-image", videoFormat: format });
+      track.mediaStreamTrack = nativeTrack;
+      source.track = track;
+      const refresh = () => {
+        context.drawImage(canvas, 0, 0);
+        if (typeof nativeTrack.requestFrame === "function") {
+          nativeTrack.requestFrame();
+        }
+      };
+      refresh();
+      source.timer = setInterval(() => {
+        if (this.source !== source) {
+          return;
+        }
+        try {
+          refresh();
+        } catch {
+          this.handleError(source);
+        }
+      }, 1e3 / format.fps);
+      source.onEnded = () => this.handleError(source);
+      nativeTrack.addEventListener("ended", source.onEnded);
+      VideoRenderRegistry.register(track, {
+        attachHandler: (view) => {
+          if (this.source !== source) {
+            return;
+          }
+          view.isMirrored = false;
+          view.setMediaStream(source.stream);
+          source.targets.add(view);
+        },
+        detachHandler: (view) => {
+          source.targets.delete(view);
+          view.setMediaStream(null);
+        }
+      });
+      return new RealtimeMediaStream({ id: "stream0" /* local */, videoTrack: track });
+    } catch (error) {
+      if (this.source === source) {
+        this.stop();
+      }
+      throw XmaxError.from(error);
+    }
+  }
+  /**
+   * 取消解码、清空预览并释放视频轨、定时器和对象 URL。
+   */
+  stop() {
+    const source = this.source;
+    this.source = void 0;
+    if (!source) {
+      return;
+    }
+    source.abort.abort();
+    clearInterval(source.timer);
+    if (source.track) {
+      VideoRenderRegistry.unregister(source.track);
+      if (source.onEnded) {
+        source.track.mediaStreamTrack?.removeEventListener("ended", source.onEnded);
+      }
+      source.track.mediaStreamTrack = void 0;
+    }
+    for (const view of source.targets) {
+      try {
+        view.setMediaStream(null);
+      } catch {
+      }
+    }
+    source.targets.clear();
+    source.stream?.getTracks().forEach((track) => track.stop());
+    source.image.removeAttribute("src");
+    URL.revokeObjectURL(source.url);
+    source.canvas.width = 0;
+    source.canvas.height = 0;
+  }
+  /**
+   * 等待浏览器完成图片解码，支持主动停止、操作取消和超时。
+   */
+  load(source, signal) {
+    return new Promise((resolve, reject) => {
+      const finish = (error) => {
+        clearTimeout(timer);
+        source.image.removeEventListener("load", loaded);
+        source.image.removeEventListener("error", failed);
+        signal.removeEventListener("abort", aborted);
+        source.abort.signal.removeEventListener("abort", aborted);
+        if (error) {
+          reject(error);
+        } else {
+          resolve();
+        }
+      };
+      const loaded = () => finish();
+      const failed = () => finish(new XmaxError("MEDIA_ERROR" /* mediaError */, "The browser cannot decode this image file"));
+      const aborted = () => finish(this.cancelled());
+      const timer = setTimeout(() => finish(new XmaxError("TIMEOUT" /* timeout */, "Local image preparation timed out")), 1e4);
+      source.image.addEventListener("load", loaded, { once: true });
+      source.image.addEventListener("error", failed, { once: true });
+      signal.addEventListener("abort", aborted, { once: true });
+      source.abort.signal.addEventListener("abort", aborted, { once: true });
+      if (signal.aborted || source.abort.signal.aborted) {
+        aborted();
+      } else {
+        source.image.src = source.url;
+      }
+    });
+  }
+  /**
+   * 输出失效时停止刷新并仅报告一次，资源由业务生命周期统一释放。
+   */
+  handleError(source) {
+    if (this.source !== source || source.timer === void 0) {
+      return;
+    }
+    clearInterval(source.timer);
+    source.timer = void 0;
+    this.onError(new XmaxError("MEDIA_ERROR" /* mediaError */, "Local image video output failed"));
+  }
+  /**
+   * 构造统一的图片操作取消错误。
+   */
+  cancelled() {
+    return new XmaxError("CANCELLED" /* cancelled */, "Local image operation was cancelled");
+  }
+};
+
+// src/Foundation/Media/Video/VideoContentMode.ts
+var VideoContentMode = /* @__PURE__ */ ((VideoContentMode2) => {
+  VideoContentMode2["fit"] = "fit";
+  VideoContentMode2["fill"] = "fill";
+  return VideoContentMode2;
+})(VideoContentMode || {});
+
+// src/Service/Realtime/RealtimePoint.ts
+var RealtimePoint = class {
+  /**
+   * 创建模型输入像素坐标点。
+   *
+   * @param init.x 模型输入像素横坐标。
+   * @param init.y 模型输入像素纵坐标。
+   */
+  constructor(init) {
+    /**
+     * 坐标
+     */
+    /**
+     * 模型输入像素横坐标。
+     */
+    __publicField(this, "x");
+    /**
+     * 模型输入像素纵坐标。
+     */
+    __publicField(this, "y");
+    this.x = init.x;
+    this.y = init.y;
+  }
+};
+
+// src/Media/Interaction/InteractionCoordinateMapper.ts
+var InteractionCoordinateMapper = class {
+  /**
+   * 计算居中显示的视频矩形；fill 允许矩形超出视口，fit 留出黑边。
+   */
+  static displayedFrame(viewport, video, mode) {
+    if (![viewport.width, viewport.height, video.width, video.height].every((value) => Number.isFinite(value) && value > 0)) {
+      return void 0;
+    }
+    const scale = (mode === "fill" /* fill */ ? Math.max : Math.min)(viewport.width / video.width, viewport.height / video.height);
+    const width = video.width * scale;
+    const height = video.height * scale;
+    return { x: (viewport.width - width) / 2, y: (viewport.height - height) / 2, width, height };
+  }
+  /**
+   * 忽略黑边和无效点，撤销显示镜像后取整并限制在模型输入范围内。
+   */
+  static map(point, frame, video) {
+    const rect = this.displayedFrame(frame.viewportSize, video, frame.contentMode);
+    if (!rect || !Number.isFinite(point.x) || !Number.isFinite(point.y)) {
+      return void 0;
+    }
+    if (frame.contentMode === "fit" /* fit */ && (point.x < rect.x || point.x > rect.x + rect.width || point.y < rect.y || point.y > rect.y + rect.height)) {
+      return void 0;
+    }
+    const x = (point.x - rect.x) / rect.width;
+    const y = (point.y - rect.y) / rect.height;
+    return new RealtimePoint({
+      x: Math.min(video.width - 1, Math.max(0, Math.round((frame.mirrored ? 1 - x : x) * video.width))),
+      y: Math.min(video.height - 1, Math.max(0, Math.round(y * video.height)))
+    });
+  }
+};
+
+// src/Media/Interaction/InteractionController.ts
+var InteractionController = class {
+  /**
+   * 注入发送能力，不持有房间或具体 RTC。
+   */
+  constructor(listener) {
+    __publicField(this, "listener", listener);
+    /**
+     * 活动任务与待发送采样；上下文对象身份隔离任务切换。
+     */
+    __publicField(this, "active");
+    __publicField(this, "pending");
+    __publicField(this, "draining");
+  }
+  /**
+   * 激活或更新任务输入格式，清除旧采样。
+   */
+  startInteraction(taskID, videoFormat) {
+    this.stopInteraction();
+    if (taskID) {
+      this.active = { taskID, videoFormat };
+    }
+  }
+  /**
+   * 立即使交互上下文失效；已提交给 RTC 的消息无法撤回。
+   */
+  stopInteraction() {
+    this.active = void 0;
+    this.pending = void 0;
+    this.draining = void 0;
+  }
+  /**
+   * 同步转换数据，发送忙时用最新采样覆盖旧采样，避免弱网积压。
+   */
+  submitInteraction(frame) {
+    const context = this.active;
+    if (!context) {
+      return;
+    }
+    const points = frame.points.flatMap((point) => {
+      const mapped = InteractionCoordinateMapper.map(point, frame, context.videoFormat);
+      return mapped ? [mapped] : [];
+    });
+    if (!points.length) {
+      return;
+    }
+    this.pending = { context, points };
+    if (this.draining !== context) {
+      void this.drain(context);
+    }
+  }
+  /**
+   * 顺序发送；失败只丢弃当前帧，不终止生成或阻止后续交互。
+   */
+  async drain(context) {
+    this.draining = context;
+    try {
+      while (this.active === context && this.pending?.context === context) {
+        const { points } = this.pending;
+        this.pending = void 0;
+        try {
+          await this.listener(context.taskID, points);
+        } catch {
+          if (context === this.active) {
+            XmaxLogger.interaction.warning(() => "\u53D1\u9001\u4EA4\u4E92\u8F68\u8FF9\u5931\u8D25\uFF0C\u5DF2\u4E22\u5F03\u5F53\u524D\u91C7\u6837\u5E27 (Interaction Sample Dropped)");
+          }
+        }
+      }
+    } finally {
+      if (this.draining === context) {
+        this.draining = void 0;
+      }
+    }
+  }
+};
+
+// src/Media/MediaController.ts
+var MediaController = class {
+  /**
+   * 注入基础能力与错误、交互输出，不自行创建跨层业务组件。
+   */
+  constructor(dependencies) {
+    __publicField(this, "dependencies", dependencies);
+    /**
+     * 本地媒体与交互组件
+     */
+    __publicField(this, "camera");
+    __publicField(this, "video");
+    __publicField(this, "image");
+    __publicField(this, "network", new NetworkVideoController());
+    __publicField(this, "external");
+    __publicField(this, "interaction");
+    this.camera = dependencies.cameraController ?? new CameraController({
+      rtcManager: dependencies.rtcManager,
+      mediaService: dependencies.mediaService,
+      errorListener: dependencies.onCameraError
+    });
+    this.video = new LocalVideoController(dependencies.onVideoError);
+    this.image = new LocalImageController(dependencies.onImageError);
+    this.external = new ExternalVideoController(dependencies.onExternalError);
+    this.interaction = new InteractionController(dependencies.interactionListener);
+  }
+  /**
+   * 当前可发布的轨道。
+   */
+  get uplinkTrack() {
+    return this.external.currentTrack ?? this.video.currentTrack ?? this.image.currentTrack ?? this.camera.currentTrack;
+  }
+  /**
+   * 当前本地源轨道，包含无上行的网络视频。
+   */
+  get currentTrack() {
+    return this.uplinkTrack ?? this.network.currentTrack;
+  }
+  /**
+   * 从实际资源推导来源，不维护另一份媒体状态。
+   */
+  get source() {
+    if (this.external.currentTrack) {
+      return "externalVideo";
+    }
+    if (this.video.isActive) {
+      return "localVideo";
+    }
+    if (this.image.isActive) {
+      return "localImage";
+    }
+    if (this.network.currentTrack) {
+      return "networkVideo";
+    }
+    if (this.camera.currentTrack) {
+      return "camera";
+    }
+    return void 0;
+  }
+  /**
+   * 当前源需要发布的音频能力。
+   */
+  get hasAudio() {
+    return this.video.isActive ? !!this.video.audioTrack : this.source === "camera" && this.camera.useMicrophone;
+  }
+  /**
+   * 非相机源不等待相机预热。
+   */
+  get isFrameValidationEnabled() {
+    return this.source === "camera" && this.camera.isFrameValidationEnabled;
+  }
+  /**
+   * 网络视频的服务端读取参数。
+   */
+  get referenceVideo() {
+    return this.network.reference;
+  }
+  /**
+   * 网络视频完成回调。
+   */
+  get onNetworkVideoFinish() {
+    return this.network.onFinish;
+  }
+  /**
+   * 创建前拒绝覆盖活动源或尚未完成的文件准备。
+   */
+  ensureNoLocalSource() {
+    if (this.currentTrack || this.video.isActive || this.image.isActive) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current local stream before creating another one");
+    }
+  }
+  /**
+   * 保持现有外部轨道能力校验与错误语义。
+   */
+  validateExternalMediaSupport(kind) {
+    if (!this.dependencies.rtcManager.setExternalMediaTracks) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, `The RTC provider does not support ${kind} video streams`);
+    }
+  }
+  /**
+   * 创建相机流，由相机组件管理 RTC 和预览。
+   */
+  createLocalCameraStream(options) {
+    this.ensureNoLocalSource();
+    return this.camera.createLocalCameraStream(options);
+  }
+  /**
+   * 同步准备网络视频源；地址校验失败不初始化 RTC。
+   */
+  createNetworkVideoStream(options) {
+    this.ensureNoLocalSource();
+    return this.network.create(options, this.dependencies.mediaService);
+  }
+  /**
+   * 先解锁用户触发的播放，再由 prepareSource 初始化 RTC。
+   */
+  createLocalVideoStream(options, signal) {
+    this.ensureNoLocalSource();
+    return this.video.create(options, this.dependencies.mediaService, signal);
+  }
+  /**
+   * 解码本地图片并准备静止视频轨，不申请设备权限。
+   */
+  createLocalImageStream(options, signal) {
+    this.ensureNoLocalSource();
+    return this.image.create(options, this.dependencies.mediaService, signal);
+  }
+  /**
+   * 接管外部视频轨副本，不停止调用方原始轨道。
+   */
+  createExternalVideoStream(options) {
+    this.ensureNoLocalSource();
+    return this.external.create(options, this.dependencies.mediaService);
+  }
+  /**
+   * 初始化 RTC 并绑定非相机轨道；取消后不继续安装轨道。
+   */
+  async prepareSource(ensureCurrent) {
+    const rtc = this.dependencies.rtcManager;
+    await rtc.initialize();
+    ensureCurrent();
+    const track = this.external.currentTrack ?? this.video.currentTrack ?? this.image.currentTrack;
+    if (track?.mediaStreamTrack) {
+      await rtc.setExternalMediaTracks({ videoTrack: track.mediaStreamTrack, audioTrack: this.video.audioTrack });
+      ensureCurrent();
+    }
+  }
+  /**
+   * 设置相机预览就绪通知。
+   */
+  setCameraPreviewReadyHandler(handler) {
+    this.camera.setPreviewReadyHandler(handler);
+  }
+  /**
+   * 等待相机预热。
+   */
+  waitForValidCameraFrame(signal) {
+    return this.camera.waitForValidCameraFrame(signal);
+  }
+  /**
+   * 切换相机；外部采集不由 SDK 控制。
+   */
+  switchCamera() {
+    if (this.external.currentTrack) {
+      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "External video capture is managed by the caller");
+    }
+    return this.camera.switchCamera();
+  }
+  /**
+   * 停止相机资源。
+   */
+  stopLocalCameraStream() {
+    return this.camera.stopLocalCameraStream();
+  }
+  /**
+   * 生成开始后启动文件播放。
+   */
+  startLocalVideo(signal) {
+    return this.video.start(signal);
+  }
+  /**
+   * 断开时保留文件预览资源但暂停时间线。
+   */
+  pauseLocalVideo() {
+    this.video.pause();
+  }
+  /**
+   * 释放当前源，RTC 销毁失败也释放外部轨和解码器。
+   */
+  async stopLocalStream() {
+    this.stopInteraction();
+    const external = this.source !== void 0 && this.source !== "camera";
+    this.network.stop();
+    try {
+      if (external) {
+        await this.dependencies.rtcManager.destroy();
+      } else {
+        await this.camera.stopLocalCameraStream();
+      }
+    } finally {
+      this.external.stop();
+      if (this.image.isActive) {
+        this.image.stop();
+      }
+      if (this.video.isActive) {
+        await this.video.stop();
+      }
+    }
+  }
+  /**
+   * 使用生成格式启用交互，不读取弱网调档后的上行规格。
+   */
+  startInteraction(taskID, format) {
+    this.interaction.startInteraction(taskID, format);
+  }
+  /**
+   * 结束任务时立即清除待发采样。
+   */
+  stopInteraction() {
+    this.interaction.stopInteraction();
+  }
+  /**
+   * 接收渲染层快照并交给坐标与发送队列处理。
+   */
+  submitInteraction(frame) {
+    this.interaction.submitInteraction(frame);
+  }
+};
+
+// src/Service/Realtime/RealtimeRecordingEvent.ts
+var RealtimeRecordingEventType = /* @__PURE__ */ ((RealtimeRecordingEventType2) => {
+  RealtimeRecordingEventType2["completed"] = "completed";
+  RealtimeRecordingEventType2["interrupted"] = "interrupted";
+  RealtimeRecordingEventType2["failed"] = "failed";
+  return RealtimeRecordingEventType2;
+})(RealtimeRecordingEventType || {});
+var RealtimeRecordingFinishReason = /* @__PURE__ */ ((RealtimeRecordingFinishReason2) => {
+  RealtimeRecordingFinishReason2["durationLimit"] = "durationLimit";
+  RealtimeRecordingFinishReason2["generationEnded"] = "generationEnded";
+  RealtimeRecordingFinishReason2["restarted"] = "restarted";
+  RealtimeRecordingFinishReason2["mediaInterrupted"] = "mediaInterrupted";
+  return RealtimeRecordingFinishReason2;
+})(RealtimeRecordingFinishReason || {});
+
+// src/Media/Recording/RecordingController.ts
+var _RecordingController = class _RecordingController {
+  constructor() {
+    /**
+     * 任务资源与结果监听
+     */
+    __publicField(this, "session");
+    __publicField(this, "listener");
+  }
+  /**
+   * 设置统一结果监听器；传入 undefined 清除，不停止正在进行的录制。
+   */
+  setListener(listener) {
+    this.listener = listener;
+  }
+  /**
+   * 开始准备当前任务的录制；准备和录制失败只通过独立事件通知。
+   */
+  start(taskID, readTracks) {
+    if (this.session && !this.session.finished) {
+      void this.stop("restarted" /* restarted */);
+    }
+    try {
+      const tracks = readTracks();
+      if (!tracks || tracks.videoTrack.readyState === "ended") {
+        throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Remote video is unavailable for recording");
+      }
+      if (typeof MediaRecorder === "undefined" || typeof AudioContext === "undefined") {
+        throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Audio/video recording is not supported by this browser");
+      }
+      let resolve;
+      const completion = new Promise((done) => {
+        resolve = done;
+      });
+      const session = {
+        taskID,
+        readTracks,
+        videoTrack: tracks.videoTrack,
+        chunks: [],
+        bytes: 0,
+        hasAudio: false,
+        stopping: false,
+        finished: false,
+        reason: "durationLimit" /* durationLimit */,
+        completion,
+        resolve
+      };
+      this.session = session;
+      session.timer = setTimeout(() => {
+        this.fail(session, new XmaxError("TIMEOUT" /* timeout */, "Timed out preparing remote recording"));
+      }, _RecordingController.preparationTimeoutMs);
+      void this.prepare(session).catch((error) => this.fail(session, XmaxError.from(error)));
+    } catch (error) {
+      this.reportFailure(taskID, XmaxError.from(error));
+    }
+  }
+  /**
+   * 请求收尾并等待最终数据；重复停止共享完成结果，且绝不停止 RTC 原始轨道。
+   */
+  stop(reason) {
+    const session = this.session;
+    if (!session) {
+      return Promise.resolve();
+    }
+    this.stopSession(session, reason);
+    return session.completion;
+  }
+  /**
+   * 不支持的录制请求使用同一错误出口，不改变生成生命周期。
+   */
+  reportFailure(taskID, error) {
+    this.emit({ type: "failed" /* failed */, taskID, error });
+  }
+  /**
+   * 使用固定音频输出轨处理晚到的音频；不在 MediaRecorder 运行中增删轨道。
+   */
+  async prepare(session) {
+    const context = new AudioContext();
+    session.audioContext = context;
+    session.audioDestination = context.createMediaStreamDestination();
+    const silence = context.createConstantSource();
+    silence.offset.value = 0;
+    silence.connect(session.audioDestination);
+    silence.start();
+    session.silenceSource = silence;
+    await context.resume();
+    if (session.stopping || session.finished) {
+      return;
+    }
+    if (context.state !== "running") {
+      throw new XmaxError("MEDIA_ERROR" /* mediaError */, "Browser did not allow recording audio to start");
+    }
+    this.updateAudio(session);
+    const video = document.createElement("video");
+    session.video = video;
+    video.muted = true;
+    video.playsInline = true;
+    video.srcObject = new MediaStream([session.videoTrack]);
+    const ready = () => {
+      if (!session.stopping && !session.finished && video.readyState >= 2) {
+        this.beginRecording(session);
+      }
+    };
+    if (typeof video.requestVideoFrameCallback === "function") {
+      session.frameCallback = video.requestVideoFrameCallback(ready);
+    } else {
+      video.onloadeddata = ready;
+      video.onplaying = ready;
+    }
+    video.onerror = () => this.fail(session, new XmaxError("MEDIA_ERROR" /* mediaError */, "Cannot read remote recording video"));
+    try {
+      await video.play();
+    } catch (error) {
+      if (!session.recorder && !session.stopping && !session.finished) {
+        throw error;
+      }
+    }
+    if (typeof video.requestVideoFrameCallback !== "function") {
+      ready();
+    }
+  }
+  /**
+   * 首帧可用后启动单个音视频录制器，计时不包含连接和媒体准备阶段。
+   */
+  beginRecording(session) {
+    if (session.recorder || session.stopping || session.finished) {
+      return;
+    }
+    try {
+      session.hasAudio = false;
+      this.updateAudio(session);
+      const stream = new MediaStream([session.videoTrack, ...session.audioDestination.stream.getAudioTracks()]);
+      const mimeType = ["video/mp4;codecs=avc1,mp4a.40.2", "video/webm;codecs=vp8,opus", "video/mp4", "video/webm"].find((type) => MediaRecorder.isTypeSupported(type));
+      if (!mimeType) {
+        throw new XmaxError("MEDIA_ERROR" /* mediaError */, "No supported audio/video recording format");
+      }
+      const recorder = new MediaRecorder(stream, { mimeType, videoBitsPerSecond: 6e6, audioBitsPerSecond: 128e3 });
+      session.recorder = recorder;
+      recorder.ondataavailable = (event) => {
+        if (session.finished || session.error || !event.data.size) {
+          return;
+        }
+        if (session.bytes + event.data.size > _RecordingController.maximumBytes) {
+          this.fail(session, new XmaxError("MEDIA_ERROR" /* mediaError */, "Recording exceeded the memory limit"));
+          return;
+        }
+        session.chunks.push(event.data);
+        session.bytes += event.data.size;
+      };
+      recorder.onerror = () => {
+        this.fail(session, new XmaxError("MEDIA_ERROR" /* mediaError */, "Remote recording encoder failed"));
+      };
+      recorder.onstop = () => {
+        if (!session.stopping) {
+          session.reason = "mediaInterrupted" /* mediaInterrupted */;
+        }
+        this.finish(session);
+      };
+      recorder.start(1e3);
+      clearTimeout(session.timer);
+      session.timer = setTimeout(() => this.stopSession(session, "durationLimit" /* durationLimit */), _RecordingController.durationMs);
+      session.monitor = setInterval(() => {
+        try {
+          const tracks = session.readTracks();
+          if (!tracks || tracks.videoTrack !== session.videoTrack || session.videoTrack.readyState === "ended") {
+            this.stopSession(session, "mediaInterrupted" /* mediaInterrupted */);
+          } else if (session.audioContext?.state !== "running") {
+            this.fail(session, new XmaxError("MEDIA_ERROR" /* mediaError */, "Recording audio context was suspended"));
+          } else {
+            this.updateAudio(session);
+          }
+        } catch (error) {
+          this.fail(session, XmaxError.from(error));
+        }
+      }, 100);
+      this.releaseVideoProbe(session);
+    } catch (error) {
+      this.fail(session, XmaxError.from(error));
+    }
+  }
+  /**
+   * 轮询仅在录制期间运行；接入原始音频，不连接扬声器，不受播放音量影响。
+   */
+  updateAudio(session) {
+    const track = session.readTracks()?.audioTrack;
+    const liveTrack = track?.readyState === "live" ? track : void 0;
+    if (liveTrack !== session.audioTrack) {
+      session.audioSource?.disconnect();
+      session.audioSource = void 0;
+      session.audioTrack = liveTrack;
+      if (liveTrack) {
+        session.audioSource = session.audioContext.createMediaStreamSource(new MediaStream([liveTrack]));
+        session.audioSource.connect(session.audioDestination);
+      }
+    }
+    if (liveTrack && !liveTrack.muted && liveTrack.enabled) {
+      session.hasAudio = true;
+    }
+  }
+  /**
+   * 标记失败并尽力停止编码；任何错误都不能冒泡到实时生成。
+   */
+  fail(session, error) {
+    if (session.finished) {
+      return;
+    }
+    session.error ?? (session.error = error);
+    this.stopSession(session, "mediaInterrupted" /* mediaInterrupted */);
+  }
+  /**
+   * 保留最后一个 dataavailable，等待 stop 后再封装；异常路径有收尾超时保护。
+   */
+  stopSession(session, reason) {
+    if (session.stopping || session.finished) {
+      return;
+    }
+    session.stopping = true;
+    session.reason = reason;
+    clearTimeout(session.timer);
+    clearInterval(session.monitor);
+    this.releaseVideoProbe(session);
+    if (!session.recorder || session.recorder.state === "inactive") {
+      this.finish(session);
+      return;
+    }
+    session.finalizationTimer = setTimeout(() => {
+      session.error ?? (session.error = new XmaxError("TIMEOUT" /* timeout */, "Timed out finalizing remote recording"));
+      this.finish(session);
+    }, _RecordingController.finalizationTimeoutMs);
+    try {
+      session.recorder.stop();
+    } catch (error) {
+      session.error ?? (session.error = XmaxError.from(error));
+      this.finish(session);
+    }
+  }
+  /**
+   * 一次性交付结果并释放所有自有资源，不保留文件副本。
+   */
+  finish(session) {
+    if (session.finished) {
+      return;
+    }
+    session.finished = true;
+    clearTimeout(session.timer);
+    clearTimeout(session.finalizationTimer);
+    clearInterval(session.monitor);
+    this.releaseVideoProbe(session);
+    const blob = new Blob(session.chunks, { type: session.recorder?.mimeType ?? session.chunks[0]?.type });
+    session.chunks = [];
+    session.audioSource?.disconnect();
+    session.silenceSource?.stop();
+    session.silenceSource?.disconnect();
+    session.audioDestination?.stream.getTracks().forEach((track) => track.stop());
+    if (session.audioContext && session.audioContext.state !== "closed") {
+      void session.audioContext.close().catch(() => {
+      });
+    }
+    if (session.recorder) {
+      session.recorder.ondataavailable = null;
+      session.recorder.onerror = null;
+      session.recorder.onstop = null;
+    }
+    if (this.session === session) {
+      this.session = void 0;
+    }
+    if (session.error || !blob.size) {
+      this.reportFailure(session.taskID, session.error ?? new XmaxError("MEDIA_ERROR" /* mediaError */, "Recording ended without usable media"));
+    } else {
+      void this.deliverResult(session.taskID, blob, session.hasAudio, session.reason);
+    }
+    session.resolve();
+  }
+  /**
+   * 按需加载后处理，成功后回调；处理失败仍交付原文件，不丢失已完成的录像。
+   */
+  async deliverResult(taskID, original, hasAudio, reason) {
+    let blob = original;
+    try {
+      const { RecordingProcessor } = await import("./RecordingProcessor-ZSBJFF4J.js");
+      blob = await new RecordingProcessor().process(original);
+    } catch (error) {
+      XmaxLogger.realtime.warning(() => `Recording gap removal failed; keeping original clip: ${XmaxError.from(error).message}`);
+    }
+    this.emit({
+      type: reason === "durationLimit" /* durationLimit */ ? "completed" /* completed */ : "interrupted" /* interrupted */,
+      taskID,
+      result: { blob, hasAudio, reason }
+    });
+  }
+  /**
+   * 释放首帧探测元素；srcObject 原始轨道不调用 stop。
+   */
+  releaseVideoProbe(session) {
+    const video = session.video;
+    if (!video) {
+      return;
+    }
+    if (session.frameCallback !== void 0) {
+      video.cancelVideoFrameCallback(session.frameCallback);
+    }
+    video.onloadeddata = null;
+    video.onplaying = null;
+    video.onerror = null;
+    video.pause();
+    video.srcObject = null;
+    session.video = void 0;
+  }
+  /**
+   * 隔离接入方监听器异常，包括异步监听器的 Promise 拒绝。
+   */
+  emit(event) {
+    try {
+      void Promise.resolve(this.listener?.(event)).catch(() => {
+        XmaxLogger.realtime.warning(() => "Recording listener rejected");
+      });
+    } catch {
+      XmaxLogger.realtime.warning(() => "Recording listener threw an error");
+    }
+  }
+};
+/**
+ * 录制资源上限
+ */
+__publicField(_RecordingController, "durationMs", 2e4);
+__publicField(_RecordingController, "maximumBytes", 64 * 1024 * 1024);
+__publicField(_RecordingController, "preparationTimeoutMs", 1e4);
+__publicField(_RecordingController, "finalizationTimeoutMs", 5e3);
+var RecordingController = _RecordingController;
+
+// src/Render/Trajectory/TrajectoryBinding.ts
+var TrajectoryBinding = class {
+  /**
+   * 注入采样回调及模型输入格式，不引用 Media Controller 实例。
+   */
+  constructor(listener, format) {
+    __publicField(this, "listener", listener);
+    __publicField(this, "format", format);
+    /**
+     * 绑定视图与可用性
+     */
+    __publicField(this, "overlay");
+    __publicField(this, "enabled", false);
+    __publicField(this, "valid", true);
+  }
+  /**
+   * 一个远端绑定只由一个交互视图持有，迁移时取消旧视图的触点。
+   */
+  attach(overlay) {
+    if (!this.valid) {
+      return;
+    }
+    if (this.overlay !== overlay) {
+      this.overlay?.setBinding(void 0);
+    }
+    this.overlay = overlay;
+    overlay.setBinding(this, this.format, this.enabled);
+  }
+  /**
+   * 只解除当前所有者，旧视图迟到的 detach 不影响新视图。
+   */
+  detach(overlay) {
+    if (this.overlay === overlay) {
+      this.overlay = void 0;
+      overlay.setBinding(void 0);
+    }
+  }
+  /**
+   * 开始、更新或结束任务时同步交互能力，并取消旧手势。
+   */
+  update(enabled, format = this.format) {
+    this.enabled = enabled;
+    this.format = format;
+    this.overlay?.setBinding(this, format, enabled);
+  }
+  /**
+   * 转发当前视图采样；注销或停用后忽略。
+   */
+  submit(frame) {
+    if (this.valid && this.enabled) {
+      this.listener(frame);
+    }
+  }
+  /**
+   * 注销绑定并释放视图交互资源，不允许旧引用重新挂载。
+   */
+  invalidate() {
+    this.valid = false;
+    this.overlay?.setBinding(void 0);
+    this.overlay = void 0;
+  }
+};
+
+// src/Render/Trajectory/TrajectoryRegistry.ts
+var TrajectoryRegistry = class {
+  /**
+   * 替换绑定前先使旧绑定失效。
+   */
+  static register(track, binding) {
+    this.unregister(track);
+    this.bindings.set(track, binding);
+  }
+  /**
+   * 查询交互能力，本地轨道不注册该能力。
+   */
+  static binding(track) {
+    return this.bindings.get(track);
+  }
+  /**
+   * 主动清理视图资源，不能仅依赖 WeakMap 垃圾回收。
+   */
+  static unregister(track) {
+    this.bindings.get(track)?.invalidate();
+    this.bindings.delete(track);
+  }
+};
+__publicField(TrajectoryRegistry, "bindings", /* @__PURE__ */ new WeakMap());
+
+// src/Render/RenderController.ts
+var RenderController = class {
+  /**
+   * 注入显示生命周期通知，不持有 Core 对象。
+   */
+  constructor(callbacks = {}) {
+    __publicField(this, "callbacks", callbacks);
+    /**
+     * 当前轨道与唯一渲染目标
+     */
+    __publicField(this, "track");
+    __publicField(this, "target");
+    __publicField(this, "interactionEnabled", false);
+    __publicField(this, "ready", false);
+  }
+  /**
+   * 当前远端视图是否已完成渲染预热。
+   */
+  get isReady() {
+    return this.ready;
+  }
+  /**
+   * 新任务重新等待首帧和预热，避免复用上一次任务的展示就绪状态。
+   */
+  prepareForGeneration() {
+    this.ready = false;
+    this.target?.prepareForGeneration?.();
+  }
+  /**
+   * 注册新轨道并使旧绑定失效；本地轨道不经过该入口。
+   */
+  registerRemoteTrack(track, listener) {
+    this.resetRemoteTrack();
+    this.track = track;
+    if (track.videoFormat) {
+      TrajectoryRegistry.register(track, new TrajectoryBinding(listener, track.videoFormat));
+    }
+    VideoRenderRegistry.register(track, {
+      // 临时缓解生成开头卡顿：首帧后继续播放 1000 ms，再渐入。
+      renderWarmupMs: 1e3,
+      renderWarmupCompletedHandler: () => {
+        if (this.track === track) {
+          this.ready = true;
+          this.callbacks.onRenderWarmupCompleted?.();
+        }
+      },
+      frameDisplayHandler: () => {
+        if (this.track === track) {
+          this.callbacks.onFrameDisplayed?.();
+        }
+      },
+      attachHandler: (view) => {
+        if (this.track !== track) {
+          return;
+        }
+        this.target?.setFrameInterpolation?.(void 0);
+        this.ready = false;
+        view.isMirrored = false;
+        this.target = view;
+        this.callbacks.onAttached?.();
+        view.setMediaStream(track.mediaStreamTrack ? new MediaStream([track.mediaStreamTrack]) : null);
+      },
+      detachHandler: (view) => {
+        if (this.target === view) {
+          this.ready = false;
+          this.callbacks.onDetached?.();
+          this.target = void 0;
+        }
+        view.setFrameInterpolation?.(void 0);
+        view.setMediaStream(null);
+      }
+    });
+  }
+  /**
+   * 更新媒体画面；暂停显示时同时禁用交互。
+   */
+  setRemoteMedia(track) {
+    this.ready = false;
+    if (this.track) {
+      TrajectoryRegistry.binding(this.track)?.update(!!track && this.interactionEnabled);
+    }
+    this.target?.setMediaStream(track ? new MediaStream([track]) : null);
+  }
+  /**
+   * 转交插帧配置，不重建交互视图。
+   */
+  setFrameInterpolation(options) {
+    this.target?.setFrameInterpolation?.(options);
+  }
+  /**
+   * 更新交互绑定的输入格式和可用性。
+   */
+  setInteractionEnabled(enabled, format) {
+    this.interactionEnabled = enabled;
+    if (this.track) {
+      TrajectoryRegistry.binding(this.track)?.update(enabled, format);
+    }
+  }
+  /**
+   * 先使能力失效再清空画面，迟到首帧和旧手势不能恢复已结束任务。
+   */
+  resetRemoteTrack() {
+    this.ready = false;
+    const track = this.track;
+    this.track = void 0;
+    this.interactionEnabled = false;
+    if (track) {
+      TrajectoryRegistry.unregister(track);
+      VideoRenderRegistry.unregister(track);
+    }
+    this.target?.setFrameInterpolation?.(void 0);
+    this.target?.setMediaStream(null);
+    this.target = void 0;
+  }
+};
+
+// src/Service/Realtime/RealtimeContext.ts
+var RealtimeContext = class {
+  /**
+   * 创建实时生成条件并规范化文本和参考路径。
+   */
+  constructor(init) {
+    /**
+     * 服务端直接读取的网络视频。
+     */
+    __publicField(this, "referenceVideo");
+    /**
+     * 生成条件
+     */
+    /**
+     * 实时生成使用的文本条件。
      */
     __publicField(this, "prompt");
     /**
@@ -5326,6 +6496,7 @@ var RealtimeConnectionState = /* @__PURE__ */ ((RealtimeConnectionState2) => {
   RealtimeConnectionState2["ready"] = "Ready";
   RealtimeConnectionState2["connecting"] = "Connecting";
   RealtimeConnectionState2["connected"] = "Connected";
+  RealtimeConnectionState2["starting"] = "Starting";
   RealtimeConnectionState2["generating"] = "Generating";
   RealtimeConnectionState2["disconnecting"] = "Disconnecting";
   return RealtimeConnectionState2;
@@ -5425,12 +6596,26 @@ var RemoteStream = class {
 var RoomEvent = class _RoomEvent {
   /**
    * 生成开始信令。
+   *
+   * @param options.userID 业务用户标识。
+   * @param options.taskID 当前生成任务标识。
+   * @param options.videoFormat 模型生成使用的视频规格。
+   * @param options.context 本次生成条件。
+   * @param options.targetSize 回传尺寸，缺省时不发送；网络视频默认使用生成尺寸。
+   * @param options.minimumBitrate 服务端回传的最低码率，单位为 kbps。
+   * @param options.maximumBitrate 服务端回传的最高码率，单位为 kbps。
+   * @param options.mirror 是否由后端镜像输入画面，默认 false。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.extraParams 已校验的本次扩展参数，合并到 params。
+   * @returns 序列化后的 start 房间消息。
    */
   static start(options) {
     return _RoomEvent.encode({
       event: "start",
       params: {
         ..._RoomEvent.generationParameters(options),
+        min_bitrate: options.minimumBitrate,
+        max_bitrate: options.maximumBitrate,
         mirror: options.mirror ?? false,
         ...options.context.referenceVideo && {
           ref_video_path: options.context.referenceVideo.path,
@@ -5448,6 +6633,15 @@ var RoomEvent = class _RoomEvent {
   }
   /**
    * 生成条件变更信令。
+   *
+   * @param options.userID 业务用户标识。
+   * @param options.taskID 当前生成任务标识。
+   * @param options.videoFormat 模型生成使用的视频规格。
+   * @param options.context 本次生成条件。
+   * @param options.targetSize 回传尺寸，缺省时不发送。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.extraParams 已校验的本次扩展参数，合并到 params。
+   * @returns 序列化后的 change_condition 房间消息。
    */
   static changeCondition(options) {
     return _RoomEvent.encode({
@@ -5458,12 +6652,14 @@ var RoomEvent = class _RoomEvent {
     });
   }
   /**
-   * 回传尺寸调整信令。
+   * 回传尺寸和码率范围调整信令，码率单位为 kbps。
    */
   static changeTargetSize(options) {
     return _RoomEvent.encode({
       event: "change_target_size",
       params: {
+        min_bitrate: options.minimumBitrate,
+        max_bitrate: options.maximumBitrate,
         target_size: [
           Math.round(options.targetSize.width),
           Math.round(options.targetSize.height)
@@ -5504,7 +6700,10 @@ var RoomEvent = class _RoomEvent {
     });
   }
   /**
-   * 生成条件参数：模型、生成尺寸、回传尺寸、文本与参考图路径。
+   * 组装生成条件参数，包含人脸回贴配置及本次扩展参数。
+   *
+   * @param options 本次生成条件类信令的参数。
+   * @returns start 与 change_condition 共用的 params 字段。
    */
   static generationParameters(options) {
     return {
@@ -5516,7 +6715,8 @@ var RoomEvent = class _RoomEvent {
         Math.round(options.targetSize.height)
       ] : void 0,
       prompt: options.context.prompt,
-      ref_image_path: options.context.referencePath
+      ref_image_path: options.context.referencePath,
+      ...options.extraParams
     };
   }
   /**
@@ -5534,6 +6734,114 @@ var RoomEvent = class _RoomEvent {
   }
 };
 
+// src/Stream/Encoding/EncodingBitratePolicy.ts
+var _EncodingBitratePolicy = class _EncodingBitratePolicy {
+  /**
+   * 最低码率固定为 100 kbps，最高码率按尺寸和帧率计算并应用预算系数。
+   */
+  static resolve(width, height, fps) {
+    new RealtimeVideoFormat({ width, height, fps }).validate();
+    const maximum = Math.round(
+      this.resolveMaximumBitrate(width * height, fps) * this.bitrateScale
+    );
+    if (!Number.isSafeInteger(maximum)) {
+      throw new XmaxError(
+        "INVALID_CONFIGURATION" /* invalidConfiguration */,
+        "Realtime video format exceeds the supported bitrate range"
+      );
+    }
+    return { minimum: 100, maximum: Math.max(100, maximum) };
+  }
+  /**
+   * 按像素面积和帧率插值计算最高码率参考值。
+   */
+  static resolveMaximumBitrate(pixels, fps) {
+    const bitrate15 = _EncodingBitratePolicy.interpolate(
+      pixels,
+      _EncodingBitratePolicy.referenceBitratesAt15FPS
+    );
+    const first30 = _EncodingBitratePolicy.referenceBitratesAt30FPS[0];
+    let bitrate30;
+    if (pixels < first30.value) {
+      const reference15 = _EncodingBitratePolicy.interpolate(
+        first30.value,
+        _EncodingBitratePolicy.referenceBitratesAt15FPS
+      );
+      bitrate30 = bitrate15 * (first30.bitrate / reference15);
+    } else {
+      bitrate30 = _EncodingBitratePolicy.interpolate(
+        pixels,
+        _EncodingBitratePolicy.referenceBitratesAt30FPS
+      );
+    }
+    const bitrate10 = bitrate15 * (400 / 500);
+    const maximum60 = bitrate30 * (6500 / 3150);
+    return _EncodingBitratePolicy.interpolate(fps, [
+      { value: 10, bitrate: bitrate10 * 2 },
+      { value: 15, bitrate: bitrate15 * 2 },
+      { value: 30, bitrate: bitrate30 * 2 },
+      { value: 60, bitrate: maximum60 }
+    ]);
+  }
+  /**
+   * 在相邻参考点间线性插值，表外按最近端点的比例外推。
+   */
+  static interpolate(value, points) {
+    const first = points[0];
+    if (value <= first.value) {
+      return first.bitrate * (value / first.value);
+    }
+    for (let index = 1; index < points.length; index += 1) {
+      const upper = points[index];
+      if (value <= upper.value) {
+        const lower = points[index - 1];
+        const ratio = (value - lower.value) / (upper.value - lower.value);
+        return lower.bitrate + (upper.bitrate - lower.bitrate) * ratio;
+      }
+    }
+    const last = points[points.length - 1];
+    return last.bitrate * (value / last.value);
+  }
+};
+/**
+ * 最高码率相对参考值的预算系数。
+ */
+__publicField(_EncodingBitratePolicy, "bitrateScale", 0.6);
+/**
+ * 流畅优先码率参考，按像素面积升序排列，单位为 kbps。
+ */
+__publicField(_EncodingBitratePolicy, "referenceBitratesAt15FPS", [
+  { value: 120 * 120, bitrate: 50 },
+  { value: 160 * 120, bitrate: 65 },
+  { value: 180 * 180, bitrate: 100 },
+  { value: 240 * 180, bitrate: 120 },
+  { value: 320 * 180, bitrate: 140 },
+  { value: 320 * 240, bitrate: 200 },
+  { value: 424 * 240, bitrate: 220 },
+  { value: 360 * 360, bitrate: 260 },
+  { value: 480 * 360, bitrate: 320 },
+  { value: 640 * 360, bitrate: 400 },
+  { value: 640 * 480, bitrate: 500 },
+  { value: 848 * 480, bitrate: 610 },
+  { value: 960 * 720, bitrate: 910 },
+  { value: 1280 * 720, bitrate: 1130 },
+  { value: 1920 * 1080, bitrate: 2080 }
+]);
+/**
+ * 30 fps 的像素面积与码率参考点，单位为 kbps。
+ */
+__publicField(_EncodingBitratePolicy, "referenceBitratesAt30FPS", [
+  { value: 360 * 360, bitrate: 400 },
+  { value: 480 * 360, bitrate: 490 },
+  { value: 640 * 360, bitrate: 600 },
+  { value: 640 * 480, bitrate: 750 },
+  { value: 848 * 480, bitrate: 930 },
+  { value: 960 * 720, bitrate: 1380 },
+  { value: 1280 * 720, bitrate: 1710 },
+  { value: 1920 * 1080, bitrate: 3150 }
+]);
+var EncodingBitratePolicy = _EncodingBitratePolicy;
+
 // src/Stream/Room/RoomHeartbeat.ts
 var RoomHeartbeat = class {
   /**
@@ -5824,7 +7132,7 @@ var RoomController = class {
    *
    * @throws 已有房间未离开、操作失效或进房失败时抛出错误。
    */
-  async join(connection, ensureActive2) {
+  async join(connection, ensureActive2, measureRtcJoin) {
     try {
       ensureActive2();
     } catch (error) {
@@ -5843,11 +7151,14 @@ var RoomController = class {
       if (!this.customCodec) this.codec = new RoomMessageCodec(
         connection.provider === "vertc" /* vertc */ ? null : connection.provider === "agora" /* agora */ ? "__agora_chunk__" : "__trtc_chunk__"
       );
-      await this.rtcManager.joinRoom(toRoomJoinConfiguration(connection));
+      const configuration = toRoomJoinConfiguration(connection);
+      const completeRtcJoin = measureRtcJoin?.();
+      await this.rtcManager.joinRoom(configuration);
       ensureActive2();
       if (this.state.kind !== "joining" || this.state.operationID !== operationID || this.leaveOperation) {
         throw new XmaxError("CANCELLED" /* cancelled */, "RTC room join was cancelled");
       }
+      completeRtcJoin?.();
       this.state = { kind: "joined", userID: connection.userID };
       this.heartbeat.start(connection.userID);
     } catch (error) {
@@ -5880,46 +7191,51 @@ var RoomController = class {
   /**
    * 发送生成开始信令。
    *
-   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
-   * @param options.mirror 是否由后端镜像输入画面，默认 false。
    * @param options.taskID 当前生成任务标识。
    * @param options.videoFormat 模型生成使用的视频规格。
-   * @param options.targetSize 服务端生成后的回传尺寸，缺省使用生成尺寸。
    * @param options.context 本次生成条件。
+   * @param options.targetSize 回传尺寸，缺省时不发送；网络视频默认使用生成尺寸。
+   * @param options.mirror 是否由后端镜像输入画面，默认 false。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.extraParams 合并到本次 start 的 params，不缓存。
    * @throws 房间未就绪或信令发送失败时抛出错误。
    */
   startGeneration(options) {
     return this.send(
       RoomEvent.start({
-        mirror: options.mirror ?? false,
-        faceRestoration: options.faceRestoration ?? false,
         userID: this.requireUserID(),
         taskID: options.taskID,
         videoFormat: options.videoFormat,
+        context: options.context,
         targetSize: options.targetSize,
-        context: options.context
+        mirror: options.mirror ?? false,
+        faceRestoration: options.faceRestoration ?? false,
+        extraParams: options.extraParams,
+        ...this.downlinkBitrates(options.targetSize ?? options.videoFormat)
       })
     );
   }
   /**
    * 发送生成条件变更信令。
    *
-   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
    * @param options.taskID 当前生成任务标识。
    * @param options.videoFormat 模型生成使用的视频规格。
-   * @param options.targetSize 服务端生成后的回传尺寸。
    * @param options.context 本次生成条件。
+   * @param options.targetSize 服务端生成后的回传尺寸，缺省时不发送。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.extraParams 合并到本次 change_condition 的 params，不缓存。
    * @throws 房间未就绪或信令发送失败时抛出错误。
    */
   changeGenerationCondition(options) {
     return this.send(
       RoomEvent.changeCondition({
-        faceRestoration: options.faceRestoration ?? false,
         userID: this.requireUserID(),
         taskID: options.taskID,
         videoFormat: options.videoFormat,
+        context: options.context,
         targetSize: options.targetSize,
-        context: options.context
+        faceRestoration: options.faceRestoration ?? false,
+        extraParams: options.extraParams
       })
     );
   }
@@ -5934,10 +7250,23 @@ var RoomController = class {
       RoomEvent.changeTargetSize({
         userID: this.requireUserID(),
         taskID: options.taskID,
-        targetSize: options.targetSize
+        targetSize: options.targetSize,
+        ...this.downlinkBitrates(options.targetSize)
       })
     );
   }
+  /**
+   * 按回传尺寸和 24 fps 估算下行码率，最高值限制在 100～10000 kbps。
+   * 估算不设置服务端帧率，也不沿用显式上传码率。
+   */
+  downlinkBitrates(size) {
+    const { maximum } = EncodingBitratePolicy.resolve(
+      Math.round(size.width),
+      Math.round(size.height),
+      24
+    );
+    return { minimumBitrate: 100, maximumBitrate: Math.min(1e4, maximum) };
+  }
   /**
    * 尝试发送生成停止信令；未进房或任务标识为空时忽略。
    */
@@ -6039,7 +7368,7 @@ var ENCODER_PREFERENCE_MAP = {
   ["maintainFramerate" /* maintainFramerate */]: "maintainFramerate" /* maintainFramerate */,
   ["maintainQuality" /* maintainQuality */]: "maintainQuality" /* maintainQuality */
 };
-var _EncodingController = class _EncodingController {
+var EncodingController = class {
   /**
    * 创建编码控制器。
    *
@@ -6064,21 +7393,13 @@ var _EncodingController = class _EncodingController {
       minimum = videoFormat.minimumBitrate;
       maximum = videoFormat.maximumBitrate;
     } else {
-      const bitrates = _EncodingController.resolveBitrates(
-        videoFormat.width * videoFormat.height,
+      const defaults = EncodingBitratePolicy.resolve(
+        videoFormat.width,
+        videoFormat.height,
         videoFormat.fps
       );
-      const maximumBitrate = Math.round(bitrates.maximum);
-      if (!Number.isFinite(maximumBitrate)) {
-        throw new XmaxError(
-          "INVALID_CONFIGURATION" /* invalidConfiguration */,
-          "Realtime video format exceeds the supported bitrate range"
-        );
-      }
-      const defaultMinimum = Math.max(1, Math.round(bitrates.minimum));
-      const defaultMaximum = Math.max(defaultMinimum + 1, maximumBitrate);
-      minimum = videoFormat.minimumBitrate ?? defaultMinimum;
-      maximum = videoFormat.maximumBitrate ?? defaultMaximum;
+      minimum = videoFormat.minimumBitrate ?? defaults.minimum;
+      maximum = videoFormat.maximumBitrate ?? defaults.maximum;
     }
     if (minimum > maximum) {
       throw new XmaxError(
@@ -6103,113 +7424,23 @@ var _EncodingController = class _EncodingController {
     if (!previous) {
       throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Apply an encoder configuration before updating frame rate");
     }
-    const format = new RealtimeVideoFormat({
-      width: previous.width,
-      height: previous.height,
-      fps,
-      minimumBitrate: previous.minimumBitrate,
-      maximumBitrate: previous.maximumBitrate,
-      encoderPreference: previous.encoderPreference === "maintainFramerate" /* maintainFramerate */ ? "maintainFramerate" /* maintainFramerate */ : "maintainQuality" /* maintainQuality */
-    });
-    format.validate();
-    if (fps !== previous.frameRate) {
-      const next = { ...previous, frameRate: fps };
-      await this.rtcManager.configureVideoEncoding(next);
-      this.lastAppliedConfiguration = next;
-    }
-    return format;
-  }
-  /**
-   * 按像素面积与帧率计算码率区间（kbps）：流畅优先为最低，画质优先为最高。
-   */
-  static resolveBitrates(pixels, fps) {
-    const bitrate15 = _EncodingController.interpolate(
-      pixels,
-      _EncodingController.referenceBitratesAt15FPS
-    );
-    const first30 = _EncodingController.referenceBitratesAt30FPS[0];
-    let bitrate30;
-    if (pixels < first30.value) {
-      const reference15 = _EncodingController.interpolate(
-        first30.value,
-        _EncodingController.referenceBitratesAt15FPS
-      );
-      bitrate30 = bitrate15 * (first30.bitrate / reference15);
-    } else {
-      bitrate30 = _EncodingController.interpolate(
-        pixels,
-        _EncodingController.referenceBitratesAt30FPS
-      );
-    }
-    const bitrate10 = bitrate15 * (400 / 500);
-    const minimum60 = bitrate30 * (4780 / 3150);
-    const maximum60 = bitrate30 * (6500 / 3150);
-    return {
-      minimum: _EncodingController.interpolate(fps, [
-        { value: 10, bitrate: bitrate10 },
-        { value: 15, bitrate: bitrate15 },
-        { value: 30, bitrate: bitrate30 },
-        { value: 60, bitrate: minimum60 }
-      ]),
-      maximum: _EncodingController.interpolate(fps, [
-        { value: 10, bitrate: bitrate10 * 2 },
-        { value: 15, bitrate: bitrate15 * 2 },
-        { value: 30, bitrate: bitrate30 * 2 },
-        { value: 60, bitrate: maximum60 }
-      ])
-    };
-  }
-  /**
-   * 在相邻参考点间线性插值，表外按最近端点的比例外推。
-   */
-  static interpolate(value, points) {
-    const first = points[0];
-    if (value <= first.value) {
-      return first.bitrate * (value / first.value);
-    }
-    for (let index = 1; index < points.length; index += 1) {
-      const upper = points[index];
-      if (value <= upper.value) {
-        const lower = points[index - 1];
-        const ratio = (value - lower.value) / (upper.value - lower.value);
-        return lower.bitrate + (upper.bitrate - lower.bitrate) * ratio;
-      }
-    }
-    const last = points[points.length - 1];
-    return last.bitrate * (value / last.value);
+    const format = new RealtimeVideoFormat({
+      width: previous.width,
+      height: previous.height,
+      fps,
+      minimumBitrate: previous.minimumBitrate,
+      maximumBitrate: previous.maximumBitrate,
+      encoderPreference: previous.encoderPreference === "maintainFramerate" /* maintainFramerate */ ? "maintainFramerate" /* maintainFramerate */ : "maintainQuality" /* maintainQuality */
+    });
+    format.validate();
+    if (fps !== previous.frameRate) {
+      const next = { ...previous, frameRate: fps };
+      await this.rtcManager.configureVideoEncoding(next);
+      this.lastAppliedConfiguration = next;
+    }
+    return format;
   }
 };
-/**
- * 流畅优先码率参考，按像素面积升序排列，单位为 kbps。
- */
-__publicField(_EncodingController, "referenceBitratesAt15FPS", [
-  { value: 120 * 120, bitrate: 50 },
-  { value: 160 * 120, bitrate: 65 },
-  { value: 180 * 180, bitrate: 100 },
-  { value: 240 * 180, bitrate: 120 },
-  { value: 320 * 180, bitrate: 140 },
-  { value: 320 * 240, bitrate: 200 },
-  { value: 424 * 240, bitrate: 220 },
-  { value: 360 * 360, bitrate: 260 },
-  { value: 480 * 360, bitrate: 320 },
-  { value: 640 * 360, bitrate: 400 },
-  { value: 640 * 480, bitrate: 500 },
-  { value: 848 * 480, bitrate: 610 },
-  { value: 960 * 720, bitrate: 910 },
-  { value: 1280 * 720, bitrate: 1130 },
-  { value: 1920 * 1080, bitrate: 2080 }
-]);
-__publicField(_EncodingController, "referenceBitratesAt30FPS", [
-  { value: 360 * 360, bitrate: 400 },
-  { value: 480 * 360, bitrate: 490 },
-  { value: 640 * 360, bitrate: 600 },
-  { value: 640 * 480, bitrate: 750 },
-  { value: 848 * 480, bitrate: 930 },
-  { value: 960 * 720, bitrate: 1380 },
-  { value: 1280 * 720, bitrate: 1710 },
-  { value: 1920 * 1080, bitrate: 3150 }
-]);
-var EncodingController = _EncodingController;
 
 // src/Stream/StreamController.ts
 function makeInitialState() {
@@ -6316,6 +7547,17 @@ var StreamController = class {
   get hasGenerationTask() {
     return this.state.generationTaskID !== void 0;
   }
+  /**
+   * 按活动结果流身份读取原始音视频，避免录制房间内其他用户的媒体。
+   */
+  getRemoteRecordingTracks() {
+    const userID = this.state.activeRemoteStream?.userID;
+    const videoTrack = userID && this.state.remoteVideoTracks.get(userID);
+    if (!userID || !videoTrack) {
+      return void 0;
+    }
+    return { videoTrack, audioTrack: this.rtcManager.getRemoteAudioTrack(userID) };
+  }
   /**
    * 设置本地主视频流统计监听器，不改变 RTC 事件监听权。
    */
@@ -6367,9 +7609,9 @@ var StreamController = class {
    *
    * @throws 连接已取消，或 RTC 进房、房间配置与本地流发布失败时抛出错误。
    */
-  async connect(connection, includeLocalAudio, ensureActive2, beforePublish, publishLocalMedia = true) {
+  async connect(connection, includeLocalAudio, ensureActive2, beforePublish, publishLocalMedia = true, measureRtcJoin) {
     this.configureRoom({ roomID: connection.roomID, botID: connection.botID });
-    await this.roomController.join(connection, ensureActive2);
+    await this.roomController.join(connection, ensureActive2, measureRtcJoin);
     ensureActive2();
     XmaxLogger.stream.info(
       () => `RTC \u623F\u95F4\u5DF2\u914D\u7F6E (RTC Room Configured)
@@ -6397,8 +7639,17 @@ var StreamController = class {
   /**
    * 建立生成任务并发送开始信令。
    *
+   * @param options.taskID 当前生成任务标识。
+   * @param options.videoFormat 模型生成使用的视频规格。
+   * @param options.context 本次生成条件。
+   * @param options.restart 是否保留连接并替换当前生成任务，默认 false；不预先发送 stop。
+   * @param options.targetSize 回传尺寸，缺省时不发送；网络视频默认使用生成尺寸。
+   * @param options.mirror 是否由后端镜像输入画面，默认 false。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.onStartSent start 发送成功后的回调，不等待生成确认。
+   * @param options.extraParams 合并到本次 start 的 params，不缓存。
    * @returns 等待远端结果流确认的 Promise。
-   * @throws 任务标识无效、RTC 房间未就绪或已有生成任务时同步抛错；
+   * @throws 任务标识无效、RTC 房间未就绪、旧任务仍在启动或未指定 restart 且已有生成任务时同步抛错；
    * 发送失败或确认超时通过返回的 Promise 拒绝。
    */
   beginGeneration(options) {
@@ -6412,7 +7663,7 @@ var StreamController = class {
     if (!this.state.roomID) {
       throw new XmaxError("RTC_ERROR" /* rtcError */, "RTC room is not configured");
     }
-    if (this.state.generationTaskID) {
+    if (this.state.generationTaskID && (!options.restart || this.state.generationWaiter)) {
       throw new XmaxError(
         "RTC_ERROR" /* rtcError */,
         "Realtime generation is already active"
@@ -6447,11 +7698,12 @@ var StreamController = class {
     try {
       const sending = this.roomController.startGeneration({
         taskID,
-        mirror: options.mirror ?? false,
-        faceRestoration: options.faceRestoration ?? false,
         videoFormat: options.videoFormat,
+        context: options.context,
         targetSize: options.targetSize,
-        context: options.context
+        mirror: options.mirror ?? false,
+        faceRestoration: options.faceRestoration ?? false,
+        extraParams: options.extraParams
       });
       const state2 = this.state;
       const sent = Promise.resolve(sending).then(async () => {
@@ -6503,16 +7755,26 @@ var StreamController = class {
   /**
    * 发送生成条件变更信令。
    *
+   * @param options.taskID 当前生成任务标识。
+   * @param options.videoFormat 模型生成使用的视频规格。
+   * @param options.context 本次生成条件。
+   * @param options.restart 本次条件更新不使用该字段。
+   * @param options.targetSize 回传尺寸，缺省时不发送。
+   * @param options.mirror 本次条件更新不使用该字段。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.onStartSent 本次条件更新不调用该回调。
+   * @param options.extraParams 合并到本次 change_condition 的 params，不缓存。
    * @throws RTC 房间未就绪或条件变更信令发送失败时抛出错误。
    */
   async updateGeneration(options) {
     try {
       await this.roomController.changeGenerationCondition({
         taskID: options.taskID,
-        faceRestoration: options.faceRestoration ?? false,
         videoFormat: options.videoFormat,
+        context: options.context,
         targetSize: options.targetSize,
-        context: options.context
+        faceRestoration: options.faceRestoration ?? false,
+        extraParams: options.extraParams
       });
     } catch (error) {
       throw XmaxError.from(error);
@@ -6947,12 +8209,13 @@ var StreamController = class {
 
 // src/Stream/Quality/QualityTiers.ts
 var INITIAL_QUALITY_LEVEL = 2;
+var MINIMUM_QUALITY_SHORT_SIDE = 240;
 var QUALITY_TIERS = {
-  L1: { width: 1024, height: 1920, frameRate: 30 },
-  L2: { width: 768, height: 1440, frameRate: 24 },
-  L3: { width: 640, height: 1200, frameRate: 24 },
-  L4: { width: 512, height: 960, frameRate: 20 },
-  L5: { width: 384, height: 720, frameRate: 16 }
+  L1: { scale: 1, width: 1024, height: 1920, frameRate: 30 },
+  L2: { scale: 0.8, width: 818, height: 1536, frameRate: 24 },
+  L3: { scale: 0.65, width: 664, height: 1248, frameRate: 24 },
+  L4: { scale: 0.5, width: 512, height: 960, frameRate: 20 },
+  L5: { scale: 0.4, width: 408, height: 768, frameRate: 16 }
 };
 
 // src/Stream/Quality/QualityPolicy.ts
@@ -6968,9 +8231,13 @@ var DEFAULT_POLICY = {
 // src/Stream/Quality/QualityController.ts
 var ORDERED_QUALITY_TIERS = Object.values(QUALITY_TIERS);
 var QualityController = class {
-  constructor(apply, now = () => performance.now(), policy = {}) {
+  /**
+   * 创建调档状态机；候选档位不满足编码约束时保持当前档位，不跨档尝试。
+   */
+  constructor(apply, now = () => performance.now(), policy = {}, canApply = () => true) {
     __publicField(this, "apply", apply);
     __publicField(this, "now", now);
+    __publicField(this, "canApply", canApply);
     __publicField(this, "policy");
     __publicField(this, "active", false);
     __publicField(this, "index", 0);
@@ -7060,10 +8327,13 @@ var QualityController = class {
     this.good = this.poor = 0;
   }
   async change(index, reason) {
+    this.resetCounts();
+    if (!this.canApply(index + 1)) {
+      return;
+    }
     const lifecycle = this.lifecycle;
     const change = { from: this.index + 1, to: index + 1, ...ORDERED_QUALITY_TIERS[index], reason };
     this.switching = true;
-    this.resetCounts();
     try {
       await this.apply(change, lifecycle.signal);
       if (lifecycle.signal.aborted) return;
@@ -7088,12 +8358,20 @@ var QualityController = class {
 // src/Stream/Quality/QualityVideoFormat.ts
 function qualityVideoSize(baseline, level) {
   const tier = Object.values(QUALITY_TIERS)[level - 1];
-  if (!Number.isInteger(level) || !tier) throw new Error("Unsupported quality level");
+  if (!Number.isInteger(level) || !tier) {
+    throw new Error("Unsupported quality level");
+  }
   baseline.validate();
-  const scale = tier.width / QUALITY_TIERS.L1.width;
-  const even = (value) => Math.max(2, Math.floor(value / 2) * 2);
+  const shortSide = Math.min(baseline.width, baseline.height);
+  const minimum = Math.min(shortSide, MINIMUM_QUALITY_SHORT_SIDE);
+  const scale = Math.max(tier.scale, minimum / shortSide);
+  const even = (value) => Math.max(2, Math.floor(value / 2 + 1e-9) * 2);
   return { width: even(baseline.width * scale), height: even(baseline.height * scale) };
 }
+function supportsQualityEncoding(format) {
+  const defaults = EncodingBitratePolicy.resolve(format.width, format.height, format.fps);
+  return (format.minimumBitrate ?? defaults.minimum) <= (format.maximumBitrate ?? defaults.maximum);
+}
 function qualityVideoFormat(baseline, level) {
   const size = qualityVideoSize(baseline, level);
   const tier = Object.values(QUALITY_TIERS)[level - 1];
@@ -7105,34 +8383,59 @@ function qualityVideoFormat(baseline, level) {
 }
 
 // src/Stream/Quality/QualityHistory.ts
-var QualityHistory = class {
-  constructor(model) {
+var _QualityHistory = class _QualityHistory {
+  /**
+   * 创建按模型与 RTC 提供方隔离的档位存储。
+   */
+  constructor(model, provider, now = Date.now) {
     __publicField(this, "model", model);
+    __publicField(this, "provider", provider);
+    __publicField(this, "now", now);
   }
-  /** 无记录、损坏、SSR 或浏览器禁止存储时使用默认 L2。 */
+  /**
+   * 无记录、过期、损坏、时钟回退或存储不可用时使用默认 L2。
+   */
   read(direction) {
     try {
-      const level = Number(globalThis.localStorage.getItem(this.key(direction)));
-      if (this.isValid(level)) return level;
+      const entry = JSON.parse(globalThis.localStorage.getItem(this.key(direction)) ?? "null");
+      const now = this.now();
+      if (entry && this.isValid(entry.level) && Number.isFinite(entry.savedAt) && entry.savedAt > 0 && now >= entry.savedAt && now - entry.savedAt < _QualityHistory.expirationMs) {
+        return entry.level;
+      }
     } catch {
     }
     return INITIAL_QUALITY_LEVEL;
   }
-  /** 仅在应用成功后调用；下行成功表示信令已发送，不代表服务端已确认生效。 */
+  /**
+   * 应用成功后保存档位并刷新一小时有效期；下行成功仅表示信令已发送。
+   */
   write(direction, level) {
-    if (!this.isValid(level)) return;
+    if (!this.isValid(level)) {
+      return;
+    }
     try {
-      globalThis.localStorage.setItem(this.key(direction), String(level));
+      globalThis.localStorage.setItem(this.key(direction), JSON.stringify({ level, savedAt: this.now() }));
     } catch {
     }
   }
+  /**
+   * 生成当前方向的存储键；无时间戳的旧记录按无效记录处理。
+   */
   key(direction) {
-    return `xmax:quality:v1:agora:${encodeURIComponent(this.model)}:${direction}`;
+    return `xmax:quality:v1:${this.provider}:${encodeURIComponent(this.model)}:${direction}`;
   }
+  /**
+   * 校验档位编号。
+   */
   isValid(level) {
     return Number.isInteger(level) && level >= 1 && level <= Object.keys(QUALITY_TIERS).length;
   }
 };
+/**
+ * 历史档位有效期，单位为毫秒。
+ */
+__publicField(_QualityHistory, "expirationMs", 60 * 60 * 1e3);
+var QualityHistory = _QualityHistory;
 
 // src/Core/Realtime/RealtimeCoordinator.ts
 function scopeAffects(scope, kind) {
@@ -7270,7 +8573,7 @@ var RealtimeCoordinator = class _RealtimeCoordinator {
       await this.errorHandler.report(error);
       throw error;
     }
-    const operationKind = kind === "generation" /* generation */ && this.state.connectionState === "Generating" /* generating */ ? "configuration" /* configuration */ : kind;
+    const operationKind = kind === "generation" /* generation */ && (this.state.connectionState === "Generating" /* generating */ || this.state.connectionState === "Starting" /* starting */ && !!this.state.taskID) ? "configuration" /* configuration */ : kind;
     const lease = new OperationLease(failureScope);
     const resultPromise = (async () => body(lease))();
     const operation = {
@@ -7310,6 +8613,19 @@ var RealtimeCoordinator = class _RealtimeCoordinator {
       new RealtimeState({ connectionState: "Ready" /* ready */ })
     );
   }
+  /**
+   * 当前生成任务和远端展示均就绪后进入 generating；迟到通知不恢复已结束任务。
+   */
+  async remotePreviewDidBecomeReady(sessionID, taskID, isCurrent) {
+    if (this.termination || this.state.connectionState !== "Starting" /* starting */ || this.state.sessionID !== sessionID || this.state.taskID !== taskID || !isCurrent()) {
+      return;
+    }
+    await this.setState(new RealtimeState({
+      connectionState: "Generating" /* generating */,
+      sessionID,
+      taskID
+    }));
+  }
   /**
    * 断开实时连接；尚未提交连接状态的活跃操作也会被取消。
    */
@@ -7602,11 +8918,16 @@ var RealtimeLaunchTimer = class {
     return this.measure("permissionMs", performance.now());
   }
   /**
-   * 开始会话与进房计时，返回连接阶段完成时调用的记录函数。
-   * 相机预热等待计入连接耗时。
+   * 开始创建业务会话的计时。
+   */
+  startSession() {
+    return this.measure("sessionMs", performance.now());
+  }
+  /**
+   * 开始 RTC 适配器进房调用的计时。
    */
-  startConnection() {
-    return this.measure("connectionMs", performance.now());
+  startRtcJoin() {
+    return this.measure("rtcJoinMs", performance.now());
   }
   /**
    * 开始发布本地流计时，返回发布完成时调用的记录函数。
@@ -7615,11 +8936,17 @@ var RealtimeLaunchTimer = class {
     return this.measure("publishMs", performance.now());
   }
   /**
-   * 开始等待远端显示首帧；完成回调同时记录首帧耗时和实际总耗时。
+   * 开始等待远端首帧提交合成器，不包含后续渲染预热。
    */
   startFirstFrame() {
     return this.measure("firstFrameMs", performance.now());
   }
+  /**
+   * 首帧就绪后开始渲染预热；结束时记录预热及实际总耗时，不含渐入动画。
+   */
+  startRenderWarmup() {
+    return this.measure("renderWarmupMs", performance.now());
+  }
   /**
    * 冻结本轮结果，令尚未完成的回调失效；下一轮相机启动才重置。
    */
@@ -7640,7 +8967,7 @@ var RealtimeLaunchTimer = class {
       this.snapshot = Object.freeze({
         ...this.snapshot,
         [key]: now - startedAt,
-        ...key === "firstFrameMs" ? { totalMs: now - this.startedAt } : {}
+        ...key === "renderWarmupMs" ? { totalMs: now - this.startedAt } : {}
       });
       this.notify();
     };
@@ -7676,7 +9003,6 @@ var XmaxRealtimeConnectionManager = class {
      * 远端轨道与渲染绑定
      */
     __publicField(this, "activeRemoteTrack");
-    __publicField(this, "remoteTarget");
   }
   /**
    * 当前活动会话标识；尚未连接或清理完成后为空。
@@ -7692,8 +9018,8 @@ var XmaxRealtimeConnectionManager = class {
   }
   /**
    * 创建会话、配置编码、进房并发布本地媒体，启动心跳后返回远端占位流。
-   * 进房结束即记录连接耗时；可选 beforePublish 检查阻塞发布，计入连接耗时；
-   * 发布本地流单独计时。
+   * 会话创建、RTC 进房和本地流发布分别计时；可选 beforePublish 检查阻塞发布，
+   * 其等待只反映在实际完整启动耗时中。
    * @param options.localTrack 当前本地媒体轨道。
    * @param options.remoteVideoFormat 原始生成及远端画面规格，缺省使用本地轨道规格。
    * @param options.localVideoFormat 发布前实际应用的上行编码格式；与原始生成及远端格式分开。
@@ -7710,10 +9036,11 @@ var XmaxRealtimeConnectionManager = class {
     const sessionService = this.requireSessionService();
     const streamController = this.dependencies.streamController;
     options.ensureCurrent();
-    const completeConnection = this.dependencies.timing.startConnection();
+    const completeSession = this.dependencies.timing.startSession();
     const session = await sessionService.createSession(options.model);
     this.activeSession = session;
     options.ensureCurrent();
+    completeSession();
     const connection = session.connection;
     if (!connection) {
       throw new XmaxError(
@@ -7746,11 +9073,10 @@ var XmaxRealtimeConnectionManager = class {
     }, async () => {
       options.ensureCurrent();
       await options.beforePublish?.();
-      completeConnection();
+      options.ensureCurrent();
       completePublish = this.dependencies.timing.startPublish();
-    }, publishLocalMedia);
+    }, publishLocalMedia, () => this.dependencies.timing.startRtcJoin());
     options.ensureCurrent();
-    completeConnection();
     completePublish?.();
     options.onPublished();
     sessionService.startHeartbeat(session.id, {
@@ -7766,21 +9092,15 @@ var XmaxRealtimeConnectionManager = class {
       videoFormat: options.remoteVideoFormat ?? options.localTrack.videoFormat
     });
     this.activeRemoteTrack = remoteTrack;
-    this.registerRemoteBinding(remoteTrack);
+    this.dependencies.renderController.registerRemoteTrack(remoteTrack, this.dependencies.onInteraction);
     streamController.setRemoteAudioVolume(this.dependencies.remoteAudioVolume());
     return new RealtimeMediaStream({ id: "stream1" /* remote */, videoTrack: remoteTrack });
   }
-  /**
-   * 更新已绑定远端视图的插帧配置；传 undefined 停用插帧。
-   */
-  setFrameInterpolation(options) {
-    this.remoteTarget?.setFrameInterpolation?.(options);
-  }
   /**
    * 清空远端视图的媒体流，保留轨道与视图绑定以供统一清理。
    */
   clearRemoteMedia() {
-    this.remoteTarget?.setMediaStream(null);
+    this.dependencies.renderController.setRemoteMedia(null);
   }
   /**
    * 停止会话心跳；未配置会话服务时不执行操作。
@@ -7860,7 +9180,7 @@ var XmaxRealtimeConnectionManager = class {
       if (track) {
         track.mediaStreamTrack = void 0;
       }
-      this.remoteTarget?.setMediaStream(null);
+      this.dependencies.renderController.setRemoteMedia(null);
       return;
     }
     if (!track) {
@@ -7870,35 +9190,7 @@ var XmaxRealtimeConnectionManager = class {
       );
     }
     track.mediaStreamTrack = binding.videoTrack;
-    this.remoteTarget?.setMediaStream(new MediaStream([binding.videoTrack]));
-  }
-  /**
-   * 为远端轨道注册渲染绑定：attach 时挂流占位，媒体轨到达后送入画面。
-   */
-  registerRemoteBinding(track) {
-    VideoRenderRegistry.register(track, {
-      frameDisplayHandler: () => {
-        if (this.activeRemoteTrack === track) {
-          this.dependencies.onFrameDisplayed();
-        }
-      },
-      attachHandler: (view) => {
-        this.remoteTarget?.setFrameInterpolation?.(void 0);
-        view.isMirrored = false;
-        this.remoteTarget = view;
-        this.dependencies.onRenderAttached();
-        const mediaTrack = track.mediaStreamTrack;
-        view.setMediaStream(mediaTrack ? new MediaStream([mediaTrack]) : null);
-      },
-      detachHandler: (view) => {
-        if (this.remoteTarget === view) {
-          this.dependencies.onRenderDetached();
-          this.remoteTarget = void 0;
-        }
-        view.setFrameInterpolation?.(void 0);
-        view.setMediaStream(null);
-      }
-    });
+    this.dependencies.renderController.setRemoteMedia(binding.videoTrack);
   }
   /**
    * 构造当前远端生成结果媒体流。
@@ -7971,12 +9263,11 @@ var XmaxRealtimeConnectionManager = class {
     }
     const track = this.activeRemoteTrack;
     if (track) {
-      VideoRenderRegistry.unregister(track);
+      this.dependencies.renderController.resetRemoteTrack();
       track.mediaStreamTrack = void 0;
     }
     this.activeSession = void 0;
     this.activeRemoteTrack = void 0;
-    this.remoteTarget = void 0;
     if (sessionID && this.dependencies.sessionService) {
       try {
         await this.dependencies.sessionService.closeSession(sessionID);
@@ -8006,8 +9297,10 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
   /**
    * 注入房间传输组件和任务标识生成器，不创建会话或启动生成。
    */
-  constructor(streamController, taskIDGenerator = _XmaxRealtimeGenerationManager.createTaskID) {
+  constructor(streamController, interactionController, renderController, taskIDGenerator = _XmaxRealtimeGenerationManager.createTaskID) {
     __publicField(this, "streamController", streamController);
+    __publicField(this, "interactionController", interactionController);
+    __publicField(this, "renderController", renderController);
     __publicField(this, "taskIDGenerator", taskIDGenerator);
     /**
      * 当前生成条件与任务标识
@@ -8033,37 +9326,50 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
    * 发送生成指令并等待确认、远端就绪和音频激活，成功后返回任务标识。
    * 条件上下文在生成确认后缓存；启动失败时尽力停止本次任务并保留原始错误。
    * @param options.videoFormat 模型生成使用的视频规格。
-   * @param options.targetSize 服务端生成后的回传尺寸，缺省使用生成尺寸。
-   * @param options.context 生成条件，缺省复用最近缓存的上下文。
-   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
-   * @param options.mirror 是否由后端水平翻转输入，默认 false；仅用于 start 信令。
    * @param options.signal 取消本次生成启动的信号。
    * @param options.ensureCurrent 校验当前操作仍有效。
    * @param options.waitUntilRemoteReady 等待远端生成流就绪。
+   * @param options.context 生成条件，缺省复用最近缓存的上下文。
+   * @param options.restart 是否替换当前任务并重新发送 start，默认 false；不发送 stop。
+   * @param options.targetSize 服务端生成后的回传尺寸，缺省时不发送。
+   * @param options.mirror 是否由后端水平翻转输入，默认 false；仅用于 start 信令。
+   * @param options.faceRestoration 是否回贴原始人脸，默认 false。
    * @param options.onStartSent start 信令发送成功后的可选异步回调。
+   * @param options.onRemoteReady 远端视频就绪后通知任务标识，不等待录制等附加功能。
+   * @param options.extraParams 合并到本次 start 的 params，不缓存。
    */
   async start(options) {
     const context = this.validateContext(options.context);
     options.ensureCurrent();
     const taskID = this.taskIDGenerator();
+    if (options.restart) {
+      this.interactionController.stopInteraction();
+      this.renderController.setInteractionEnabled(false);
+    }
     this.activeTaskID = taskID;
     try {
       const confirmation = this.streamController.beginGeneration({
         taskID,
         videoFormat: options.videoFormat,
         context,
+        restart: options.restart,
         ...options.targetSize && { targetSize: options.targetSize },
         mirror: options.mirror ?? false,
         faceRestoration: options.faceRestoration ?? false,
-        ...options.onStartSent && { onStartSent: options.onStartSent }
+        ...options.onStartSent && { onStartSent: options.onStartSent },
+        extraParams: options.extraParams
       });
       await this.awaitConfirmation(confirmation, options.signal);
       options.ensureCurrent();
       this.currentContext = context;
       await options.waitUntilRemoteReady();
       options.ensureCurrent();
+      options.onRemoteReady?.(taskID);
+      options.ensureCurrent();
       await this.streamController.activateRemoteAudio();
       options.ensureCurrent();
+      this.interactionController.startInteraction(taskID, options.videoFormat);
+      this.renderController.setInteractionEnabled(true, options.videoFormat);
       return taskID;
     } catch (error) {
       await this.stop(taskID);
@@ -8074,9 +9380,10 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
    * 更新活动任务的生成条件；信令发送成功后才覆盖缓存，无任务或上下文时抛错。
    * @param taskID 当前活动任务标识。
    * @param options.videoFormat 模型生成使用的视频规格。
-   * @param options.targetSize 服务端生成后的回传尺寸。
    * @param options.context 生成条件，缺省复用最近缓存的上下文。
+   * @param options.targetSize 服务端生成后的回传尺寸，缺省时不发送。
    * @param options.faceRestoration 是否回贴原始人脸，默认 false。
+   * @param options.extraParams 合并到本次 change_condition 的 params，不缓存。
    */
   async update(taskID, options) {
     const context = options.context ?? this.currentContext;
@@ -8087,11 +9394,14 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
       taskID,
       videoFormat: options.videoFormat,
       context,
+      ...options.targetSize && { targetSize: options.targetSize },
       faceRestoration: options.faceRestoration ?? false,
-      ...options.targetSize && { targetSize: options.targetSize }
+      extraParams: options.extraParams
     });
     if (this.activeTaskID !== taskID) throw RealtimeCoordinator.cancelledError();
     this.currentContext = context;
+    this.interactionController.startInteraction(taskID, options.videoFormat);
+    this.renderController.setInteractionEnabled(true, options.videoFormat);
   }
   /**
    * 幂等停止指定活动任务；并发调用共享结果，停止失败仅记录日志。
@@ -8102,6 +9412,8 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
     }
     if (!taskID || this.activeTaskID !== taskID) return;
     this.activeTaskID = void 0;
+    this.interactionController.stopInteraction();
+    this.renderController.setInteractionEnabled(false);
     const completion = (async () => {
       try {
         await this.streamController.stopGeneration(taskID);
@@ -8122,6 +9434,8 @@ var XmaxRealtimeGenerationManager = class _XmaxRealtimeGenerationManager {
    */
   async reset(taskID) {
     this.currentContext = void 0;
+    this.interactionController.stopInteraction();
+    this.renderController.setInteractionEnabled(false);
     await this.stop(this.activeTaskID ?? (taskID || void 0));
   }
   /**
@@ -8178,6 +9492,10 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
      */
     __publicField(this, "options");
     __publicField(this, "mediaService");
+    /**
+     * 可选的任务录制；未开启时不分配浏览器录制资源。
+     */
+    __publicField(this, "recordingController", new RecordingController());
     /**
      * 本地流创建时的生成格式；上行编码调整不改变模型输入配置与远端插帧尺寸。
      */
@@ -8194,20 +9512,14 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
      */
     __publicField(this, "coordinator");
     __publicField(this, "errorHandler");
-    __publicField(this, "cameraController");
-    __publicField(this, "networkVideoController", new NetworkVideoController());
-    __publicField(this, "localVideoController", new LocalVideoController((error) => {
-      void this.coordinator.terminateWithError(error, 0 /* connection */);
-    }));
-    __publicField(this, "externalVideoController", new ExternalVideoController((error) => {
-      void this.coordinator.terminateWithError(error, 1 /* all */);
-    }));
-    __publicField(this, "rtcManager");
+    __publicField(this, "mediaController");
+    __publicField(this, "renderController");
     /**
      * 启动计时与首帧通知
      */
     __publicField(this, "launchTimer", new RealtimeLaunchTimer());
     __publicField(this, "remoteFrameDisplayHandler");
+    __publicField(this, "remoteRenderWarmupCompletedHandler");
     /**
      * 媒体权限弹窗观察
      */
@@ -8247,14 +9559,6 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     this.supportsInterpolation = dependencies?.supportsFrameInterpolation ?? (async (size) => await frameInterpolationAdapter(size) !== null);
     this.errorHandler = new RealtimeErrorHandler();
     const rtcManager = dependencies?.rtcManager ?? createRtcManager(options.provider, dependencies?.environment ?? "china" /* china */);
-    this.rtcManager = rtcManager;
-    this.cameraController = dependencies?.cameraController ?? new CameraController({
-      rtcManager,
-      mediaService: this.mediaService,
-      errorListener: (error) => {
-        void this.errorHandler.report(error);
-      }
-    });
     const sessionService = dependencies?.sessionService ?? (dependencies?.apiService ? new RealtimeSessionService({ apiService: dependencies.apiService, provider: options.provider }) : void 0);
     this.streamController = dependencies?.streamController ?? new StreamController({
       rtcManager,
@@ -8265,10 +9569,42 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         void this.errorHandler.report(error);
       },
       remoteStreamListener: (binding) => {
+        if (!binding) {
+          void this.recordingController.stop("mediaInterrupted" /* mediaInterrupted */);
+        }
         this.clearRemoteVideoStatistics();
         this.connectionManager.handleRemoteStreamBinding(binding);
       }
     });
+    this.mediaController = new MediaController({
+      rtcManager,
+      mediaService: this.mediaService,
+      cameraController: dependencies?.cameraController,
+      onCameraError: (error) => {
+        void this.errorHandler.report(error);
+      },
+      onVideoError: (error) => {
+        void this.coordinator.terminateWithError(error, 0 /* connection */);
+      },
+      onExternalError: (error) => {
+        void this.coordinator.terminateWithError(error, 1 /* all */);
+      },
+      onImageError: (error) => {
+        void this.coordinator.terminateWithError(error, 1 /* all */);
+      },
+      interactionListener: (taskID, points) => this.streamController.sendTracks(taskID, points)
+    });
+    this.renderController = new RenderController({
+      onFrameDisplayed: () => this.remoteFrameDisplayHandler?.(),
+      onRenderWarmupCompleted: () => {
+        this.remoteRenderWarmupCompletedHandler?.();
+        void this.completeGenerationPresentation().catch((error) => this.errorHandler.report(error));
+      },
+      onAttached: () => this.applyRemoteInterpolation(),
+      onDetached: () => {
+        this.interpolationRevision++;
+      }
+    });
     this.connectionManager = new XmaxRealtimeConnectionManager({
       provider: options.provider,
       sessionService,
@@ -8278,35 +9614,24 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       onHeartbeatFailure: (sessionID, error) => {
         void this.handleHeartbeatFailure(sessionID, error);
       },
-      onFrameDisplayed: () => this.remoteFrameDisplayHandler?.(),
-      onRenderAttached: () => this.applyRemoteInterpolation(),
-      onRenderDetached: () => {
-        this.interpolationRevision++;
-      }
+      renderController: this.renderController,
+      onInteraction: (frame) => this.mediaController.submitInteraction(frame)
     });
-    this.generationManager = new XmaxRealtimeGenerationManager(this.streamController);
+    this.generationManager = new XmaxRealtimeGenerationManager(this.streamController, this.mediaController, this.renderController);
     this.coordinator = new RealtimeCoordinator({
       errorHandler: this.errorHandler,
       cleanup: (scope, taskID) => this.performCleanup(scope, taskID)
     });
-    if (options.provider === "agora" /* agora */) {
-      this.qualityHistory = new QualityHistory(options.model);
+    if (options.provider === "agora" /* agora */ || options.provider === "trtc" /* trtc */) {
+      this.qualityHistory = new QualityHistory(options.model, options.provider);
       this.qualityController = new QualityController(async (change, signal) => {
-        if (signal.aborted || this.currentState.connectionState !== "Generating" /* generating */) {
-          throw new XmaxError("CANCELLED" /* cancelled */, "Adaptive video format update was cancelled");
-        }
         await this.coordinator.run("configuration" /* configuration */, void 0, async (token) => {
-          const track = this.currentUplinkTrack;
-          const state2 = track && this.qualityStates.get(track);
-          if (!track || !state2) throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Adaptive video baseline is unavailable");
-          const format = qualityVideoFormat(state2.baseline, change.to);
-          await this.streamController.updateUplinkVideoFormat(format);
-          token.ensureCurrent();
-          this.generationVideoFormat ?? (this.generationVideoFormat = state2.baseline);
-          track.updateVideoFormat(format);
-          state2.level = change.to;
-          this.qualityHistory?.write("uplink", change.to);
+          await this.applyUplinkQuality(change.to, token, signal);
         });
+      }, void 0, {}, (level) => {
+        const track = this.currentUplinkTrack;
+        const state2 = track && this.qualityStates.get(track);
+        return !!state2 && supportsQualityEncoding(this.uplinkQualityFormat(state2.baseline, level));
       });
       this.downlinkQualityController = new QualityController(async (change, signal) => {
         await this.coordinator.run("configuration" /* configuration */, void 0, async (token) => {
@@ -8363,13 +9688,61 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       this.applyRemoteInterpolation();
     });
   }
+  /**
+   * 手动调整上行档位，保留原始基准，自动调档从新档位继续。
+   * @param direction 升一档或降一档；到达 L1/L5 边界时不重复应用。
+   */
+  async adjustUplinkQuality(direction) {
+    await this.coordinator.run("configuration" /* configuration */, void 0, async (token) => {
+      const controller = this.qualityController;
+      const track = this.currentUplinkTrack;
+      const state2 = track && this.qualityStates.get(track);
+      if (!controller || !state2 || this.currentState.connectionState !== "Generating" /* generating */ || direction !== "upgrade" && direction !== "downgrade") {
+        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Uplink quality adjustment requires an active adaptive-quality generation and a valid direction");
+      }
+      const level = Math.max(1, Math.min(Object.keys(QUALITY_TIERS).length, state2.level + (direction === "upgrade" ? -1 : 1)));
+      if (level === state2.level) return;
+      if (!supportsQualityEncoding(this.uplinkQualityFormat(state2.baseline, level))) {
+        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Quality level conflicts with explicit bitrate constraints");
+      }
+      this.adaptiveQualityRevision++;
+      controller.resetSamples();
+      await this.applyUplinkQuality(level, token);
+      controller.start(level);
+    });
+  }
+  async applyUplinkQuality(level, token, signal) {
+    const track = this.currentUplinkTrack;
+    const state2 = track && this.qualityStates.get(track);
+    const ensureActive2 = () => {
+      token.ensureCurrent();
+      if (signal?.aborted || !track || !state2 || track !== this.currentUplinkTrack || state2 !== this.qualityStates.get(track) || this.currentState.connectionState !== "Generating" /* generating */) {
+        throw new XmaxError("CANCELLED" /* cancelled */, "Adaptive video format update was cancelled");
+      }
+    };
+    ensureActive2();
+    if (!track || !state2) return;
+    const target = this.uplinkQualityFormat(state2.baseline, level);
+    let format;
+    if (this.options.provider === "trtc" /* trtc */) {
+      format = await this.streamController.updateUplinkFrameRate(target.fps);
+    } else {
+      await this.streamController.updateUplinkVideoFormat(target);
+      format = target;
+    }
+    ensureActive2();
+    this.generationVideoFormat ?? (this.generationVideoFormat = state2.baseline);
+    track.updateVideoFormat(format);
+    state2.level = level;
+    this.qualityHistory?.write("uplink", level);
+  }
   /** 手动调试与自动调档使用同一尺寸信令路径，不修改生成或上行配置。 */
   async adjustDownlinkQuality(direction) {
     await this.coordinator.run("configuration" /* configuration */, void 0, async (token) => {
       const controller = this.downlinkQualityController;
       const state2 = this.downlinkQualityState;
       if (!controller || !state2 || this.currentState.connectionState !== "Generating" /* generating */ || direction !== "upgrade" && direction !== "downgrade") {
-        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Downlink quality adjustment requires an active Agora generation and a valid direction");
+        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Downlink quality adjustment requires an active adaptive-quality generation and a valid direction");
       }
       const level = Math.max(1, Math.min(Object.keys(QUALITY_TIERS).length, state2.level + (direction === "upgrade" ? -1 : 1)));
       if (level === state2.level) return;
@@ -8451,7 +9824,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
   applyRemoteInterpolation() {
     const revision = ++this.interpolationRevision;
     const size = this.interpolationSize;
-    this.connectionManager.setFrameInterpolation(size ? {
+    this.renderController.setFrameInterpolation(size ? {
       size,
       onFailure: (error) => {
         if (revision === this.interpolationRevision) this.handleInterpolationFailure(error);
@@ -8621,7 +9994,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       "media" /* media */,
       void 0,
       async (token) => {
-        this.ensureNoLocalSource();
+        this.mediaController.ensureNoLocalSource();
         await this.coordinator.commit(
           new RealtimeState({
             connectionState: "Preparing" /* preparing */
@@ -8642,7 +10015,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         let stream;
         try {
           token.ensureCurrent();
-          stream = await this.cameraController.createLocalCameraStream(options);
+          stream = await this.mediaController.createLocalCameraStream(options);
         } catch (error) {
           this.disposePermissionWatch();
           this.launchTimer.cancel();
@@ -8651,7 +10024,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         token.ensureCurrent();
         this.generationVideoFormat = stream.videoTrack?.videoFormat;
         completeCamera();
-        this.cameraController.setPreviewReadyHandler((isCurrent) => {
+        this.mediaController.setCameraPreviewReadyHandler((isCurrent) => {
           void this.coordinator.localPreviewDidBecomeReady(isCurrent);
         });
         return stream;
@@ -8667,12 +10040,12 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   async createNetworkVideoStream(options) {
     return this.coordinator.run("media" /* media */, void 0, async (token) => {
-      this.ensureNoLocalSource();
-      const stream = this.networkVideoController.create(options, this.mediaService);
+      this.mediaController.ensureNoLocalSource();
+      const stream = this.mediaController.createNetworkVideoStream(options);
       token.setFailureScope(1 /* all */);
       this.launchTimer.start();
       this.clearVideoStatistics();
-      await this.rtcManager.initialize();
+      await this.mediaController.prepareSource(() => token.ensureCurrent());
       token.ensureCurrent();
       this.generationVideoFormat = stream.videoTrack?.videoFormat;
       await this.coordinator.commit(new RealtimeState({ connectionState: "Ready" /* ready */ }), token);
@@ -8688,22 +10061,32 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   async createLocalVideoStream(options) {
     return this.coordinator.run("media" /* media */, void 0, async (token) => {
-      this.ensureNoLocalSource();
-      if (!this.rtcManager.setExternalMediaTracks) {
-        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "The RTC provider does not support local video streams");
-      }
+      this.mediaController.ensureNoLocalSource();
+      this.mediaController.validateExternalMediaSupport("local");
       token.setFailureScope(1 /* all */);
       this.launchTimer.start();
       this.clearVideoStatistics();
-      const stream = await this.localVideoController.create(options, this.mediaService, token.signal);
-      token.ensureCurrent();
-      await this.rtcManager.initialize();
+      const stream = await this.mediaController.createLocalVideoStream(options, token.signal);
       token.ensureCurrent();
-      await this.rtcManager.setExternalMediaTracks({
-        videoTrack: stream.videoTrack.mediaStreamTrack,
-        audioTrack: this.localVideoController.audioTrack
-      });
+      await this.mediaController.prepareSource(() => token.ensureCurrent());
+      this.generationVideoFormat = stream.videoTrack?.videoFormat;
+      await this.coordinator.commit(new RealtimeState({ connectionState: "Ready" /* ready */ }), token);
+      return stream;
+    });
+  }
+  /**
+   * 创建本地图片静止视频源并准备 RTC，失败或取消时释放本次资源。
+   */
+  async createLocalImageStream(options) {
+    return this.coordinator.run("media" /* media */, void 0, async (token) => {
+      this.mediaController.ensureNoLocalSource();
+      this.mediaController.validateExternalMediaSupport("image");
+      token.setFailureScope(1 /* all */);
+      this.launchTimer.start();
+      this.clearVideoStatistics();
+      const stream = await this.mediaController.createLocalImageStream(options, token.signal);
       token.ensureCurrent();
+      await this.mediaController.prepareSource(() => token.ensureCurrent());
       this.generationVideoFormat = stream.videoTrack?.videoFormat;
       await this.coordinator.commit(new RealtimeState({ connectionState: "Ready" /* ready */ }), token);
       return stream;
@@ -8716,18 +10099,13 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    */
   async createExternalVideoStream(options) {
     return this.coordinator.run("media" /* media */, void 0, async (token) => {
-      this.ensureNoLocalSource();
-      if (!this.rtcManager.setExternalMediaTracks) {
-        throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "The RTC provider does not support external video streams");
-      }
-      const stream = this.externalVideoController.create(options, this.mediaService);
+      this.mediaController.ensureNoLocalSource();
+      this.mediaController.validateExternalMediaSupport("external");
+      const stream = this.mediaController.createExternalVideoStream(options);
       token.setFailureScope(1 /* all */);
       this.launchTimer.start();
       this.clearVideoStatistics();
-      await this.rtcManager.initialize();
-      token.ensureCurrent();
-      await this.rtcManager.setExternalMediaTracks({ videoTrack: stream.videoTrack.mediaStreamTrack });
-      token.ensureCurrent();
+      await this.mediaController.prepareSource(() => token.ensureCurrent());
       this.generationVideoFormat = stream.videoTrack?.videoFormat;
       await this.coordinator.commit(new RealtimeState({ connectionState: "Ready" /* ready */ }), token);
       return stream;
@@ -8735,19 +10113,11 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
   }
   /** 当前可发布的本地视频轨，不包含服务端直接读取的网络视频。 */
   get currentUplinkTrack() {
-    return this.externalVideoController.currentTrack ?? this.localVideoController.currentTrack ?? this.cameraController.currentTrack;
+    return this.mediaController.uplinkTrack;
   }
   /** 当前 Manager 拥有的媒体源轨道。 */
   get currentLocalTrack() {
-    return this.currentUplinkTrack ?? this.networkVideoController.currentTrack;
-  }
-  /**
-   * 创建前拒绝覆盖活动源，避免旧预览或连接资源被静默遗留。
-   */
-  ensureNoLocalSource() {
-    if (this.currentLocalTrack || this.localVideoController.isActive) {
-      throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Close the current local stream before creating another one");
-    }
+    return this.mediaController.currentTrack;
   }
   /**
    * 移除媒体权限弹窗观察；授权决定已记录或不再需要观察时调用。
@@ -8796,7 +10166,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     const track = this.currentUplinkTrack;
     const previous = track?.videoFormat;
     const state2 = this.currentState.connectionState;
-    if (!track || !previous || state2 !== "Connected" /* connected */ && state2 !== "Generating" /* generating */) {
+    if (!track || !previous || state2 !== "Connected" /* connected */ && state2 !== "Starting" /* starting */ && state2 !== "Generating" /* generating */) {
       throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Frame rate updates require a connected local camera, external or file stream");
     }
     if (!Number.isFinite(fps) || fps <= 0) {
@@ -8856,7 +10226,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    * 停止本地相机流并释放本地预览与 RTC 资源。
    */
   async stopLocalCameraStream() {
-    if (this.networkVideoController.currentTrack || this.localVideoController.isActive || this.externalVideoController.currentTrack) {
+    if (this.mediaController.source && this.mediaController.source !== "camera") {
       return;
     }
     await this.coordinator.run(
@@ -8866,7 +10236,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         this.launchTimer.cancel();
         this.clearVideoStatistics();
         this.disposePermissionWatch();
-        await this.cameraController.stopLocalCameraStream();
+        await this.mediaController.stopLocalCameraStream();
         token.ensureCurrent();
         this.generationVideoFormat = void 0;
         await this.coordinator.commit(
@@ -8889,11 +10259,11 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       "cameraSwitch" /* cameraSwitch */,
       void 0,
       async (token) => {
-        if (this.externalVideoController.currentTrack) {
+        if (this.mediaController.source === "externalVideo") {
           throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "External video capture is managed by the caller");
         }
         this.qualityController?.stop();
-        const stream = await this.cameraController.switchCamera();
+        const stream = await this.mediaController.switchCamera();
         token.ensureCurrent();
         return stream;
       }
@@ -8917,7 +10287,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       void 0,
       async (token) => {
         const connectionState = this.coordinator.currentState.connectionState;
-        if (connectionState === "Connecting" /* connecting */ || connectionState === "Connected" /* connected */ || connectionState === "Generating" /* generating */) {
+        if (connectionState === "Connecting" /* connecting */ || connectionState === "Connected" /* connected */ || connectionState === "Starting" /* starting */ || connectionState === "Generating" /* generating */) {
           throw new XmaxError(
             "INVALID_CONFIGURATION" /* invalidConfiguration */,
             "A realtime connection is already active"
@@ -8930,19 +10300,25 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
   /**
    * 按需建立连接并开始生成。
    *
-   * 尚未连接时先建立实时连接；已在生成时仅更新生成条件，不重启生成。
+   * 尚未连接时先建立实时连接；已在生成时默认更新条件，restart 为 true 时重新开始生成。
    * 首次生成必须提供条件上下文，之后缺省时复用最近一次缓存的上下文。
+   * 返回后请将远端流挂载到 SDK 视频视图；首帧及渲染预热完成后状态才进入 generating。
    *
    * @param options.localStream 由当前 Manager 创建的摄像头、外部视频轨、本地文件或网络视频源。
    * @param options.context 本次生成使用的条件上下文；缺省时复用缓存。
+   * @param options.restart 是否保留 RTC 连接并创建新任务发送 start，默认 false；不预先发送 stop。
    * @param options.faceRestoration 是否启用原始人脸回贴，默认 false；正在生成时通过 change_condition 更新。
-   * @returns 承载远端生成画面的媒体流。
+   * @param options.extraParams 合并到本次 start 或 change_condition 的 params；不缓存，自动恢复时不携带，不允许覆盖 SDK 字段。
+   * @param options.record 是否录制远端原始音视频约 20 秒，默认 false；仅 start 有效，条件更新时忽略，重启录制暂不支持。
+   * @returns 可挂载的远端媒体流，不等待渲染预热；展示就绪以 generating 状态为准。
+   * @throws extraParams 包含非 JSON 数据、循环引用或 SDK 保留字段时，在连接或更新前抛出 invalidConfiguration。
    * @throws 本地流不属于当前 Manager、缺少可用的条件上下文、信令发送
    * 或生成确认失败时抛出错误；失败时自动停止生成任务并释放连接资源。
    */
   async startGeneration(options) {
+    const extraParams = snapshotExtraParams(options.extraParams);
     return this.coordinator.run(
-      "generation" /* generation */,
+      options.restart === true ? "generationRestart" /* generationRestart */ : "generation" /* generation */,
       void 0,
       async (token) => {
         const localTrack = options.localStream.videoTrack;
@@ -8960,34 +10336,50 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
           );
         }
         const currentState = this.coordinator.currentState;
-        if (currentState.connectionState === "Generating" /* generating */) {
+        const hasGeneration = currentState.connectionState === "Generating" /* generating */ || currentState.connectionState === "Starting" /* starting */ && !!currentState.taskID;
+        if (hasGeneration && options.restart !== true) {
           await this.generationManager.update(currentState.taskID, {
             videoFormat,
-            faceRestoration: options.faceRestoration ?? false,
+            context: options.context,
             targetSize: this.downlinkQualityController ? this.downlinkQualityState?.size : void 0,
-            context: options.context
+            faceRestoration: options.faceRestoration ?? false,
+            extraParams
           });
           token.ensureCurrent();
           return this.connectionManager.makeRemoteStream();
         }
         const supplied = this.generationManager.validateContext(options.context);
-        const referenceVideo = this.networkVideoController.reference;
+        const referenceVideo = this.mediaController.referenceVideo;
         if (!referenceVideo && supplied.referenceVideo) {
           throw new XmaxError("INVALID_CONFIGURATION" /* invalidConfiguration */, "Create a network video stream before using a reference video");
         }
         const context = referenceVideo ? new RealtimeContext({ ...supplied, referenceVideo }) : supplied;
-        if (currentState.connectionState !== "Connected" /* connected */) {
+        if (currentState.connectionState !== "Connected" /* connected */ && !hasGeneration) {
           await this.performConnect(options.localStream, token);
         }
-        return this.performStartGeneration(token, videoFormat, context, options.faceRestoration ?? false);
+        return this.performStartGeneration(
+          token,
+          videoFormat,
+          context,
+          options.restart ?? false,
+          options.faceRestoration ?? false,
+          extraParams,
+          options.record ?? false
+        );
       }
     );
   }
+  /**
+   * 设置录制最终事件监听器；清除监听不停止录制，录制错误不影响生成。
+   */
+  setRecordingListener(listener) {
+    this.recordingController.setListener(listener);
+  }
   /**
    * 断开实时连接并保留当前本地媒体预览。
    */
   async disconnect() {
-    this.localVideoController.pause();
+    this.mediaController.pauseLocalVideo();
     this.launchTimer.cancel();
     this.clearVideoStatistics();
     await this.coordinator.disconnect();
@@ -8997,19 +10389,28 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    * 关闭期间重复调用会等待同一个释放任务；关闭完成后仍可重新创建本地流。
    */
   async close() {
-    this.localVideoController.pause();
+    this.mediaController.pauseLocalVideo();
     this.launchTimer.cancel();
     this.clearVideoStatistics();
     await this.coordinator.terminate(1 /* all */);
   }
+  /** TRTC 临时只按档位调整帧率；启动时也保留原始分辨率。 */
+  uplinkQualityFormat(baseline, level) {
+    const format = qualityVideoFormat(baseline, level);
+    return this.options.provider === "trtc" /* trtc */ ? format.resized(baseline.width, baseline.height) : format;
+  }
   /** 仅为尚无档位记录的本地上行选择初始档位；不应用配置或覆盖重连状态。 */
   resolveInitialUplinkQuality(track) {
     if (!this.qualityController) return void 0;
-    if (this.networkVideoController.currentTrack) return void 0;
+    if (this.mediaController.source === "networkVideo") return void 0;
     if (this.qualityStates.has(track)) return void 0;
     const baseline = track.videoFormat;
     if (!baseline) return void 0;
-    return { baseline, level: this.qualityHistory.read("uplink") };
+    let level = this.qualityHistory.read("uplink");
+    while (level > 1 && !supportsQualityEncoding(this.uplinkQualityFormat(baseline, level))) {
+      level--;
+    }
+    return { baseline, level };
   }
   /**
    * 建立实时连接：创建会话、进房发布、启动心跳并准备远端渲染轨道。
@@ -9038,8 +10439,8 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     if (token.signal.aborted) abortWarmup();
     try {
       let beforePublish;
-      if (localTrack === this.cameraController.currentTrack && this.cameraController.isFrameValidationEnabled) {
-        const cameraReady = this.cameraController.waitForValidCameraFrame(warmupController.signal).then(() => {
+      if (this.mediaController.isFrameValidationEnabled) {
+        const cameraReady = this.mediaController.waitForValidCameraFrame(warmupController.signal).then(() => {
           token.ensureCurrent();
         });
         void cameraReady.catch(() => {
@@ -9047,7 +10448,7 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
         beforePublish = () => cameraReady;
       }
       const initialQuality = this.resolveInitialUplinkQuality(localTrack);
-      const initialFormat = initialQuality ? qualityVideoFormat(initialQuality.baseline, initialQuality.level) : void 0;
+      const initialFormat = initialQuality ? this.uplinkQualityFormat(initialQuality.baseline, initialQuality.level) : void 0;
       const remote = await this.connectionManager.connect({
         localTrack,
         remoteVideoFormat: this.generationVideoFormat ?? localTrack.videoFormat,
@@ -9060,8 +10461,8 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
           this.qualityHistory?.write("uplink", initialQuality.level);
         },
         model: this.options.model,
-        includeLocalAudio: this.localVideoController.isActive ? this.localVideoController.audioTrack !== void 0 : localTrack === this.cameraController.currentTrack && this.cameraController.useMicrophone,
-        publishLocalMedia: !this.networkVideoController.currentTrack,
+        includeLocalAudio: this.mediaController.hasAudio,
+        publishLocalMedia: this.mediaController.source !== "networkVideo",
         ensureCurrent: () => token.ensureCurrent(),
         onPublished: () => {
           this.acceptsVideoStatistics = true;
@@ -9083,38 +10484,73 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
   }
   /**
    * 编排插帧、首帧计时和生成状态，任务与确认由生成管理器负责。
-   */
-  async performStartGeneration(token, videoFormat, context, faceRestoration) {
+   *
+   * @param token 当前生成操作的取消与状态控制令牌。
+   * @param videoFormat 模型生成使用的视频规格。
+   * @param context 本次已解析的生成条件。
+   * @param restart 是否替换当前生成任务并重新发送 start。
+   * @param faceRestoration 是否回贴原始人脸。
+   * @param extraParams 合并到本次 start 的 params，不缓存。
+   * @param record 是否为本次任务开启独立录制，不影响生成返回时间。
+   * @returns 承载生成结果的远端媒体流。
+   */
+  async performStartGeneration(token, videoFormat, context, restart, faceRestoration, extraParams, record2 = false) {
     token.setFailureScope(0 /* connection */);
+    const sessionID = this.connectionManager.currentSessionID;
+    if (!sessionID) {
+      throw new XmaxError("SESSION_ERROR" /* sessionError */, "Realtime session is unavailable");
+    }
+    await this.coordinator.commit(
+      new RealtimeState({ connectionState: "Starting" /* starting */, sessionID }),
+      token
+    );
+    token.ensureCurrent();
+    if (restart) {
+      void this.recordingController.stop("restarted" /* restarted */);
+    }
     const initialLevel = this.qualityHistory?.read("downlink") ?? 1;
     const targetSize = this.downlinkQualityController ? qualityVideoSize(videoFormat, initialLevel) : void 0;
     await this.prepareFrameInterpolation(targetSize ?? videoFormat, token);
     const completeFirstFrame = this.launchTimer.startFirstFrame();
+    this.remoteRenderWarmupCompletedHandler = void 0;
     this.remoteFrameDisplayHandler = () => {
-      if (!token.signal.aborted) completeFirstFrame();
+      if (!token.signal.aborted) {
+        completeFirstFrame();
+        this.remoteRenderWarmupCompletedHandler ?? (this.remoteRenderWarmupCompletedHandler = this.launchTimer.startRenderWarmup());
+      }
     };
+    this.renderController.prepareForGeneration();
     const taskID = await this.generationManager.start({
       videoFormat,
-      targetSize,
-      context,
-      faceRestoration,
-      mirror: this.currentLocalTrack === this.cameraController.currentTrack && this.cameraController.currentTrack?.position === "front" /* front */,
       signal: token.signal,
       ensureCurrent: () => token.ensureCurrent(),
-      onStartSent: this.localVideoController.isActive ? async () => {
-        token.ensureCurrent();
-        await this.localVideoController.start(token.signal);
-        token.ensureCurrent();
-      } : void 0,
       waitUntilRemoteReady: () => this.connectionManager.waitUntilRemoteTrackReady(
         REMOTE_FIRST_FRAME_TIMEOUT_MS,
         token.signal
-      )
-    });
-    const sessionID = this.connectionManager.currentSessionID;
-    if (!sessionID) {
-      throw new XmaxError("SESSION_ERROR" /* sessionError */, "Realtime session is unavailable");
-    }
+      ),
+      context,
+      restart,
+      onRemoteReady: record2 ? (taskID2) => {
+        if (restart) {
+          this.recordingController.reportFailure(taskID2, new XmaxError(
+            "INVALID_CONFIGURATION" /* invalidConfiguration */,
+            "Recording restarted generation tasks is not supported"
+          ));
+        } else {
+          this.recordingController.start(taskID2, () => this.streamController.getRemoteRecordingTracks());
+        }
+      } : void 0,
+      targetSize,
+      mirror: this.mediaController.source === "camera" && this.currentLocalTrack?.position === "front" /* front */,
+      faceRestoration,
+      onStartSent: this.mediaController.source === "localVideo" ? async () => {
+        token.ensureCurrent();
+        await this.mediaController.startLocalVideo(token.signal);
+        token.ensureCurrent();
+      } : void 0,
+      extraParams
+    });
+    token.ensureCurrent();
     this.downlinkQualityController?.stop();
     this.downlinkQualityState = {
       taskID,
@@ -9123,20 +10559,38 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
       size: targetSize ?? { width: videoFormat.width, height: videoFormat.height }
     };
     await this.coordinator.commit(
-      new RealtimeState({ connectionState: "Generating" /* generating */, sessionID, taskID }),
+      new RealtimeState({ connectionState: "Starting" /* starting */, sessionID, taskID }),
       token
     );
+    token.ensureCurrent();
+    await this.completeGenerationPresentation();
+    token.ensureCurrent();
     this.qualityHistory?.write("downlink", initialLevel);
-    const onFinish = this.networkVideoController.onFinish;
-    if (this.networkVideoController.currentTrack) {
-      this.streamController.activateNetworkVideoCompletion(onFinish && (() => {
-        if (this.currentState.taskID === taskID && this.currentState.connectionState === "Generating" /* generating */) {
-          return onFinish();
+    const onFinish = this.mediaController.onNetworkVideoFinish;
+    if (this.mediaController.source === "networkVideo") {
+      this.streamController.activateNetworkVideoCompletion(() => {
+        if (this.currentState.taskID === taskID && (this.currentState.connectionState === "Starting" /* starting */ || this.currentState.connectionState === "Generating" /* generating */)) {
+          void this.recordingController.stop("generationEnded" /* generationEnded */);
+          return onFinish?.();
         }
-      }));
+      });
     }
     return this.connectionManager.makeRemoteStream();
   }
+  /**
+   * 任务启动成功且当前视图完成预热后提交展示就绪状态，不阻塞远端流返回。
+   */
+  async completeGenerationPresentation() {
+    const { sessionID, taskID } = this.currentState;
+    if (!sessionID || !taskID) {
+      return;
+    }
+    await this.coordinator.remotePreviewDidBecomeReady(
+      sessionID,
+      taskID,
+      () => this.renderController.isReady
+    );
+  }
   /**
    * 心跳失败或会话失效：结束当前连接生命周期并通过最终状态给出原因。
    */
@@ -9151,9 +10605,11 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
    * 统一清理顺序：停止心跳与生成，再断开连接；all 额外释放本地媒体。
    */
   async performCleanup(scope, taskID) {
-    this.localVideoController.pause();
+    const recordingFinished = this.recordingController.stop("generationEnded" /* generationEnded */);
+    this.mediaController.pauseLocalVideo();
     this.launchTimer.cancel();
     this.remoteFrameDisplayHandler = void 0;
+    this.remoteRenderWarmupCompletedHandler = void 0;
     this.clearVideoStatistics();
     this.interpolationSize = void 0;
     this.applyRemoteInterpolation();
@@ -9161,27 +10617,17 @@ var XmaxRealtimeManager = class _XmaxRealtimeManager {
     this.connectionManager.stopHeartbeat();
     await this.generationManager.reset(taskID);
     const sessionID = await this.connectionManager.disconnect();
+    await recordingFinished;
     if (scope === 1 /* all */) {
-      const hadExternalSource = this.networkVideoController.currentTrack !== void 0 || this.localVideoController.isActive || this.externalVideoController.currentTrack !== void 0;
-      this.networkVideoController.stop();
       this.generationVideoFormat = void 0;
       this.disposePermissionWatch();
       try {
-        if (hadExternalSource) {
-          await this.rtcManager.destroy();
-        } else {
-          await this.cameraController.stopLocalCameraStream();
-        }
+        await this.mediaController.stopLocalStream();
       } catch (error) {
         XmaxLogger.realtime.error(
           () => `\u91CA\u653E\u672C\u5730\u5A92\u4F53\u5931\u8D25 (Failed to Release Local Media)
 \u2514\u2500 ${XmaxLogger.localized("\u539F\u56E0\uFF1A", "Reason: ")}${XmaxError.from(error).message}`
         );
-      } finally {
-        this.externalVideoController.stop();
-        if (this.localVideoController.isActive) {
-          await this.localVideoController.stop();
-        }
       }
     }
     return {
@@ -9706,9 +11152,9 @@ var XmaxClient = class {
   /**
    * 创建媒体处理与能力查询 Service。
    *
-   * @param model 媒体输入规则使用的模型，默认为 `x2.0-trtc`。
+   * @param model 媒体输入规则使用的模型，默认为 `x2.1.1-preview-cn`。
    */
-  createMediaService(model = "x2.0-trtc" /* x2_0_trtc */) {
+  createMediaService(model = "x2.1.1-preview-cn" /* x2_1_1_preview_cn */) {
     return new MediaService(model);
   }
   /**
@@ -9726,7 +11172,7 @@ var RealtimeConfiguration = class {
   /**
    * 创建实时业务配置。
    *
-   * @param init.model 实时生成业务使用的模型；未知名称原样透传，默认配置同 x2.1-preview。
+   * @param init.model 实时生成业务使用的模型；未知名称原样透传，默认配置同 x2.1.1-preview-cn。
    * @param init.provider RTC 提供方，默认按模型定义选择；必须受模型支持，创建后不可切换。
    * @param init.isFrameInterpolationEnabled 是否默认开启远端生成画面的插帧，默认 false。
    */
@@ -9759,13 +11205,6 @@ var RealtimeConfiguration = class {
   }
 };
 
-// src/Foundation/Media/Video/VideoContentMode.ts
-var VideoContentMode = /* @__PURE__ */ ((VideoContentMode2) => {
-  VideoContentMode2["fit"] = "fit";
-  VideoContentMode2["fill"] = "fill";
-  return VideoContentMode2;
-})(VideoContentMode || {});
-
 // src/Render/Video/RenderStatisticsController.ts
 var RenderStatisticsController = class {
   /**
@@ -9906,6 +11345,75 @@ var RenderStatisticsController = class {
   }
 };
 
+// src/Render/Video/RenderWarmupController.ts
+var RenderWarmupController = class {
+  /**
+   * 创建视图预热控制器。
+   */
+  constructor(element) {
+    __publicField(this, "element", element);
+    /**
+     * 预热配置与生命周期
+     */
+    __publicField(this, "durationMs");
+    __publicField(this, "timer");
+    __publicField(this, "started", false);
+    __publicField(this, "completed", false);
+  }
+  /**
+   * 是否仍在等待首帧或预热完成；期间不允许对不可见画面交互。
+   */
+  get isPending() {
+    return this.durationMs !== void 0 && !this.completed;
+  }
+  /**
+   * 为新媒体隐藏画面；undefined 表示直接显示，不启用预热。
+   */
+  prepare(durationMs) {
+    this.reset();
+    this.durationMs = durationMs;
+    if (durationMs === void 0) {
+      return;
+    }
+    this.element.style.transition = "none";
+    this.element.style.opacity = "0";
+    this.element.style.pointerEvents = "none";
+  }
+  /**
+   * 首帧就绪后开始一次性预热，结束时通知并渐入画面。
+   */
+  start(onCompleted) {
+    if (this.durationMs === void 0 || this.started) {
+      return;
+    }
+    this.started = true;
+    this.timer = setTimeout(() => {
+      this.timer = void 0;
+      this.completed = true;
+      const reduceMotion = globalThis.matchMedia?.("(prefers-reduced-motion: reduce)").matches;
+      this.element.style.transition = reduceMotion ? "none" : "opacity 300ms ease-in-out";
+      this.element.style.opacity = "1";
+      this.element.style.pointerEvents = "";
+      onCompleted();
+    }, this.durationMs);
+  }
+  /**
+   * 换流或卸载时取消预热和渐入，防止旧任务显示新画面。
+   */
+  reset() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+    this.started = false;
+    this.completed = false;
+    if (this.durationMs !== void 0) {
+      this.element.style.transition = "";
+      this.element.style.opacity = "";
+      this.element.style.pointerEvents = "";
+    }
+    this.durationMs = void 0;
+  }
+};
+
 // ../../node_modules/.pnpm/framegen@1.4.0/node_modules/framegen/rt.js
 var WG = 8;
 var texBgSeq = 0;
@@ -12275,6 +13783,498 @@ var RemoteVideoFramePipeline = class {
   }
 };
 
+// src/Render/Trajectory/TrajectoryOverlayView.ts
+var TrajectoryOverlayView = class {
+  /**
+   * 安装透明交互层及独立 Renderer；只有任务就绪时接管指针。
+   */
+  constructor(renderer) {
+    __publicField(this, "renderer", renderer);
+    /**
+     * 视图与显示配置
+     */
+    __publicField(this, "element", document.createElement("div"));
+    __publicField(this, "binding");
+    __publicField(this, "format");
+    __publicField(this, "contentMode", "fill" /* fill */);
+    __publicField(this, "mirrored", false);
+    __publicField(this, "requested", true);
+    __publicField(this, "enabled", false);
+    /**
+     * 手势采样与生命周期资源
+     */
+    __publicField(this, "pointers", /* @__PURE__ */ new Map());
+    __publicField(this, "nextID", 0);
+    __publicField(this, "animation");
+    __publicField(this, "lastSample", 0);
+    __publicField(this, "resizeObserver");
+    __publicField(this, "viewport");
+    __publicField(this, "visibilityChanged", () => {
+      if (document.hidden) {
+        this.cancel();
+      }
+      this.updateStyle();
+    });
+    __publicField(this, "onDown", (event) => this.begin(event));
+    __publicField(this, "onMove", (event) => this.move(event));
+    __publicField(this, "onEnd", (event) => this.end(event.pointerId));
+    Object.assign(this.element.style, { position: "absolute", inset: "0", zIndex: "2", overflow: "hidden" });
+    Object.assign(renderer.element.style, { position: "absolute", inset: "0", width: "100%", height: "100%", pointerEvents: "none" });
+    this.element.appendChild(renderer.element);
+    this.element.addEventListener("pointerdown", this.onDown);
+    this.element.addEventListener("pointermove", this.onMove);
+    this.element.addEventListener("pointerup", this.onEnd);
+    this.element.addEventListener("pointercancel", this.onEnd);
+    this.element.addEventListener("lostpointercapture", this.onEnd);
+    document.addEventListener("visibilitychange", this.visibilityChanged);
+    if (typeof ResizeObserver !== "undefined") {
+      this.resizeObserver = new ResizeObserver(() => this.cancel());
+      this.resizeObserver.observe(this.element);
+    }
+    this.updateStyle();
+  }
+  /**
+   * 更新任务绑定，清除旧任务手势和采样。
+   */
+  setBinding(binding, format, enabled = false) {
+    this.cancel();
+    this.binding = binding;
+    this.format = format;
+    this.enabled = enabled;
+    this.updateStyle();
+  }
+  /**
+   * 同步显示配置；配置变化后旧坐标不再继续发送。
+   */
+  configure(mode, mirrored, enabled) {
+    if (this.contentMode !== mode || this.mirrored !== mirrored || this.requested !== enabled) {
+      this.cancel();
+    }
+    this.contentMode = mode;
+    this.mirrored = mirrored;
+    this.requested = enabled;
+    this.updateStyle();
+  }
+  /**
+   * 卸载时取消采样、动画、捕获和事件监听；Renderer 可以再次挂载。
+   */
+  dispose() {
+    this.binding?.detach(this);
+    this.cancel();
+    this.resizeObserver?.disconnect();
+    document.removeEventListener("visibilitychange", this.visibilityChanged);
+    this.element.removeEventListener("pointerdown", this.onDown);
+    this.element.removeEventListener("pointermove", this.onMove);
+    this.element.removeEventListener("pointerup", this.onEnd);
+    this.element.removeEventListener("pointercancel", this.onEnd);
+    this.element.removeEventListener("lostpointercapture", this.onEnd);
+    this.element.remove();
+  }
+  /**
+   * 无任务或被禁用时不阻止页面滚动。
+   */
+  updateStyle() {
+    const active = this.requested && this.enabled && !!this.binding && !document.hidden;
+    this.element.style.pointerEvents = active ? "auto" : "none";
+    this.element.style.touchAction = active ? "none" : "auto";
+    this.element.style.userSelect = active ? "none" : "auto";
+  }
+  /**
+   * 根据实际显示区域拒绝黑边，移动到视口外时限制在可见视频边缘。
+   */
+  point(event, id, clamp) {
+    const viewport = this.element.getBoundingClientRect();
+    if (!this.format) {
+      return void 0;
+    }
+    const rect = InteractionCoordinateMapper.displayedFrame(viewport, this.format, this.contentMode);
+    if (!rect || !Number.isFinite(event.clientX) || !Number.isFinite(event.clientY)) {
+      return void 0;
+    }
+    const minX = Math.max(0, rect.x);
+    const minY = Math.max(0, rect.y);
+    const maxX = Math.min(viewport.width, rect.x + rect.width);
+    const maxY = Math.min(viewport.height, rect.y + rect.height);
+    let x = event.clientX - viewport.left;
+    let y = event.clientY - viewport.top;
+    if (!clamp && (x < minX || x > maxX || y < minY || y > maxY)) {
+      return void 0;
+    }
+    x = Math.max(minX, Math.min(maxX, x));
+    y = Math.max(minY, Math.min(maxY, y));
+    return Object.freeze({
+      id,
+      location: Object.freeze({ x, y }),
+      normalizedLocation: Object.freeze({ x: (x - rect.x) / rect.width, y: (y - rect.y) / rect.height }),
+      timestamp: performance.now()
+    });
+  }
+  /**
+   * 按下立即采样，不等待定时窗口；只接受鼠标主键。
+   */
+  begin(event) {
+    if (!this.requested || !this.enabled || !this.binding || document.hidden || event.button !== 0) {
+      return;
+    }
+    const point = this.point(event, ++this.nextID, false);
+    if (!point) {
+      return;
+    }
+    event.preventDefault();
+    this.pointers.set(event.pointerId, point);
+    try {
+      this.element.setPointerCapture(event.pointerId);
+    } catch {
+    }
+    this.render(() => this.renderer.renderBegan([point]));
+    this.sample(performance.now(), true);
+    this.schedule();
+  }
+  /**
+   * 高频指针事件只更新最新位置及视觉效果，不直接发送网络消息。
+   */
+  move(event) {
+    const previous = this.pointers.get(event.pointerId);
+    if (!previous) {
+      return;
+    }
+    const point = this.point(event, previous.id, true);
+    if (point) {
+      this.pointers.set(event.pointerId, point);
+      this.render(() => this.renderer.renderMoved([point]));
+    }
+  }
+  /**
+   * 释放单个指针，多指交互继续；最后一个指针释放后停止采样。
+   */
+  end(pointerID) {
+    const point = this.pointers.get(pointerID);
+    if (!point) {
+      return;
+    }
+    this.pointers.delete(pointerID);
+    try {
+      this.element.releasePointerCapture(pointerID);
+    } catch {
+    }
+    this.render(() => this.renderer.renderEnded([point.id]));
+    if (!this.pointers.size) {
+      this.stopSampling();
+    }
+  }
+  /**
+   * 取消全部手势及视觉效果，不保留跨生命周期轨迹。
+   */
+  cancel() {
+    for (const id of [...this.pointers.keys()]) {
+      this.end(id);
+    }
+    this.stopSampling();
+    this.render(() => this.renderer.reset());
+  }
+  /**
+   * 清理采样回调与视口快照。
+   */
+  stopSampling() {
+    if (this.animation !== void 0) {
+      cancelAnimationFrame(this.animation);
+    }
+    this.animation = void 0;
+    this.viewport = void 0;
+    this.lastSample = 0;
+  }
+  /**
+   * 只在存在活动触点时运行动画时钟。
+   */
+  schedule() {
+    if (this.animation === void 0 && this.pointers.size) {
+      this.animation = requestAnimationFrame((now) => {
+        this.animation = void 0;
+        this.sample(now);
+        this.schedule();
+      });
+    }
+  }
+  /**
+   * 固定频率发送所有活动触点的快照，布局变化时取消而非发送旧坐标。
+   */
+  sample(now, force = false) {
+    if (document.hidden) {
+      this.cancel();
+      return;
+    }
+    const { width, height } = this.element.getBoundingClientRect();
+    if (this.viewport && (width !== this.viewport.width || height !== this.viewport.height)) {
+      this.cancel();
+      return;
+    }
+    this.viewport = { width, height };
+    if (!force && now - this.lastSample < 1e3 / 30) {
+      return;
+    }
+    this.lastSample = now;
+    this.binding?.submit({
+      points: [...this.pointers.values()].map((point) => point.location),
+      viewportSize: this.viewport,
+      contentMode: this.contentMode,
+      mirrored: this.mirrored
+    });
+  }
+  /**
+   * 自定义效果异常不影响触点采集和网络发送。
+   */
+  render(action) {
+    try {
+      action();
+    } catch {
+      XmaxLogger.render.warning(() => "\u8F68\u8FF9\u6548\u679C\u7ED8\u5236\u5931\u8D25 (Trajectory Rendering Failed)");
+    }
+  }
+};
+
+// src/Render/Trajectory/DefaultTrajectoryEffectRenderer.ts
+var VISUAL = {
+  outerWidth: 18,
+  outerBlur: 12,
+  outerAlpha: 0.35,
+  middleWidth: 10,
+  middleBlur: 6,
+  middleAlpha: 0.75,
+  coreWidth: 3,
+  headRadius: 5,
+  headGlowRadius: 14,
+  headGlowAlpha: 0.9,
+  ringCount: 2,
+  ringStartRadius: 10,
+  ringSpacing: 14,
+  ringLineWidth: 2,
+  ringPulseSpeed: 1.2,
+  ringMaxAlpha: 0.6,
+  particleCount: 4,
+  particleRadius: 3,
+  particleOrbitRadius: 22,
+  particleSpeed: 0.06,
+  particleAlpha: 0.6,
+  fadeAlpha: 0.05,
+  idleFadeFrames: 64
+};
+var DefaultTrajectoryEffectRenderer = class {
+  /**
+   * 安装独立视觉图层，不注册指针事件。
+   */
+  constructor() {
+    /**
+     * 画布与动画资源；尾迹保留像素渐隐，触点装饰每帧重绘。
+     */
+    __publicField(this, "element", document.createElement("div"));
+    __publicField(this, "trailCanvas", document.createElement("canvas"));
+    __publicField(this, "effectCanvas", document.createElement("canvas"));
+    __publicField(this, "animation");
+    __publicField(this, "hasTrailPixels", false);
+    __publicField(this, "idleFadeFrames", 0);
+    /**
+     * 活动触点和等待下一帧绘制的线段。
+     */
+    __publicField(this, "pointers", /* @__PURE__ */ new Map());
+    __publicField(this, "segments", []);
+    for (const canvas of [this.trailCanvas, this.effectCanvas]) {
+      Object.assign(canvas.style, { position: "absolute", inset: "0", width: "100%", height: "100%", pointerEvents: "none" });
+      this.element.appendChild(canvas);
+    }
+  }
+  /**
+   * 开始触点装饰，脉冲动画以本次按下时间为起点。
+   */
+  renderBegan(points) {
+    for (const point of points) {
+      this.pointers.set(point.id, { point, startedAt: point.timestamp });
+    }
+    this.idleFadeFrames = 0;
+    this.schedule();
+  }
+  /**
+   * 只绘制新线段，旧像素自然衰减，不反复加亮整条历史轨迹。
+   */
+  renderMoved(points) {
+    for (const point of points) {
+      const pointer = this.pointers.get(point.id);
+      if (pointer) {
+        this.segments.push({ from: pointer.point, to: point });
+        pointer.point = point;
+      }
+    }
+    this.schedule();
+  }
+  /**
+   * 释放触点后移除装饰，仅保留尾迹的渐隐动画。
+   */
+  renderEnded(identifiers) {
+    for (const id of identifiers) {
+      this.pointers.delete(id);
+    }
+    this.schedule();
+  }
+  /**
+   * 清除画面、待绘制数据及动画，允许同一 Renderer 再次挂载。
+   */
+  reset() {
+    if (this.animation !== void 0) {
+      cancelAnimationFrame(this.animation);
+    }
+    this.animation = void 0;
+    this.pointers.clear();
+    this.segments.length = 0;
+    this.hasTrailPixels = false;
+    this.idleFadeFrames = 0;
+    for (const canvas of [this.trailCanvas, this.effectCanvas]) {
+      canvas.getContext("2d")?.clearRect(0, 0, canvas.width, canvas.height);
+    }
+  }
+  /**
+   * 仅在触点、待绘制线段或残留尾迹存在时申请下一帧。
+   */
+  schedule() {
+    if (this.animation === void 0 && (this.pointers.size || this.segments.length || this.hasTrailPixels)) {
+      this.animation = requestAnimationFrame((now) => this.draw(now));
+    }
+  }
+  /**
+   * 同步画布分辨率，分别更新尾迹和触点视觉图层。
+   */
+  draw(now) {
+    this.animation = void 0;
+    const trail = this.trailCanvas.getContext("2d");
+    const effects = this.effectCanvas.getContext("2d");
+    if (!trail || !effects) {
+      this.reset();
+      return;
+    }
+    const rect = this.element.getBoundingClientRect();
+    const dpr = globalThis.devicePixelRatio || 1;
+    const width = Math.max(1, Math.round(rect.width * dpr));
+    const height = Math.max(1, Math.round(rect.height * dpr));
+    for (const canvas of [this.trailCanvas, this.effectCanvas]) {
+      if (canvas.width !== width || canvas.height !== height) {
+        canvas.width = width;
+        canvas.height = height;
+        this.hasTrailPixels = false;
+      }
+    }
+    if (this.hasTrailPixels) {
+      trail.save();
+      trail.globalCompositeOperation = "destination-out";
+      trail.fillStyle = "rgba(0,0,0," + VISUAL.fadeAlpha + ")";
+      trail.fillRect(0, 0, width, height);
+      trail.restore();
+    }
+    if (this.segments.length) {
+      this.drawSegments(trail, dpr);
+      this.segments.length = 0;
+      this.hasTrailPixels = true;
+      this.idleFadeFrames = 0;
+    }
+    effects.clearRect(0, 0, width, height);
+    effects.save();
+    effects.globalCompositeOperation = "lighter";
+    for (const { point, startedAt } of this.pointers.values()) {
+      const x = point.location.x * dpr;
+      const y = point.location.y * dpr;
+      if (this.pointers.size === 1) {
+        this.drawRings(effects, x, y, dpr, (now - startedAt) / 1e3);
+        this.drawParticles(effects, x, y, dpr, (now - startedAt) / 1e3);
+      }
+      this.drawGlow(effects, x, y, VISUAL.headGlowRadius * dpr, VISUAL.headGlowAlpha, true);
+      effects.fillStyle = "rgba(255,255,255,1)";
+      effects.beginPath();
+      effects.arc(x, y, VISUAL.headRadius * dpr, 0, Math.PI * 2);
+      effects.fill();
+    }
+    effects.restore();
+    if (this.pointers.size) {
+      this.idleFadeFrames = 0;
+    } else if (this.hasTrailPixels && ++this.idleFadeFrames > VISUAL.idleFadeFrames) {
+      trail.clearRect(0, 0, width, height);
+      this.hasTrailPixels = false;
+      this.idleFadeFrames = 0;
+    }
+    this.schedule();
+  }
+  /**
+   * 叠加绿色外晕、中层和白色线芯；多指时省略阴影降低绘制开销。
+   */
+  drawSegments(context, dpr) {
+    const layers = [
+      { width: VISUAL.outerWidth, blur: VISUAL.outerBlur, color: this.green(VISUAL.outerAlpha) },
+      { width: VISUAL.middleWidth, blur: VISUAL.middleBlur, color: this.green(VISUAL.middleAlpha) },
+      { width: VISUAL.coreWidth, blur: 0, color: "rgba(255,255,255,1)" }
+    ];
+    for (const layer of layers) {
+      context.save();
+      context.globalCompositeOperation = "lighter";
+      context.lineCap = "round";
+      context.lineJoin = "round";
+      context.lineWidth = layer.width * dpr;
+      context.strokeStyle = layer.color;
+      context.shadowBlur = this.pointers.size > 1 ? 0 : layer.blur * dpr;
+      context.shadowColor = context.shadowBlur ? layer.color : "transparent";
+      context.beginPath();
+      for (const { from, to } of this.segments) {
+        context.moveTo(from.location.x * dpr, from.location.y * dpr);
+        context.lineTo(to.location.x * dpr, to.location.y * dpr);
+      }
+      context.stroke();
+      context.restore();
+    }
+  }
+  /**
+   * 绘制触点周围两层不同相位的脉冲圆环。
+   */
+  drawRings(context, x, y, dpr, elapsed) {
+    context.lineWidth = VISUAL.ringLineWidth * dpr;
+    for (let index = 0; index < VISUAL.ringCount; index++) {
+      const pulse = (Math.sin((elapsed * VISUAL.ringPulseSpeed + index * 0.5) * Math.PI * 2) + 1) / 2;
+      const radius = (VISUAL.ringStartRadius + index * VISUAL.ringSpacing + pulse * 6) * dpr;
+      context.strokeStyle = this.green(VISUAL.ringMaxAlpha * (1 - index * 0.2) * (0.5 + pulse * 0.5));
+      context.beginPath();
+      context.arc(x, y, radius, 0, Math.PI * 2);
+      context.stroke();
+    }
+  }
+  /**
+   * 绘制四个反向交错运动的柔和环绕粒子。
+   */
+  drawParticles(context, x, y, dpr, elapsed) {
+    for (let index = 0; index < VISUAL.particleCount; index++) {
+      const direction = index % 2 === 0 ? 1 : -1;
+      const angle = index / VISUAL.particleCount * Math.PI * 2 + elapsed * VISUAL.particleSpeed * direction;
+      const radius = VISUAL.particleOrbitRadius * dpr;
+      const alpha = VISUAL.particleAlpha * (0.6 + Math.sin(elapsed * 3 + index) * 0.4);
+      this.drawGlow(context, x + Math.cos(angle) * radius, y + Math.sin(angle) * radius, VISUAL.particleRadius * 2 * dpr, alpha);
+    }
+  }
+  /**
+   * 绘制径向绿色光晕，触点核心增加中间色阶。
+   */
+  drawGlow(context, x, y, radius, alpha, head = false) {
+    const gradient = context.createRadialGradient(x, y, 0, x, y, radius);
+    gradient.addColorStop(0, this.green(alpha));
+    if (head) {
+      gradient.addColorStop(0.4, this.green(alpha * 0.6));
+    }
+    gradient.addColorStop(1, this.green(0));
+    context.fillStyle = gradient;
+    context.beginPath();
+    context.arc(x, y, radius, 0, Math.PI * 2);
+    context.fill();
+  }
+  /**
+   * 统一轨迹主题色，透明度由各视觉层指定。
+   */
+  green(alpha) {
+    return "rgba(0,255,100," + alpha + ")";
+  }
+};
+
 // src/Render/Video/XmaxVideoView.ts
 var OBJECT_FIT = {
   ["fit" /* fit */]: "contain",
@@ -12328,15 +14328,27 @@ var XmaxVideoView = class {
      * 呈现统计组件
      */
     __publicField(this, "statisticsController");
+    /**
+     * 远端画面预热与渐入组件
+     */
+    __publicField(this, "warmupController");
     /**
      * DOM 挂载状态
      */
     __publicField(this, "detached", false);
+    /**
+     * 轨迹交互配置与懒加载视图
+     */
+    __publicField(this, "interactionEnabled", true);
+    __publicField(this, "customTrajectoryRenderer");
+    __publicField(this, "trajectoryOverlay");
     this.contentMode = options?.videoContentMode ?? "fill" /* fill */;
+    this.interactionEnabled = options?.isInteractionEnabled ?? true;
     this.element = document.createElement("div");
     this.element.style.position = "relative";
     this.element.style.overflow = "hidden";
     this.element.style.backgroundColor = "black";
+    this.warmupController = new RenderWarmupController(this.element);
     this.videoElement = document.createElement("video");
     this.statisticsController = new RenderStatisticsController(this.videoElement);
     this.videoElement.autoplay = true;
@@ -12349,6 +14361,36 @@ var XmaxVideoView = class {
     this.applyContentMode();
     this.element.appendChild(this.videoElement);
   }
+  /**
+   * 是否允许远端轨迹交互；本地轨道没有交互绑定，不受此开关影响。
+   */
+  get isInteractionEnabled() {
+    return this.interactionEnabled;
+  }
+  /**
+   * 关闭时立即取消当前手势，不影响视频播放。
+   */
+  set isInteractionEnabled(enabled) {
+    this.interactionEnabled = enabled;
+    this.trajectoryOverlay?.configure(this.contentMode, this.mirrored, enabled && !this.warmupController.isPending);
+  }
+  /**
+   * 自定义轨迹视觉效果；undefined 表示使用 SDK 默认效果。
+   */
+  get trajectoryRenderer() {
+    return this.customTrajectoryRenderer;
+  }
+  /**
+   * 替换效果前释放旧动画，采样及网络发送仍由 SDK 管理。
+   */
+  set trajectoryRenderer(renderer) {
+    if (this.customTrajectoryRenderer === renderer) {
+      return;
+    }
+    this.disposeTrajectory();
+    this.customTrajectoryRenderer = renderer;
+    this.attachTrajectory();
+  }
   /**
    * 当前显示的视频轨道；切换时自动解绑旧轨道。
    */
@@ -12421,6 +14463,7 @@ var XmaxVideoView = class {
   attach(to) {
     this.detached = false;
     to.appendChild(this.element);
+    this.attachTrajectory();
     if ((this.videoElement.srcObject || this.videoElement.getAttribute("src")) && this.videoElement.autoplay && !this.videoElement.ended && this.videoElement.paused && typeof this.videoElement.play === "function") {
       void this.videoElement.play().catch((error) => {
         XmaxLogger.render.warning(() => `\u6062\u590D\u89C6\u9891\u64AD\u653E\u5931\u8D25 (Failed to Resume Video Playback)
@@ -12430,6 +14473,7 @@ var XmaxVideoView = class {
     this.startInterpolation();
     this.startRenderStatistics();
     if ((this.videoElement.srcObject || this.videoElement.getAttribute("src")) && !this.hasNotifiedFrameDisplay) {
+      this.prepareRenderWarmup();
       this.armFrameDisplayNotification();
     }
   }
@@ -12438,9 +14482,12 @@ var XmaxVideoView = class {
    */
   detach() {
     this.detached = true;
+    this.disposeTrajectory();
     this.statisticsController.stop();
     this.stopInterpolation();
     this.cancelFrameDisplayNotification();
+    this.warmupController.reset();
+    this.hasNotifiedFrameDisplay = false;
     if (this.videoElement.getAttribute("src")) {
       this.videoElement.pause();
     }
@@ -12450,6 +14497,7 @@ var XmaxVideoView = class {
    * 设置网络视频预览；静音播放一次，不捕获或发布媒体轨道。 @internal
    */
   setVideoURL(url) {
+    this.warmupController.reset();
     this.statisticsController.stop();
     this.stopInterpolation();
     this.cancelFrameDisplayNotification();
@@ -12478,13 +14526,27 @@ var XmaxVideoView = class {
     this.cancelFrameDisplayNotification();
     this.hasNotifiedFrameDisplay = false;
     this.videoElement.srcObject = stream;
+    this.warmupController.reset();
     if (stream) {
       this.videoElement.autoplay = true;
+      this.prepareRenderWarmup();
       this.armFrameDisplayNotification();
       this.startInterpolation();
       this.startRenderStatistics();
     }
   }
+  /**
+   * 新生成任务重新等待首帧和预热，不替换正在播放的媒体流。 @internal
+   */
+  prepareForGeneration() {
+    this.cancelFrameDisplayNotification();
+    this.warmupController.reset();
+    this.hasNotifiedFrameDisplay = false;
+    this.prepareRenderWarmup();
+    if (!this.detached && this.videoElement.srcObject) {
+      this.armFrameDisplayNotification();
+    }
+  }
   /**
    * 由远端绑定注入配置；本地预览不走此管线。 @internal
    */
@@ -12544,6 +14606,7 @@ var XmaxVideoView = class {
     const binding = VideoRenderRegistry.binding(track);
     if (binding) {
       binding.attachHandler(this, this.contentMode);
+      this.attachTrajectory();
       return;
     }
     if (track.mediaStreamTrack) {
@@ -12558,6 +14621,8 @@ var XmaxVideoView = class {
    * 解绑当前轨道并清空渲染内容。
    */
   detachCurrentTrack() {
+    this.warmupController.reset();
+    this.disposeTrajectory();
     this.statisticsController.stop();
     const track = this.currentTrack;
     if (track) {
@@ -12584,8 +14649,15 @@ var XmaxVideoView = class {
       }
       this.hasNotifiedFrameDisplay = true;
       this.cancelFrameDisplayNotification();
+      const notifiedSequence = this.frameNotificationSequence;
       binding?.frameDisplayHandler?.();
       this.frameDisplayHandler?.();
+      if (notifiedSequence === this.frameNotificationSequence) {
+        this.warmupController.start(() => {
+          this.applyContentMode();
+          binding?.renderWarmupCompletedHandler?.();
+        });
+      }
     };
     if (typeof this.videoElement.requestVideoFrameCallback === "function") {
       this.videoFrameCallbackID = this.videoElement.requestVideoFrameCallback(notify);
@@ -12613,10 +14685,19 @@ var XmaxVideoView = class {
       this.onPlaying = void 0;
     }
   }
+  /**
+   * 仅远端渲染绑定启用预热，本地预览和普通媒体直接显示。
+   */
+  prepareRenderWarmup() {
+    const binding = this.currentTrack ? VideoRenderRegistry.binding(this.currentTrack) : void 0;
+    this.warmupController.prepare(binding?.renderWarmupMs);
+    this.applyContentMode();
+  }
   /**
    * 应用显示模式与镜像样式。
    */
   applyContentMode() {
+    this.trajectoryOverlay?.configure(this.contentMode, this.mirrored, this.interactionEnabled && !this.warmupController.isPending);
     this.videoElement.style.objectFit = OBJECT_FIT[this.contentMode];
     this.videoElement.style.transform = this.mirrored ? "scaleX(-1)" : "";
     if (this.interpolationCanvas) {
@@ -12630,6 +14711,30 @@ var XmaxVideoView = class {
   startRenderStatistics() {
     if (!this.detached) this.statisticsController.start();
   }
+  /**
+   * 仅为具备交互能力的轨道创建覆盖层，普通视频和本地预览不分配 Canvas。
+   */
+  attachTrajectory() {
+    if (this.detached || this.trajectoryOverlay || !this.currentTrack) {
+      return;
+    }
+    const binding = TrajectoryRegistry.binding(this.currentTrack);
+    if (!binding) {
+      return;
+    }
+    const overlay = new TrajectoryOverlayView(this.customTrajectoryRenderer ?? new DefaultTrajectoryEffectRenderer());
+    this.trajectoryOverlay = overlay;
+    overlay.configure(this.contentMode, this.mirrored, this.interactionEnabled && !this.warmupController.isPending);
+    this.element.appendChild(overlay.element);
+    binding.attach(overlay);
+  }
+  /**
+   * 换轨或卸载时移除全部交互资源；再次挂载时重新建立绑定。
+   */
+  disposeTrajectory() {
+    this.trajectoryOverlay?.dispose();
+    this.trajectoryOverlay = void 0;
+  }
 };
 
 // src/Render/Video/XmaxRealtimeVideoView.ts
@@ -12668,8 +14773,8 @@ var XmaxRealtimeVideoView = class {
     this.element.style.position = "relative";
     this.element.style.overflow = "hidden";
     this.element.style.backgroundColor = "black";
-    this.localVideoView = new XmaxVideoView({ videoContentMode: this.contentMode });
-    this.remoteVideoView = new XmaxVideoView({ videoContentMode: this.contentMode });
+    this.localVideoView = new XmaxVideoView({ videoContentMode: this.contentMode, isInteractionEnabled: false });
+    this.remoteVideoView = new XmaxVideoView({ videoContentMode: this.contentMode, isInteractionEnabled: options?.isInteractionEnabled });
     for (const view of [this.localVideoView, this.remoteVideoView]) {
       view.element.style.position = "absolute";
       view.element.style.inset = "0";
@@ -12684,6 +14789,30 @@ var XmaxRealtimeVideoView = class {
   get localTrack() {
     return this.currentLocalTrack;
   }
+  /**
+   * 只控制远端视图的轨迹交互，本地预览始终不接管手势。
+   */
+  get isInteractionEnabled() {
+    return this.remoteVideoView.isInteractionEnabled;
+  }
+  /**
+   * 转交远端交互开关。
+   */
+  set isInteractionEnabled(enabled) {
+    this.remoteVideoView.isInteractionEnabled = enabled;
+  }
+  /**
+   * 远端视图的自定义轨迹效果。
+   */
+  get trajectoryRenderer() {
+    return this.remoteVideoView.trajectoryRenderer;
+  }
+  /**
+   * undefined 恢复默认效果，不改变轨迹发送逻辑。
+   */
+  set trajectoryRenderer(renderer) {
+    this.remoteVideoView.trajectoryRenderer = renderer;
+  }
   /**
    * 替换本地预览轨道；轨道未变化时保留当前绑定。
    */
@@ -12696,7 +14825,7 @@ var XmaxRealtimeVideoView = class {
   }
   /**
    * 当前显示的远端生成视频轨道。
-   * 设置新轨道后等待首帧提交显示再渐入；置空时立即恢复本地预览。
+   * SDK 远端轨道等待首帧及预热后渐入；置空时立即恢复本地预览。
    */
   get remoteTrack() {
     return this.currentRemoteTrack;
@@ -12757,18 +14886,23 @@ var XmaxRealtimeVideoView = class {
     this.element.remove();
   }
   /**
-   * 更新远端轨道绑定：重置渐入状态，等待首帧提交后再显示远端画面。
+   * 更新远端轨道绑定；SDK 轨道共用单轨视图的预热，普通轨道等待首帧后渐入。
    */
   updateRemoteTrack() {
     const remoteTrack = this.currentRemoteTrack;
     this.remoteVideoView.frameDisplayHandler = void 0;
+    this.remoteVideoView.track = void 0;
     this.remoteVideoView.element.style.transition = "";
     this.remoteVideoView.element.style.opacity = "0";
     this.remoteVideoView.element.style.visibility = "hidden";
-    this.remoteVideoView.track = void 0;
     if (!remoteTrack) {
       return;
     }
+    if (VideoRenderRegistry.binding(remoteTrack)?.renderWarmupMs !== void 0) {
+      this.remoteVideoView.element.style.visibility = "visible";
+      this.remoteVideoView.track = remoteTrack;
+      return;
+    }
     this.remoteVideoView.frameDisplayHandler = () => {
       if (this.currentRemoteTrack !== remoteTrack) {
         return;
@@ -12815,6 +14949,9 @@ export {
   RealtimeVideoTrack,
   RealtimeMediaStream,
   RealtimeVideoSampleMethod,
+  VideoContentMode,
+  RealtimeRecordingEventType,
+  RealtimeRecordingFinishReason,
   RealtimeContext,
   RealtimeConnectionState,
   RealtimeReason,
@@ -12825,8 +14962,7 @@ export {
   NonRealtimeTaskError,
   XmaxClient,
   RealtimeConfiguration,
-  VideoContentMode,
   XmaxVideoView,
   XmaxRealtimeVideoView
 };
-//# sourceMappingURL=chunk-JGDZ3RD3.js.map
+//# sourceMappingURL=chunk-LOYJFYQT.js.map