@xmaxai/sdk 0.1.0

package/dist/experimental/index.cjs

@@ -0,0 +1,3897 @@
+'use strict';
+
+var COS = require('cos-js-sdk-v5');
+var VERTC = require('@volcengine/rtc');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var COS__default = /*#__PURE__*/_interopDefault(COS);
+var VERTC__default = /*#__PURE__*/_interopDefault(VERTC);
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/rtc/local-publish-diagnostics.ts
+var local_publish_diagnostics_exports = {};
+__export(local_publish_diagnostics_exports, {
+  waitForMediaStreamTrackFrames: () => waitForMediaStreamTrackFrames
+});
+async function waitForMediaStreamTrackFrames(track, options = {}) {
+  const minFrames = options.minFrames ?? 3;
+  const timeoutMs = options.timeoutMs ?? 3e3;
+  const startedAtMs = performance.now();
+  if (track.readyState === "ended") {
+    return { ready: false, frameCount: 0, elapsedMs: 0 };
+  }
+  return new Promise((resolve) => {
+    let frameCount = 0;
+    let settled = false;
+    let rvfcHandle = null;
+    let rafId = null;
+    const finish = (ready) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timeoutTimer);
+      const video = videoEl;
+      if (rvfcHandle !== null) {
+        video.cancelVideoFrameCallback?.(rvfcHandle);
+      }
+      if (rafId !== null) {
+        window.cancelAnimationFrame(rafId);
+      }
+      try {
+        videoEl.pause();
+        videoEl.srcObject = null;
+        videoEl.remove();
+      } catch {
+      }
+      resolve({
+        ready,
+        frameCount,
+        elapsedMs: Number((performance.now() - startedAtMs).toFixed(1))
+      });
+    };
+    const onFrame = () => {
+      frameCount += 1;
+      if (frameCount >= minFrames) {
+        finish(true);
+      }
+    };
+    const videoEl = document.createElement("video");
+    videoEl.muted = true;
+    videoEl.playsInline = true;
+    videoEl.autoplay = true;
+    videoEl.srcObject = new MediaStream([track]);
+    videoEl.style.cssText = "position:fixed;left:-9999px;top:-9999px;width:1px;height:1px;opacity:0;pointer-events:none";
+    const schedule = () => {
+      if (settled) {
+        return;
+      }
+      const video = videoEl;
+      if (video.requestVideoFrameCallback) {
+        rvfcHandle = video.requestVideoFrameCallback(() => {
+          onFrame();
+          schedule();
+        });
+        return;
+      }
+      rafId = window.requestAnimationFrame(() => {
+        onFrame();
+        schedule();
+      });
+    };
+    const timeoutTimer = setTimeout(() => finish(frameCount >= minFrames), timeoutMs);
+    void videoEl.play().then(() => {
+      if (!settled) {
+        schedule();
+      }
+    }).catch(() => finish(false));
+  });
+}
+var init_local_publish_diagnostics = __esm({
+  "src/rtc/local-publish-diagnostics.ts"() {
+  }
+});
+
+// src/i18n/en-US.ts
+var enUS = {
+  "errors.apiKeyEmpty": "apiKey cannot be empty",
+  "errors.baseUrlEmpty": "baseUrl is required \u2014 pass XMAX_OPEN_API_PRODUCTION_BASE_URL for production",
+  "errors.modelEmpty": "model cannot be empty",
+  "errors.invalidJson": "Response is not valid JSON",
+  "errors.invalidPayload": "Response payload is invalid",
+  "errors.requestFailed": "Request failed",
+  "errors.requestRetry": "Request failed. Please try again later.",
+  "errors.requestTimeout": "Request timeout",
+  "errors.invalidFile": "file must be a File",
+  "errors.invalidFileType": "invalid file type: {type}",
+  "errors.sessionJoinInfoIncomplete": "session does not contain complete RTC join info",
+  "errors.sessionUidMissing": "session does not contain sessionUid",
+  "errors.refImageMissing": "missing reference image",
+  "errors.captureStreamUnsupported": "captureStream is not supported in this browser",
+  "errors.videoTrackMissing": "failed to create video track from file",
+  "errors.imageTrackMissing": "failed to create video track from image file",
+  "errors.imageLoadFailed": "failed to load image \u2014 try again after selecting the file",
+  "errors.invalidMediaFileType": "unsupported media file type: {type}",
+  "errors.videoPlaybackFailed": "failed to start video playback \u2014 try again after selecting the file",
+  "errors.rtcNotJoined": "Please join the RTC room first",
+  "errors.rtcNotJoinedForMessaging": "Please join the RTC room before sending events",
+  "rtc.alreadyInRoom": "RTC is already in the target room. Skip duplicate join.",
+  "rtc.joiningRoom": "Joining RTC room",
+  "rtc.joinSuccess": "RTC joinRoom succeeded",
+  "rtc.roomUsers": "Current room users: {users}",
+  "rtc.localVideoAlreadyPublished": "Local video is already published",
+  "rtc.localVideoPublished": "Local video capture started and stream published",
+  "rtc.externalVideoPublished": "External video stream published",
+  "rtc.localVideoStopped": "Local video publishing stopped",
+  "rtc.leaveRoomError": "Error occurred during RTC leaveRoom",
+  "rtc.engineDestroyed": "RTC engine destroyed",
+  "rtc.roomEventSent": "RTC event sent",
+  "rtc.remotePlayerRefreshed": "Remote video player refreshed: {userId}",
+  "rtc.remotePlayerRefreshFailed": "Failed to refresh remote video player",
+  "rtc.userJoined": "User joined RTC room: {userId}",
+  "rtc.userLeft": "User left RTC room: {userId}",
+  "rtc.connectionStateChanged": "RTC connection state changed",
+  "rtc.userPublished": "User published stream: {userId}",
+  "rtc.userUnpublished": "User unpublished stream: {userId}",
+  "rtc.seiReceived": "Remote SEI received: {userId}",
+  "rtc.error": "RTC error: {code}",
+  "rtc.captureSizeSet": "Local video capture size set: {width} x {height}",
+  "rtc.encoderPreferenceSet": "Video encoder preference set to H.264",
+  "rtc.encoderPreferenceFailed": "Failed to set video encoder preference",
+  "rtc.remoteWaitSei": "Remote video is waiting for SEI gate: {userId}",
+  "rtc.remoteContainerNotReady": "Remote video container is not ready. Skip binding.",
+  "rtc.remotePlayerBound": "Remote video player bound: {userId}",
+  "rtc.remoteOutputStalled": "Remote output stalled for 15s; attempting to recover generation",
+  "rtc.sendSeiFailed": "Failed to send SEI. The browser or encoder config may not support it.",
+  "rtc.seiUnsupported": "H.264 is not supported. SEI gate will be disabled and output will not be blocked.",
+  "rtc.seiGateFallback": "SEI gate timed out \u2014 showing remote output",
+  "rtc.getCodecsFailed": "Failed to get supported codecs. SEI gate will be disabled and output will not be blocked."
+};
+
+// src/i18n/zh-CN.ts
+var zhCN = {
+  "errors.apiKeyEmpty": "apiKey \u4E0D\u80FD\u4E3A\u7A7A",
+  "errors.baseUrlEmpty": "baseUrl \u4E3A\u5FC5\u586B\u9879 \u2014 \u751F\u4EA7\u73AF\u5883\u8BF7\u4F20\u5165 XMAX_OPEN_API_PRODUCTION_BASE_URL",
+  "errors.modelEmpty": "model \u4E0D\u80FD\u4E3A\u7A7A",
+  "errors.invalidJson": "\u54CD\u5E94\u4E0D\u662F\u6709\u6548\u7684 JSON",
+  "errors.invalidPayload": "\u54CD\u5E94\u6570\u636E\u683C\u5F0F\u4E0D\u6B63\u786E",
+  "errors.requestFailed": "\u8BF7\u6C42\u5931\u8D25",
+  "errors.requestRetry": "\u8BF7\u6C42\u5931\u8D25\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  "errors.requestTimeout": "\u8BF7\u6C42\u8D85\u65F6",
+  "errors.invalidFile": "file \u5FC5\u987B\u662F File \u7C7B\u578B",
+  "errors.invalidFileType": "\u6587\u4EF6\u7C7B\u578B\u4E0D\u6B63\u786E\uFF1A{type}",
+  "errors.sessionJoinInfoIncomplete": "session \u7F3A\u5C11\u5B8C\u6574\u7684 RTC \u8FDB\u623F\u4FE1\u606F",
+  "errors.sessionUidMissing": "session \u7F3A\u5C11 sessionUid",
+  "errors.refImageMissing": "\u7F3A\u5C11\u53C2\u8003\u56FE",
+  "errors.captureStreamUnsupported": "\u5F53\u524D\u6D4F\u89C8\u5668\u4E0D\u652F\u6301 captureStream",
+  "errors.videoTrackMissing": "\u672A\u80FD\u4ECE\u89C6\u9891\u6587\u4EF6\u521B\u5EFA video track",
+  "errors.imageTrackMissing": "\u672A\u80FD\u4ECE\u56FE\u7247\u6587\u4EF6\u521B\u5EFA video track",
+  "errors.imageLoadFailed": "\u56FE\u7247\u65E0\u6CD5\u52A0\u8F7D\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u6587\u4EF6\u540E\u518D\u8BD5",
+  "errors.invalidMediaFileType": "\u4E0D\u652F\u6301\u7684\u5A92\u4F53\u6587\u4EF6\u7C7B\u578B\uFF1A{type}",
+  "errors.videoPlaybackFailed": "\u89C6\u9891\u65E0\u6CD5\u5F00\u59CB\u64AD\u653E\uFF0C\u8BF7\u91CD\u65B0\u9009\u62E9\u6587\u4EF6\u540E\u518D\u8BD5",
+  "errors.rtcNotJoined": "\u8BF7\u5148\u6210\u529F\u52A0\u5165 RTC \u623F\u95F4",
+  "errors.rtcNotJoinedForMessaging": "\u8BF7\u5148\u6210\u529F\u52A0\u5165 RTC \u623F\u95F4\u540E\u518D\u53D1\u9001\u4E8B\u4EF6",
+  "rtc.alreadyInRoom": "RTC \u5DF2\u5728\u76EE\u6807\u623F\u95F4\u4E2D\uFF0C\u8DF3\u8FC7\u91CD\u590D\u8FDB\u623F",
+  "rtc.joiningRoom": "\u51C6\u5907\u52A0\u5165 RTC \u623F\u95F4",
+  "rtc.joinSuccess": "RTC joinRoom \u6210\u529F",
+  "rtc.roomUsers": "\u5F53\u524D\u623F\u95F4\u7528\u6237: {users}",
+  "rtc.localVideoAlreadyPublished": "\u672C\u5730\u89C6\u9891\u5DF2\u5904\u4E8E\u53D1\u5E03\u72B6\u6001",
+  "rtc.localVideoPublished": "\u5DF2\u5F00\u542F\u672C\u5730\u89C6\u9891\u91C7\u96C6\u5E76\u53D1\u5E03\u89C6\u9891\u6D41",
+  "rtc.externalVideoPublished": "\u5DF2\u53D1\u5E03\u81EA\u5B9A\u4E49\u89C6\u9891\u6D41",
+  "rtc.localVideoStopped": "\u5DF2\u505C\u6B62\u672C\u5730\u89C6\u9891\u53D1\u5E03",
+  "rtc.leaveRoomError": "RTC leaveRoom \u8FC7\u7A0B\u4E2D\u51FA\u73B0\u5F02\u5E38",
+  "rtc.engineDestroyed": "RTC \u5F15\u64CE\u5DF2\u9500\u6BC1",
+  "rtc.roomEventSent": "\u5DF2\u53D1\u9001 RTC \u4E8B\u4EF6",
+  "rtc.remotePlayerRefreshed": "\u5DF2\u5237\u65B0\u8FDC\u7AEF\u89C6\u9891\u64AD\u653E\u5668: {userId}",
+  "rtc.remotePlayerRefreshFailed": "\u5237\u65B0\u8FDC\u7AEF\u89C6\u9891\u64AD\u653E\u5668\u5931\u8D25",
+  "rtc.userJoined": "\u7528\u6237\u52A0\u5165 RTC \u623F\u95F4: {userId}",
+  "rtc.userLeft": "\u7528\u6237\u79BB\u5F00 RTC \u623F\u95F4: {userId}",
+  "rtc.connectionStateChanged": "RTC \u8FDE\u63A5\u72B6\u6001\u53D8\u5316",
+  "rtc.userPublished": "\u7528\u6237\u53D1\u5E03\u6D41: {userId}",
+  "rtc.userUnpublished": "\u7528\u6237\u53D6\u6D88\u53D1\u5E03\u6D41: {userId}",
+  "rtc.seiReceived": "\u6536\u5230\u8FDC\u7AEF SEI: {userId}",
+  "rtc.error": "RTC \u9519\u8BEF: {code}",
+  "rtc.captureSizeSet": "\u5DF2\u8BBE\u7F6E\u672C\u5730\u89C6\u9891\u91C7\u96C6\u5C3A\u5BF8: {width} x {height}",
+  "rtc.encoderPreferenceSet": "\u5DF2\u8BBE\u7F6E\u89C6\u9891\u7F16\u7801\u504F\u597D\u4E3A H.264",
+  "rtc.encoderPreferenceFailed": "\u8BBE\u7F6E\u89C6\u9891\u7F16\u7801\u504F\u597D\u5931\u8D25",
+  "rtc.remoteWaitSei": "\u8FDC\u7AEF\u89C6\u9891\u7B49\u5F85 SEI \u653E\u884C: {userId}",
+  "rtc.remoteContainerNotReady": "\u8FDC\u7AEF\u89C6\u9891\u5BB9\u5668\u672A\u5C31\u7EEA\uFF0C\u8DF3\u8FC7\u7ED1\u5B9A",
+  "rtc.remotePlayerBound": "\u5DF2\u7ED1\u5B9A\u8FDC\u7AEF\u89C6\u9891\u64AD\u653E\u5668: {userId}",
+  "rtc.remoteOutputStalled": "\u8FDC\u7AEF\u8F93\u51FA\u8D85\u8FC7 15 \u79D2\u65E0\u65B0\u5E27\uFF0C\u5C1D\u8BD5\u6062\u590D\u751F\u6210\u4EFB\u52A1",
+  "rtc.sendSeiFailed": "\u53D1\u9001 SEI \u5931\u8D25\uFF0C\u5F53\u524D\u6D4F\u89C8\u5668\u6216\u7F16\u7801\u914D\u7F6E\u53EF\u80FD\u4E0D\u652F\u6301\u8BE5\u80FD\u529B",
+  "rtc.seiUnsupported": "\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301 H.264\uFF0CSEI gate \u5C06\u4E0D\u4F1A\u751F\u6548\uFF0Coutput \u5C06\u4E0D\u518D\u88AB\u62E6\u622A",
+  "rtc.seiGateFallback": "SEI \u95E8\u63A7\u8D85\u65F6\uFF0C\u5DF2\u663E\u793A\u8FDC\u7AEF\u8F93\u51FA",
+  "rtc.getCodecsFailed": "\u83B7\u53D6\u6D4F\u89C8\u5668\u7F16\u89E3\u7801\u652F\u6301\u5931\u8D25\uFF0CSEI gate \u5C06\u4E0D\u4F1A\u751F\u6548\uFF0Coutput \u5C06\u4E0D\u518D\u88AB\u62E6\u622A"
+};
+
+// src/i18n/api-error-codes.ts
+var SYSTEM_OVERLOADED = {
+  "zh-CN": "\u5F53\u524D\u4F7F\u7528\u4EBA\u6570\u8FC7\u591A\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5",
+  "en-US": "The system is currently overloaded. Please retry after some time."
+};
+var API_ERROR_MESSAGES = {
+  "46001": { "zh-CN": "X-Api-Key \u4E0D\u80FD\u4E3A\u7A7A", "en-US": "X-Api-Key cannot be empty" },
+  "46002": { "zh-CN": "\u65E0\u6548\u7684\u7528\u6237 API Key", "en-US": "Invalid user API Key" },
+  "46003": { "zh-CN": "model \u4E0D\u80FD\u4E3A\u7A7A", "en-US": "model cannot be empty" },
+  "46004": { "zh-CN": "sessionUid \u4E0D\u80FD\u4E3A\u7A7A", "en-US": "sessionUid cannot be empty" },
+  "46005": { "zh-CN": "\u6A21\u578B\u7C7B\u578B\u4E0D\u5B58\u5728", "en-US": "Model type does not exist" },
+  "46006": SYSTEM_OVERLOADED,
+  "46007": SYSTEM_OVERLOADED,
+  "46008": SYSTEM_OVERLOADED,
+  "46009": SYSTEM_OVERLOADED,
+  "46010": SYSTEM_OVERLOADED,
+  "46012": { "zh-CN": "\u4F1A\u8BDD\u4E0D\u5B58\u5728", "en-US": "Session does not exist" },
+  "46013": { "zh-CN": "\u4F1A\u8BDD\u4E0D\u5C5E\u4E8E\u5F53\u524D\u7528\u6237", "en-US": "Session does not belong to the current user" },
+  "46014": { "zh-CN": "\u4F1A\u8BDD\u5DF2\u5173\u95ED", "en-US": "Session has been closed" },
+  "46015": { "zh-CN": "\u4F1A\u8BDD\u5DF2\u8D85\u65F6", "en-US": "Session has timed out" },
+  "46018": { "zh-CN": "\u4E34\u65F6 API Key \u5DF2\u8FC7\u671F", "en-US": "Temporary API Key has expired" },
+  "46019": {
+    "zh-CN": "\u4E34\u65F6 API Key \u5DF2\u8FBE\u5230\u79EF\u5206\u4E0A\u9650",
+    "en-US": "Temporary API Key has reached its points limit"
+  },
+  "46021": {
+    "zh-CN": "\u4E34\u65F6 API Key \u4E0D\u5141\u8BB8\u518D\u521B\u5EFA\u4E34\u65F6 API Key",
+    "en-US": "A temporary API Key cannot create another temporary API Key"
+  }
+};
+function resolveApiErrorMessage(code, locale) {
+  if (code === null || code === void 0) return void 0;
+  const entry = API_ERROR_MESSAGES[String(code)];
+  if (!entry) return void 0;
+  return entry[locale] ?? entry["en-US"];
+}
+
+// src/i18n/index.ts
+function formatTemplate(template, params) {
+  if (!params) return template;
+  return template.replace(/\{(\w+)\}/g, (_, rawKey) => {
+    const value = params[rawKey];
+    return value === null || value === void 0 ? "" : String(value);
+  });
+}
+function getDefaultMessages(locale) {
+  return locale === "zh-CN" ? zhCN : enUS;
+}
+function createSDKI18n(input) {
+  const locale = input?.locale ?? "en-US";
+  if (typeof input?.t === "function") {
+    return { locale, t: input.t };
+  }
+  const base = getDefaultMessages(locale);
+  const merged = { ...base, ...input?.messages ?? {} };
+  return {
+    locale,
+    t: (key, params) => {
+      const template = merged[key] ?? key;
+      return formatTemplate(template, params);
+    }
+  };
+}
+
+// src/shared/browser-toast.ts
+var TOAST_ROOT_ID = "Xmax-sdk-toast-root";
+var TOAST_DURATION_MS = 3e3;
+var toastSeed = 0;
+var timeoutMap = /* @__PURE__ */ new Map();
+var elementMap = /* @__PURE__ */ new Map();
+function ensureToastRoot() {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  let root = document.getElementById(TOAST_ROOT_ID);
+  if (root) {
+    return root;
+  }
+  root = document.createElement("div");
+  root.id = TOAST_ROOT_ID;
+  root.setAttribute("aria-live", "polite");
+  Object.assign(root.style, {
+    position: "fixed",
+    left: "50%",
+    top: "24px",
+    transform: "translateX(-50%)",
+    zIndex: "3000",
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    gap: "12px",
+    pointerEvents: "none"
+  });
+  document.body.appendChild(root);
+  return root;
+}
+function createIcon(type) {
+  const icon = document.createElement("span");
+  icon.setAttribute("aria-hidden", "true");
+  icon.innerHTML = type === "success" ? '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 12 12" fill="none"><path d="M10 3L4.5 8.5 2 6" stroke="#4ade80" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>' : '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 12 12" fill="none"><circle cx="6" cy="6" r="5" stroke="#f87171" stroke-width="1.5"/><path d="M4 4l4 4M8 4L4 8" stroke="#f87171" stroke-width="1.5" stroke-linecap="round"/></svg>';
+  Object.assign(icon.style, {
+    display: "inline-flex",
+    width: "12px",
+    height: "12px",
+    flexShrink: "0"
+  });
+  return icon;
+}
+function clearToastTimer(id) {
+  const timer = timeoutMap.get(id);
+  if (timer) {
+    window.clearTimeout(timer);
+    timeoutMap.delete(id);
+  }
+}
+function destroyToast(id) {
+  if (!id) {
+    timeoutMap.forEach((timer) => window.clearTimeout(timer));
+    timeoutMap.clear();
+    elementMap.forEach((element2) => element2.remove());
+    elementMap.clear();
+    const root2 = typeof document !== "undefined" ? document.getElementById(TOAST_ROOT_ID) : null;
+    root2?.remove();
+    return;
+  }
+  clearToastTimer(id);
+  const element = elementMap.get(id);
+  element?.remove();
+  elementMap.delete(id);
+  const root = typeof document !== "undefined" ? document.getElementById(TOAST_ROOT_ID) : null;
+  if (root && !root.childElementCount) {
+    root.remove();
+  }
+}
+function showToast(type, message, options) {
+  const root = ensureToastRoot();
+  if (!root) {
+    return "";
+  }
+  const id = options?.key || `toast-${Date.now()}-${++toastSeed}`;
+  clearToastTimer(id);
+  elementMap.get(id)?.remove();
+  const isMobile = typeof window !== "undefined" && window.matchMedia("(max-width: 768px)").matches;
+  const textSize = isMobile ? "12px" : "14px";
+  const toast = document.createElement("div");
+  toast.setAttribute("role", "status");
+  Object.assign(toast.style, {
+    pointerEvents: "auto",
+    display: "flex",
+    alignItems: "center",
+    gap: "12px",
+    minWidth: "240px",
+    padding: "16px",
+    borderRadius: "12px",
+    border: "1px solid rgba(255, 255, 255, 0.20)",
+    background: "rgba(0, 0, 0, 0.80)",
+    boxShadow: "0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)",
+    fontFamily: "Rubik, ui-sans-serif, system-ui, sans-serif",
+    fontSize: textSize,
+    fontWeight: "400",
+    lineHeight: "14px"
+  });
+  const content = document.createElement("span");
+  content.textContent = message;
+  Object.assign(content.style, {
+    paddingRight: "0px",
+    textAlign: "center",
+    color: "#ffffff",
+    fontFamily: "Rubik, ui-sans-serif, system-ui, sans-serif",
+    fontSize: textSize,
+    fontWeight: "400",
+    lineHeight: "14px"
+  });
+  toast.appendChild(createIcon(type));
+  toast.appendChild(content);
+  root.appendChild(toast);
+  elementMap.set(id, toast);
+  const timer = window.setTimeout(() => {
+    destroyToast(id);
+  }, options?.duration ?? TOAST_DURATION_MS);
+  timeoutMap.set(id, timer);
+  return id;
+}
+var browserToast = {
+  success(message, options) {
+    return showToast("success", message, options);
+  },
+  error(message, options) {
+    return showToast("error", message, options);
+  },
+  destroy(id) {
+    destroyToast(id);
+  }
+};
+
+// src/shared/error-utils.ts
+function notifyError(error, notifier, fallbackMessage) {
+  const resolved = error instanceof Error ? error : Object.assign(new Error(fallbackMessage), { cause: error });
+  if (!resolved.__XmaxNotified) {
+    resolved.__XmaxNotified = true;
+    const message = resolved.message || fallbackMessage;
+    if (notifier) {
+      notifier(message, error);
+    } else if (typeof window !== "undefined" && typeof document !== "undefined") {
+      browserToast.error(message);
+    }
+  }
+  return resolved;
+}
+
+// src/sdk/client.ts
+var XMAX_OPEN_API_BASE_URLS = {
+  // 国内 — @xmaxai/sdk
+  cn: "https://cloud.xmax.22duck.cn/open/api/v1",
+  // 海外 — @xmaxai/sdk-global
+  global: "https://api.xmax.cloud/open/api/v1"
+};
+var XMAX_SDK_BUILD_REGION = "cn";
+var XMAX_OPEN_API_PRODUCTION_BASE_URL = XMAX_OPEN_API_BASE_URLS[XMAX_SDK_BUILD_REGION];
+var ACTIVE_STATUS = "ACTIVE";
+var STS_TTL_MS = 30 * 60 * 1e3;
+var STS_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+function sanitizeFileName(fileName) {
+  return fileName.trim().replace(/[^\w.\-一-龥]/g, "_").replace(/_+/g, "_");
+}
+function buildCosFileUrl(endpoint, bucket, key) {
+  const trimmed = endpoint.trim();
+  const url = new URL(
+    /^https?:\/\//i.test(trimmed) ? trimmed.endsWith("/") ? trimmed : `${trimmed}/` : `https://${trimmed.replace(/^\/+/, "")}${trimmed.endsWith("/") ? "" : "/"}`
+  );
+  if (url.hostname.startsWith("cos.") && !url.hostname.startsWith(`${bucket}.`)) {
+    url.hostname = `${bucket}.${url.hostname}`;
+  }
+  return new URL(key.replace(/^\/+/, ""), url.toString()).toString();
+}
+function resolveCosUploadUrl(raw, sts, key) {
+  const location = raw?.Location?.trim();
+  if (location) {
+    return /^https?:\/\//i.test(location) ? location : `https://${location.replace(/^\/+/, "")}`;
+  }
+  const endpoint = sts.endpoint?.trim();
+  if (endpoint) {
+    return buildCosFileUrl(endpoint, sts.bucket, key);
+  }
+  return `https://${sts.bucket}.cos.${sts.region}.myqcloud.com/${key.replace(/^\/+/, "")}`;
+}
+var XmaxOpenClient = class {
+  constructor(options) {
+    this.stsCache = null;
+    this.heartbeatIntervalId = null;
+    this.suppressErrorNotification = false;
+    this.teardownAbortController = null;
+    this.pendingRequestControllers = /* @__PURE__ */ new Set();
+    const i18n = options.i18n ?? createSDKI18n({ locale: options.locale });
+    if (!options.apiKey?.trim()) {
+      throw new Error(i18n.t("errors.apiKeyEmpty"));
+    }
+    if (!options.baseUrl?.trim()) {
+      throw new Error(i18n.t("errors.baseUrlEmpty"));
+    }
+    this.apiKey = options.apiKey;
+    this.authToken = options.authToken;
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.i18n = i18n;
+    this.onError = options.onError;
+  }
+  throwError(message, cause) {
+    const error = new Error(message);
+    if (cause !== void 0) {
+      error.cause = cause;
+    }
+    if (this.suppressErrorNotification) {
+      throw error;
+    }
+    throw notifyError(error, this.onError, message);
+  }
+  /** Stop heartbeat, abort in-flight API requests, and suppress error toasts during teardown. */
+  beginTeardown() {
+    this.suppressErrorNotification = true;
+    this.stopHeartbeat();
+    if (this.teardownAbortController) {
+      this.teardownAbortController.abort();
+    }
+    this.teardownAbortController = new AbortController();
+    this.pendingRequestControllers.forEach((controller) => {
+      controller.abort();
+    });
+    this.pendingRequestControllers.clear();
+  }
+  endTeardown() {
+    this.suppressErrorNotification = false;
+    this.teardownAbortController = null;
+  }
+  isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError";
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    this.pendingRequestControllers.add(controller);
+    const onAbort = () => controller.abort();
+    this.teardownAbortController?.signal.addEventListener("abort", onAbort);
+    const timeoutId = window.setTimeout(() => controller.abort(), this.timeoutMs);
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "X-Api-Key": this.apiKey
+    };
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      const text = await response.text();
+      let payload;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch (parseError) {
+        throw this.throwError(this.i18n.t("errors.invalidJson"), parseError);
+      }
+      if (typeof payload !== "object" || payload === null) {
+        throw this.throwError(this.i18n.t("errors.invalidPayload"));
+      }
+      const p = payload;
+      if (response.ok && p.success === true) {
+        return p.data;
+      }
+      const mappedMessage = resolveApiErrorMessage(p.code, this.i18n.locale);
+      const errorMessage = mappedMessage ?? this.i18n.t("errors.requestRetry");
+      throw new Error(errorMessage);
+    } catch (error) {
+      if (this.isAbortError(error)) {
+        if (this.suppressErrorNotification) {
+          throw new Error(this.i18n.t("errors.requestTimeout"));
+        }
+        throw this.throwError(this.i18n.t("errors.requestTimeout"), error);
+      } else if (error instanceof Error) {
+        if (this.suppressErrorNotification) {
+          throw error;
+        }
+        throw notifyError(error, this.onError, error.message || this.i18n.t("errors.requestFailed"));
+      } else {
+        throw this.throwError(this.i18n.t("errors.requestFailed"), error);
+      }
+    } finally {
+      this.teardownAbortController?.signal.removeEventListener("abort", onAbort);
+      this.pendingRequestControllers.delete(controller);
+      window.clearTimeout(timeoutId);
+    }
+  }
+  async createSession(model) {
+    if (!model.trim()) {
+      this.throwError(this.i18n.t("errors.modelEmpty"));
+    }
+    return this.request("POST", "/session", { model });
+  }
+  async getSession(sessionUid) {
+    return this.request("GET", `/session/${sessionUid}`);
+  }
+  async heartbeatSession(sessionUid) {
+    return this.request("PUT", `/session/${sessionUid}/heartbeat`);
+  }
+  async closeSession(sessionUid) {
+    const previousSuppress = this.suppressErrorNotification;
+    this.suppressErrorNotification = true;
+    try {
+      return await this.request("DELETE", `/session/${sessionUid}`);
+    } catch {
+      return null;
+    } finally {
+      this.suppressErrorNotification = previousSuppress;
+    }
+  }
+  async getCosSts(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && this.stsCache && now - this.stsCache.fetchedAt < STS_TTL_MS - STS_REFRESH_BUFFER_MS) {
+      return this.stsCache.value;
+    }
+    const sts = await this.request("GET", "/cos/sts");
+    this.stsCache = {
+      value: sts,
+      fetchedAt: now
+    };
+    return sts;
+  }
+  async uploadObject(file, expectedTypePrefix) {
+    if (!(file instanceof File)) {
+      this.throwError(this.i18n.t("errors.invalidFile"));
+    }
+    if (!file.type.startsWith(expectedTypePrefix)) {
+      this.throwError(this.i18n.t("errors.invalidFileType", { type: file.type }));
+    }
+    const sts = await this.getCosSts();
+    const safeFileName = sanitizeFileName(file.name) || "image";
+    const key = `${sts.prefix}${Date.now()}_${safeFileName}`;
+    const cos = new COS__default.default({
+      SecretId: sts.credentials.accessKeyId,
+      SecretKey: sts.credentials.secretAccessKey,
+      SecurityToken: sts.credentials.sessionToken
+    });
+    const raw = await new Promise((resolve, reject) => {
+      cos.putObject(
+        {
+          Bucket: sts.bucket,
+          Region: sts.region,
+          Key: key,
+          Body: file,
+          ContentType: file.type
+        },
+        (error, data) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+          resolve(data);
+        }
+      );
+    });
+    return {
+      key,
+      url: resolveCosUploadUrl(raw, sts, key),
+      raw,
+      sts
+    };
+  }
+  async uploadImage(file) {
+    return this.uploadObject(file, "image/");
+  }
+  async uploadVideo(file) {
+    return this.uploadObject(file, "video/");
+  }
+  startHeartbeat(sessionUid, intervalMs = 1e4, onHeartbeat, onError) {
+    this.stopHeartbeat();
+    const heartbeat = async () => {
+      try {
+        const session = await this.heartbeatSession(sessionUid);
+        onHeartbeat?.(session);
+        if (session.status !== ACTIVE_STATUS) {
+          this.stopHeartbeat();
+        }
+      } catch (error) {
+        onError?.(error);
+        this.stopHeartbeat();
+      }
+    };
+    heartbeat();
+    this.heartbeatIntervalId = window.setInterval(heartbeat, intervalMs);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatIntervalId !== null) {
+      clearInterval(this.heartbeatIntervalId);
+      this.heartbeatIntervalId = null;
+    }
+  }
+  getRtcJoinInfo(session) {
+    const roomId = session.modelExtra?.room_id?.trim();
+    const appId = session.modelExtra?.rtc_app_id?.trim();
+    const token = session.modelExtra?.room_token?.trim();
+    const userId = session.modelExtra?.user_id?.trim() || session.userUid?.trim() || "";
+    if (!roomId || !appId || !token || !userId) {
+      this.throwError(this.i18n.t("errors.sessionJoinInfoIncomplete"));
+    }
+    return {
+      appId,
+      roomId,
+      userId,
+      token,
+      botName: session.modelExtra?.bot_name
+    };
+  }
+};
+
+// src/sdk/rtc-events.ts
+function createTaskUid() {
+  return `task-${Date.now()}`;
+}
+function createStartRtcRoomEvent(input) {
+  const resolvedPrompt = input.prompt?.trim() ?? "";
+  const refImagePath = input.refImagePath?.trim() || input.refImage?.trim() || void 0;
+  const useRefImage = !!refImagePath;
+  return {
+    event: "start",
+    user_id: input.userId?.trim() || void 0,
+    uid: input.uid?.trim() || void 0,
+    session_uid: input.sessionUid?.trim() || void 0,
+    params: {
+      model: input.model.trim(),
+      size: input.size,
+      prompt: resolvedPrompt,
+      ref_image_path: useRefImage ? refImagePath : void 0,
+      ref_image: useRefImage ? refImagePath : void 0,
+      static_generate: input.staticGenerate === void 0 ? void 0 : input.staticGenerate,
+      ...input.extraParams ?? {}
+    }
+  };
+}
+function createStopRtcRoomEvent(input) {
+  return {
+    event: "stop",
+    user_id: input.userId?.trim() || void 0,
+    session_uid: input.sessionUid?.trim() || void 0
+  };
+}
+function createTracksRtcRoomEvent(input) {
+  return {
+    event: "tracks",
+    user_id: input.userId?.trim() || void 0,
+    uid: input.uid?.trim() || void 0,
+    session_uid: input.sessionUid?.trim() || void 0,
+    tracks: input.tracks
+  };
+}
+
+// src/rtc/video-frame-rate.ts
+var COMMON_VIDEO_FPS = [24, 25, 30, 48, 50, 60];
+function snapToCommonVideoFps(fps) {
+  if (!Number.isFinite(fps) || fps <= 0) {
+    return 30;
+  }
+  const clamped = Math.max(1, Math.min(120, fps));
+  let best = 30;
+  let bestDiff = Infinity;
+  for (const candidate of COMMON_VIDEO_FPS) {
+    const diff = Math.abs(clamped - candidate);
+    if (diff < bestDiff || diff === bestDiff && candidate < best) {
+      bestDiff = diff;
+      best = candidate;
+    }
+  }
+  return best;
+}
+function snapToCommonVideoFpsConservative(fps) {
+  if (!Number.isFinite(fps) || fps <= 0) {
+    return 30;
+  }
+  const snapped = snapToCommonVideoFps(fps);
+  if (snapped <= fps + 0.5) {
+    return snapped;
+  }
+  const lowerCandidates = COMMON_VIDEO_FPS.filter((candidate) => candidate < snapped);
+  if (lowerCandidates.length > 0) {
+    return lowerCandidates[lowerCandidates.length - 1];
+  }
+  return snapped;
+}
+function resolveTrackFrameRate(track, fallback) {
+  const settings = track.getSettings?.();
+  if (typeof settings?.frameRate === "number" && settings.frameRate > 0) {
+    return snapToCommonVideoFpsConservative(settings.frameRate);
+  }
+  return snapToCommonVideoFpsConservative(fallback);
+}
+function resolvePlaybackDrivenEncoderFps(track, fallback = 24) {
+  return resolveTrackFrameRate(track, fallback);
+}
+
+// src/rtc/preview-media-layout.ts
+var PREVIEW_UPLOAD_LAYOUT_ATTR = "data-preview-upload-layout";
+var PREVIEW_UPLOAD_FIT_ATTR = "data-preview-upload-fit";
+var PREVIEW_OUTPUT_LAYOUT_ATTR = "data-preview-output-layout";
+var PREVIEW_CONTAIN_ATTR = "data-preview-contain";
+var PREVIEW_COVER_ATTR = "data-preview-cover";
+function hasFitPreviewLayout(container) {
+  return container.hasAttribute(PREVIEW_UPLOAD_LAYOUT_ATTR) || container.hasAttribute(PREVIEW_OUTPUT_LAYOUT_ATTR) || container.hasAttribute(PREVIEW_CONTAIN_ATTR) || container.closest(`[${PREVIEW_UPLOAD_LAYOUT_ATTR}]`) !== null || container.closest(`[${PREVIEW_OUTPUT_LAYOUT_ATTR}]`) !== null || container.closest(`[${PREVIEW_CONTAIN_ATTR}]`) !== null;
+}
+function hasCoverPreviewLayout(container) {
+  return container.hasAttribute(PREVIEW_COVER_ATTR) || container.closest(`[${PREVIEW_COVER_ATTR}]`) !== null;
+}
+function resolveUploadFitMode(container) {
+  const node = container.hasAttribute(PREVIEW_UPLOAD_FIT_ATTR) ? container : container.closest(`[${PREVIEW_UPLOAD_FIT_ATTR}]`);
+  const fit = node?.getAttribute(PREVIEW_UPLOAD_FIT_ATTR);
+  return fit === "landscape" ? "landscape" : "portrait";
+}
+function applyUploadPreviewMediaLayout(container) {
+  if (hasCoverPreviewLayout(container)) {
+    return;
+  }
+  if (!hasFitPreviewLayout(container)) {
+    return;
+  }
+  const fitMode = resolveUploadFitMode(container);
+  container.style.overflow = "hidden";
+  container.style.display = "flex";
+  container.style.alignItems = "center";
+  container.style.justifyContent = "center";
+  container.querySelectorAll("div").forEach((node) => {
+    if (node === container) {
+      return;
+    }
+    const el = node;
+    el.style.width = "100%";
+    el.style.height = "100%";
+    if (fitMode === "landscape") {
+      el.style.display = "flex";
+      el.style.alignItems = "center";
+      el.style.justifyContent = "center";
+      el.style.overflow = "hidden";
+    }
+  });
+  container.querySelectorAll("video, canvas").forEach((node) => {
+    const el = node;
+    el.style.display = "block";
+    el.style.objectFit = "contain";
+    el.style.objectPosition = "center";
+    el.style.position = "relative";
+    el.style.left = "auto";
+    el.style.right = "auto";
+    el.style.top = "auto";
+    el.style.bottom = "auto";
+    el.style.transform = "none";
+    if (fitMode === "landscape") {
+      el.style.width = "100%";
+      el.style.height = "100%";
+      el.style.maxWidth = "none";
+      el.style.maxHeight = "none";
+      el.style.margin = "0";
+      return;
+    }
+    el.style.height = "100%";
+    el.style.width = "auto";
+    el.style.maxWidth = "none";
+    el.style.maxHeight = "none";
+    el.style.marginLeft = "auto";
+    el.style.marginRight = "auto";
+    el.style.marginTop = "auto";
+    el.style.marginBottom = "auto";
+  });
+}
+function observeUploadPreviewMediaLayout(container) {
+  if (!hasFitPreviewLayout(container) && !hasCoverPreviewLayout(container)) {
+    return () => {
+    };
+  }
+  let rafId = null;
+  const apply = () => applyUploadPreviewMediaLayout(container);
+  const scheduleApply = () => {
+    if (rafId !== null) {
+      return;
+    }
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      apply();
+    });
+  };
+  apply();
+  const observer = new MutationObserver(() => scheduleApply());
+  observer.observe(container, {
+    childList: true,
+    subtree: true,
+    attributes: true
+  });
+  return () => {
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+    }
+    observer.disconnect();
+  };
+}
+
+// src/rtc/rtc-manager.ts
+function resolveVideoRenderMode(container) {
+  if (container.hasAttribute(PREVIEW_UPLOAD_LAYOUT_ATTR) || container.hasAttribute(PREVIEW_OUTPUT_LAYOUT_ATTR) || container.hasAttribute("data-preview-contain") || container.hasAttribute(PREVIEW_UPLOAD_FIT_ATTR) || container.closest(`[${PREVIEW_UPLOAD_LAYOUT_ATTR}]`) || container.closest(`[${PREVIEW_OUTPUT_LAYOUT_ATTR}]`) || container.closest("[data-preview-contain]") || container.closest(`[${PREVIEW_UPLOAD_FIT_ATTR}]`)) {
+    return VERTC.VideoRenderMode.RENDER_MODE_FIT;
+  }
+  if (container.hasAttribute("data-preview-cover") || container.hasAttribute("data-upload-preview-cover") || container.closest("[data-preview-cover]") || container.closest("[data-upload-preview-cover]")) {
+    return VERTC.VideoRenderMode.RENDER_MODE_HIDDEN;
+  }
+  const rect = container.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) {
+    return VERTC.VideoRenderMode.RENDER_MODE_FIT;
+  }
+  const isCompactPreview = rect.width <= 160;
+  const isPortraitFrame = rect.height > rect.width;
+  return isCompactPreview || isPortraitFrame ? VERTC.VideoRenderMode.RENDER_MODE_HIDDEN : VERTC.VideoRenderMode.RENDER_MODE_FIT;
+}
+var REMOTE_OUTPUT_STALL_MS = 2e4;
+var REMOTE_OUTPUT_RECOVERY_COOLDOWN_MS = 6e4;
+var SESSION_SEI_INTERVAL_MS = 500;
+var DEFAULT_SEI_REPEAT_COUNT = 1;
+var PUBLISH_START_MIN_FRAMES = 5;
+var PUBLISH_START_FRAME_TIMEOUT_MS = 800;
+var PUBLISH_COLD_MIN_FRAMES = 12;
+var PUBLISH_COLD_FRAME_TIMEOUT_MS = 1500;
+var PUBLISH_COLD_WARMUP_MS = 600;
+var PUBLISH_WARM_SKIP_MS = 800;
+var COLD_START_MIN_FRAMES = 3;
+var WARM_START_MIN_FRAMES = 1;
+var WARM_START_FRAME_TIMEOUT_MS = 200;
+var COLD_START_SETTLE_MS = 50;
+var COLD_START_OUTBOUND_TIMEOUT_MS = 1500;
+var COLD_START_OUTBOUND_STABLE_MS = 200;
+var COLD_START_MIN_OUTBOUND_FPS = 5;
+var PUBLISH_READY_BUFFER_MS = 300;
+var PUBLISH_READY_TIMEOUT_MS = 5e3;
+var _RtcManager = class _RtcManager {
+  constructor(options = {}) {
+    this.engine = null;
+    this.leaveTask = null;
+    this.users = /* @__PURE__ */ new Set();
+    this.currentJoinInfo = null;
+    this.joined = false;
+    this.preserveRemoteDom = false;
+    this.localVideoPublished = false;
+    this.localVideoSourceType = VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL;
+    this.shouldMirrorLocalPreview = false;
+    this.externalVideoTrack = null;
+    this.remoteVideoUserId = null;
+    this.pendingRemoteVideoUserId = null;
+    this.pendingRemoteVideoMediaType = VERTC.MediaType.VIDEO;
+    /** Subscribed to RTC media, but player may still be gated by SEI / container. */
+    this.subscribedRemoteUserId = null;
+    this.subscribedRemoteMediaType = VERTC.MediaType.VIDEO;
+    this.localVideoContainer = null;
+    this.remoteVideoContainer = null;
+    this.expectedRemoteSei = null;
+    this.lastRemoteSei = null;
+    this.lastRemoteSeiUserId = null;
+    this.localSeiMessage = null;
+    this.localSeiRepeatCount = DEFAULT_SEI_REPEAT_COUNT;
+    this.seiSendInterval = null;
+    this.lastSeiSentAtMs = 0;
+    this.hasLoggedSeiSendFailure = false;
+    this.seiSupport = "unknown";
+    this.hasLoggedSeiUnsupported = false;
+    this.lastDebugSeiMatched = null;
+    this.lastDebugRemoteSei = null;
+    this.remoteFrameWatchStop = null;
+    this.uploadPreviewLayoutObserverStop = null;
+    this.remoteOutputRecoveryCooldownUntil = 0;
+    this.joinedAtMs = 0;
+    this.publishStartedAtMs = 0;
+    this.lastRoomStartEventAtMs = 0;
+    this.localStreamStatsCount = 0;
+    this.firstNonZeroSentFrameRateAtMs = 0;
+    this.lastObservedSentFrameRate = 0;
+    this.publishReadyWaiters = [];
+    this.stablePublishWaiters = [];
+    this.publishReadyBufferTimer = null;
+    this.seiGateFallbackTimer = null;
+    this.seiMatchedDelayTimer = null;
+    this.lastSentResolution = "";
+    this.lastReceivedResolution = "";
+    this.onLog = options.onLog;
+    this.onStateChange = options.onStateChange;
+    this.onSeiGateChange = options.onSeiGateChange;
+    this.onRemoteSeiReceived = options.onRemoteSeiReceived;
+    this.onRemoteOutputStalled = options.onRemoteOutputStalled;
+    this.debug = options.debug ?? false;
+    this.i18n = options.i18n ?? createSDKI18n();
+  }
+  emitSeiGateState() {
+    const matched = this.isSeiMatched();
+    this.onSeiGateChange?.({
+      expectedSei: this.expectedRemoteSei,
+      sei: this.lastRemoteSei,
+      userId: this.lastRemoteSeiUserId,
+      matched
+    });
+  }
+  setPreserveRemoteDom(preserve) {
+    this.preserveRemoteDom = preserve;
+  }
+  setOnRemotePlayerMounted(callback) {
+    this.onRemotePlayerMounted = callback;
+  }
+  setLocalVideoContainer(container) {
+    const previous = this.localVideoContainer;
+    const changed = previous !== container;
+    this.localVideoContainer = container;
+    if (previous && changed) {
+      previous.replaceChildren();
+    }
+    if (container && changed) {
+      container.replaceChildren();
+    }
+    if (container && this.localVideoPublished && this.engine) {
+      this.bindLocalVideoPlayer();
+    }
+  }
+  setRemoteVideoContainer(container) {
+    const previous = this.remoteVideoContainer;
+    if (previous === container) {
+      if (this.debug && container && container.childElementCount === 0 && (this.remoteVideoUserId || this.pendingRemoteVideoUserId)) {
+        this.debugLog("setRemoteVideoContainer skipped but container empty", {
+          remoteVideoUserId: this.remoteVideoUserId,
+          pendingRemoteVideoUserId: this.pendingRemoteVideoUserId
+        });
+      }
+      return;
+    }
+    this.remoteVideoContainer = container;
+    this.debugLog("setRemoteVideoContainer", {
+      hadPrevious: !!previous,
+      next: !!container,
+      remoteVideoUserId: this.remoteVideoUserId,
+      pendingRemoteVideoUserId: this.pendingRemoteVideoUserId
+    });
+    if (previous) {
+      previous.replaceChildren();
+    }
+    if (container && this.engine && this.joined && (this.remoteVideoUserId || this.pendingRemoteVideoUserId)) {
+      void this.refreshRemoteVideoBinding();
+    }
+  }
+  /** Display-only gate: expect bot output SEI to match task id — no local SEI send, no start blocking. */
+  configureSessionSei(sessionId, _options = {}) {
+    const normalizedSessionId = this.normalizeSei(sessionId);
+    const previousExpectedRemoteSei = this.expectedRemoteSei;
+    this.stopSeiSending();
+    this.clearSeiGateFallbackTimer();
+    this.clearSeiMatchedDelayTimer();
+    this.localSeiMessage = null;
+    this.expectedRemoteSei = this.seiSupport === "unsupported" ? null : normalizedSessionId;
+    this.lastRemoteSei = null;
+    this.lastRemoteSeiUserId = null;
+    this.hasLoggedSeiSendFailure = false;
+    if (previousExpectedRemoteSei !== this.expectedRemoteSei && this.remoteVideoUserId) {
+      this.pendingRemoteVideoUserId = this.remoteVideoUserId;
+      this.remoteVideoUserId = null;
+    }
+    this.emitSeiGateState();
+    if (previousExpectedRemoteSei !== this.expectedRemoteSei && !this.preserveRemoteDom) {
+      this.clearContainer(this.remoteVideoContainer);
+    }
+    this.scheduleSeiGateFallback(normalizedSessionId);
+  }
+  clearSeiGateFallbackTimer() {
+    if (this.seiGateFallbackTimer !== null) {
+      clearTimeout(this.seiGateFallbackTimer);
+      this.seiGateFallbackTimer = null;
+    }
+  }
+  clearSeiMatchedDelayTimer() {
+    if (this.seiMatchedDelayTimer !== null) {
+      clearTimeout(this.seiMatchedDelayTimer);
+      this.seiMatchedDelayTimer = null;
+    }
+  }
+  /** Show output if bot SEI never arrives — UI gate only, RTC bind is not blocked. */
+  scheduleSeiGateFallback(expectedSei) {
+    this.clearSeiGateFallbackTimer();
+    if (!expectedSei) {
+      return;
+    }
+    this.seiGateFallbackTimer = setTimeout(() => {
+      this.seiGateFallbackTimer = null;
+      if (this.expectedRemoteSei !== expectedSei || this.isSeiMatched()) {
+        return;
+      }
+      this.log("warn", this.i18n.t("rtc.seiGateFallback"), { expectedSei });
+      this.expectedRemoteSei = null;
+      this.emitSeiGateState();
+      void this.refreshRemoteVideoBinding({ force: true });
+    }, _RtcManager.SEI_GATE_FALLBACK_MS);
+  }
+  get snapshot() {
+    return {
+      roomId: this.currentJoinInfo?.roomId ?? null,
+      userId: this.currentJoinInfo?.userId ?? null,
+      appId: this.currentJoinInfo?.appId ?? null,
+      botUserId: this.currentJoinInfo?.botName ?? null,
+      joined: this.joined,
+      localVideoPublished: this.localVideoPublished,
+      remoteVideoUserId: this.remoteVideoUserId,
+      users: Array.from(this.users)
+    };
+  }
+  getLocalVideoSize() {
+    if (!this.engine || !this.joined) {
+      return null;
+    }
+    const track = this.engine.getLocalStreamTrack(VERTC.StreamIndex.STREAM_INDEX_MAIN, "video");
+    if (!track) {
+      return null;
+    }
+    const settings = track.getSettings?.();
+    const width = typeof settings?.width === "number" ? settings.width : 0;
+    const height = typeof settings?.height === "number" ? settings.height : 0;
+    if (!width || !height) {
+      return null;
+    }
+    return { width, height };
+  }
+  async join(joinInfo) {
+    if (this.currentJoinInfo?.roomId === joinInfo.roomId && this.joined) {
+      this.log("info", this.i18n.t("rtc.alreadyInRoom"), joinInfo);
+      return;
+    }
+    await this.leave();
+    this.currentJoinInfo = joinInfo;
+    this.users.clear();
+    this.users.add(joinInfo.userId);
+    this.localVideoPublished = false;
+    this.remoteVideoUserId = null;
+    this.pendingRemoteVideoUserId = null;
+    this.pendingRemoteVideoMediaType = VERTC.MediaType.VIDEO;
+    this.lastRemoteSei = null;
+    this.lastRemoteSeiUserId = null;
+    this.clearVideoContainers();
+    const engine = VERTC__default.default.createEngine(joinInfo.appId);
+    this.engine = engine;
+    this.bindEngineEvents(engine);
+    this.log("info", this.i18n.t("rtc.joiningRoom"), joinInfo);
+    await engine.joinRoom(
+      joinInfo.token,
+      joinInfo.roomId,
+      {
+        userId: joinInfo.userId
+      },
+      {
+        isAutoPublish: false,
+        isAutoSubscribeAudio: false,
+        isAutoSubscribeVideo: true,
+        roomProfileType: VERTC.RoomProfileType.communication
+      }
+    );
+    this.joined = true;
+    this.joinedAtMs = performance.now();
+    this.ensureSeiSupport();
+    this.emitState();
+    this.log("success", this.i18n.t("rtc.joinSuccess"), this.snapshot);
+    this.log("info", this.i18n.t("rtc.roomUsers", { users: this.snapshot.users.join(", ") }), this.snapshot.users);
+  }
+  async startVideoPublishing(size) {
+    if (!this.engine || !this.currentJoinInfo || !this.joined) {
+      throw new Error(this.i18n.t("errors.rtcNotJoined"));
+    }
+    const publishStartedAtMs = performance.now();
+    await this.applyVideoEncoderPreference(size);
+    if (size) {
+      await this.applyLocalVideoCaptureConfig(size);
+    }
+    if (this.localVideoPublished) {
+      this.log("info", this.i18n.t("rtc.localVideoAlreadyPublished"));
+      return;
+    }
+    this.shouldMirrorLocalPreview = true;
+    this.bindLocalVideoPlayer();
+    await this.switchToInternalVideoSource();
+    await this.engine.startVideoCapture();
+    await this.engine.publishStream(VERTC.MediaType.VIDEO);
+    this.localVideoPublished = true;
+    this.publishStartedAtMs = publishStartedAtMs;
+    this.localStreamStatsCount = 0;
+    this.firstNonZeroSentFrameRateAtMs = 0;
+    this.lastObservedSentFrameRate = 0;
+    this.ensureSeiSupport();
+    this.emitState();
+    this.log("success", this.i18n.t("rtc.localVideoPublished"));
+  }
+  async startExternalVideoPublishing(track, encoderSize, publishOptions) {
+    if (!this.engine || !this.currentJoinInfo || !this.joined) {
+      throw new Error(this.i18n.t("errors.rtcNotJoined"));
+    }
+    if (this.localVideoPublished) {
+      this.log("info", this.i18n.t("rtc.localVideoAlreadyPublished"));
+      return;
+    }
+    const publishStartedAtMs = performance.now();
+    const settings = track.getSettings?.();
+    const width = typeof settings?.width === "number" && settings.width > 0 ? settings.width : void 0;
+    const height = typeof settings?.height === "number" && settings.height > 0 ? settings.height : void 0;
+    const encoderOptions = publishOptions?.highQuality !== false ? {
+      ...publishOptions,
+      highQuality: true,
+      fps: publishOptions?.fps ?? resolvePlaybackDrivenEncoderFps(track)
+    } : publishOptions;
+    this.shouldMirrorLocalPreview = false;
+    this.bindLocalVideoPlayer();
+    await this.switchToExternalVideoSource(track);
+    await this.engine.publishStream(VERTC.MediaType.VIDEO);
+    await this.applyVideoEncoderPreference(
+      encoderSize ?? (width && height ? [width, height] : void 0),
+      encoderOptions
+    );
+    this.localVideoPublished = true;
+    this.publishStartedAtMs = publishStartedAtMs;
+    this.localStreamStatsCount = 0;
+    this.firstNonZeroSentFrameRateAtMs = 0;
+    this.lastObservedSentFrameRate = 0;
+    this.ensureSeiSupport();
+    this.emitState();
+    this.log("success", this.i18n.t("rtc.externalVideoPublished"));
+  }
+  async stopVideoPublishing(options) {
+    if (!this.engine) {
+      return;
+    }
+    this.stopSeiSending();
+    this.clearPublishReadyWaiters();
+    if (this.localVideoPublished) {
+      await this.engine.unpublishStream(VERTC.MediaType.VIDEO);
+    }
+    if (this.localVideoSourceType === VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL) {
+      await this.engine.stopVideoCapture();
+    }
+    if (this.externalVideoTrack) {
+      if (!options?.preserveExternalTrack) {
+        try {
+          this.externalVideoTrack.stop();
+        } catch {
+        }
+      }
+      this.externalVideoTrack = null;
+    }
+    await this.switchToInternalVideoSource(false);
+    this.clearUploadPreviewLayoutObserver();
+    this.clearContainer(this.localVideoContainer);
+    this.clearRemoteVideo();
+    this.localVideoPublished = false;
+    this.publishStartedAtMs = 0;
+    this.lastSentResolution = "";
+    this.emitState();
+    this.log("warn", this.i18n.t("rtc.localVideoStopped"));
+  }
+  async leave() {
+    if (this.leaveTask) {
+      await this.leaveTask;
+      return;
+    }
+    const engine = this.engine;
+    if (!engine) {
+      return;
+    }
+    this.leaveTask = (async () => {
+      try {
+        if (this.localVideoPublished) {
+          await this.stopVideoPublishing();
+        }
+        await engine.leaveRoom();
+      } catch (error) {
+        this.log("warn", this.i18n.t("rtc.leaveRoomError"), error);
+      } finally {
+        try {
+          engine.destroy();
+        } catch {
+        }
+        if (this.engine === engine) {
+          this.engine = null;
+        }
+        this.currentJoinInfo = null;
+        this.users.clear();
+        this.joined = false;
+        this.localVideoPublished = false;
+        this.localVideoSourceType = VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL;
+        this.shouldMirrorLocalPreview = false;
+        this.externalVideoTrack = null;
+        this.remoteVideoUserId = null;
+        this.pendingRemoteVideoUserId = null;
+        this.pendingRemoteVideoMediaType = VERTC.MediaType.VIDEO;
+        this.subscribedRemoteUserId = null;
+        this.subscribedRemoteMediaType = VERTC.MediaType.VIDEO;
+        this.stopSeiSending();
+        this.clearSeiGateFallbackTimer();
+        this.clearSeiMatchedDelayTimer();
+        this.stopRemoteFrameWatch();
+        this.clearPublishReadyWaiters();
+        this.joinedAtMs = 0;
+        this.publishStartedAtMs = 0;
+        this.lastRoomStartEventAtMs = 0;
+        this.localStreamStatsCount = 0;
+        this.firstNonZeroSentFrameRateAtMs = 0;
+        this.lastSentResolution = "";
+        this.lastReceivedResolution = "";
+        this.clearVideoContainers();
+        this.emitState();
+        this.log("info", this.i18n.t("rtc.engineDestroyed"));
+      }
+    })();
+    try {
+      await this.leaveTask;
+    } finally {
+      this.leaveTask = null;
+    }
+  }
+  /**
+   * Resolve whether to wait for input frames before start.
+   * Warm pipelines (restart / long-lived publish) skip — iOS sends start while frames already flow.
+   */
+  resolveInputFrameWaitOptions() {
+    if (!this.localVideoPublished || this.publishStartedAtMs <= 0) {
+      return {
+        minFrames: PUBLISH_COLD_MIN_FRAMES,
+        timeoutMs: PUBLISH_COLD_FRAME_TIMEOUT_MS,
+        minPublishMs: PUBLISH_COLD_WARMUP_MS
+      };
+    }
+    const elapsedMs = performance.now() - this.publishStartedAtMs;
+    if (elapsedMs >= PUBLISH_WARM_SKIP_MS) {
+      return null;
+    }
+    return {
+      minFrames: PUBLISH_COLD_MIN_FRAMES,
+      timeoutMs: Math.max(400, PUBLISH_COLD_FRAME_TIMEOUT_MS - Math.floor(elapsedMs)),
+      minPublishMs: Math.max(0, PUBLISH_COLD_WARMUP_MS - elapsedMs)
+    };
+  }
+  /**
+   * Wait until the published input track produces enough frames before sending start.
+   * Uses actual frame delivery instead of sentFrameRate (~2s Volcengine stats window).
+   */
+  async waitForPublishedInputFrames(options = {}) {
+    const track = this.externalVideoTrack ?? this.engine?.getLocalStreamTrack(VERTC.StreamIndex.STREAM_INDEX_MAIN, "video") ?? null;
+    if (!track || track.readyState === "ended") {
+      return { ready: false, frameCount: 0, elapsedMs: 0 };
+    }
+    const { waitForMediaStreamTrackFrames: waitForMediaStreamTrackFrames2 } = await Promise.resolve().then(() => (init_local_publish_diagnostics(), local_publish_diagnostics_exports));
+    return waitForMediaStreamTrackFrames2(track, {
+      minFrames: options.minFrames ?? PUBLISH_START_MIN_FRAMES,
+      timeoutMs: options.timeoutMs ?? PUBLISH_START_FRAME_TIMEOUT_MS
+    });
+  }
+  /**
+   * Before every start: ensure the publish track is producing frames.
+   * Cold — longer warmup; warm restart — quick sync (~200ms) so backend gets steady input after start.
+   */
+  async ensurePublishedInputBeforeStart() {
+    if (!this.localVideoPublished || this.publishStartedAtMs <= 0) {
+      return;
+    }
+    const publishAgeMs = performance.now() - this.publishStartedAtMs;
+    const isCold = publishAgeMs < PUBLISH_WARM_SKIP_MS;
+    if (!isCold && this.lastObservedSentFrameRate >= 15) {
+      this.debugLog("ensurePublishedInputBeforeStart (warm, outbound steady)", {
+        publishAgeMs: Number(publishAgeMs.toFixed(1)),
+        sentFrameRate: this.lastObservedSentFrameRate
+      });
+      return;
+    }
+    if (isCold) {
+      const [frameResult2] = await Promise.all([
+        this.waitForPublishedInputFrames({
+          minFrames: COLD_START_MIN_FRAMES,
+          timeoutMs: PUBLISH_START_FRAME_TIMEOUT_MS
+        }),
+        this.waitForMinPublishDuration(PUBLISH_COLD_WARMUP_MS)
+      ]);
+      {
+        await new Promise((resolve) => {
+          setTimeout(resolve, COLD_START_SETTLE_MS);
+        });
+      }
+      this.debugLog("ensurePublishedInputBeforeStart (cold)", {
+        publishAgeMs: Number(publishAgeMs.toFixed(1)),
+        frameReady: frameResult2.ready,
+        frameCount: frameResult2.frameCount,
+        sentFrameRate: this.lastObservedSentFrameRate
+      });
+      return;
+    }
+    const frameResult = await this.waitForPublishedInputFrames({
+      minFrames: WARM_START_MIN_FRAMES,
+      timeoutMs: WARM_START_FRAME_TIMEOUT_MS
+    });
+    if (!frameResult.ready && this.lastObservedSentFrameRate <= 0) {
+      await this.waitForLocalPublishReady({ timeoutMs: 800 });
+    }
+    this.debugLog("ensurePublishedInputBeforeStart (warm sync)", {
+      publishAgeMs: Number(publishAgeMs.toFixed(1)),
+      frameReady: frameResult.ready,
+      frameCount: frameResult.frameCount,
+      sentFrameRate: this.lastObservedSentFrameRate
+    });
+  }
+  /** @deprecated Use {@link ensurePublishedInputBeforeStart}. */
+  async waitForRtcOutboundBeforeStart(options) {
+    const timeoutMs = options?.timeoutMs ?? PUBLISH_READY_TIMEOUT_MS;
+    const publishAgeMs = this.publishStartedAtMs > 0 ? performance.now() - this.publishStartedAtMs : 0;
+    const localFramesPromise = publishAgeMs >= PUBLISH_WARM_SKIP_MS ? Promise.resolve({ ready: true, frameCount: 0, elapsedMs: 0 }) : this.waitForPublishedInputFrames({
+      minFrames: PUBLISH_START_MIN_FRAMES,
+      timeoutMs: PUBLISH_START_FRAME_TIMEOUT_MS
+    });
+    const [, rtcReady] = await Promise.all([
+      localFramesPromise,
+      this.waitForLocalPublishReady({ timeoutMs })
+    ]);
+    return rtcReady;
+  }
+  /** @deprecated Use {@link waitForRtcOutboundBeforeStart}. */
+  async waitForPublishedInputFramesBeforeStart() {
+    const waitOptions = this.resolveInputFrameWaitOptions();
+    const waitTasks = [
+      this.waitForLocalPublishReady({ timeoutMs: PUBLISH_READY_TIMEOUT_MS })
+    ];
+    if (waitOptions) {
+      waitTasks.push(
+        this.waitForMinPublishDuration(waitOptions.minPublishMs),
+        this.waitForPublishedInputFrames({
+          minFrames: waitOptions.minFrames,
+          timeoutMs: waitOptions.timeoutMs
+        })
+      );
+    }
+    const [rtcResult, ...rest] = await Promise.all(waitTasks);
+    const rtcSend = rtcResult;
+    const frameResult = waitOptions ? rest[1] : { ready: true, frameCount: 0, elapsedMs: 0 };
+    return {
+      ...frameResult,
+      rtcSendReady: rtcSend.ready,
+      rtcSendReason: rtcSend.reason,
+      rtcSendElapsedMs: rtcSend.elapsedSincePublishMs
+    };
+  }
+  async waitForMinPublishDuration(minMs) {
+    if (minMs <= 0 || this.publishStartedAtMs <= 0) {
+      return;
+    }
+    const elapsedMs = performance.now() - this.publishStartedAtMs;
+    const remainingMs = minMs - elapsedMs;
+    if (remainingMs <= 0) {
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, remainingMs);
+    });
+  }
+  /**
+   * Subscribe to the bot output stream before start — iOS bindRemoteVideoRenderer runs pre-request.
+   */
+  async prepareRemoteVideoForGeneration() {
+    const botUserId = this.currentJoinInfo?.botName?.trim();
+    if (!botUserId || !this.engine || !this.joined) {
+      return;
+    }
+    this.pendingRemoteVideoUserId = botUserId;
+    this.pendingRemoteVideoMediaType = VERTC.MediaType.VIDEO;
+    await this.ensureRemoteStreamSubscribed(botUserId, VERTC.MediaType.VIDEO);
+  }
+  /**
+   * Wait until outbound sentFrameRate reaches minFps and stays there for stableMs.
+   * Avoids starting while Volcengine encoder is still ramping (causes early dropped frames).
+   */
+  async waitForStableLocalPublishReady(options) {
+    const minFps = options?.minFps ?? COLD_START_MIN_OUTBOUND_FPS;
+    const timeoutMs = options?.timeoutMs ?? COLD_START_OUTBOUND_TIMEOUT_MS;
+    const stableMs = options?.stableMs ?? COLD_START_OUTBOUND_STABLE_MS;
+    const publishStartedAtMs = this.publishStartedAtMs;
+    if (!this.localVideoPublished || publishStartedAtMs <= 0) {
+      return {
+        ready: false,
+        reason: "not-published",
+        elapsedSincePublishMs: 0
+      };
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      let stableTimer = null;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timeoutTimer);
+        if (stableTimer !== null) {
+          clearTimeout(stableTimer);
+        }
+        const index = this.stablePublishWaiters.indexOf(check);
+        if (index >= 0) {
+          this.stablePublishWaiters.splice(index, 1);
+        }
+        resolve(result);
+      };
+      const check = () => {
+        if (this.lastObservedSentFrameRate >= minFps) {
+          if (stableTimer === null) {
+            stableTimer = setTimeout(() => {
+              finish({
+                ready: true,
+                reason: "sent-frame-rate",
+                elapsedSincePublishMs: Number((performance.now() - publishStartedAtMs).toFixed(1))
+              });
+            }, stableMs);
+          }
+          return;
+        }
+        if (stableTimer !== null) {
+          clearTimeout(stableTimer);
+          stableTimer = null;
+        }
+      };
+      this.stablePublishWaiters.push(check);
+      check();
+      const timeoutTimer = setTimeout(() => {
+        finish({
+          ready: this.lastObservedSentFrameRate > 0,
+          reason: "timeout",
+          elapsedSincePublishMs: Number((performance.now() - publishStartedAtMs).toFixed(1))
+        });
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Wait until Volcengine reports non-zero sentFrameRate (~2s stats window).
+   * Prefer this over local track frame counts before start — backend only processes from start.
+   */
+  async waitForLocalPublishReady(options) {
+    const timeoutMs = options?.timeoutMs ?? PUBLISH_READY_TIMEOUT_MS;
+    const publishStartedAtMs = this.publishStartedAtMs;
+    if (!this.localVideoPublished || publishStartedAtMs <= 0) {
+      return {
+        ready: false,
+        reason: "not-published",
+        elapsedSincePublishMs: 0
+      };
+    }
+    if (this.firstNonZeroSentFrameRateAtMs > 0) {
+      return {
+        ready: true,
+        reason: "already-ready",
+        elapsedSincePublishMs: Number((this.firstNonZeroSentFrameRateAtMs - publishStartedAtMs).toFixed(1))
+      };
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish = (result) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        clearTimeout(timeoutTimer);
+        const index = this.publishReadyWaiters.indexOf(onReady);
+        if (index >= 0) {
+          this.publishReadyWaiters.splice(index, 1);
+        }
+        resolve(result);
+      };
+      const onReady = (result) => finish(result);
+      this.publishReadyWaiters.push(onReady);
+      const timeoutTimer = setTimeout(() => {
+        finish({
+          ready: false,
+          reason: "timeout",
+          elapsedSincePublishMs: Number((performance.now() - publishStartedAtMs).toFixed(1))
+        });
+      }, timeoutMs);
+    });
+  }
+  async sendRoomEvent(event) {
+    this.ensureReadyForMessaging();
+    const payload = JSON.stringify(event);
+    const eventName = typeof event === "object" && event !== null && "event" in event ? String(event.event ?? "unknown") : "unknown";
+    if (eventName === "start") {
+      this.lastRoomStartEventAtMs = performance.now();
+    }
+    await this.engine?.sendRoomMessage(payload);
+    this.log("success", this.i18n.t("rtc.roomEventSent"), event);
+  }
+  clearRemoteVideo(options) {
+    this.stopRemoteFrameWatch();
+    if (!options?.preserveDom && !this.preserveRemoteDom) {
+      this.clearContainer(this.remoteVideoContainer);
+    }
+    if (this.remoteVideoUserId) {
+      this.pendingRemoteVideoUserId = this.remoteVideoUserId;
+      this.remoteVideoUserId = null;
+      this.emitState();
+    }
+  }
+  async refreshRemoteVideoBinding(options) {
+    const targetUserId = this.remoteVideoUserId ?? this.pendingRemoteVideoUserId;
+    if (!this.engine || !targetUserId || !this.remoteVideoContainer) {
+      return;
+    }
+    await this.ensureRemoteStreamSubscribed(targetUserId, this.pendingRemoteVideoMediaType);
+    if (!this.canRenderRemoteVideo(targetUserId)) {
+      this.debugLog("refreshRemoteVideoBinding blocked by SEI gate", {
+        targetUserId,
+        expectedRemoteSei: this.expectedRemoteSei,
+        lastRemoteSei: this.lastRemoteSei
+      });
+      return;
+    }
+    if (!options?.force && this.remoteVideoUserId === targetUserId && this.remoteVideoContainer && this.remoteVideoContainer.childElementCount > 0) {
+      this.debugLog("refreshRemoteVideoBinding skipped (already mounted)", { targetUserId });
+      return;
+    }
+    try {
+      await this.mountRemoteVideoPlayer(
+        targetUserId,
+        this.remoteVideoContainer,
+        this.pendingRemoteVideoMediaType,
+        options?.force
+      );
+      this.remoteVideoUserId = targetUserId;
+      this.pendingRemoteVideoUserId = null;
+      this.emitState();
+      this.startRemoteFrameWatch(targetUserId);
+      this.emitRemotePlayerMounted();
+      this.log("info", this.i18n.t("rtc.remotePlayerRefreshed", { userId: targetUserId }));
+    } catch (error) {
+      this.log("warn", this.i18n.t("rtc.remotePlayerRefreshFailed"), error);
+    }
+  }
+  bindEngineEvents(engine) {
+    engine.on(VERTC__default.default.events.onUserJoined, (event) => {
+      this.users.add(event.userInfo.userId);
+      this.emitState();
+      this.log("success", this.i18n.t("rtc.userJoined", { userId: event.userInfo.userId }), event);
+      this.log("info", this.i18n.t("rtc.roomUsers", { users: this.snapshot.users.join(", ") }), this.snapshot.users);
+    });
+    engine.on(VERTC__default.default.events.onUserLeave, (event) => {
+      this.users.delete(event.userInfo.userId);
+      if (this.remoteVideoUserId === event.userInfo.userId) {
+        this.remoteVideoUserId = null;
+        this.clearContainer(this.remoteVideoContainer);
+      }
+      if (this.pendingRemoteVideoUserId === event.userInfo.userId) {
+        this.pendingRemoteVideoUserId = null;
+      }
+      this.emitState();
+      this.log("warn", this.i18n.t("rtc.userLeft", { userId: event.userInfo.userId }), event);
+      this.log("info", this.i18n.t("rtc.roomUsers", { users: this.snapshot.users.join(", ") }), this.snapshot.users);
+    });
+    engine.on(VERTC__default.default.events.onConnectionStateChanged, (event) => {
+      this.log("info", this.i18n.t("rtc.connectionStateChanged"), event);
+    });
+    engine.on(VERTC__default.default.events.onUserPublishStream, (event) => {
+      this.log("success", this.i18n.t("rtc.userPublished", { userId: event.userId }), event);
+      if (this.supportsVideo(event.mediaType)) {
+        void this.attachRemoteVideo(event.userId, event.mediaType);
+      }
+    });
+    engine.on(VERTC__default.default.events.onUserUnpublishStream, (event) => {
+      this.log("warn", this.i18n.t("rtc.userUnpublished", { userId: event.userId }), event);
+      this.debugLog("onUserUnpublishStream", {
+        userId: event.userId,
+        mediaType: event.mediaType,
+        remoteVideoUserId: this.remoteVideoUserId,
+        expectedRemoteSei: this.expectedRemoteSei,
+        lastRemoteSei: this.lastRemoteSei
+      });
+      if (this.remoteVideoUserId === event.userId && this.supportsVideo(event.mediaType)) {
+        this.pendingRemoteVideoUserId = event.userId;
+        this.pendingRemoteVideoMediaType = event.mediaType;
+        this.remoteVideoUserId = null;
+        this.stopRemoteFrameWatch();
+        if (!this.preserveRemoteDom) {
+          this.clearContainer(this.remoteVideoContainer);
+        }
+        this.emitState();
+        return;
+      }
+    });
+    engine.on(VERTC__default.default.events.onSEIMessageReceived, (event) => {
+      const userId = event.remoteStreamKey.userId;
+      const sei = this.normalizeSei(this.decodeSeiMessage(event.sei));
+      if (sei && this.isRemoteSeiUser(userId)) {
+        this.onRemoteSeiReceived?.({ sei, userId });
+      }
+      this.lastRemoteSei = sei;
+      this.lastRemoteSeiUserId = userId;
+      const matched = this.isSeiMatched();
+      const seiStateChanged = this.lastDebugSeiMatched !== matched || this.lastDebugRemoteSei !== sei;
+      if (!this.debug || seiStateChanged) {
+        this.log("info", this.i18n.t("rtc.seiReceived", { userId }), { userId, sei, matched });
+      }
+      if (this.debug && seiStateChanged) {
+        this.debugLog("onSEIMessageReceived", {
+          userId,
+          sei,
+          matched,
+          expectedRemoteSei: this.expectedRemoteSei
+        });
+        this.lastDebugSeiMatched = matched;
+        this.lastDebugRemoteSei = sei;
+      }
+      if (!matched) {
+        this.onSeiGateChange?.({
+          expectedSei: this.expectedRemoteSei,
+          sei,
+          userId,
+          matched: false
+        });
+        return;
+      }
+      if (this.seiMatchedDelayTimer !== null) {
+        return;
+      }
+      this.clearSeiGateFallbackTimer();
+      this.stopSeiSending();
+      this.seiMatchedDelayTimer = setTimeout(() => {
+        this.seiMatchedDelayTimer = null;
+        if (!this.isSeiMatched()) {
+          return;
+        }
+        this.onSeiGateChange?.({
+          expectedSei: this.expectedRemoteSei,
+          sei,
+          userId,
+          matched: true
+        });
+        if (this.remoteVideoUserId === userId) {
+          return;
+        }
+        void this.attachRemoteVideo(userId, this.pendingRemoteVideoMediaType);
+      }, _RtcManager.SEI_MATCHED_DISPLAY_DELAY_MS);
+    });
+    engine.on(VERTC__default.default.events.onError, (event) => {
+      this.log("error", this.i18n.t("rtc.error", { code: String(event.errorCode) }), event);
+    });
+    engine.on(VERTC__default.default.events.onPublishResult, (event) => {
+      this.debugLog("onPublishResult", {
+        ...event,
+        elapsedSincePublishMs: this.publishStartedAtMs > 0 ? Number((performance.now() - this.publishStartedAtMs).toFixed(1)) : null
+      });
+    });
+    engine.on(VERTC__default.default.events.onLocalStreamStats, (stats) => {
+      this.logLocalStreamStats(stats);
+      if (stats.videoStats) {
+        const width = stats.videoStats.sentResolutionWidth ?? stats.videoStats.encodedFrameWidth ?? 0;
+        const height = stats.videoStats.sentResolutionHeight ?? stats.videoStats.encodedFrameHeight ?? 0;
+        stats.videoStats.sentFrameRate ?? 0;
+        const res = `${width}x${height}`;
+        if (width > 0 && height > 0 && res !== this.lastSentResolution) {
+          this.lastSentResolution = res;
+        }
+      }
+    });
+    engine.on(VERTC__default.default.events.onRemoteStreamStats, (stats) => {
+      if (stats?.videoStats) {
+        const { width, height, receivedFrameRate } = stats.videoStats;
+        const w = width ?? 0;
+        const h = height ?? 0;
+        const res = `${w}x${h}`;
+        if (w > 0 && h > 0 && res !== this.lastReceivedResolution) {
+          this.lastReceivedResolution = res;
+        }
+      }
+    });
+    engine.on(VERTC__default.default.events.onLocalStatsException, (exception) => {
+      this.debugLog("onLocalStatsException", {
+        exception,
+        elapsedSincePublishMs: this.publishStartedAtMs > 0 ? Number((performance.now() - this.publishStartedAtMs).toFixed(1)) : null
+      });
+    });
+    engine.on(VERTC__default.default.events.onTrackMute, (event) => {
+      this.debugLog("onTrackMute", event);
+    });
+    engine.on(VERTC__default.default.events.onTrackUnmute, (event) => {
+      this.debugLog("onTrackUnmute", event);
+    });
+  }
+  emitState() {
+    this.onStateChange?.(this.snapshot);
+  }
+  ensureReadyForMessaging() {
+    if (!this.engine || !this.joined) {
+      throw new Error(this.i18n.t("errors.rtcNotJoinedForMessaging"));
+    }
+  }
+  bindLocalVideoPlayer(force = false) {
+    if (!this.localVideoContainer) {
+      return;
+    }
+    const container = this.getRequiredContainer(this.localVideoContainer, "local");
+    if (!force && container.childElementCount > 0) {
+      this.bindUploadPreviewLayout(container);
+      return;
+    }
+    container.replaceChildren();
+    this.engine?.setLocalVideoMirrorType(
+      this.shouldMirrorLocalPreview ? VERTC.MirrorType.MIRROR_TYPE_RENDER : VERTC.MirrorType.MIRROR_TYPE_NONE
+    );
+    this.engine?.setLocalVideoPlayer(VERTC.StreamIndex.STREAM_INDEX_MAIN, {
+      renderDom: container,
+      renderMode: resolveVideoRenderMode(container)
+    });
+    this.bindUploadPreviewLayout(container);
+  }
+  bindUploadPreviewLayout(container) {
+    this.uploadPreviewLayoutObserverStop?.();
+    this.uploadPreviewLayoutObserverStop = null;
+    applyUploadPreviewMediaLayout(container);
+    this.uploadPreviewLayoutObserverStop = observeUploadPreviewMediaLayout(container);
+  }
+  clearUploadPreviewLayoutObserver() {
+    this.uploadPreviewLayoutObserverStop?.();
+    this.uploadPreviewLayoutObserverStop = null;
+  }
+  /** Re-bind local preview after the container becomes visible or is resized (mobile H5). */
+  refreshLocalVideoPreview(options) {
+    if (!this.engine || !this.localVideoPublished || !this.localVideoContainer) {
+      return;
+    }
+    this.bindLocalVideoPlayer(options?.force);
+  }
+  async switchToExternalVideoSource(track) {
+    if (!this.engine) {
+      return;
+    }
+    this.externalVideoTrack = track;
+    await this.engine.setVideoSourceType(VERTC.StreamIndex.STREAM_INDEX_MAIN, VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
+    await this.engine.setExternalVideoTrack(VERTC.StreamIndex.STREAM_INDEX_MAIN, track);
+    this.localVideoSourceType = VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL;
+  }
+  async switchToInternalVideoSource(shouldSetConfig = true) {
+    if (!this.engine) {
+      return;
+    }
+    if (this.localVideoSourceType === VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL) {
+      return;
+    }
+    await this.engine.setVideoSourceType(VERTC.StreamIndex.STREAM_INDEX_MAIN, VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL);
+    this.localVideoSourceType = VERTC.VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL;
+    if (shouldSetConfig && this.externalVideoTrack) {
+      this.externalVideoTrack = null;
+    }
+  }
+  async applyLocalVideoCaptureConfig([width, height]) {
+    if (!this.engine) {
+      return;
+    }
+    await this.engine.setVideoCaptureConfig({
+      width,
+      height
+    });
+    this.log("info", this.i18n.t("rtc.captureSizeSet", { width, height }));
+  }
+  resolveEncoderMaxKbps(width, height, highQuality = true) {
+    const pixels = width * height;
+    if (highQuality) {
+      if (pixels >= 2e6) {
+        return 6e3;
+      }
+      if (pixels >= 1e6) {
+        return 4e3;
+      }
+      return 3e3;
+    }
+    if (pixels >= 2e6) {
+      return 5e3;
+    }
+    if (pixels >= 1e6) {
+      return 3e3;
+    }
+    return 2e3;
+  }
+  async applyVideoEncoderPreference(size, publishOptions) {
+    if (!this.engine) {
+      return;
+    }
+    try {
+      const width = size?.[0] ?? 1280;
+      const height = size?.[1] ?? 720;
+      if (publishOptions) {
+        const fps = publishOptions.fps ?? 30;
+        const maxKbps = this.resolveEncoderMaxKbps(width, height, publishOptions.highQuality);
+        await this.engine.setVideoEncoderConfig({
+          width,
+          height,
+          frameRate: fps,
+          maxKbps,
+          contentHint: "detail",
+          preferCodecName: VERTC.VideoCodecType.H264
+        });
+      } else {
+        await this.engine.setVideoEncoderConfig({
+          width,
+          height,
+          frameRate: 24,
+          maxKbps: -1,
+          contentHint: "detail",
+          // @ts-expect-error: encodePreference is supported by ByteRTC SDK but may be missing from current typings
+          encodePreference: 1,
+          preferCodecName: VERTC.VideoCodecType.H264
+        });
+      }
+      this.log("info", this.i18n.t("rtc.encoderPreferenceSet"), size);
+    } catch (error) {
+      this.log("warn", this.i18n.t("rtc.encoderPreferenceFailed"), error);
+    }
+  }
+  async attachRemoteVideo(userId, mediaType) {
+    if (!this.engine || !this.currentJoinInfo) {
+      return;
+    }
+    const preferredBotUserId = this.currentJoinInfo.botName?.trim() || null;
+    const shouldReplaceCurrent = this.remoteVideoUserId === null || userId === preferredBotUserId || this.remoteVideoUserId !== preferredBotUserId;
+    if (!shouldReplaceCurrent) {
+      return;
+    }
+    this.pendingRemoteVideoUserId = userId;
+    this.pendingRemoteVideoMediaType = mediaType;
+    await this.ensureRemoteStreamSubscribed(userId, mediaType);
+    if (!this.canRenderRemoteVideo(userId)) {
+      this.log("info", this.i18n.t("rtc.remoteWaitSei", { userId }), {
+        expectedRemoteSei: this.expectedRemoteSei,
+        lastRemoteSei: this.lastRemoteSei,
+        lastRemoteSeiUserId: this.lastRemoteSeiUserId
+      });
+      return;
+    }
+    const container = this.remoteVideoContainer;
+    if (!container) {
+      this.log("warn", this.i18n.t("rtc.remoteContainerNotReady"), { userId, mediaType });
+      return;
+    }
+    await this.mountRemoteVideoPlayer(userId, container, mediaType);
+    this.remoteVideoUserId = userId;
+    this.pendingRemoteVideoUserId = null;
+    this.emitState();
+    this.startRemoteFrameWatch(userId);
+    this.emitRemotePlayerMounted();
+    this.log("success", this.i18n.t("rtc.remotePlayerBound", { userId }));
+  }
+  async ensureRemoteStreamSubscribed(userId, mediaType) {
+    if (!this.engine) {
+      return;
+    }
+    if (this.subscribedRemoteUserId === userId) {
+      return;
+    }
+    await this.engine.subscribeStream(userId, mediaType);
+    this.subscribedRemoteUserId = userId;
+    this.subscribedRemoteMediaType = mediaType;
+    this.debugLog("ensureRemoteStreamSubscribed", { userId, mediaType });
+  }
+  bindRemoteVideoPlayerToContainer(userId, container) {
+    if (!this.engine) {
+      return;
+    }
+    this.engine.setRemoteVideoPlayer(VERTC.StreamIndex.STREAM_INDEX_MAIN, {
+      userId,
+      renderDom: container,
+      renderMode: resolveVideoRenderMode(container)
+    });
+    this.bindUploadPreviewLayout(container);
+  }
+  async mountRemoteVideoPlayer(userId, container, mediaType, force = false) {
+    if (!this.engine) {
+      return;
+    }
+    if (!force && this.remoteVideoUserId === userId && container === this.remoteVideoContainer && container.childElementCount > 0) {
+      this.debugLog("mountRemoteVideoPlayer skipped (already mounted)", { userId });
+      return;
+    }
+    this.debugLog(force ? "mountRemoteVideoPlayer (force)" : "mountRemoteVideoPlayer", {
+      userId,
+      mediaType,
+      childCountBefore: container.childElementCount
+    });
+    this.stopRemoteFrameWatch();
+    container.replaceChildren();
+    await this.ensureRemoteStreamSubscribed(userId, mediaType);
+    this.bindRemoteVideoPlayerToContainer(userId, container);
+  }
+  startRemoteFrameWatch(userId) {
+    this.stopRemoteFrameWatch();
+    let lastFrameAt = 0;
+    let hadFirstFrame = false;
+    let rvfcHandle = null;
+    let watchedVideo = null;
+    const onFrame = () => {
+      lastFrameAt = Date.now();
+      hadFirstFrame = true;
+    };
+    const bindRvfc = (video) => {
+      if (watchedVideo === video && rvfcHandle !== null) {
+        return;
+      }
+      if (watchedVideo && watchedVideo !== video) {
+        watchedVideo.removeEventListener("timeupdate", onFrame);
+      }
+      watchedVideo = video;
+      const rvfcVideo = video;
+      if (rvfcVideo.requestVideoFrameCallback) {
+        const schedule = () => {
+          if (this.remoteVideoUserId !== userId) {
+            return;
+          }
+          rvfcHandle = rvfcVideo.requestVideoFrameCallback(() => {
+            onFrame();
+            schedule();
+          });
+        };
+        schedule();
+        return;
+      }
+      video.addEventListener("timeupdate", onFrame);
+    };
+    const pollTimer = setInterval(() => {
+      if (this.remoteVideoUserId !== userId || !this.remoteVideoContainer) {
+        return;
+      }
+      const video = this.remoteVideoContainer.querySelector("video");
+      if (video) {
+        bindRvfc(video);
+      }
+      if (!hadFirstFrame || lastFrameAt === 0) {
+        return;
+      }
+      const stallMs = Date.now() - lastFrameAt;
+      if (stallMs < REMOTE_OUTPUT_STALL_MS) {
+        return;
+      }
+      if (Date.now() < this.remoteOutputRecoveryCooldownUntil) {
+        return;
+      }
+      this.remoteOutputRecoveryCooldownUntil = Date.now() + REMOTE_OUTPUT_RECOVERY_COOLDOWN_MS;
+      this.debugLog("remote output stalled", { userId, stallMs });
+      this.log("warn", this.i18n.t("rtc.remoteOutputStalled"), { userId, stallMs });
+      this.onRemoteOutputStalled?.({ userId, stallMs });
+      hadFirstFrame = false;
+      lastFrameAt = 0;
+    }, 3e3);
+    this.remoteFrameWatchStop = () => {
+      clearInterval(pollTimer);
+      if (watchedVideo) {
+        watchedVideo.removeEventListener("timeupdate", onFrame);
+      }
+      if (rvfcHandle !== null && watchedVideo) {
+        const rvfcVideo = watchedVideo;
+        rvfcVideo.cancelVideoFrameCallback?.(rvfcHandle);
+      }
+      rvfcHandle = null;
+      watchedVideo = null;
+    };
+  }
+  stopRemoteFrameWatch() {
+    this.remoteFrameWatchStop?.();
+    this.remoteFrameWatchStop = null;
+  }
+  isRemoteSeiUser(userId) {
+    const localUserId = this.currentJoinInfo?.userId?.trim();
+    if (localUserId && userId === localUserId) {
+      return false;
+    }
+    const botUserId = this.currentJoinInfo?.botName?.trim();
+    if (botUserId) {
+      return userId === botUserId;
+    }
+    return true;
+  }
+  /** Always mount remote player — SEI gate is UI-only (see deriveOutputVisibility). */
+  canRenderRemoteVideo(_userId) {
+    return true;
+  }
+  /** Whether remote SEI matches the active task (display gate). */
+  isSeiMatched() {
+    if (this.seiSupport === "unsupported") {
+      return true;
+    }
+    if (!this.expectedRemoteSei) {
+      return true;
+    }
+    return this.lastRemoteSei === this.expectedRemoteSei;
+  }
+  /** Low-rate SEI until remote output SEI matches — avoids Volcengine sendSEIMessage timeouts. */
+  startContinuousSeiSending() {
+    this.stopSeiSending();
+    if (!this.localSeiMessage || !this.engine || !this.joined || !this.localVideoPublished || this.seiSupport === "unsupported") {
+      return;
+    }
+    const tick = () => {
+      if (this.isSeiMatched() && this.expectedRemoteSei) {
+        this.stopSeiSending();
+        return;
+      }
+      this.flushSeiMessage();
+    };
+    this.seiSendInterval = setInterval(tick, SESSION_SEI_INTERVAL_MS);
+  }
+  stopSeiSending() {
+    if (this.seiSendInterval !== null) {
+      this.debugLog("stopSeiSending");
+      clearInterval(this.seiSendInterval);
+      this.seiSendInterval = null;
+    }
+    this.lastSeiSentAtMs = 0;
+  }
+  canSendLocalSeiNow() {
+    if (this.firstNonZeroSentFrameRateAtMs <= 0) {
+      return false;
+    }
+    const now = performance.now();
+    return now - this.lastSeiSentAtMs >= SESSION_SEI_INTERVAL_MS - 16;
+  }
+  flushSeiMessage() {
+    if (!this.engine || !this.joined || !this.localVideoPublished || !this.localSeiMessage || this.seiSupport === "unsupported") {
+      return;
+    }
+    if (!this.canSendLocalSeiNow()) {
+      return;
+    }
+    this.lastSeiSentAtMs = performance.now();
+    try {
+      this.engine.sendSEIMessage(VERTC.StreamIndex.STREAM_INDEX_MAIN, this.localSeiMessage, this.localSeiRepeatCount);
+    } catch (error) {
+      if (!this.hasLoggedSeiSendFailure) {
+        this.log("warn", this.i18n.t("rtc.sendSeiFailed"), error);
+        this.hasLoggedSeiSendFailure = true;
+      }
+      this.stopSeiSending();
+    }
+  }
+  ensureSeiSupport() {
+    if (this.seiSupport !== "unknown") {
+      return;
+    }
+    void VERTC__default.default.getSupportedCodecs().then((codecs) => {
+      const supported = codecs.some((c) => c.toLowerCase() === "h264" || c.toLowerCase() === "h.264");
+      this.seiSupport = supported ? "supported" : "unsupported";
+      if (this.seiSupport === "unsupported" && !this.hasLoggedSeiUnsupported) {
+        this.hasLoggedSeiUnsupported = true;
+        this.log("warn", this.i18n.t("rtc.seiUnsupported"), codecs);
+      }
+      if (this.seiSupport === "unsupported") {
+        this.expectedRemoteSei = null;
+        this.emitSeiGateState();
+        void this.refreshRemoteVideoBinding();
+      } else if (this.localSeiMessage) {
+        this.startContinuousSeiSending();
+        this.emitSeiGateState();
+        void this.refreshRemoteVideoBinding();
+      }
+    }).catch((error) => {
+      this.seiSupport = "unsupported";
+      if (!this.hasLoggedSeiUnsupported) {
+        this.hasLoggedSeiUnsupported = true;
+        this.log("warn", this.i18n.t("rtc.getCodecsFailed"), error);
+      }
+      this.expectedRemoteSei = null;
+      this.emitSeiGateState();
+      void this.refreshRemoteVideoBinding();
+    });
+  }
+  normalizeSei(value) {
+    const normalized = value?.trim();
+    if (!normalized) {
+      return null;
+    }
+    return normalized.startsWith("task-") ? normalized.slice("task-".length) : normalized;
+  }
+  normalizeSeiRepeatCount(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      return DEFAULT_SEI_REPEAT_COUNT;
+    }
+    return Math.max(0, Math.min(4, Math.floor(value)));
+  }
+  decodeSeiMessage(sei) {
+    try {
+      return new TextDecoder().decode(sei);
+    } catch {
+      return null;
+    }
+  }
+  supportsVideo(mediaType) {
+    return mediaType === VERTC.MediaType.VIDEO || mediaType === VERTC.MediaType.AUDIO_AND_VIDEO;
+  }
+  clearVideoContainers() {
+    this.stopRemoteFrameWatch();
+    this.clearContainer(this.localVideoContainer);
+    this.clearContainer(this.remoteVideoContainer);
+  }
+  clearContainer(container) {
+    container?.replaceChildren();
+  }
+  getRequiredContainer(container, containerType) {
+    if (!container) {
+      throw new Error(`missing ${containerType} video container`);
+    }
+    return container;
+  }
+  emitRemotePlayerMounted() {
+    this.onRemotePlayerMounted?.();
+  }
+  log(level, message, data) {
+    this.onLog?.({ level, message, data });
+  }
+  resolvePublishReadyWaiters(reason) {
+    if (this.publishReadyWaiters.length === 0 || this.publishStartedAtMs <= 0) {
+      return;
+    }
+    const result = {
+      ready: true,
+      reason,
+      elapsedSincePublishMs: Number((performance.now() - this.publishStartedAtMs).toFixed(1))
+    };
+    const waiters = this.publishReadyWaiters.splice(0);
+    for (const waiter of waiters) {
+      waiter(result);
+    }
+  }
+  clearPublishReadyWaiters() {
+    if (this.publishReadyBufferTimer !== null) {
+      clearTimeout(this.publishReadyBufferTimer);
+      this.publishReadyBufferTimer = null;
+    }
+    this.publishReadyWaiters = [];
+    this.stablePublishWaiters = [];
+  }
+  notifyStablePublishWaiters() {
+    if (this.stablePublishWaiters.length === 0) {
+      return;
+    }
+    const waiters = this.stablePublishWaiters.slice();
+    for (const waiter of waiters) {
+      waiter();
+    }
+  }
+  schedulePublishReadyWhenStable(sentFrameRate) {
+    if (this.publishReadyWaiters.length === 0 || this.publishReadyBufferTimer !== null) {
+      return;
+    }
+    if (sentFrameRate <= 0) {
+      return;
+    }
+    this.publishReadyBufferTimer = setTimeout(() => {
+      this.publishReadyBufferTimer = null;
+      this.resolvePublishReadyWaiters("sent-frame-rate");
+    }, PUBLISH_READY_BUFFER_MS);
+  }
+  logLocalStreamStats(stats) {
+    if (!this.localVideoPublished) {
+      return;
+    }
+    this.localStreamStatsCount += 1;
+    const nowMs = performance.now();
+    const sentFrameRate = stats.videoStats?.sentFrameRate ?? 0;
+    if (sentFrameRate > 0 && this.firstNonZeroSentFrameRateAtMs === 0) {
+      this.firstNonZeroSentFrameRateAtMs = nowMs;
+    }
+    this.lastObservedSentFrameRate = sentFrameRate;
+    this.schedulePublishReadyWhenStable(sentFrameRate);
+    this.notifyStablePublishWaiters();
+  }
+  debugLog(message, data) {
+    if (!this.debug) {
+      return;
+    }
+    this.log("info", `[debug] ${message}`, data);
+  }
+};
+_RtcManager.SEI_GATE_FALLBACK_MS = 6e3;
+_RtcManager.SEI_MATCHED_DISPLAY_DELAY_MS = 200;
+var RtcManager = _RtcManager;
+
+// src/rtc/capture-host.ts
+var captureHostRoot = null;
+var CAPTURE_VIDEO_STYLE = "position:fixed;left:-10000px;top:0;width:640px;height:480px;opacity:1;pointer-events:none;z-index:-1;";
+function mountCaptureVideo(videoEl) {
+  if (!captureHostRoot) {
+    captureHostRoot = document.createElement("div");
+    captureHostRoot.setAttribute("data-xmax-capture-host", "true");
+    captureHostRoot.style.cssText = "position:fixed;left:0;top:0;width:0;height:0;overflow:hidden;pointer-events:none;z-index:-1;";
+    document.body.appendChild(captureHostRoot);
+  }
+  videoEl.setAttribute("playsinline", "true");
+  videoEl.setAttribute("webkit-playsinline", "true");
+  videoEl.style.cssText = CAPTURE_VIDEO_STYLE;
+  captureHostRoot.appendChild(videoEl);
+}
+
+// src/rtc/camera-stream-v2.ts
+async function createNativeCameraStream(sourceStream, options = {}) {
+  const i18n = options.i18n ?? createSDKI18n();
+  const sourceTrack = sourceStream.getVideoTracks()[0];
+  if (!sourceTrack) {
+    throw new Error(i18n.t("errors.videoTrackMissing"));
+  }
+  const videoEl = document.createElement("video");
+  videoEl.playsInline = true;
+  videoEl.muted = true;
+  videoEl.autoplay = true;
+  videoEl.srcObject = sourceStream;
+  mountCaptureVideo(videoEl);
+  await new Promise((resolve, reject) => {
+    const onOk = () => {
+      cleanup();
+      resolve();
+    };
+    const onErr = () => {
+      cleanup();
+      reject(new Error(`failed to load video metadata`));
+    };
+    const cleanup = () => {
+      videoEl.removeEventListener("loadedmetadata", onOk);
+      videoEl.removeEventListener("error", onErr);
+    };
+    videoEl.addEventListener("loadedmetadata", onOk, { once: true });
+    videoEl.addEventListener("error", onErr, { once: true });
+  });
+  const playResult = videoEl.play();
+  if (playResult && typeof playResult.then === "function") {
+    await playResult;
+  }
+  const width = videoEl.videoWidth || 0;
+  const height = videoEl.videoHeight || 0;
+  if (!width || !height) {
+    throw new Error(i18n.t("errors.videoTrackMissing"));
+  }
+  const destroy = () => {
+    try {
+      videoEl.pause();
+    } catch {
+    }
+    try {
+      videoTrack.stop();
+    } catch {
+    }
+    try {
+      sourceStream.getTracks().forEach((track) => {
+        if (track.readyState !== "ended") {
+          track.stop();
+        }
+      });
+    } catch {
+    }
+    try {
+      videoEl.srcObject = null;
+      videoEl.remove();
+    } catch {
+    }
+  };
+  const videoTrack = sourceTrack;
+  return {
+    sourceStream,
+    previewStream: sourceStream,
+    // No canvas mirror, preview is the raw stream
+    videoTrack,
+    videoEl,
+    width,
+    height,
+    destroy
+  };
+}
+
+// src/drag/map-viewport.ts
+function clamp(n, min, max) {
+  return Math.min(Math.max(n, min), max);
+}
+function getFitContentRect(rect, targetSize, fitMode = "contain") {
+  const [targetWidth, targetHeight] = targetSize;
+  if (!targetWidth || !targetHeight || !rect.width || !rect.height) {
+    return {
+      left: rect.left,
+      top: rect.top,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+  const scale = fitMode === "cover" ? Math.max(rect.width / targetWidth, rect.height / targetHeight) : Math.min(rect.width / targetWidth, rect.height / targetHeight);
+  const width = targetWidth * scale;
+  const height = targetHeight * scale;
+  return {
+    left: rect.left + (rect.width - width) / 2,
+    top: rect.top + (rect.height - height) / 2,
+    width,
+    height
+  };
+}
+function getContentRect(rect, targetSize) {
+  return getFitContentRect(rect, targetSize, "contain");
+}
+function findDragMediaElement(dragSurface) {
+  const root = dragSurface.parentElement ?? dragSurface;
+  if (typeof root.querySelector !== "function") {
+    return null;
+  }
+  const videoHost = root.querySelector("[data-xmax-remote-video]") ?? root;
+  if (typeof videoHost.querySelector !== "function") {
+    return null;
+  }
+  const media = videoHost.querySelector("video, canvas");
+  return media ?? null;
+}
+function toContentRect(rect) {
+  return {
+    left: rect.left,
+    top: rect.top,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isMediaInsetInContainer(mediaRect, containerRect) {
+  if (!mediaRect.width || !mediaRect.height || !containerRect.width || !containerRect.height) {
+    return false;
+  }
+  const widthRatio = mediaRect.width / containerRect.width;
+  const heightRatio = mediaRect.height / containerRect.height;
+  return widthRatio < 0.98 || heightRatio < 0.98;
+}
+function resolveMappingContext(dragSurface, targetSize, fitMode = "cover") {
+  const containerRect = dragSurface.getBoundingClientRect();
+  const media = findDragMediaElement(dragSurface);
+  if (media) {
+    const mediaRect = media.getBoundingClientRect();
+    if (mediaRect.width > 0 && mediaRect.height > 0 && isMediaInsetInContainer(mediaRect, containerRect)) {
+      const content2 = toContentRect(mediaRect);
+      return { content: content2, hitRect: content2, source: "media" };
+    }
+  }
+  const content = getFitContentRect(containerRect, targetSize, fitMode);
+  return {
+    content,
+    hitRect: toContentRect(containerRect),
+    source: "fit"
+  };
+}
+function mapViewportPointToCoordinateSpace(e, container, targetSize, options = {}) {
+  const fitMode = options.fitMode ?? "cover";
+  const mirrored = options.mirrored ?? false;
+  const [targetWidth, targetHeight] = targetSize;
+  if (!targetWidth || !targetHeight) {
+    return null;
+  }
+  const { content, hitRect } = resolveMappingContext(container, targetSize, fitMode);
+  if (!content.width || !content.height) {
+    return null;
+  }
+  if (e.clientX < hitRect.left || e.clientY < hitRect.top || e.clientX > hitRect.left + hitRect.width || e.clientY > hitRect.top + hitRect.height) {
+    return null;
+  }
+  const x = Math.round((e.clientX - content.left) * targetWidth / content.width);
+  const y = Math.round((e.clientY - content.top) * targetHeight / content.height);
+  const normalizedX = mirrored ? targetWidth - 1 - x : x;
+  return [
+    clamp(normalizedX, 0, targetWidth - 1),
+    clamp(y, 0, targetHeight - 1)
+  ];
+}
+function mapTargetPointToCanvas(point, container, targetSize, dpr, options = {}) {
+  const fitMode = options.fitMode ?? "cover";
+  const mirrored = options.mirrored ?? false;
+  const containerRect = container.getBoundingClientRect();
+  const [targetWidth, targetHeight] = targetSize;
+  const { content } = resolveMappingContext(container, targetSize, fitMode);
+  if (!targetWidth || !targetHeight || !content.width || !content.height) {
+    return null;
+  }
+  const displayX = mirrored ? targetWidth - 1 - point[0] : point[0];
+  const originX = (content.left - containerRect.left) * dpr;
+  const originY = (content.top - containerRect.top) * dpr;
+  const contentW = content.width * dpr;
+  const contentH = content.height * dpr;
+  return [
+    originX + displayX / targetWidth * contentW,
+    originY + point[1] / targetHeight * contentH
+  ];
+}
+
+// src/drag/drag-track-controller.ts
+function fadeCanvas(ctx) {
+  ctx.save();
+  ctx.globalCompositeOperation = "destination-out";
+  ctx.fillStyle = "rgba(0,0,0,0.06)";
+  ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+  ctx.restore();
+}
+function drawNeon(ctx, segs, container, targetSize, dpr, fitMode, mirrored) {
+  if (segs.length === 0) {
+    return;
+  }
+  const coreW = 3.6 * dpr;
+  const lineW = 10 * dpr;
+  const glowRadius = 28 * dpr;
+  const color = { r: 20, g: 255, b: 80 };
+  const rgba = (a) => `rgba(${color.r},${color.g},${color.b},${a})`;
+  const strokeSegs = (opts) => {
+    ctx.save();
+    ctx.globalCompositeOperation = opts.composite;
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    ctx.lineWidth = opts.width;
+    ctx.strokeStyle = rgba(opts.alpha);
+    ctx.shadowBlur = opts.shadowBlur;
+    ctx.shadowColor = rgba(opts.shadowAlpha);
+    ctx.beginPath();
+    for (const seg of segs) {
+      const start = mapTargetPointToCanvas(seg.a, container, targetSize, dpr, { fitMode, mirrored });
+      const end = mapTargetPointToCanvas(seg.b, container, targetSize, dpr, { fitMode, mirrored });
+      if (!start || !end) {
+        continue;
+      }
+      ctx.moveTo(start[0], start[1]);
+      ctx.lineTo(end[0], end[1]);
+    }
+    ctx.stroke();
+    ctx.restore();
+  };
+  strokeSegs({
+    width: lineW,
+    shadowBlur: glowRadius,
+    shadowAlpha: 0.9,
+    alpha: 0.45,
+    composite: "lighter"
+  });
+  strokeSegs({
+    width: lineW,
+    shadowBlur: 12 * dpr,
+    shadowAlpha: 0.9,
+    alpha: 0.9,
+    composite: "lighter"
+  });
+  strokeSegs({
+    width: coreW,
+    shadowBlur: 6 * dpr,
+    shadowAlpha: 0.8,
+    alpha: 1,
+    composite: "source-over"
+  });
+  ctx.save();
+  ctx.globalCompositeOperation = "lighter";
+  ctx.fillStyle = rgba(1);
+  ctx.shadowBlur = 10 * dpr;
+  ctx.shadowColor = rgba(0.8);
+  const head = segs[segs.length - 1];
+  if (head) {
+    const headPoint = mapTargetPointToCanvas(head.b, container, targetSize, dpr, { fitMode, mirrored });
+    if (headPoint) {
+      ctx.beginPath();
+      ctx.arc(headPoint[0], headPoint[1], 3.2 * dpr, 0, Math.PI * 2);
+      ctx.fill();
+    }
+  }
+  ctx.restore();
+}
+var DragTrackController = class {
+  constructor(container, options) {
+    this.activePointers = /* @__PURE__ */ new Map();
+    this.lastTargetPoints = /* @__PURE__ */ new Map();
+    this.segQueue = [];
+    this.sampleTimer = null;
+    this.sampleInFlight = false;
+    this.rafId = null;
+    this.resizeObserver = null;
+    this.container = container;
+    this.onTracks = options.onTracks;
+    this.targetSize = options.targetSize;
+    this.fitMode = options.fitMode ?? "cover";
+    this.mirrored = options.mirrored ?? false;
+    this.enabled = options.enabled ?? true;
+    this.emitEmptyTracksWhenIdle = options.emitEmptyTracksWhenIdle ?? false;
+    this.canvas = document.createElement("canvas");
+    this.canvas.className = "Xmax-drag-track-canvas";
+    this.canvas.style.cssText = "position:absolute;inset:0;z-index:21;width:100%;height:100%;pointer-events:none;";
+    container.appendChild(this.canvas);
+    this.onWindowResize = () => this.resizeCanvas();
+    this.onPointerDown = (e) => this.handlePointerDown(e);
+    this.onPointerMove = (e) => this.handlePointerMove(e);
+    this.onPointerUp = (e) => this.handlePointerUp(e);
+    this.onPointerCancel = (e) => this.handlePointerCancel(e);
+    this.resizeCanvas();
+    this.bindResizeObserver();
+    this.bindPointerEvents();
+    this.applyInteractionStyle();
+    if (this.enabled && this.emitEmptyTracksWhenIdle) {
+      this.startSampling();
+    }
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    this.applyInteractionStyle();
+    if (!enabled) {
+      this.finishStroke({ stopIdleSampling: true });
+      return;
+    }
+    if (this.emitEmptyTracksWhenIdle && this.activePointers.size === 0) {
+      this.startSampling();
+    }
+  }
+  setEmitEmptyTracksWhenIdle(emitEmptyTracksWhenIdle) {
+    if (this.emitEmptyTracksWhenIdle === emitEmptyTracksWhenIdle) {
+      return;
+    }
+    this.emitEmptyTracksWhenIdle = emitEmptyTracksWhenIdle;
+    if (emitEmptyTracksWhenIdle && this.enabled && this.activePointers.size === 0) {
+      this.startSampling();
+      return;
+    }
+    if (!emitEmptyTracksWhenIdle && this.activePointers.size === 0) {
+      this.stopSampling();
+    }
+  }
+  setTargetSize(targetSize) {
+    this.targetSize = targetSize;
+  }
+  setFitMode(fitMode) {
+    this.fitMode = fitMode;
+  }
+  setMirrored(mirrored) {
+    this.mirrored = mirrored;
+  }
+  destroy() {
+    this.finishStroke({ stopIdleSampling: true });
+    this.unbindPointerEvents();
+    this.unbindResizeObserver();
+    this.canvas.remove();
+  }
+  applyInteractionStyle() {
+    this.container.style.pointerEvents = this.enabled ? "auto" : "none";
+    this.container.style.touchAction = this.enabled ? "none" : "auto";
+  }
+  bindResizeObserver() {
+    const ResizeObserverCtor = globalThis.ResizeObserver;
+    if (ResizeObserverCtor) {
+      this.resizeObserver = new ResizeObserverCtor(() => this.resizeCanvas());
+      this.resizeObserver.observe(this.container);
+      return;
+    }
+    window.addEventListener("resize", this.onWindowResize);
+  }
+  unbindResizeObserver() {
+    this.resizeObserver?.disconnect();
+    this.resizeObserver = null;
+    window.removeEventListener("resize", this.onWindowResize);
+  }
+  bindPointerEvents() {
+    this.container.addEventListener("pointerdown", this.onPointerDown);
+    this.container.addEventListener("pointermove", this.onPointerMove);
+    this.container.addEventListener("pointerup", this.onPointerUp);
+    this.container.addEventListener("pointercancel", this.onPointerCancel);
+  }
+  unbindPointerEvents() {
+    this.container.removeEventListener("pointerdown", this.onPointerDown);
+    this.container.removeEventListener("pointermove", this.onPointerMove);
+    this.container.removeEventListener("pointerup", this.onPointerUp);
+    this.container.removeEventListener("pointercancel", this.onPointerCancel);
+    this.activePointers.clear();
+    this.lastTargetPoints.clear();
+    this.sampleInFlight = false;
+  }
+  clearCanvas() {
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) {
+      return;
+    }
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    ctx.restore();
+  }
+  resizeCanvas() {
+    const rect = this.container.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    const cssW = Math.max(1, Math.round(rect.width));
+    const cssH = Math.max(1, Math.round(rect.height));
+    const nextW = Math.max(1, Math.round(cssW * dpr));
+    const nextH = Math.max(1, Math.round(cssH * dpr));
+    if (this.canvas.width !== nextW || this.canvas.height !== nextH) {
+      this.canvas.width = nextW;
+      this.canvas.height = nextH;
+      this.canvas.style.width = `${cssW}px`;
+      this.canvas.style.height = `${cssH}px`;
+      this.clearCanvas();
+    }
+  }
+  toTargetPoint(e) {
+    return mapViewportPointToCoordinateSpace(e, this.container, this.targetSize, {
+      fitMode: this.fitMode,
+      mirrored: this.mirrored
+    });
+  }
+  stopDrawLoop() {
+    if (this.rafId !== null) {
+      window.cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+  }
+  startDrawLoop() {
+    if (this.rafId !== null) {
+      return;
+    }
+    const tick = () => {
+      const ctx = this.canvas.getContext("2d");
+      if (!ctx) {
+        this.rafId = null;
+        return;
+      }
+      const dpr = window.devicePixelRatio || 1;
+      fadeCanvas(ctx);
+      drawNeon(ctx, this.segQueue.splice(0), this.container, this.targetSize, dpr, this.fitMode, this.mirrored);
+      if (this.activePointers.size > 0) {
+        this.rafId = window.requestAnimationFrame(tick);
+      } else {
+        this.rafId = null;
+      }
+    };
+    this.rafId = window.requestAnimationFrame(tick);
+  }
+  stopSampling() {
+    if (this.sampleTimer !== null) {
+      window.clearInterval(this.sampleTimer);
+      this.sampleTimer = null;
+    }
+  }
+  collectCurrentTracks() {
+    const tracks = [];
+    for (const pointer of Array.from(this.activePointers.values())) {
+      const point = this.toTargetPoint(pointer);
+      if (point) {
+        tracks.push(point);
+      }
+    }
+    return tracks;
+  }
+  flushTracks() {
+    if (this.sampleInFlight) {
+      return;
+    }
+    const tracks = this.collectCurrentTracks();
+    if (!tracks.length && !this.emitEmptyTracksWhenIdle) {
+      return;
+    }
+    this.sampleInFlight = true;
+    Promise.resolve(this.onTracks(tracks)).catch(() => {
+    }).finally(() => {
+      this.sampleInFlight = false;
+    });
+  }
+  startSampling() {
+    if (this.sampleTimer !== null) {
+      return;
+    }
+    this.flushTracks();
+    this.sampleTimer = window.setInterval(() => {
+      this.flushTracks();
+    }, 30);
+  }
+  finishStroke(options) {
+    const stopIdleSampling = options?.stopIdleSampling ?? !this.emitEmptyTracksWhenIdle;
+    if (stopIdleSampling) {
+      this.stopSampling();
+    }
+    this.stopDrawLoop();
+    this.segQueue.length = 0;
+    this.clearCanvas();
+  }
+  handlePointerDown(e) {
+    if (!this.enabled) {
+      return;
+    }
+    try {
+      this.container.setPointerCapture(e.pointerId);
+    } catch {
+    }
+    this.resizeCanvas();
+    if (this.activePointers.size === 0) {
+      this.segQueue.length = 0;
+      this.clearCanvas();
+    }
+    this.activePointers.set(e.pointerId, {
+      pointerId: e.pointerId,
+      clientX: e.clientX,
+      clientY: e.clientY
+    });
+    const targetPoint = this.toTargetPoint(e);
+    if (targetPoint) {
+      this.lastTargetPoints.set(e.pointerId, targetPoint);
+    }
+    this.startDrawLoop();
+    this.startSampling();
+  }
+  handlePointerMove(e) {
+    if (!this.enabled || !this.activePointers.has(e.pointerId)) {
+      return;
+    }
+    const nextTargetPoint = this.toTargetPoint(e);
+    const last = this.lastTargetPoints.get(e.pointerId);
+    if (last && nextTargetPoint) {
+      this.segQueue.push({ a: last, b: nextTargetPoint });
+    }
+    if (nextTargetPoint) {
+      this.lastTargetPoints.set(e.pointerId, nextTargetPoint);
+    }
+    this.activePointers.set(e.pointerId, {
+      pointerId: e.pointerId,
+      clientX: e.clientX,
+      clientY: e.clientY
+    });
+  }
+  handlePointerUp(e) {
+    if (!this.activePointers.has(e.pointerId)) {
+      return;
+    }
+    this.activePointers.delete(e.pointerId);
+    this.lastTargetPoints.delete(e.pointerId);
+    try {
+      this.container.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+    if (this.activePointers.size === 0) {
+      this.finishStroke();
+    }
+  }
+  handlePointerCancel(e) {
+    if (!this.activePointers.has(e.pointerId)) {
+      return;
+    }
+    this.activePointers.delete(e.pointerId);
+    this.lastTargetPoints.delete(e.pointerId);
+    if (this.activePointers.size === 0) {
+      this.finishStroke();
+    }
+  }
+};
+function createDragTrackController(container, options) {
+  return new DragTrackController(container, options);
+}
+
+// src/drag/remote-view-host.ts
+function createRemoteViewHost(wrapper) {
+  const computed = getComputedStyle(wrapper);
+  if (computed.position === "static") {
+    wrapper.style.position = "relative";
+  }
+  const videoHost = document.createElement("div");
+  videoHost.dataset.XmaxRemoteVideo = "true";
+  videoHost.style.cssText = "position:relative;z-index:0;width:100%;height:100%;overflow:hidden;display:flex;align-items:center;justify-content:center;";
+  const dragHost = document.createElement("div");
+  dragHost.dataset.XmaxDragSurface = "true";
+  dragHost.style.cssText = "position:absolute;inset:0;z-index:20;touch-action:none;";
+  wrapper.replaceChildren();
+  wrapper.appendChild(videoHost);
+  wrapper.appendChild(dragHost);
+  return { wrapper, videoHost, dragHost };
+}
+
+// src/shared/ref-image.ts
+async function resolveRefImageUrl(client, input) {
+  if (input instanceof File) {
+    return (await client.uploadImage(input)).url;
+  }
+  const raw = input.trim();
+  if (!raw) {
+    return "";
+  }
+  if (/^https?:\/\//i.test(raw)) {
+    return raw;
+  }
+  const res = await fetch(raw);
+  if (!res.ok) {
+    throw new Error(`Failed to load ref image: ${res.status}`);
+  }
+  const blob = await res.blob();
+  const mime = blob.type || "image/png";
+  const ext = mime === "image/jpeg" ? "jpg" : mime === "image/webp" ? "webp" : mime === "image/gif" ? "gif" : "png";
+  const file = new File([blob], `ref.${ext}`, { type: mime });
+  return (await client.uploadImage(file)).url;
+}
+var DEFAULT_SESSION_TARGET_SIZE = [1472, 832];
+var UPLOAD_VIDEO_BASE = 832;
+var UPLOAD_SIZE_ALIGN = 32;
+var MAX_LANDSCAPE_ASPECT = 16 / 9;
+var MAX_PORTRAIT_HEIGHT_RATIO = 16 / 9;
+function alignToSizeMultiple(value) {
+  return Math.max(UPLOAD_SIZE_ALIGN, Math.round(value / UPLOAD_SIZE_ALIGN) * UPLOAD_SIZE_ALIGN);
+}
+function resolveUploadVideoSize(sourceWidth, sourceHeight) {
+  if (sourceWidth <= 0 || sourceHeight <= 0) {
+    return DEFAULT_SESSION_TARGET_SIZE;
+  }
+  if (sourceWidth === sourceHeight) {
+    return [UPLOAD_VIDEO_BASE, UPLOAD_VIDEO_BASE];
+  }
+  const aspect = sourceWidth / sourceHeight;
+  if (sourceHeight > sourceWidth) {
+    const width2 = UPLOAD_VIDEO_BASE;
+    let height2 = alignToSizeMultiple(width2 / aspect);
+    const maxHeight = alignToSizeMultiple(width2 * MAX_PORTRAIT_HEIGHT_RATIO);
+    if (height2 > maxHeight) {
+      height2 = maxHeight;
+    }
+    return [width2, height2];
+  }
+  const height = UPLOAD_VIDEO_BASE;
+  let width = alignToSizeMultiple(height * aspect);
+  const maxWidth = alignToSizeMultiple(height * MAX_LANDSCAPE_ASPECT);
+  if (width > maxWidth) {
+    width = maxWidth;
+  }
+  return [width, height];
+}
+function resolveSessionTargetSize(input) {
+  if (input.overrideSize) {
+    return input.overrideSize;
+  }
+  if (input.localVideoSize?.width && input.localVideoSize?.height) {
+    return [input.localVideoSize.width, input.localVideoSize.height];
+  }
+  return DEFAULT_SESSION_TARGET_SIZE;
+}
+
+// src/realtime/initial-state.ts
+var DEFAULT_RTC_START_MODEL = "default";
+function resolveGenerationModel(model) {
+  const trimmed = model?.trim();
+  return trimmed || DEFAULT_RTC_START_MODEL;
+}
+function resolvePromptText(prompt) {
+  if (typeof prompt === "string") {
+    return prompt.trim();
+  }
+  return prompt?.text?.trim() ?? "";
+}
+function resolveInitialRefImage(initialState) {
+  if (!initialState) {
+    return void 0;
+  }
+  if (typeof initialState.refImage === "string" && initialState.refImage.trim()) {
+    return initialState.refImage.trim();
+  }
+  if (typeof initialState.image === "string" && initialState.image.trim()) {
+    return initialState.image.trim();
+  }
+  return void 0;
+}
+function shouldAutoStartOnConnect(initialState) {
+  return initialState?.autoStart === true;
+}
+
+// src/rtc/publish-fps.ts
+var MOBILE_PUBLISH_MAX_WIDTH_PX = 768;
+var RTC_PUBLISH_FPS_WEB = 30;
+var RTC_PUBLISH_FPS_MOBILE = 24;
+function isMobilePublishEnvironment() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia(`(max-width: ${MOBILE_PUBLISH_MAX_WIDTH_PX}px)`).matches;
+}
+function resolveRtcPublishFps(options = {}) {
+  if (typeof options.fps === "number" && Number.isFinite(options.fps) && options.fps > 0) {
+    return options.fps;
+  }
+  const mobile = options.mobile ?? isMobilePublishEnvironment();
+  return mobile ? RTC_PUBLISH_FPS_MOBILE : RTC_PUBLISH_FPS_WEB;
+}
+
+// src/realtime/prewarm.ts
+var RealtimePrewarmHandle = class _RealtimePrewarmHandle {
+  constructor(client, rtc, sessionUid, modelName) {
+    this.client = client;
+    this.rtc = rtc;
+    this.sessionUid = sessionUid;
+    this.consumed = false;
+    this.disposed = false;
+    this.modelName = modelName;
+  }
+  static async create(model, clientOptions) {
+    const modelName = model.name.trim();
+    if (!modelName) {
+      throw new Error("model.name is required");
+    }
+    const sdkI18n = createSDKI18n({});
+    const client = new XmaxOpenClient({
+      apiKey: clientOptions.apiKey,
+      authToken: clientOptions.authToken,
+      baseUrl: clientOptions.baseUrl ?? XMAX_OPEN_API_PRODUCTION_BASE_URL,
+      onError: clientOptions.onError
+    });
+    const rtc = new RtcManager({
+      onLog: (entry) => clientOptions.onLog?.({ scope: "rtc", ...entry }),
+      onRemoteSeiReceived: clientOptions.onRemoteSei,
+      onSeiGateChange: clientOptions.onSeiGateChange,
+      i18n: sdkI18n
+    });
+    const createdSession = await client.createSession(modelName);
+    const sessionUid = createdSession.sessionUid?.trim();
+    if (!sessionUid) {
+      throw new Error("Session uid is missing");
+    }
+    const joinInfo = client.getRtcJoinInfo(createdSession);
+    await rtc.join(joinInfo);
+    const handle = new _RealtimePrewarmHandle(client, rtc, sessionUid, modelName);
+    client.startHeartbeat(
+      sessionUid,
+      clientOptions.heartbeatIntervalMs ?? 1e4,
+      (heartbeatSession) => {
+        if (heartbeatSession.status !== ACTIVE_STATUS) {
+          void handle.cancel();
+        }
+      },
+      () => {
+        void handle.cancel();
+      }
+    );
+    return handle;
+  }
+  consume(expectedModelName) {
+    const normalized = expectedModelName.trim();
+    if (this.consumed || this.disposed || !normalized || this.modelName !== normalized) {
+      return null;
+    }
+    this.consumed = true;
+    return {
+      client: this.client,
+      rtc: this.rtc,
+      sessionUid: this.sessionUid
+    };
+  }
+  async cancel() {
+    if (this.consumed || this.disposed) {
+      return;
+    }
+    this.disposed = true;
+    this.client.beginTeardown();
+    try {
+      await this.client.closeSession(this.sessionUid);
+    } catch {
+    }
+    try {
+      await this.rtc.leave();
+    } catch {
+    }
+    this.client.endTeardown();
+  }
+};
+
+// src/realtime/session.ts
+function resolvePromptInput(prompt) {
+  if (typeof prompt === "string") {
+    return prompt.trim();
+  }
+  return prompt?.text?.trim() ?? "";
+}
+function resolveRefImagePath(refImage) {
+  const trimmed = refImage?.trim();
+  return trimmed || void 0;
+}
+function getVideoTrack(stream) {
+  const track = stream.getVideoTracks()[0];
+  if (!track) {
+    throw new Error("Missing video track in MediaStream");
+  }
+  return track;
+}
+function readVideoSize(track) {
+  const settings = track.getSettings?.();
+  if (typeof settings?.width === "number" && settings.width > 0 && typeof settings?.height === "number" && settings.height > 0) {
+    return { width: settings.width, height: settings.height };
+  }
+  return null;
+}
+var RealtimeSession = class _RealtimeSession {
+  constructor(client, rtc, reportError, options, clientOptions) {
+    this.sessionUid = null;
+    this.taskUid = null;
+    this.localVideoSize = null;
+    this.currentPrompt = "";
+    this.currentGenerationModel = "";
+    this.currentStaticGenerate = void 0;
+    this.disconnected = false;
+    this.remoteViewHost = null;
+    this.dragController = null;
+    this.dragTrackFitMode = "cover";
+    this.sessionTargetSize = null;
+    this.mirroredInputStream = null;
+    this.hiddenRemoteElement = null;
+    this.remoteStreamNotifyTimer = null;
+    this.lastNotifiedRemoteStream = null;
+    this.dragOption = void 0;
+    this.client = client;
+    this.rtc = rtc;
+    this.reportError = reportError;
+    this.onRemoteStream = options.onRemoteStream;
+    this.onPublishPipelineWaitChange = clientOptions?.onPublishPipelineWaitChange;
+    if (options.remoteElement) {
+      this.remoteElement = options.remoteElement;
+      if (options.drag !== false) {
+        this.remoteViewHost = createRemoteViewHost(this.remoteElement);
+      }
+      return;
+    }
+    if (options.onRemoteStream) {
+      const hidden = document.createElement("div");
+      hidden.setAttribute("data-Xmax-remote-host", "true");
+      hidden.style.cssText = "position:fixed;left:-9999px;top:-9999px;width:1px;height:1px;opacity:0;pointer-events:none;overflow:hidden";
+      document.body.appendChild(hidden);
+      this.hiddenRemoteElement = hidden;
+      this.remoteElement = hidden;
+      this.remoteViewHost = createRemoteViewHost(hidden);
+      this.rtc.setOnRemotePlayerMounted(() => {
+        this.scheduleNotifyRemoteStream();
+      });
+      return;
+    }
+    this.remoteElement = null;
+  }
+  get remoteVideoContainer() {
+    return this.remoteViewHost?.videoHost ?? this.remoteElement;
+  }
+  static async connect(stream, options, clientOptions) {
+    const sdkI18n = createSDKI18n({});
+    const notifyUserError = clientOptions.onError;
+    const reportError = (error, fallbackMessage) => {
+      throw notifyError(error, notifyUserError, fallbackMessage ?? sdkI18n.t("errors.requestFailed"));
+    };
+    const modelName = options.model.name.trim();
+    const prewarmed = options.prewarmed instanceof RealtimePrewarmHandle ? options.prewarmed.consume(modelName) : null;
+    const client = prewarmed?.client ?? new XmaxOpenClient({
+      apiKey: clientOptions.apiKey,
+      authToken: clientOptions.authToken,
+      baseUrl: clientOptions.baseUrl ?? XMAX_OPEN_API_PRODUCTION_BASE_URL,
+      onError: notifyUserError
+    });
+    const rtc = prewarmed?.rtc ?? new RtcManager({
+      onLog: (entry) => clientOptions.onLog?.({ scope: "rtc", ...entry }),
+      onRemoteSeiReceived: clientOptions.onRemoteSei,
+      onSeiGateChange: clientOptions.onSeiGateChange,
+      i18n: sdkI18n
+    });
+    const session = new _RealtimeSession(client, rtc, reportError, options, clientOptions);
+    try {
+      await session.bootstrap(stream, options, clientOptions.heartbeatIntervalMs ?? 1e4, prewarmed);
+      return session;
+    } catch (error) {
+      await session.safeDisconnect();
+      throw reportError(error);
+    }
+  }
+  async bootstrap(stream, options, heartbeatIntervalMs, prewarmed = null) {
+    this.dragOption = options.drag;
+    const modelName = options.model.name.trim();
+    if (!modelName) {
+      throw new Error("model.name is required");
+    }
+    if (prewarmed) {
+      this.sessionUid = prewarmed.sessionUid;
+    } else {
+      const createdSession = await this.client.createSession(modelName);
+      if (!createdSession.sessionUid?.trim()) {
+        throw new Error("Session uid is missing");
+      }
+      this.sessionUid = createdSession.sessionUid;
+      this.client.startHeartbeat(
+        createdSession.sessionUid,
+        heartbeatIntervalMs,
+        (heartbeatSession) => {
+          if (heartbeatSession.status !== ACTIVE_STATUS) {
+            void this.safeDisconnect();
+          }
+        },
+        () => {
+          void this.safeDisconnect();
+        }
+      );
+      const joinInfo = this.client.getRtcJoinInfo(createdSession);
+      await this.rtc.join(joinInfo);
+    }
+    if (options.localElement) {
+      this.rtc.setLocalVideoContainer(options.localElement);
+    }
+    if (this.remoteVideoContainer) {
+      this.rtc.setRemoteVideoContainer(this.remoteVideoContainer);
+    }
+    this.sessionSizeOverride = options.size;
+    const videoTrack = getVideoTrack(stream);
+    const isFileInput = options.inputKind === "file";
+    this.dragTrackFitMode = isFileInput ? "contain" : "cover";
+    const rawVideoSize = readVideoSize(videoTrack);
+    const publishSize = options.size ?? (rawVideoSize ? resolveUploadVideoSize(rawVideoSize.width, rawVideoSize.height) : DEFAULT_SESSION_TARGET_SIZE);
+    let publishTrack = videoTrack;
+    if (isFileInput) {
+      if (options.size) {
+        this.localVideoSize = { width: options.size[0], height: options.size[1] };
+      } else if (rawVideoSize) {
+        this.localVideoSize = { width: rawVideoSize.width, height: rawVideoSize.height };
+      } else {
+        this.localVideoSize = null;
+      }
+    } else if (options.prebuiltCameraStream) {
+      this.mirroredInputStream = options.prebuiltCameraStream;
+      publishTrack = options.prebuiltCameraStream.videoTrack;
+      this.localVideoSize = {
+        width: options.prebuiltCameraStream.width,
+        height: options.prebuiltCameraStream.height
+      };
+    } else {
+      const processedStream = await createNativeCameraStream(stream);
+      this.mirroredInputStream = processedStream;
+      publishTrack = processedStream.videoTrack;
+      this.localVideoSize = { width: processedStream.width, height: processedStream.height };
+    }
+    const initialState = options.initialState;
+    this.currentPrompt = resolvePromptText(initialState?.prompt);
+    this.currentGenerationModel = resolveGenerationModel(initialState?.model);
+    this.currentStaticGenerate = initialState?.staticGenerate;
+    const publishFpsOptions = {
+      mobile: options.mobile,
+      highQuality: true,
+      fps: isFileInput ? options.model.fps : resolveRtcPublishFps({ mobile: options.mobile })
+    };
+    await this.rtc.startExternalVideoPublishing(publishTrack, publishSize, publishFpsOptions);
+    let initialRefImageUrl;
+    const initialRefImage = resolveInitialRefImage(initialState);
+    if (initialRefImage) {
+      initialRefImageUrl = await resolveRefImageUrl(this.client, initialRefImage);
+    } else if (initialState?.image instanceof File) {
+      initialRefImageUrl = await resolveRefImageUrl(this.client, initialState.image);
+    } else if (initialState?.image instanceof Blob) {
+      const mime = initialState.image.type || "image/png";
+      const file = new File([initialState.image], "ref-image", { type: mime });
+      initialRefImageUrl = await resolveRefImageUrl(this.client, file);
+    }
+    if (options.localElement) {
+      queueMicrotask(() => this.refreshLocalPreview());
+    }
+    if (shouldAutoStartOnConnect(initialState)) {
+      await this.runStart({
+        prompt: this.currentPrompt || void 0,
+        model: this.currentGenerationModel || void 0,
+        size: options.size,
+        refImage: initialRefImageUrl,
+        staticGenerate: this.currentStaticGenerate
+      });
+    }
+  }
+  async setPrompt(prompt, _options) {
+    try {
+      const promptText = resolvePromptInput(prompt);
+      this.currentPrompt = promptText;
+      if (!this.taskUid) {
+        await this.runStart({
+          prompt: promptText || void 0
+        });
+        return;
+      }
+      await this.restart({ prompt: promptText });
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async set(input) {
+    try {
+      let refImage;
+      if (input.image === null) {
+        refImage = void 0;
+      } else if (input.image !== void 0) {
+        refImage = await this.setRefImage(input.image);
+      }
+      const prompt = input.prompt !== void 0 ? resolvePromptInput(input.prompt) : void 0;
+      if (prompt !== void 0) {
+        this.currentPrompt = prompt;
+      }
+      await this.restart({
+        prompt,
+        refImage
+      });
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async setImage(image, options) {
+    try {
+      const refImage = await this.setRefImage(image);
+      const prompt = options?.prompt ? resolvePromptInput(options.prompt) : void 0;
+      if (prompt !== void 0) {
+        this.currentPrompt = prompt;
+      }
+      await this.restart({
+        prompt,
+        refImage
+      });
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async setRefImage(input) {
+    try {
+      const resolved = await resolveRefImageUrl(this.client, input);
+      return resolved;
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async restart(options) {
+    try {
+      let resolvedRefImage;
+      if (options && "refImage" in options) {
+        const ref = options.refImage;
+        if (ref === null || ref === "") {
+          resolvedRefImage = void 0;
+        } else if (typeof ref === "string" && ref.trim()) {
+          resolvedRefImage = await this.setRefImage(ref.trim());
+        }
+      }
+      if (options?.prompt !== void 0) {
+        this.currentPrompt = options.prompt.trim();
+      }
+      if (options?.model !== void 0) {
+        this.currentGenerationModel = resolveGenerationModel(options.model);
+      }
+      if (options?.staticGenerate !== void 0) {
+        this.currentStaticGenerate = options.staticGenerate;
+      }
+      await this.runStart({
+        prompt: this.currentPrompt || void 0,
+        model: this.currentGenerationModel || void 0,
+        size: options?.size,
+        refImage: resolvedRefImage,
+        staticGenerate: this.currentStaticGenerate
+      });
+    } catch (error) {
+      this.reportError(error);
+    }
+  }
+  async setMode(options) {
+    return this.restart(options);
+  }
+  async refreshRemoteOutput(options) {
+    if (!this.remoteVideoContainer) {
+      return;
+    }
+    this.rtc.setRemoteVideoContainer(this.remoteVideoContainer);
+    await this.rtc.refreshRemoteVideoBinding(options);
+    this.scheduleNotifyRemoteStream();
+  }
+  refreshLocalPreview() {
+    this.rtc.refreshLocalVideoPreview();
+  }
+  getInputPreviewStream() {
+    return this.mirroredInputStream?.previewStream ?? null;
+  }
+  detachRemoteOutput() {
+    this.rtc.setRemoteVideoContainer(null);
+  }
+  async sendTracks(tracks) {
+    if (!this.rtc.snapshot.joined || !this.taskUid) {
+      return;
+    }
+    try {
+      await this.rtc.sendRoomEvent(
+        createTracksRtcRoomEvent({
+          userId: this.rtc.snapshot.userId ?? void 0,
+          uid: this.taskUid,
+          sessionUid: this.taskUid,
+          tracks
+        })
+      );
+    } catch {
+    }
+  }
+  async stop(options) {
+    this.updateDragController(false);
+    const preserveRemoteDom = options?.preserveRemoteDom ?? false;
+    if (preserveRemoteDom) {
+      this.rtc.setPreserveRemoteDom(true);
+    }
+    if (!this.rtc.snapshot.joined) {
+      this.rtc.clearRemoteVideo({ preserveDom: preserveRemoteDom });
+      if (!preserveRemoteDom && this.remoteVideoContainer) {
+        this.rtc.setRemoteVideoContainer(null);
+      }
+      this.taskUid = null;
+      if (preserveRemoteDom) {
+        this.rtc.setPreserveRemoteDom(false);
+      }
+      return;
+    }
+    try {
+      await this.rtc.sendRoomEvent(
+        createStopRtcRoomEvent({
+          userId: this.rtc.snapshot.userId ?? void 0,
+          sessionUid: this.taskUid ?? void 0
+        })
+      );
+    } finally {
+      this.rtc.clearRemoteVideo({ preserveDom: preserveRemoteDom });
+      if (!preserveRemoteDom && this.remoteVideoContainer) {
+        this.rtc.setRemoteVideoContainer(null);
+      }
+      this.taskUid = null;
+      if (preserveRemoteDom) {
+        this.rtc.setPreserveRemoteDom(false);
+      }
+    }
+  }
+  async disconnect(options) {
+    if (this.disconnected) {
+      return;
+    }
+    this.disconnected = true;
+    await this.safeDisconnect(options);
+  }
+  getSessionUid() {
+    return this.sessionUid;
+  }
+  async runStart(options) {
+    if (!this.rtc.snapshot.joined) {
+      return;
+    }
+    const startPrompt = options.prompt?.trim() ?? this.currentPrompt;
+    if (options.model !== void 0) {
+      this.currentGenerationModel = resolveGenerationModel(options.model);
+    }
+    if (options.staticGenerate !== void 0) {
+      this.currentStaticGenerate = options.staticGenerate;
+    }
+    const modelLabel = resolveGenerationModel(this.currentGenerationModel);
+    await this.rtc.ensurePublishedInputBeforeStart();
+    this.rtc.setRemoteVideoContainer(null);
+    this.rtc.clearRemoteVideo();
+    const size = resolveSessionTargetSize({
+      localVideoSize: this.localVideoSize,
+      overrideSize: options.size ?? this.sessionSizeOverride
+    });
+    this.sessionTargetSize = size;
+    const taskUid = createTaskUid();
+    this.taskUid = taskUid;
+    this.rtc.configureSessionSei(taskUid);
+    try {
+      if (this.remoteVideoContainer) {
+        this.rtc.setRemoteVideoContainer(this.remoteVideoContainer);
+      }
+      const startRoomEvent = createStartRtcRoomEvent({
+        userId: this.rtc.snapshot.userId ?? void 0,
+        uid: taskUid,
+        sessionUid: taskUid,
+        model: modelLabel,
+        size,
+        prompt: startPrompt,
+        refImagePath: resolveRefImagePath(options.refImage),
+        staticGenerate: this.currentStaticGenerate
+      });
+      console.log("[Xmax SDK] \u771F\u5B9E\u53D1\u9001 start ->", startRoomEvent);
+      await this.rtc.sendRoomEvent(startRoomEvent);
+      await this.rtc.refreshRemoteVideoBinding({ force: true });
+      this.updateDragController(true);
+      this.scheduleNotifyRemoteStream();
+    } catch (error) {
+      this.rtc.configureSessionSei(null);
+      throw error;
+    }
+  }
+  isDragEnabled() {
+    if (this.dragOption === false) {
+      return false;
+    }
+    if (this.dragOption === true) {
+      return true;
+    }
+    return Boolean(this.remoteElement && !this.hiddenRemoteElement);
+  }
+  updateDragController(active) {
+    const dragHost = this.remoteViewHost?.dragHost;
+    if (!dragHost || !active || !this.taskUid || !this.isDragEnabled()) {
+      this.dragController?.setEnabled(false);
+      return;
+    }
+    const targetSize = this.sessionTargetSize ?? DEFAULT_SESSION_TARGET_SIZE;
+    if (!this.dragController) {
+      this.dragController = createDragTrackController(dragHost, {
+        targetSize,
+        fitMode: this.dragTrackFitMode,
+        mirrored: false,
+        enabled: true,
+        onTracks: (tracks) => {
+          const media = this.remoteViewHost?.videoHost?.querySelector("video, canvas");
+          const mediaRect = media?.getBoundingClientRect();
+          const dragRect = dragHost.getBoundingClientRect();
+          console.log("[Xmax] sendTracks", {
+            taskUid: this.taskUid,
+            targetSize: this.sessionTargetSize,
+            fitMode: this.dragTrackFitMode,
+            tracks,
+            dragRect: dragRect ? { w: dragRect.width, h: dragRect.height } : null,
+            mediaRect: mediaRect ? { w: mediaRect.width, h: mediaRect.height, l: mediaRect.left, t: mediaRect.top } : null
+          });
+          void this.sendTracks(tracks);
+        }
+      });
+      return;
+    }
+    this.dragController.setTargetSize(targetSize);
+    this.dragController.setFitMode(this.dragTrackFitMode);
+    this.dragController.setMirrored(false);
+    this.dragController.setEnabled(true);
+  }
+  scheduleNotifyRemoteStream() {
+    if (!this.onRemoteStream) {
+      return;
+    }
+    this.clearRemoteStreamNotifyTimer();
+    if (this.notifyRemoteStreamOnce()) {
+      return;
+    }
+    let attempts = 0;
+    this.remoteStreamNotifyTimer = setInterval(() => {
+      attempts += 1;
+      if (this.notifyRemoteStreamOnce() || attempts >= 60) {
+        this.clearRemoteStreamNotifyTimer();
+      }
+    }, 500);
+  }
+  notifyRemoteStreamOnce() {
+    const videoRoot = this.remoteVideoContainer;
+    if (!this.onRemoteStream || !videoRoot) {
+      return false;
+    }
+    const video = videoRoot instanceof HTMLVideoElement ? videoRoot : videoRoot.querySelector("video");
+    if (!(video instanceof HTMLVideoElement) || !(video.srcObject instanceof MediaStream)) {
+      return false;
+    }
+    if (this.lastNotifiedRemoteStream === video.srcObject) {
+      return true;
+    }
+    this.lastNotifiedRemoteStream = video.srcObject;
+    this.onRemoteStream(video.srcObject);
+    return true;
+  }
+  clearRemoteStreamNotifyTimer() {
+    if (this.remoteStreamNotifyTimer !== null) {
+      clearInterval(this.remoteStreamNotifyTimer);
+      this.remoteStreamNotifyTimer = null;
+    }
+  }
+  async safeDisconnect(options) {
+    this.clearRemoteStreamNotifyTimer();
+    this.lastNotifiedRemoteStream = null;
+    const activeSessionUid = this.sessionUid;
+    this.sessionUid = null;
+    this.client.beginTeardown();
+    if (activeSessionUid) {
+      try {
+        await this.client.closeSession(activeSessionUid);
+      } catch {
+      }
+    }
+    const generationActive = !!this.taskUid && this.rtc.snapshot.joined;
+    try {
+      if (generationActive) {
+        await this.stop();
+      } else {
+        this.updateDragController(false);
+        this.rtc.clearRemoteVideo();
+        if (this.remoteVideoContainer) {
+          this.rtc.setRemoteVideoContainer(null);
+        }
+        this.taskUid = null;
+      }
+    } catch {
+    }
+    try {
+      if (this.rtc.snapshot.joined) {
+        await this.rtc.stopVideoPublishing();
+      }
+    } catch {
+    }
+    try {
+      if (this.rtc.snapshot.joined) {
+        await this.rtc.leave();
+      }
+    } catch {
+    }
+    this.client.endTeardown();
+    this.taskUid = null;
+    this.currentPrompt = "";
+    this.currentGenerationModel = "";
+    this.currentStaticGenerate = void 0;
+    this.sessionTargetSize = null;
+    this.dragController?.destroy();
+    this.dragController = null;
+    this.mirroredInputStream?.destroy();
+    this.mirroredInputStream = null;
+    if (this.hiddenRemoteElement) {
+      this.hiddenRemoteElement.remove();
+      this.hiddenRemoteElement = null;
+    }
+  }
+};
+
+// src/realtime/models.ts
+var DEFAULT_REALTIME_SIZE = {
+  width: 1280,
+  height: 960,
+  fps: 24
+};
+var models = {
+  realtime(name, options) {
+    return {
+      name,
+      width: options?.width ?? DEFAULT_REALTIME_SIZE.width,
+      height: options?.height ?? DEFAULT_REALTIME_SIZE.height,
+      fps: options?.fps ?? DEFAULT_REALTIME_SIZE.fps
+    };
+  }
+};
+
+// src/realtime/create-client.ts
+function resolveClientOptions(options) {
+  return {
+    ...options,
+    baseUrl: options.baseUrl?.trim() || XMAX_OPEN_API_PRODUCTION_BASE_URL
+  };
+}
+function createXmaxClient(options) {
+  const resolved = resolveClientOptions(options);
+  const httpClient = new XmaxOpenClient({
+    apiKey: resolved.apiKey,
+    authToken: resolved.authToken,
+    baseUrl: resolved.baseUrl,
+    onError: resolved.onError
+  });
+  return {
+    files: {
+      uploadImage: (file) => httpClient.uploadImage(file),
+      uploadVideo: (file) => httpClient.uploadVideo(file),
+      upload: (file) => httpClient.uploadImage(file)
+    },
+    realtime: {
+      prewarm: (options2) => RealtimePrewarmHandle.create(options2.model, resolved),
+      connect: (stream, connectOptions) => RealtimeSession.connect(stream, connectOptions, resolved)
+    }
+  };
+}
+
+// src/drag/drag-video-sync.ts
+var DRAG_SYNCED_ATTR = "data-xmax-drag-synced";
+function toContentRect2(rect) {
+  return {
+    left: rect.left,
+    top: rect.top,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isMediaInsetInContainer2(mediaRect, containerRect) {
+  if (!mediaRect.width || !mediaRect.height || !containerRect.width || !containerRect.height) {
+    return false;
+  }
+  const widthRatio = mediaRect.width / containerRect.width;
+  const heightRatio = mediaRect.height / containerRect.height;
+  return widthRatio < 0.98 || heightRatio < 0.98;
+}
+function intersectContentRects(a, b) {
+  const left = Math.max(a.left, b.left);
+  const top = Math.max(a.top, b.top);
+  const right = Math.min(a.left + a.width, b.left + b.width);
+  const bottom = Math.min(a.top + a.height, b.top + b.height);
+  return {
+    left,
+    top,
+    width: Math.max(0, right - left),
+    height: Math.max(0, bottom - top)
+  };
+}
+function readMediaIntrinsicSize(media) {
+  const video = media;
+  if ("videoWidth" in video && video.videoWidth > 0 && video.videoHeight > 0) {
+    return [video.videoWidth, video.videoHeight];
+  }
+  if (media.width > 0 && media.height > 0) {
+    return [media.width, media.height];
+  }
+  return null;
+}
+function resolveMediaObjectFit(media, fallback) {
+  if (typeof getComputedStyle !== "function") {
+    return fallback;
+  }
+  const fit = getComputedStyle(media).objectFit;
+  if (fit === "contain" || fit === "cover" || fit === "fill") {
+    return fit;
+  }
+  return fallback;
+}
+function resolveRemoteDragLayout(input) {
+  const { wrapperRect, mediaRect, media, targetSize, fitMode } = input;
+  if (!wrapperRect.width || !wrapperRect.height || !mediaRect.width || !mediaRect.height) {
+    return null;
+  }
+  const wrapper = toContentRect2(wrapperRect);
+  if (fitMode === "contain") {
+    const overlay2 = toContentRect2(mediaRect);
+    const hitRect = intersectContentRects(overlay2, wrapper);
+    const drawable2 = hitRect.width > 0 && hitRect.height > 0 ? hitRect : wrapper;
+    return { overlay: drawable2, mapping: overlay2, hitRect: drawable2, source: "media" };
+  }
+  if (isMediaInsetInContainer2(mediaRect, wrapperRect)) {
+    const overlay2 = toContentRect2(mediaRect);
+    return { overlay: overlay2, mapping: overlay2, hitRect: overlay2, source: "media" };
+  }
+  const intrinsic = media ? readMediaIntrinsicSize(media) : null;
+  const frameSize = intrinsic ?? targetSize;
+  const objectFit = media ? resolveMediaObjectFit(media, fitMode) : fitMode;
+  if (objectFit === "fill") {
+    const overlay2 = toContentRect2(mediaRect);
+    return { overlay: overlay2, mapping: overlay2, hitRect: wrapper, source: "intrinsic" };
+  }
+  const mapping = getFitContentRect(mediaRect, frameSize, objectFit);
+  const overlay = intersectContentRects(mapping, wrapper);
+  const drawable = overlay.width > 0 && overlay.height > 0 ? overlay : wrapper;
+  return {
+    overlay: drawable,
+    mapping,
+    hitRect: wrapper,
+    source: intrinsic ? "intrinsic" : "fit"
+  };
+}
+function resetDragSurfaceFullBleed(dragSurface) {
+  dragSurface.style.inset = "0";
+  dragSurface.style.left = "";
+  dragSurface.style.top = "";
+  dragSurface.style.right = "";
+  dragSurface.style.bottom = "";
+  dragSurface.style.width = "";
+  dragSurface.style.height = "";
+  dragSurface.removeAttribute(DRAG_SYNCED_ATTR);
+}
+function applyDragSurfaceOverlayStyles(dragSurface, overlay, wrapperRect) {
+  const nextLeft = `${overlay.left - wrapperRect.left}px`;
+  const nextTop = `${overlay.top - wrapperRect.top}px`;
+  const nextWidth = `${overlay.width}px`;
+  const nextHeight = `${overlay.height}px`;
+  if (dragSurface.hasAttribute(DRAG_SYNCED_ATTR) && dragSurface.style.inset === "auto" && dragSurface.style.left === nextLeft && dragSurface.style.top === nextTop && dragSurface.style.width === nextWidth && dragSurface.style.height === nextHeight) {
+    return false;
+  }
+  dragSurface.style.inset = "auto";
+  dragSurface.style.left = nextLeft;
+  dragSurface.style.top = nextTop;
+  dragSurface.style.width = nextWidth;
+  dragSurface.style.height = nextHeight;
+  dragSurface.style.right = "";
+  dragSurface.style.bottom = "";
+  dragSurface.setAttribute(DRAG_SYNCED_ATTR, "");
+  return true;
+}
+function syncDragSurfaceToVideo(dragSurface, targetSize, fitMode) {
+  const wrapper = dragSurface.parentElement;
+  if (!wrapper) {
+    resetDragSurfaceFullBleed(dragSurface);
+    return false;
+  }
+  const layout = resolveRemoteDragLayoutFromSurface(dragSurface, targetSize, fitMode);
+  if (!layout || !layout.overlay.width || !layout.overlay.height) {
+    resetDragSurfaceFullBleed(dragSurface);
+    return false;
+  }
+  const wrapperRect = wrapper.getBoundingClientRect();
+  const { overlay } = layout;
+  return applyDragSurfaceOverlayStyles(dragSurface, overlay, wrapperRect);
+}
+function resolveRemoteDragLayoutFromSurface(dragSurface, targetSize, fitMode) {
+  const wrapper = dragSurface.parentElement;
+  if (!wrapper) {
+    return null;
+  }
+  const videoHost = wrapper.querySelector("[data-xmax-remote-video]");
+  if (!videoHost) {
+    return null;
+  }
+  const media = videoHost.querySelector("video, canvas");
+  if (!media) {
+    return null;
+  }
+  return resolveRemoteDragLayout({
+    wrapperRect: wrapper.getBoundingClientRect(),
+    mediaRect: media.getBoundingClientRect(),
+    media,
+    targetSize,
+    fitMode
+  });
+}
+function observeDragSurfaceVideoSync(dragSurface, options) {
+  const wrapper = dragSurface.parentElement;
+  if (!wrapper) {
+    return () => {
+    };
+  }
+  const mediaListeners = /* @__PURE__ */ new Map();
+  let rafId = null;
+  let observedVideoHost = null;
+  const bindMediaListeners = (media) => {
+    if (mediaListeners.has(media)) {
+      return;
+    }
+    const rerender = () => scheduleApply();
+    const bindings = [];
+    const add = (type) => {
+      media.addEventListener(type, rerender);
+      bindings.push(() => media.removeEventListener(type, rerender));
+    };
+    add("loadedmetadata");
+    add("loadeddata");
+    add("resize");
+    mediaListeners.set(media, bindings);
+  };
+  const apply = () => {
+    const changed = syncDragSurfaceToVideo(dragSurface, options.getTargetSize(), options.getFitMode());
+    if (changed) {
+      options.onSync?.();
+    }
+    const videoHost2 = wrapper.querySelector("[data-xmax-remote-video]");
+    const media = videoHost2?.querySelector("video, canvas");
+    if (media) {
+      bindMediaListeners(media);
+    }
+  };
+  const scheduleApply = () => {
+    if (rafId !== null) {
+      return;
+    }
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      apply();
+    });
+  };
+  const bindVideoHostObserver = (videoHostObserver) => {
+    const host = wrapper.querySelector("[data-xmax-remote-video]");
+    if (!host || host === observedVideoHost || !videoHostObserver) {
+      return;
+    }
+    videoHostObserver.disconnect();
+    observedVideoHost = host;
+    videoHostObserver.observe(host, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["style", "class", "width", "height"]
+    });
+  };
+  apply();
+  const resizeObserver = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => scheduleApply()) : null;
+  resizeObserver?.observe(wrapper);
+  const videoHost = wrapper.querySelector("[data-xmax-remote-video]");
+  if (videoHost) {
+    resizeObserver?.observe(videoHost);
+  }
+  const observeMedia = () => {
+    const host = wrapper.querySelector("[data-xmax-remote-video]");
+    const media = host?.querySelector("video, canvas");
+    if (media) {
+      resizeObserver?.observe(media);
+      bindMediaListeners(media);
+    }
+  };
+  observeMedia();
+  const videoHostMutationObserver = typeof MutationObserver !== "undefined" ? new MutationObserver(() => {
+    observeMedia();
+    scheduleApply();
+  }) : null;
+  bindVideoHostObserver(videoHostMutationObserver);
+  const wrapperMutationObserver = typeof MutationObserver !== "undefined" ? new MutationObserver(() => {
+    bindVideoHostObserver(videoHostMutationObserver);
+    observeMedia();
+    scheduleApply();
+  }) : null;
+  wrapperMutationObserver?.observe(wrapper, {
+    childList: true,
+    subtree: true
+  });
+  const onWindowChange = () => scheduleApply();
+  window.addEventListener("resize", onWindowChange);
+  window.addEventListener("scroll", onWindowChange, true);
+  return () => {
+    if (rafId !== null) {
+      cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    resizeObserver?.disconnect();
+    wrapperMutationObserver?.disconnect();
+    videoHostMutationObserver?.disconnect();
+    for (const unbind of Array.from(mediaListeners.values())) {
+      unbind.forEach((dispose) => dispose());
+    }
+    mediaListeners.clear();
+    window.removeEventListener("resize", onWindowChange);
+    window.removeEventListener("scroll", onWindowChange, true);
+    resetDragSurfaceFullBleed(dragSurface);
+  };
+}
+
+exports.RealtimePrewarmHandle = RealtimePrewarmHandle;
+exports.RealtimeSession = RealtimeSession;
+exports.createDragTrackController = createDragTrackController;
+exports.createRemoteViewHost = createRemoteViewHost;
+exports.createXmaxClient = createXmaxClient;
+exports.getContentRect = getContentRect;
+exports.mapTargetPointToCanvas = mapTargetPointToCanvas;
+exports.mapViewportPointToCoordinateSpace = mapViewportPointToCoordinateSpace;
+exports.models = models;
+exports.observeDragSurfaceVideoSync = observeDragSurfaceVideoSync;
+exports.syncDragSurfaceToVideo = syncDragSurfaceToVideo;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map