@xmaxai/sdk 0.1.0

package/dist/react/index.cjs

@@ -0,0 +1,4304 @@
+'use strict';
+
+var react = require('react');
+var COS = require('cos-js-sdk-v5');
+var VERTC = require('@volcengine/rtc');
+var jsxRuntime = require('react/jsx-runtime');
+
+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;
+}
+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 median(values) {
+  if (values.length === 0) {
+    return 30;
+  }
+  const sorted = [...values].sort((a, b) => a - b);
+  const mid = Math.floor(sorted.length / 2);
+  if (sorted.length % 2 === 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2;
+  }
+  return sorted[mid];
+}
+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;
+}
+async function estimateVideoFrameRate(videoEl, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e3;
+  const sampleDurationMs = options.sampleDurationMs ?? 900;
+  const fallbackFps = options.fallbackFps ?? 30;
+  const video = videoEl;
+  if (!video.requestVideoFrameCallback) {
+    return fallbackFps;
+  }
+  return new Promise((resolve) => {
+    let settled = false;
+    let startWallMs = 0;
+    let startPresented = 0;
+    const deltas = [];
+    let lastMediaTime = -1;
+    const finish = (rawFps) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve(snapToCommonVideoFpsConservative(rawFps));
+    };
+    const timer = setTimeout(() => {
+      if (startWallMs > 0) {
+        finish(fallbackFps);
+        return;
+      }
+      if (deltas.length > 0) {
+        finish(median(deltas.map((delta) => 1 / delta)));
+        return;
+      }
+      finish(fallbackFps);
+    }, timeoutMs);
+    const schedule = () => {
+      if (settled) {
+        return;
+      }
+      video.requestVideoFrameCallback((now, metadata) => {
+        if (lastMediaTime >= 0) {
+          const delta = metadata.mediaTime - lastMediaTime;
+          if (delta > 1e-3 && delta < 0.5) {
+            deltas.push(delta);
+          }
+        }
+        lastMediaTime = metadata.mediaTime;
+        if (startWallMs === 0) {
+          startWallMs = now;
+          startPresented = metadata.presentedFrames;
+          schedule();
+          return;
+        }
+        const elapsedMs = now - startWallMs;
+        if (elapsedMs >= sampleDurationMs) {
+          const frameCount = metadata.presentedFrames - startPresented;
+          if (frameCount > 0) {
+            finish(frameCount / (elapsedMs / 1e3));
+            return;
+          }
+        }
+        schedule();
+      });
+    };
+    schedule();
+  });
+}
+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/publish-fps.ts
+var MOBILE_PUBLISH_MAX_WIDTH_PX = 768;
+function isMobilePublishEnvironment() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  return window.matchMedia(`(max-width: ${MOBILE_PUBLISH_MAX_WIDTH_PX}px)`).matches;
+}
+var MEDIA_TIME_EPSILON_S = 1e-3;
+var MEDIA_TIME_LOOP_JUMP_S = 0.05;
+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/rtc/capture-crop.ts
+function computeCenterCropRect(sourceWidth, sourceHeight, targetAspect) {
+  const sourceAspect = sourceWidth / sourceHeight;
+  if (sourceAspect > targetAspect) {
+    const height2 = sourceHeight;
+    const width2 = sourceHeight * targetAspect;
+    return {
+      x: (sourceWidth - width2) / 2,
+      y: 0,
+      width: width2,
+      height: height2
+    };
+  }
+  const width = sourceWidth;
+  const height = sourceWidth / targetAspect;
+  return {
+    x: 0,
+    y: (sourceHeight - height) / 2,
+    width,
+    height
+  };
+}
+
+// src/rtc/canvas-frame-draw.ts
+function drawSourceCenterCrop(ctx, source, outputWidth, outputHeight, sourceWidth, sourceHeight) {
+  ctx.imageSmoothingEnabled = true;
+  ctx.imageSmoothingQuality = "high";
+  ctx.clearRect(0, 0, outputWidth, outputHeight);
+  const crop = computeCenterCropRect(
+    sourceWidth,
+    sourceHeight,
+    outputWidth / outputHeight
+  );
+  ctx.drawImage(
+    source,
+    crop.x,
+    crop.y,
+    crop.width,
+    crop.height,
+    0,
+    0,
+    outputWidth,
+    outputHeight
+  );
+}
+
+// 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/video-file-stream.ts
+var STALL_CATCHUP_MS = 1500;
+function shouldSampleAtMediaTime(lastMediaTimeS, mediaTimeS) {
+  if (!Number.isFinite(mediaTimeS) || mediaTimeS < 0) {
+    return false;
+  }
+  if (lastMediaTimeS < 0) {
+    return true;
+  }
+  if (mediaTimeS + MEDIA_TIME_LOOP_JUMP_S < lastMediaTimeS) {
+    return true;
+  }
+  return mediaTimeS > lastMediaTimeS + MEDIA_TIME_EPSILON_S;
+}
+function sampleCanvasFingerprint(ctx, width, height) {
+  const points = [
+    [0, 0],
+    [Math.max(0, (width >> 1) - 1), Math.max(0, (height >> 1) - 1)],
+    [Math.max(0, width - 1), Math.max(0, height - 1)]
+  ];
+  return points.map(([x, y]) => {
+    const data = ctx.getImageData(x, y, 1, 1).data;
+    return `${data[0]},${data[1]},${data[2]}`;
+  }).join("|");
+}
+async function applyPublishTrackConstraints(track, width, height) {
+  if (typeof track.applyConstraints !== "function") {
+    return;
+  }
+  try {
+    await track.applyConstraints({
+      width: { ideal: width, max: width },
+      height: { ideal: height, max: height }
+    });
+  } catch {
+  }
+}
+async function createVideoFileStream(fileOrUrl, options = {}) {
+  const i18n = options.i18n ?? createSDKI18n();
+  const isUrl = typeof fileOrUrl === "string";
+  const url = isUrl ? fileOrUrl : URL.createObjectURL(fileOrUrl);
+  const videoEl = document.createElement("video");
+  videoEl.muted = options.muted ?? true;
+  videoEl.playsInline = true;
+  if (isUrl) {
+    videoEl.crossOrigin = "anonymous";
+  }
+  videoEl.src = url;
+  videoEl.loop = options.loop ?? true;
+  videoEl.autoplay = true;
+  mountCaptureVideo(videoEl);
+  try {
+    videoEl.load();
+    await waitForEvent(videoEl, "loadedmetadata");
+    await waitForCanPlay(videoEl);
+  } catch (error) {
+    if (!isUrl) URL.revokeObjectURL(url);
+    throw error;
+  }
+  if (typeof options.playbackRate === "number") {
+    videoEl.playbackRate = options.playbackRate;
+  }
+  await startVideoPlayback(videoEl, i18n);
+  const sourceWidth = videoEl.videoWidth || 0;
+  const sourceHeight = videoEl.videoHeight || 0;
+  if (!sourceWidth || !sourceHeight) {
+    if (!isUrl) URL.revokeObjectURL(url);
+    throw new Error(i18n.t("errors.videoTrackMissing"));
+  }
+  const measuredFps = typeof options.fps === "number" && options.fps > 0 ? options.fps : await estimateVideoFrameRate(videoEl);
+  const [outputWidth, outputHeight] = options.targetSize ?? resolveUploadVideoSize(sourceWidth, sourceHeight);
+  const canvas = document.createElement("canvas");
+  canvas.width = outputWidth;
+  canvas.height = outputHeight;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    if (!isUrl) URL.revokeObjectURL(url);
+    throw new Error(i18n.t("errors.captureStreamUnsupported"));
+  }
+  const captureStreamFn = canvas.captureStream ?? canvas.mozCaptureStream;
+  if (!captureStreamFn) {
+    if (!isUrl) URL.revokeObjectURL(url);
+    throw new Error(i18n.t("errors.captureStreamUnsupported"));
+  }
+  const previewStream = captureStreamFn.call(canvas);
+  const videoTrack = previewStream.getVideoTracks()[0];
+  if (!videoTrack) {
+    if (!isUrl) URL.revokeObjectURL(url);
+    throw new Error(i18n.t("errors.videoTrackMissing"));
+  }
+  const publishFps = resolvePlaybackDrivenEncoderFps(videoTrack, measuredFps);
+  await applyPublishTrackConstraints(videoTrack, outputWidth, outputHeight);
+  let destroyed = false;
+  let lastAdvanceAt = Date.now();
+  let lastDrawMediaTimeS = -1;
+  let videoFrameCallbackId = null;
+  let rafId = null;
+  const logPublishFrames = options.logPublishFrames ?? false;
+  let publishFrameIndex = 0;
+  let lastPublishWallMs = 0;
+  let lastPublishMediaTimeS = -1;
+  let publishFramesInWindow = 0;
+  let publishWindowStartMs = 0;
+  const drawFrame = () => {
+    if (destroyed) {
+      return;
+    }
+    drawSourceCenterCrop(
+      ctx,
+      videoEl,
+      outputWidth,
+      outputHeight,
+      sourceWidth,
+      sourceHeight
+    );
+  };
+  const logPublishedFrame = (mediaTimeS, presentedFrames) => {
+    if (!logPublishFrames) {
+      return;
+    }
+    publishFrameIndex += 1;
+    const wallNowMs = performance.now();
+    const wallDeltaMs = lastPublishWallMs > 0 ? wallNowMs - lastPublishWallMs : 0;
+    const mediaDeltaS = lastPublishMediaTimeS >= 0 ? mediaTimeS - lastPublishMediaTimeS : 0;
+    lastPublishWallMs = wallNowMs;
+    lastPublishMediaTimeS = mediaTimeS;
+    publishFramesInWindow += 1;
+    if (publishWindowStartMs === 0) {
+      publishWindowStartMs = wallNowMs;
+    }
+    const fingerprint = sampleCanvasFingerprint(ctx, outputWidth, outputHeight);
+    console.warn("[upload-video \u2192 publishFrame]", {
+      frameIndex: publishFrameIndex,
+      mediaTimeS: Number(mediaTimeS.toFixed(4)),
+      mediaDeltaS: Number(mediaDeltaS.toFixed(4)),
+      wallDeltaMs: Number(wallDeltaMs.toFixed(1)),
+      effectiveFps: wallDeltaMs > 0 ? Number((1e3 / wallDeltaMs).toFixed(1)) : null,
+      presentedFrames,
+      size: `${outputWidth}\xD7${outputHeight}`,
+      fingerprint
+    });
+    const windowElapsedMs = wallNowMs - publishWindowStartMs;
+    if (windowElapsedMs >= 1e3) {
+      console.warn("[upload-video \u2192 publishFps]", {
+        framesInLast1s: publishFramesInWindow,
+        avgFps: Number((publishFramesInWindow / (windowElapsedMs / 1e3)).toFixed(2)),
+        videoCurrentTime: Number(videoEl.currentTime.toFixed(4)),
+        videoPaused: videoEl.paused,
+        videoReadyState: videoEl.readyState
+      });
+      publishFramesInWindow = 0;
+      publishWindowStartMs = wallNowMs;
+    }
+  };
+  const onPlaybackSample = (mediaTimeS, presentedFrames) => {
+    if (destroyed || !shouldSampleAtMediaTime(lastDrawMediaTimeS, mediaTimeS)) {
+      return;
+    }
+    lastDrawMediaTimeS = mediaTimeS;
+    lastAdvanceAt = Date.now();
+    drawFrame();
+    logPublishedFrame(mediaTimeS, presentedFrames);
+  };
+  const schedulePlaybackWatch = () => {
+    if (destroyed) {
+      return;
+    }
+    const video = videoEl;
+    if (video.requestVideoFrameCallback) {
+      videoFrameCallbackId = video.requestVideoFrameCallback((_now, metadata) => {
+        onPlaybackSample(metadata.mediaTime, metadata.presentedFrames);
+        schedulePlaybackWatch();
+      });
+      return;
+    }
+    rafId = window.requestAnimationFrame(() => {
+      onPlaybackSample(videoEl.currentTime);
+      schedulePlaybackWatch();
+    });
+  };
+  drawFrame();
+  logPublishedFrame(videoEl.currentTime);
+  schedulePlaybackWatch();
+  const ensurePlaying = () => {
+    if (destroyed) {
+      return;
+    }
+    if (videoEl.ended && videoEl.loop) {
+      videoEl.currentTime = 0;
+      lastDrawMediaTimeS = -1;
+    }
+    if (videoEl.paused) {
+      void videoEl.play().catch(() => void 0);
+    }
+  };
+  const markAdvance = () => {
+    lastAdvanceAt = Date.now();
+  };
+  videoEl.addEventListener("timeupdate", markAdvance);
+  videoEl.addEventListener("pause", ensurePlaying);
+  videoEl.addEventListener("ended", ensurePlaying);
+  videoEl.addEventListener("stalled", ensurePlaying);
+  videoEl.addEventListener("waiting", ensurePlaying);
+  if (logPublishFrames) {
+    const logPlaybackEvent = (eventName) => {
+      console.warn("[upload-video \u2192 playbackEvent]", {
+        event: eventName,
+        currentTime: Number(videoEl.currentTime.toFixed(4)),
+        readyState: videoEl.readyState,
+        paused: videoEl.paused
+      });
+    };
+    videoEl.addEventListener("waiting", () => logPlaybackEvent("waiting"));
+    videoEl.addEventListener("stalled", () => logPlaybackEvent("stalled"));
+  }
+  const healthIntervalMs = options.healthIntervalMs ?? 3e3;
+  let healthTimer = null;
+  if (options.onHealthReport) {
+    const reportHealth = options.onHealthReport;
+    healthTimer = setInterval(() => {
+      ensurePlaying();
+      const now = Date.now();
+      const currentTime = videoEl.currentTime;
+      const duration = videoEl.duration;
+      const nearEnd = duration > 0 && currentTime >= duration - 0.2;
+      const stalled = !videoEl.paused && !videoEl.ended && !nearEnd && now - lastAdvanceAt >= healthIntervalMs;
+      if (stalled && now - lastAdvanceAt >= STALL_CATCHUP_MS) {
+        void videoEl.play().catch(() => void 0);
+      }
+      reportHealth({
+        currentTime,
+        duration,
+        paused: videoEl.paused,
+        ended: videoEl.ended,
+        readyState: videoEl.readyState,
+        trackReadyState: videoTrack.readyState,
+        trackMuted: videoTrack.muted,
+        stalled,
+        timeSinceAdvanceMs: now - lastAdvanceAt
+      });
+    }, healthIntervalMs);
+  }
+  const destroy = () => {
+    destroyed = true;
+    videoEl.removeEventListener("timeupdate", markAdvance);
+    videoEl.removeEventListener("pause", ensurePlaying);
+    videoEl.removeEventListener("ended", ensurePlaying);
+    videoEl.removeEventListener("stalled", ensurePlaying);
+    videoEl.removeEventListener("waiting", ensurePlaying);
+    const video = videoEl;
+    if (videoFrameCallbackId !== null) {
+      video.cancelVideoFrameCallback?.(videoFrameCallbackId);
+      videoFrameCallbackId = null;
+    }
+    if (rafId !== null) {
+      window.cancelAnimationFrame(rafId);
+      rafId = null;
+    }
+    if (healthTimer !== null) {
+      clearInterval(healthTimer);
+      healthTimer = null;
+    }
+    try {
+      videoEl.pause();
+    } catch {
+    }
+    try {
+      videoTrack.stop();
+    } catch {
+    }
+    try {
+      previewStream.getTracks().forEach((track) => {
+        if (track.readyState !== "ended") {
+          track.stop();
+        }
+      });
+    } catch {
+    }
+    try {
+      videoEl.remove();
+    } catch {
+    }
+    try {
+      videoEl.src = "";
+      videoEl.load();
+    } catch {
+    }
+    if (!isUrl) URL.revokeObjectURL(url);
+  };
+  return {
+    url,
+    previewStream,
+    videoEl,
+    videoTrack,
+    fps: publishFps,
+    width: outputWidth,
+    height: outputHeight,
+    sourceWidth,
+    sourceHeight,
+    destroy
+  };
+}
+function waitForEvent(el, eventName) {
+  return new Promise((resolve, reject) => {
+    const onOk = () => {
+      cleanup();
+      resolve();
+    };
+    const onErr = (e) => {
+      cleanup();
+      const mediaEl = el;
+      const code = mediaEl.error ? mediaEl.error.code : "unknown";
+      const message = mediaEl.error ? mediaEl.error.message : "no message";
+      const src = mediaEl.src || "unknown src";
+      reject(new Error(`failed to load video metadata: ${String(eventName)} (code: ${code}, message: ${message}, src: ${src})`));
+    };
+    const cleanup = () => {
+      el.removeEventListener(eventName, onOk);
+      el.removeEventListener("error", onErr);
+    };
+    el.addEventListener(eventName, onOk, { once: true });
+    el.addEventListener("error", onErr, { once: true });
+  });
+}
+function waitForCanPlay(videoEl) {
+  if (videoEl.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const onReady = () => {
+      cleanup();
+      resolve();
+    };
+    const cleanup = () => {
+      videoEl.removeEventListener("canplay", onReady);
+      videoEl.removeEventListener("loadeddata", onReady);
+    };
+    videoEl.addEventListener("canplay", onReady, { once: true });
+    videoEl.addEventListener("loadeddata", onReady, { once: true });
+  });
+}
+async function startVideoPlayback(videoEl, i18n) {
+  try {
+    const playResult = videoEl.play();
+    if (playResult && typeof playResult.then === "function") {
+      await playResult;
+    }
+  } catch {
+    throw new Error(i18n.t("errors.videoPlaybackFailed"));
+  }
+  try {
+    await waitForPlaying(videoEl);
+  } catch {
+    throw new Error(i18n.t("errors.videoPlaybackFailed"));
+  }
+  if (videoEl.paused || videoEl.readyState < HTMLMediaElement.HAVE_CURRENT_DATA) {
+    throw new Error(i18n.t("errors.videoPlaybackFailed"));
+  }
+}
+function waitForPlaying(videoEl) {
+  if (!videoEl.paused && videoEl.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve, reject) => {
+    const onPlaying = () => {
+      cleanup();
+      resolve();
+    };
+    const onErr = () => {
+      cleanup();
+      reject(new Error("video playback failed"));
+    };
+    const cleanup = () => {
+      videoEl.removeEventListener("playing", onPlaying);
+      videoEl.removeEventListener("error", onErr);
+    };
+    videoEl.addEventListener("playing", onPlaying, { once: true });
+    videoEl.addEventListener("error", onErr, { once: true });
+  });
+}
+
+// src/shared/camera-stream.ts
+function getCameraEnvironmentIssue() {
+  if (typeof window === "undefined") {
+    return "api-unavailable";
+  }
+  if (!window.isSecureContext) {
+    return "insecure-context";
+  }
+  if (typeof navigator?.mediaDevices?.getUserMedia !== "function") {
+    return "api-unavailable";
+  }
+  return null;
+}
+function buildVideoConstraints(options, resolution) {
+  const size = resolution === "min" ? { width: { min: options.width, ideal: options.width }, height: { min: options.height, ideal: options.height } } : { width: { ideal: options.width }, height: { ideal: options.height } };
+  return {
+    ...size,
+    frameRate: { ideal: options.frameRate ?? 30 },
+    ...options.facingMode !== void 0 ? { facingMode: options.facingMode } : {}
+  };
+}
+function isOverconstrainedCameraError(error) {
+  if (!(error instanceof DOMException)) {
+    return false;
+  }
+  return error.name === "OverconstrainedError" || error.name === "ConstraintNotSatisfiedError";
+}
+function isEnvironmentFacing(facingMode) {
+  if (facingMode === "environment") {
+    return true;
+  }
+  if (typeof facingMode === "object" && facingMode !== null && "exact" in facingMode) {
+    return facingMode.exact === "environment";
+  }
+  return false;
+}
+function waitTwoAnimationFrames() {
+  return new Promise((resolve) => {
+    requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+  });
+}
+async function stabilizeCameraVideoTrack(track, options) {
+  if (!isEnvironmentFacing(options?.facingMode)) {
+    return;
+  }
+  const caps = track.getCapabilities?.();
+  if (!caps) {
+    return;
+  }
+  const advanced = [];
+  if (Array.isArray(caps.focusMode)) {
+    if (caps.focusMode.includes("single-shot")) {
+      advanced.push({ focusMode: "single-shot" });
+    } else if (caps.focusMode.includes("manual") && caps.focusDistance) {
+      const settings = track.getSettings?.();
+      const { min, max } = caps.focusDistance;
+      const distance = typeof settings?.focusDistance === "number" ? settings.focusDistance : Math.min(max, Math.max(min, 1));
+      advanced.push({ focusMode: "manual", focusDistance: distance });
+    }
+  }
+  if (caps.zoom && typeof caps.zoom.min === "number" && typeof caps.zoom.max === "number") {
+    const zoom = 1;
+    if (zoom >= caps.zoom.min && zoom <= caps.zoom.max) {
+      advanced.push({ zoom });
+    }
+  }
+  if (advanced.length === 0) {
+    return;
+  }
+  try {
+    await track.applyConstraints({ advanced });
+  } catch {
+  }
+}
+async function openCameraStream(options) {
+  try {
+    return await navigator.mediaDevices.getUserMedia({
+      audio: false,
+      video: buildVideoConstraints(options, "min")
+    });
+  } catch (error) {
+    if (!isOverconstrainedCameraError(error)) {
+      throw error;
+    }
+    return navigator.mediaDevices.getUserMedia({
+      audio: false,
+      video: buildVideoConstraints(options, "ideal")
+    });
+  }
+}
+async function requestCameraMediaStream(options) {
+  const environmentIssue = getCameraEnvironmentIssue();
+  if (environmentIssue === "insecure-context") {
+    throw new DOMException("Camera requires a secure context (HTTPS).", "SecurityError");
+  }
+  if (environmentIssue === "api-unavailable") {
+    throw new Error("Camera is not supported in this browser.");
+  }
+  const stream = await openCameraStream(options);
+  const track = stream.getVideoTracks()[0];
+  if (track && isEnvironmentFacing(options.facingMode)) {
+    await waitTwoAnimationFrames();
+    await stabilizeCameraVideoTrack(track, { facingMode: options.facingMode });
+  }
+  return stream;
+}
+
+// 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/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/shared/session-debug.ts
+function createSessionDebugLogger(enabled, onLog) {
+  return (category, level, message, data) => {
+    if (!enabled || !onLog) {
+      return;
+    }
+    const scope = category === "rtc" || category === "sei" ? "rtc" : "client";
+    onLog({
+      scope,
+      level,
+      message: `[${category}] ${message}`,
+      data
+    });
+  };
+}
+function seiGateChanged(prev, next) {
+  if (!prev) {
+    return true;
+  }
+  return prev.matched !== next.matched || prev.expectedSei !== next.expectedSei || prev.sei !== next.sei || prev.userId !== next.userId;
+}
+function outputVisibilityChanged(prev, next) {
+  if (!prev) {
+    return true;
+  }
+  return prev.showOutputVideo !== next.showOutputVideo || prev.outputEnabled !== next.outputEnabled || prev.hasResult !== next.hasResult || prev.remoteVideoUserId !== next.remoteVideoUserId || prev.localVideoPublished !== next.localVideoPublished || prev.inputSource !== next.inputSource || prev.seiMatched !== next.seiMatched;
+}
+function isVideoInputUnhealthy(health) {
+  return health.stalled || health.paused || health.ended || health.trackReadyState === "ended";
+}
+function videoInputHealthChanged(prev, next) {
+  if (!prev) {
+    return isVideoInputUnhealthy(next);
+  }
+  const prevBad = isVideoInputUnhealthy(prev);
+  const nextBad = isVideoInputUnhealthy(next);
+  if (prevBad !== nextBad) {
+    return true;
+  }
+  if (nextBad) {
+    return prev.stalled !== next.stalled || prev.paused !== next.paused || prev.ended !== next.ended || prev.trackReadyState !== next.trackReadyState;
+  }
+  return false;
+}
+var XmaxContext = react.createContext(null);
+var createDefaultRtcSnapshot = () => ({
+  roomId: null,
+  userId: null,
+  appId: null,
+  botUserId: null,
+  joined: false,
+  localVideoPublished: false,
+  remoteVideoUserId: null,
+  users: []
+});
+var createDefaultSeiGateState = () => ({
+  expectedSei: null,
+  sei: null,
+  userId: null,
+  matched: true
+});
+function XmaxProvider({ config, children }) {
+  const sdkI18n = react.useMemo(() => config.i18n ?? createSDKI18n({ locale: config.locale }), [config.i18n, config.locale]);
+  const debugEnabled = config.debug ?? false;
+  const debugLog = react.useMemo(
+    () => createSessionDebugLogger(debugEnabled, config.onLog),
+    [config.onLog, debugEnabled]
+  );
+  const debugLogRef = react.useRef(debugLog);
+  debugLogRef.current = debugLog;
+  const debugEnabledRef = react.useRef(debugEnabled);
+  debugEnabledRef.current = debugEnabled;
+  const prevSeiGateRef = react.useRef(null);
+  const prevOutputVisibilityRef = react.useRef(null);
+  const prevVideoHealthRef = react.useRef(null);
+  const resetDebugSnapshots = react.useCallback(() => {
+    prevSeiGateRef.current = null;
+    prevOutputVisibilityRef.current = null;
+    prevVideoHealthRef.current = null;
+  }, []);
+  const externalOnError = config.onError;
+  const clientRef = react.useRef(null);
+  const sessionUidRef = react.useRef(null);
+  const taskUidRef = react.useRef(null);
+  const lastStartPromptRef = react.useRef(void 0);
+  const lastStartModelRef = react.useRef("");
+  const lastStartRefImageRef = react.useRef(void 0);
+  const videoFileStreamRef = react.useRef(null);
+  const cameraStreamRef = react.useRef(null);
+  const localVideoSizeRef = react.useRef(null);
+  const inputSourceRef = react.useRef("none");
+  const disconnectRef = react.useRef(null);
+  const disconnectPromiseRef = react.useRef(null);
+  const localContainerRef = react.useRef(null);
+  const remoteContainerRef = react.useRef(null);
+  const outputEnabledRef = react.useRef(false);
+  const activeModeCodeRef = react.useRef(null);
+  const onRemoteOutputStalledRef = react.useRef(null);
+  const [rtcState, setRtcState] = react.useState(createDefaultRtcSnapshot);
+  const [inputSource, setInputSource] = react.useState("none");
+  const [isCameraOn, setIsCameraOn] = react.useState(false);
+  const [isRecording, setIsRecording] = react.useState(false);
+  const [isGenerating, setIsGenerating] = react.useState(false);
+  const [hasResult, setHasResult] = react.useState(false);
+  const [outputEnabled, setOutputEnabled] = react.useState(false);
+  const [activeModeCode, setActiveModeCode] = react.useState(null);
+  const [localVideoSize, setLocalVideoSize] = react.useState(null);
+  const [sessionTargetSize, setSessionTargetSize] = react.useState(null);
+  const [seiGate, setSeiGate] = react.useState(createDefaultSeiGateState);
+  inputSourceRef.current = inputSource;
+  localVideoSizeRef.current = localVideoSize;
+  outputEnabledRef.current = outputEnabled;
+  activeModeCodeRef.current = activeModeCode;
+  const ensureLocalVideoContainer = react.useCallback(() => {
+    const rtc = rtcManagerRef.current;
+    const container = localContainerRef.current;
+    if (!rtc || !container) {
+      return;
+    }
+    rtc.setLocalVideoContainer(container);
+  }, []);
+  const bindRemoteContainer = react.useCallback(() => {
+    const rtc = rtcManagerRef.current;
+    const container = remoteContainerRef.current;
+    if (!rtc || !container) {
+      return;
+    }
+    rtc.setRemoteVideoContainer(container);
+    void rtc.refreshRemoteVideoBinding();
+  }, []);
+  const detachRemoteContainer = react.useCallback(() => {
+    rtcManagerRef.current?.setRemoteVideoContainer(null);
+  }, []);
+  const notifyUserError = react.useCallback((message, error) => {
+    if (externalOnError) {
+      externalOnError(message, error);
+      return;
+    }
+    if (typeof window !== "undefined" && typeof document !== "undefined") {
+      browserToast.error(message);
+    }
+  }, [externalOnError]);
+  const reportError = react.useCallback((error, fallbackMessage) => {
+    return notifyError(error, notifyUserError, fallbackMessage ?? sdkI18n.t("errors.requestFailed"));
+  }, [notifyUserError, sdkI18n]);
+  const rtcManagerRef = react.useRef(null);
+  if (!rtcManagerRef.current) {
+    rtcManagerRef.current = new RtcManager({
+      onStateChange: (state) => setRtcState(state),
+      onSeiGateChange: (state) => {
+        setSeiGate(state);
+        if (debugEnabledRef.current && seiGateChanged(prevSeiGateRef.current, state)) {
+          debugLogRef.current("sei", state.matched ? "success" : "warn", "gate change", state);
+          prevSeiGateRef.current = state;
+        }
+      },
+      onLog: (entry) => config.onLog?.({ scope: "rtc", ...entry }),
+      onRemoteOutputStalled: (info) => onRemoteOutputStalledRef.current?.(info),
+      debug: debugEnabled,
+      i18n: sdkI18n
+    });
+  }
+  const getClient = react.useCallback(() => {
+    const existing = clientRef.current;
+    if (existing) {
+      return existing;
+    }
+    const created = new XmaxOpenClient({
+      apiKey: config.apiKey,
+      authToken: config.authToken,
+      baseUrl: config.baseUrl,
+      locale: config.locale,
+      i18n: sdkI18n,
+      onError: notifyUserError
+    });
+    clientRef.current = created;
+    return created;
+  }, [config.apiKey, config.authToken, config.baseUrl, config.locale, notifyUserError, sdkI18n]);
+  const ensureConnected = react.useCallback(async () => {
+    const client = getClient();
+    const rtc = rtcManagerRef.current;
+    if (!rtc) {
+      return;
+    }
+    if (rtc.snapshot.joined && sessionUidRef.current) {
+      return;
+    }
+    const model = config.model ?? "x2.0";
+    const session = await client.createSession(model);
+    if (!session.sessionUid?.trim()) {
+      throw new Error(sdkI18n.t("errors.sessionUidMissing"));
+    }
+    sessionUidRef.current = session.sessionUid;
+    client.startHeartbeat(
+      session.sessionUid,
+      config.heartbeatIntervalMs ?? 1e4,
+      (heartbeatSession) => {
+        if (heartbeatSession.status !== ACTIVE_STATUS) {
+          void disconnectRef.current?.();
+        }
+      },
+      () => {
+        void disconnectRef.current?.();
+      }
+    );
+    const joinInfo = client.getRtcJoinInfo(session);
+    await rtc.join(joinInfo);
+    ensureLocalVideoContainer();
+  }, [config.heartbeatIntervalMs, config.model, ensureLocalVideoContainer, getClient, sdkI18n]);
+  const connect = react.useCallback(async () => {
+    try {
+      await ensureConnected();
+    } catch (error) {
+      throw reportError(error);
+    }
+  }, [ensureConnected, reportError]);
+  const stopPublishing = react.useCallback(async () => {
+    const rtc = rtcManagerRef.current;
+    if (!rtc) {
+      return;
+    }
+    try {
+      await rtc.stopVideoPublishing();
+    } catch {
+    }
+    rtc.clearRemoteVideo();
+    detachRemoteContainer();
+    setOutputEnabled(false);
+    setHasResult(false);
+    if (videoFileStreamRef.current) {
+      videoFileStreamRef.current.destroy();
+      videoFileStreamRef.current = null;
+    }
+    if (cameraStreamRef.current) {
+      cameraStreamRef.current.destroy();
+      cameraStreamRef.current = null;
+    }
+    setInputSource("none");
+    setIsCameraOn(false);
+    setIsRecording(false);
+    setLocalVideoSize(null);
+    localVideoSizeRef.current = null;
+    setSessionTargetSize(null);
+    setSeiGate(createDefaultSeiGateState());
+    resetDebugSnapshots();
+    debugLogRef.current("lifecycle", "info", "stopPublishing", { inputSource: inputSourceRef.current });
+  }, [detachRemoteContainer, resetDebugSnapshots]);
+  const stop = react.useCallback(async () => {
+    try {
+      const rtc = rtcManagerRef.current;
+      taskUidRef.current = null;
+      rtc?.configureSessionSei(null);
+      setSeiGate(createDefaultSeiGateState());
+      resetDebugSnapshots();
+      debugLogRef.current("lifecycle", "info", "stop", {});
+      if (!rtc?.snapshot.joined) {
+        rtc?.clearRemoteVideo();
+        detachRemoteContainer();
+        setHasResult(false);
+        setOutputEnabled(false);
+        return;
+      }
+      try {
+        const stopEvent = createStopRtcRoomEvent({
+          userId: rtc.snapshot.userId ?? void 0,
+          sessionUid: sessionUidRef.current ?? void 0
+        });
+        await rtc.sendRoomEvent(stopEvent);
+      } finally {
+        rtc.clearRemoteVideo();
+        detachRemoteContainer();
+        setHasResult(false);
+        setOutputEnabled(false);
+      }
+    } catch (error) {
+      throw reportError(error);
+    }
+  }, [detachRemoteContainer, reportError, resetDebugSnapshots]);
+  const disconnect = react.useCallback(async () => {
+    if (disconnectPromiseRef.current) {
+      return disconnectPromiseRef.current;
+    }
+    const run = async () => {
+      const client = clientRef.current;
+      const rtc = rtcManagerRef.current;
+      const activeSessionUid = sessionUidRef.current;
+      client?.beginTeardown();
+      rtc?.configureSessionSei(null);
+      setSeiGate(createDefaultSeiGateState());
+      taskUidRef.current = null;
+      resetDebugSnapshots();
+      rtc?.clearRemoteVideo();
+      try {
+        await stop();
+      } catch {
+      }
+      await stopPublishing();
+      if (rtc) {
+        try {
+          rtc.configureSessionSei(null);
+          await rtc.leave();
+        } catch {
+        }
+      }
+      if (client && activeSessionUid) {
+        try {
+          await client.closeSession(activeSessionUid);
+        } catch {
+        }
+      }
+      client?.endTeardown();
+      sessionUidRef.current = null;
+      taskUidRef.current = null;
+      setHasResult(false);
+      setOutputEnabled(false);
+      setActiveModeCode(null);
+      setSessionTargetSize(null);
+      setIsRecording(false);
+      detachRemoteContainer();
+      setRtcState(createDefaultRtcSnapshot());
+      setSeiGate(createDefaultSeiGateState());
+    };
+    const promise = run().finally(() => {
+      if (disconnectPromiseRef.current === promise) {
+        disconnectPromiseRef.current = null;
+      }
+    });
+    disconnectPromiseRef.current = promise;
+    return promise;
+  }, [detachRemoteContainer, stop, stopPublishing, resetDebugSnapshots]);
+  disconnectRef.current = disconnect;
+  react.useEffect(() => {
+    return () => {
+      void disconnectRef.current?.();
+    };
+  }, []);
+  react.useEffect(() => {
+    if (!debugEnabled) {
+      return;
+    }
+    const snapshot = {
+      outputEnabled,
+      hasResult,
+      showOutputVideo: outputEnabled && (hasResult || !!rtcState.remoteVideoUserId),
+      remoteVideoUserId: rtcState.remoteVideoUserId,
+      localVideoPublished: rtcState.localVideoPublished,
+      inputSource,
+      seiMatched: seiGate.matched,
+      expectedSei: seiGate.expectedSei,
+      lastSei: seiGate.sei
+    };
+    if (!outputVisibilityChanged(prevOutputVisibilityRef.current, snapshot)) {
+      return;
+    }
+    const level = snapshot.showOutputVideo ? "info" : "warn";
+    debugLog("output", level, "visibility change", snapshot);
+    prevOutputVisibilityRef.current = snapshot;
+  }, [
+    debugEnabled,
+    debugLog,
+    outputEnabled,
+    hasResult,
+    rtcState.remoteVideoUserId,
+    rtcState.localVideoPublished,
+    inputSource,
+    seiGate.matched,
+    seiGate.expectedSei,
+    seiGate.sei
+  ]);
+  react.useEffect(() => {
+    const rtc = rtcManagerRef.current;
+    if (!rtc) {
+      return;
+    }
+    if (!outputEnabled) {
+      rtc.clearRemoteVideo();
+      detachRemoteContainer();
+      return;
+    }
+    bindRemoteContainer();
+  }, [bindRemoteContainer, detachRemoteContainer, outputEnabled]);
+  const openCamera = react.useCallback(async (options) => {
+    try {
+      await ensureConnected();
+      const rtc = rtcManagerRef.current;
+      if (!rtc) {
+        return;
+      }
+      await stopPublishing();
+      ensureLocalVideoContainer();
+      const defaultCamera = models.realtime("x2.0");
+      const cameraHint = options?.size ?? [defaultCamera.width, defaultCamera.height];
+      const precomputedSize = resolveUploadVideoSize(cameraHint[0], cameraHint[1]);
+      setSessionTargetSize(precomputedSize);
+      const rawStream = await requestCameraMediaStream({
+        width: cameraHint[0],
+        height: cameraHint[1],
+        frameRate: 30,
+        facingMode: "user"
+      });
+      const publishStream = await createNativeCameraStream(rawStream);
+      cameraStreamRef.current = publishStream;
+      await rtc.startExternalVideoPublishing(publishStream.videoTrack, precomputedSize, {
+        mobile: isMobilePublishEnvironment(),
+        highQuality: true
+      });
+      const sessionDims = { width: publishStream.width, height: publishStream.height };
+      setLocalVideoSize(sessionDims);
+      localVideoSizeRef.current = sessionDims;
+      setSessionTargetSize([sessionDims.width, sessionDims.height]);
+      setIsCameraOn(true);
+      setIsRecording(true);
+      setInputSource("camera");
+    } catch (error) {
+      throw reportError(error);
+    }
+  }, [ensureConnected, ensureLocalVideoContainer, reportError, sdkI18n, stopPublishing]);
+  const closeCamera = react.useCallback(async () => {
+    await disconnect();
+  }, [disconnect]);
+  const loadVideoFile = react.useCallback(async (file, options) => {
+    try {
+      await ensureConnected();
+      const rtc = rtcManagerRef.current;
+      if (!rtc) {
+        return null;
+      }
+      await stopPublishing();
+      ensureLocalVideoContainer();
+      prevVideoHealthRef.current = null;
+      const stream = await createVideoFileStream(file, {
+        muted: true,
+        loop: true,
+        mobile: isMobilePublishEnvironment(),
+        targetSize: options?.size,
+        i18n: sdkI18n,
+        onHealthReport: debugEnabled ? (health) => {
+          if (!videoInputHealthChanged(prevVideoHealthRef.current, health)) {
+            return;
+          }
+          prevVideoHealthRef.current = health;
+          const level = health.stalled || health.paused || health.ended ? "warn" : "info";
+          debugLogRef.current("video-input", level, "health change", health);
+        } : void 0
+      });
+      if (videoFileStreamRef.current) {
+        videoFileStreamRef.current.destroy();
+      }
+      videoFileStreamRef.current = stream;
+      await rtc.startExternalVideoPublishing(stream.videoTrack, [stream.width, stream.height], {
+        mobile: isMobilePublishEnvironment(),
+        fps: stream.fps,
+        highQuality: true
+      });
+      setInputSource("video");
+      setIsCameraOn(true);
+      setIsRecording(true);
+      debugLogRef.current("lifecycle", "info", "loadVideoFile", {
+        width: stream.width,
+        height: stream.height,
+        fileName: file.name
+      });
+      if (stream.width && stream.height) {
+        const size = { width: stream.width, height: stream.height };
+        setLocalVideoSize(size);
+        localVideoSizeRef.current = size;
+        setSessionTargetSize([stream.width, stream.height]);
+      } else {
+        setLocalVideoSize(null);
+        localVideoSizeRef.current = null;
+      }
+      const targetSize = [stream.width, stream.height];
+      return {
+        url: stream.url,
+        width: stream.width,
+        height: stream.height,
+        previewStream: stream.previewStream,
+        videoEl: stream.videoEl,
+        targetSize
+      };
+    } catch (error) {
+      throw reportError(error);
+    }
+  }, [ensureConnected, ensureLocalVideoContainer, reportError, sdkI18n, stopPublishing, debugEnabled]);
+  const clearInput = react.useCallback(async () => {
+    await disconnect();
+  }, [disconnect]);
+  const uploadImage = react.useCallback(async (file) => {
+    try {
+      const client = getClient();
+      return await client.uploadImage(file);
+    } catch (error) {
+      throw reportError(error);
+    }
+  }, [getClient, reportError]);
+  const setRefImage = react.useCallback(async (input) => {
+    try {
+      if (typeof input !== "string") {
+        const result2 = await uploadImage(input);
+        return result2.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 });
+      const result = await uploadImage(file);
+      return result.url;
+    } catch (error) {
+      throw reportError(error);
+    }
+  }, [reportError, uploadImage]);
+  const start = react.useCallback(async (options) => {
+    try {
+      await ensureConnected();
+      const rtc = rtcManagerRef.current;
+      if (!rtc?.snapshot.joined) {
+        return;
+      }
+      const refForEvent = options.refImage;
+      const resolvedPrompt = options.prompt?.trim() ?? "";
+      setIsGenerating(true);
+      rtc.clearRemoteVideo();
+      rtc.setRemoteVideoContainer(null);
+      setHasResult(false);
+      setOutputEnabled(true);
+      outputEnabledRef.current = true;
+      const size = resolveSessionTargetSize({
+        localVideoSize: localVideoSizeRef.current,
+        overrideSize: options.size
+      });
+      setSessionTargetSize(size);
+      const taskUid = createTaskUid();
+      taskUidRef.current = taskUid;
+      lastStartPromptRef.current = resolvedPrompt || void 0;
+      lastStartModelRef.current = options.model;
+      lastStartRefImageRef.current = refForEvent?.trim() || void 0;
+      prevSeiGateRef.current = null;
+      rtc.configureSessionSei(taskUid);
+      debugLogRef.current("lifecycle", "info", "start", {
+        taskUid,
+        size,
+        inputSource: inputSourceRef.current
+      });
+      const startEvent = createStartRtcRoomEvent({
+        userId: rtc.snapshot.userId ?? void 0,
+        uid: taskUid,
+        sessionUid: taskUid,
+        model: options.model,
+        size,
+        prompt: resolvedPrompt || void 0,
+        extraParams: options.extraParams,
+        refImagePath: refForEvent?.trim() || void 0
+      });
+      if (remoteContainerRef.current) {
+        rtc.setRemoteVideoContainer(remoteContainerRef.current);
+      }
+      await rtc.ensurePublishedInputBeforeStart();
+      await rtc.sendRoomEvent(startEvent);
+      await rtc.refreshRemoteVideoBinding({ force: true });
+      setHasResult(true);
+    } catch (error) {
+      setOutputEnabled(false);
+      throw reportError(error);
+    } finally {
+      setIsGenerating(false);
+    }
+  }, [ensureConnected, reportError]);
+  const sendTracks = react.useCallback(async (options) => {
+    const rtc = rtcManagerRef.current;
+    if (!rtc?.snapshot.joined) {
+      return;
+    }
+    const activeTaskUid = taskUidRef.current;
+    if (!activeTaskUid) {
+      return;
+    }
+    console.log("[Xmax] sendTracks", {
+      taskUid: activeTaskUid,
+      targetSize: sessionTargetSize,
+      tracks: options.tracks
+    });
+    try {
+      const event = createTracksRtcRoomEvent({
+        userId: rtc.snapshot.userId ?? void 0,
+        uid: activeTaskUid,
+        sessionUid: activeTaskUid,
+        tracks: options.tracks
+      });
+      await rtc.sendRoomEvent(event);
+    } catch {
+    }
+  }, [sessionTargetSize]);
+  react.useCallback(async () => {
+    const rtc = rtcManagerRef.current;
+    if (!rtc?.snapshot.joined || !outputEnabledRef.current) {
+      return;
+    }
+    try {
+      debugLogRef.current("lifecycle", "warn", "recoverGeneration", {
+        inputSource: inputSourceRef.current
+      });
+      const taskUid = createTaskUid();
+      taskUidRef.current = taskUid;
+      prevSeiGateRef.current = null;
+      const size = resolveSessionTargetSize({
+        localVideoSize: localVideoSizeRef.current
+      });
+      const startEvent = createStartRtcRoomEvent({
+        userId: rtc.snapshot.userId ?? void 0,
+        uid: taskUid,
+        sessionUid: taskUid,
+        model: lastStartModelRef.current,
+        size,
+        prompt: lastStartPromptRef.current,
+        refImagePath: lastStartRefImageRef.current
+      });
+      if (remoteContainerRef.current) {
+        rtc.setRemoteVideoContainer(remoteContainerRef.current);
+      }
+      await rtc.sendRoomEvent(startEvent);
+      if (remoteContainerRef.current) {
+        rtc.setRemoteVideoContainer(remoteContainerRef.current);
+      }
+      await rtc.refreshRemoteVideoBinding({ force: true });
+    } catch (error) {
+      reportError(error);
+    }
+  }, [reportError]);
+  react.useEffect(() => {
+    onRemoteOutputStalledRef.current = (info) => {
+      debugLogRef.current("lifecycle", "warn", "remote output stalled", info);
+    };
+  }, []);
+  const changeModel = react.useCallback(async () => {
+    return;
+  }, []);
+  const bindLocalView = react.useCallback((el) => {
+    localContainerRef.current = el;
+    rtcManagerRef.current?.setLocalVideoContainer(el);
+  }, []);
+  const bindRemoteView = react.useCallback((el) => {
+    remoteContainerRef.current = el;
+    if (!el) {
+      detachRemoteContainer();
+      return;
+    }
+    if (outputEnabledRef.current) {
+      bindRemoteContainer();
+    }
+  }, [bindRemoteContainer, detachRemoteContainer]);
+  const value = react.useMemo(() => ({
+    snapshot: {
+      sessionUid: sessionUidRef.current,
+      rtc: rtcState,
+      inputSource,
+      isCameraOn,
+      isRecording,
+      isGenerating,
+      isOutputVerifying: !!seiGate.expectedSei && !seiGate.matched,
+      hasResult,
+      outputEnabled,
+      dragEnabled: outputEnabled && isRecording,
+      showOutputVideo: outputEnabled && (hasResult || !!rtcState.remoteVideoUserId),
+      localVideoSize,
+      sessionTargetSize,
+      seiGate
+    },
+    connect,
+    disconnect,
+    openCamera,
+    closeCamera,
+    loadVideoFile,
+    clearInput,
+    uploadImage,
+    setRefImage,
+    start,
+    sendTracks,
+    stop,
+    changeModel,
+    bindLocalView,
+    bindRemoteView
+  }), [
+    rtcState,
+    inputSource,
+    isCameraOn,
+    isRecording,
+    isGenerating,
+    seiGate,
+    hasResult,
+    outputEnabled,
+    localVideoSize,
+    sessionTargetSize,
+    connect,
+    disconnect,
+    openCamera,
+    closeCamera,
+    loadVideoFile,
+    clearInput,
+    uploadImage,
+    setRefImage,
+    start,
+    sendTracks,
+    stop,
+    changeModel,
+    bindLocalView,
+    bindRemoteView
+  ]);
+  return /* @__PURE__ */ jsxRuntime.jsx(XmaxContext.Provider, { value, children });
+}
+function useXmax() {
+  const ctx = react.useContext(XmaxContext);
+  if (!ctx) {
+    throw new Error("useXmax must be used within XmaxProvider");
+  }
+  return ctx;
+}
+
+// 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 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);
+}
+function DragTrackSurface({
+  enabled,
+  targetSize,
+  onTracks,
+  className,
+  style,
+  fitMode = "cover"
+}) {
+  const containerRef = react.useRef(null);
+  const controllerRef = react.useRef(null);
+  const onTracksRef = react.useRef(onTracks);
+  onTracksRef.current = onTracks;
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) {
+      return;
+    }
+    const controller = createDragTrackController(container, {
+      targetSize,
+      fitMode,
+      enabled,
+      onTracks: (tracks) => onTracksRef.current(tracks)
+    });
+    controllerRef.current = controller;
+    return () => {
+      controller.destroy();
+      controllerRef.current = null;
+    };
+  }, []);
+  react.useEffect(() => {
+    controllerRef.current?.setEnabled(enabled);
+  }, [enabled]);
+  react.useEffect(() => {
+    controllerRef.current?.setTargetSize(targetSize);
+  }, [targetSize]);
+  react.useEffect(() => {
+    controllerRef.current?.setFitMode(fitMode);
+  }, [fitMode]);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className, style });
+}
+function XmaxView({
+  kind,
+  className,
+  style
+}) {
+  const ref = react.useRef(null);
+  const { bindLocalView, bindRemoteView, snapshot, sendTracks } = useXmax();
+  react.useEffect(() => {
+    const el = ref.current;
+    if (!el) {
+      return;
+    }
+    if (kind === "local") {
+      bindLocalView(el);
+      return () => bindLocalView(null);
+    }
+    bindRemoteView(el);
+    return () => bindRemoteView(null);
+  }, [bindLocalView, bindRemoteView, kind]);
+  if (kind === "remote") {
+    const dragTargetSize = snapshot.sessionTargetSize ?? DEFAULT_SESSION_TARGET_SIZE;
+    return /* @__PURE__ */ jsxRuntime.jsxs("div", { className, style: { position: "relative", ...style }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx("div", { ref, style: { width: "100%", height: "100%" } }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        DragTrackSurface,
+        {
+          enabled: snapshot.dragEnabled,
+          targetSize: dragTargetSize,
+          fitMode: "contain",
+          onTracks: (tracks) => {
+            void sendTracks({ tracks });
+          },
+          className: "absolute inset-0 touch-none",
+          style: { zIndex: 10 }
+        }
+      )
+    ] });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref, className, style });
+}
+
+exports.DragTrackSurface = DragTrackSurface;
+exports.XmaxProvider = XmaxProvider;
+exports.XmaxView = XmaxView;
+exports.useXmax = useXmax;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map