@xmaxai/sdk 0.1.0

package/dist/chunk-67XSD3QJ.js

@@ -0,0 +1,2673 @@
+import { createSDKI18n, resolveApiErrorMessage, resolvePlaybackDrivenEncoderFps, mountCaptureVideo } from './chunk-PLU2YVAS.js';
+import COS from 'cos-js-sdk-v5';
+import VERTC, { VideoSourceType, MediaType, StreamIndex, RoomProfileType, MirrorType, VideoCodecType, VideoRenderMode } from '@volcengine/rtc';
+
+// src/shared/browser-toast.ts
+var TOAST_ROOT_ID = "Xmax-sdk-toast-root";
+var TOAST_DURATION_MS = 3e3;
+var toastSeed = 0;
+var timeoutMap = /* @__PURE__ */ new Map();
+var elementMap = /* @__PURE__ */ new Map();
+function ensureToastRoot() {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  let root = document.getElementById(TOAST_ROOT_ID);
+  if (root) {
+    return root;
+  }
+  root = document.createElement("div");
+  root.id = TOAST_ROOT_ID;
+  root.setAttribute("aria-live", "polite");
+  Object.assign(root.style, {
+    position: "fixed",
+    left: "50%",
+    top: "24px",
+    transform: "translateX(-50%)",
+    zIndex: "3000",
+    display: "flex",
+    flexDirection: "column",
+    alignItems: "center",
+    gap: "12px",
+    pointerEvents: "none"
+  });
+  document.body.appendChild(root);
+  return root;
+}
+function createIcon(type) {
+  const icon = document.createElement("span");
+  icon.setAttribute("aria-hidden", "true");
+  icon.innerHTML = type === "success" ? '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 12 12" fill="none"><path d="M10 3L4.5 8.5 2 6" stroke="#4ade80" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/></svg>' : '<svg xmlns="http://www.w3.org/2000/svg" width="12" height="12" viewBox="0 0 12 12" fill="none"><circle cx="6" cy="6" r="5" stroke="#f87171" stroke-width="1.5"/><path d="M4 4l4 4M8 4L4 8" stroke="#f87171" stroke-width="1.5" stroke-linecap="round"/></svg>';
+  Object.assign(icon.style, {
+    display: "inline-flex",
+    width: "12px",
+    height: "12px",
+    flexShrink: "0"
+  });
+  return icon;
+}
+function clearToastTimer(id) {
+  const timer = timeoutMap.get(id);
+  if (timer) {
+    window.clearTimeout(timer);
+    timeoutMap.delete(id);
+  }
+}
+function destroyToast(id) {
+  if (!id) {
+    timeoutMap.forEach((timer) => window.clearTimeout(timer));
+    timeoutMap.clear();
+    elementMap.forEach((element2) => element2.remove());
+    elementMap.clear();
+    const root2 = typeof document !== "undefined" ? document.getElementById(TOAST_ROOT_ID) : null;
+    root2?.remove();
+    return;
+  }
+  clearToastTimer(id);
+  const element = elementMap.get(id);
+  element?.remove();
+  elementMap.delete(id);
+  const root = typeof document !== "undefined" ? document.getElementById(TOAST_ROOT_ID) : null;
+  if (root && !root.childElementCount) {
+    root.remove();
+  }
+}
+function showToast(type, message, options) {
+  const root = ensureToastRoot();
+  if (!root) {
+    return "";
+  }
+  const id = options?.key || `toast-${Date.now()}-${++toastSeed}`;
+  clearToastTimer(id);
+  elementMap.get(id)?.remove();
+  const isMobile = typeof window !== "undefined" && window.matchMedia("(max-width: 768px)").matches;
+  const textSize = isMobile ? "12px" : "14px";
+  const toast = document.createElement("div");
+  toast.setAttribute("role", "status");
+  Object.assign(toast.style, {
+    pointerEvents: "auto",
+    display: "flex",
+    alignItems: "center",
+    gap: "12px",
+    minWidth: "240px",
+    padding: "16px",
+    borderRadius: "12px",
+    border: "1px solid rgba(255, 255, 255, 0.20)",
+    background: "rgba(0, 0, 0, 0.80)",
+    boxShadow: "0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1)",
+    fontFamily: "Rubik, ui-sans-serif, system-ui, sans-serif",
+    fontSize: textSize,
+    fontWeight: "400",
+    lineHeight: "14px"
+  });
+  const content = document.createElement("span");
+  content.textContent = message;
+  Object.assign(content.style, {
+    paddingRight: "0px",
+    textAlign: "center",
+    color: "#ffffff",
+    fontFamily: "Rubik, ui-sans-serif, system-ui, sans-serif",
+    fontSize: textSize,
+    fontWeight: "400",
+    lineHeight: "14px"
+  });
+  toast.appendChild(createIcon(type));
+  toast.appendChild(content);
+  root.appendChild(toast);
+  elementMap.set(id, toast);
+  const timer = window.setTimeout(() => {
+    destroyToast(id);
+  }, options?.duration ?? TOAST_DURATION_MS);
+  timeoutMap.set(id, timer);
+  return id;
+}
+var browserToast = {
+  success(message, options) {
+    return showToast("success", message, options);
+  },
+  error(message, options) {
+    return showToast("error", message, options);
+  },
+  destroy(id) {
+    destroyToast(id);
+  }
+};
+
+// src/shared/error-utils.ts
+function notifyError(error, notifier, fallbackMessage) {
+  const resolved = error instanceof Error ? error : Object.assign(new Error(fallbackMessage), { cause: error });
+  if (!resolved.__XmaxNotified) {
+    resolved.__XmaxNotified = true;
+    const message = resolved.message || fallbackMessage;
+    if (notifier) {
+      notifier(message, error);
+    } else if (typeof window !== "undefined" && typeof document !== "undefined") {
+      browserToast.error(message);
+    }
+  }
+  return resolved;
+}
+
+// src/sdk/client.ts
+var XMAX_OPEN_API_BASE_URLS = {
+  // 国内 — @xmaxai/sdk
+  cn: "https://cloud.xmax.22duck.cn/open/api/v1",
+  // 海外 — @xmaxai/sdk-global
+  global: "https://api.xmax.cloud/open/api/v1"
+};
+var XMAX_SDK_BUILD_REGION = "cn";
+var XMAX_OPEN_API_PRODUCTION_BASE_URL = XMAX_OPEN_API_BASE_URLS[XMAX_SDK_BUILD_REGION];
+var ACTIVE_STATUS = "ACTIVE";
+var STS_TTL_MS = 30 * 60 * 1e3;
+var STS_REFRESH_BUFFER_MS = 5 * 60 * 1e3;
+function sanitizeFileName(fileName) {
+  return fileName.trim().replace(/[^\w.\-一-龥]/g, "_").replace(/_+/g, "_");
+}
+function buildCosFileUrl(endpoint, bucket, key) {
+  const trimmed = endpoint.trim();
+  const url = new URL(
+    /^https?:\/\//i.test(trimmed) ? trimmed.endsWith("/") ? trimmed : `${trimmed}/` : `https://${trimmed.replace(/^\/+/, "")}${trimmed.endsWith("/") ? "" : "/"}`
+  );
+  if (url.hostname.startsWith("cos.") && !url.hostname.startsWith(`${bucket}.`)) {
+    url.hostname = `${bucket}.${url.hostname}`;
+  }
+  return new URL(key.replace(/^\/+/, ""), url.toString()).toString();
+}
+function resolveCosUploadUrl(raw, sts, key) {
+  const location = raw?.Location?.trim();
+  if (location) {
+    return /^https?:\/\//i.test(location) ? location : `https://${location.replace(/^\/+/, "")}`;
+  }
+  const endpoint = sts.endpoint?.trim();
+  if (endpoint) {
+    return buildCosFileUrl(endpoint, sts.bucket, key);
+  }
+  return `https://${sts.bucket}.cos.${sts.region}.myqcloud.com/${key.replace(/^\/+/, "")}`;
+}
+var XmaxOpenClient = class {
+  constructor(options) {
+    this.stsCache = null;
+    this.heartbeatIntervalId = null;
+    this.suppressErrorNotification = false;
+    this.teardownAbortController = null;
+    this.pendingRequestControllers = /* @__PURE__ */ new Set();
+    const i18n = options.i18n ?? createSDKI18n({ locale: options.locale });
+    if (!options.apiKey?.trim()) {
+      throw new Error(i18n.t("errors.apiKeyEmpty"));
+    }
+    if (!options.baseUrl?.trim()) {
+      throw new Error(i18n.t("errors.baseUrlEmpty"));
+    }
+    this.apiKey = options.apiKey;
+    this.authToken = options.authToken;
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? 1e4;
+    this.i18n = i18n;
+    this.onError = options.onError;
+  }
+  throwError(message, cause) {
+    const error = new Error(message);
+    if (cause !== void 0) {
+      error.cause = cause;
+    }
+    if (this.suppressErrorNotification) {
+      throw error;
+    }
+    throw notifyError(error, this.onError, message);
+  }
+  /** Stop heartbeat, abort in-flight API requests, and suppress error toasts during teardown. */
+  beginTeardown() {
+    this.suppressErrorNotification = true;
+    this.stopHeartbeat();
+    if (this.teardownAbortController) {
+      this.teardownAbortController.abort();
+    }
+    this.teardownAbortController = new AbortController();
+    this.pendingRequestControllers.forEach((controller) => {
+      controller.abort();
+    });
+    this.pendingRequestControllers.clear();
+  }
+  endTeardown() {
+    this.suppressErrorNotification = false;
+    this.teardownAbortController = null;
+  }
+  isAbortError(error) {
+    return error instanceof DOMException && error.name === "AbortError";
+  }
+  async request(method, path, body) {
+    const controller = new AbortController();
+    this.pendingRequestControllers.add(controller);
+    const onAbort = () => controller.abort();
+    this.teardownAbortController?.signal.addEventListener("abort", onAbort);
+    const timeoutId = window.setTimeout(() => controller.abort(), this.timeoutMs);
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "X-Api-Key": this.apiKey
+    };
+    if (this.authToken) {
+      headers["Authorization"] = `Bearer ${this.authToken}`;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}${path}`, {
+        method,
+        headers,
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+      const text = await response.text();
+      let payload;
+      try {
+        payload = text ? JSON.parse(text) : null;
+      } catch (parseError) {
+        throw this.throwError(this.i18n.t("errors.invalidJson"), parseError);
+      }
+      if (typeof payload !== "object" || payload === null) {
+        throw this.throwError(this.i18n.t("errors.invalidPayload"));
+      }
+      const p = payload;
+      if (response.ok && p.success === true) {
+        return p.data;
+      }
+      const mappedMessage = resolveApiErrorMessage(p.code, this.i18n.locale);
+      const errorMessage = mappedMessage ?? this.i18n.t("errors.requestRetry");
+      throw new Error(errorMessage);
+    } catch (error) {
+      if (this.isAbortError(error)) {
+        if (this.suppressErrorNotification) {
+          throw new Error(this.i18n.t("errors.requestTimeout"));
+        }
+        throw this.throwError(this.i18n.t("errors.requestTimeout"), error);
+      } else if (error instanceof Error) {
+        if (this.suppressErrorNotification) {
+          throw error;
+        }
+        throw notifyError(error, this.onError, error.message || this.i18n.t("errors.requestFailed"));
+      } else {
+        throw this.throwError(this.i18n.t("errors.requestFailed"), error);
+      }
+    } finally {
+      this.teardownAbortController?.signal.removeEventListener("abort", onAbort);
+      this.pendingRequestControllers.delete(controller);
+      window.clearTimeout(timeoutId);
+    }
+  }
+  async createSession(model) {
+    if (!model.trim()) {
+      this.throwError(this.i18n.t("errors.modelEmpty"));
+    }
+    return this.request("POST", "/session", { model });
+  }
+  async getSession(sessionUid) {
+    return this.request("GET", `/session/${sessionUid}`);
+  }
+  async heartbeatSession(sessionUid) {
+    return this.request("PUT", `/session/${sessionUid}/heartbeat`);
+  }
+  async closeSession(sessionUid) {
+    const previousSuppress = this.suppressErrorNotification;
+    this.suppressErrorNotification = true;
+    try {
+      return await this.request("DELETE", `/session/${sessionUid}`);
+    } catch {
+      return null;
+    } finally {
+      this.suppressErrorNotification = previousSuppress;
+    }
+  }
+  async getCosSts(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && this.stsCache && now - this.stsCache.fetchedAt < STS_TTL_MS - STS_REFRESH_BUFFER_MS) {
+      return this.stsCache.value;
+    }
+    const sts = await this.request("GET", "/cos/sts");
+    this.stsCache = {
+      value: sts,
+      fetchedAt: now
+    };
+    return sts;
+  }
+  async uploadObject(file, expectedTypePrefix) {
+    if (!(file instanceof File)) {
+      this.throwError(this.i18n.t("errors.invalidFile"));
+    }
+    if (!file.type.startsWith(expectedTypePrefix)) {
+      this.throwError(this.i18n.t("errors.invalidFileType", { type: file.type }));
+    }
+    const sts = await this.getCosSts();
+    const safeFileName = sanitizeFileName(file.name) || "image";
+    const key = `${sts.prefix}${Date.now()}_${safeFileName}`;
+    const cos = new COS({
+      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/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();
+  };
+}
+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 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 VideoRenderMode.RENDER_MODE_HIDDEN;
+  }
+  const rect = container.getBoundingClientRect();
+  if (rect.width <= 0 || rect.height <= 0) {
+    return VideoRenderMode.RENDER_MODE_FIT;
+  }
+  const isCompactPreview = rect.width <= 160;
+  const isPortraitFrame = rect.height > rect.width;
+  return isCompactPreview || isPortraitFrame ? VideoRenderMode.RENDER_MODE_HIDDEN : 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 = VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL;
+    this.shouldMirrorLocalPreview = false;
+    this.externalVideoTrack = null;
+    this.remoteVideoUserId = null;
+    this.pendingRemoteVideoUserId = null;
+    this.pendingRemoteVideoMediaType = MediaType.VIDEO;
+    /** Subscribed to RTC media, but player may still be gated by SEI / container. */
+    this.subscribedRemoteUserId = null;
+    this.subscribedRemoteMediaType = 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(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 = MediaType.VIDEO;
+    this.lastRemoteSei = null;
+    this.lastRemoteSeiUserId = null;
+    this.clearVideoContainers();
+    const engine = VERTC.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: 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(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(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(MediaType.VIDEO);
+    }
+    if (this.localVideoSourceType === 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 = VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL;
+        this.shouldMirrorLocalPreview = false;
+        this.externalVideoTrack = null;
+        this.remoteVideoUserId = null;
+        this.pendingRemoteVideoUserId = null;
+        this.pendingRemoteVideoMediaType = MediaType.VIDEO;
+        this.subscribedRemoteUserId = null;
+        this.subscribedRemoteMediaType = 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(StreamIndex.STREAM_INDEX_MAIN, "video") ?? null;
+    if (!track || track.readyState === "ended") {
+      return { ready: false, frameCount: 0, elapsedMs: 0 };
+    }
+    const { waitForMediaStreamTrackFrames } = await import('./local-publish-diagnostics-ABLL56IT.js');
+    return waitForMediaStreamTrackFrames(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 = MediaType.VIDEO;
+    await this.ensureRemoteStreamSubscribed(botUserId, 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.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.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.events.onConnectionStateChanged, (event) => {
+      this.log("info", this.i18n.t("rtc.connectionStateChanged"), event);
+    });
+    engine.on(VERTC.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.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.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.events.onError, (event) => {
+      this.log("error", this.i18n.t("rtc.error", { code: String(event.errorCode) }), event);
+    });
+    engine.on(VERTC.events.onPublishResult, (event) => {
+      this.debugLog("onPublishResult", {
+        ...event,
+        elapsedSincePublishMs: this.publishStartedAtMs > 0 ? Number((performance.now() - this.publishStartedAtMs).toFixed(1)) : null
+      });
+    });
+    engine.on(VERTC.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.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.events.onLocalStatsException, (exception) => {
+      this.debugLog("onLocalStatsException", {
+        exception,
+        elapsedSincePublishMs: this.publishStartedAtMs > 0 ? Number((performance.now() - this.publishStartedAtMs).toFixed(1)) : null
+      });
+    });
+    engine.on(VERTC.events.onTrackMute, (event) => {
+      this.debugLog("onTrackMute", event);
+    });
+    engine.on(VERTC.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 ? MirrorType.MIRROR_TYPE_RENDER : MirrorType.MIRROR_TYPE_NONE
+    );
+    this.engine?.setLocalVideoPlayer(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(StreamIndex.STREAM_INDEX_MAIN, VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL);
+    await this.engine.setExternalVideoTrack(StreamIndex.STREAM_INDEX_MAIN, track);
+    this.localVideoSourceType = VideoSourceType.VIDEO_SOURCE_TYPE_EXTERNAL;
+  }
+  async switchToInternalVideoSource(shouldSetConfig = true) {
+    if (!this.engine) {
+      return;
+    }
+    if (this.localVideoSourceType === VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL) {
+      return;
+    }
+    await this.engine.setVideoSourceType(StreamIndex.STREAM_INDEX_MAIN, VideoSourceType.VIDEO_SOURCE_TYPE_INTERNAL);
+    this.localVideoSourceType = 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: 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: 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(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(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.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 === MediaType.VIDEO || mediaType === 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/shared/camera-stream.ts
+var CAMERA_ACCESS_ERROR_NAMES = /* @__PURE__ */ new Set([
+  "NotFoundError",
+  "NotAllowedError",
+  "PermissionDeniedError",
+  "NotReadableError",
+  "OverconstrainedError",
+  "ConstraintNotSatisfiedError",
+  "AbortError",
+  "SecurityError"
+]);
+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 isCameraAccessError(error) {
+  return classifyCameraAccessError(error) !== null;
+}
+function classifyCameraAccessError(error) {
+  if (error instanceof DOMException) {
+    switch (error.name) {
+      case "NotFoundError":
+        return "not-found";
+      case "NotAllowedError":
+        return "not-allowed";
+      case "PermissionDeniedError":
+        return "permission-denied";
+      case "NotReadableError":
+        return "in-use";
+      case "OverconstrainedError":
+      case "ConstraintNotSatisfiedError":
+        return "overconstrained";
+      case "TypeError":
+        return "generic";
+      case "AbortError":
+      case "SecurityError":
+        return "generic";
+      default:
+        if (CAMERA_ACCESS_ERROR_NAMES.has(error.name)) {
+          return "generic";
+        }
+        return null;
+    }
+  }
+  if (error instanceof Error) {
+    if (error.message.includes("Camera is not supported")) {
+      return "unsupported";
+    }
+    if (error.message.includes("captureStream is not supported")) {
+      return "capture-unsupported";
+    }
+    if (error.message.includes("No active video track")) {
+      return "in-use";
+    }
+  }
+  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 openNativeCameraStream(options = {}) {
+  const i18n = options.i18n ?? createSDKI18n();
+  const stream = await requestCameraMediaStream({
+    width: options.width ?? 1280,
+    height: options.height ?? 720,
+    frameRate: options.frameRate ?? 30,
+    facingMode: options.facingMode ?? "user"
+  });
+  return createNativeCameraStream(stream, { i18n });
+}
+async function createNativeCameraStream(sourceStream, options = {}) {
+  const i18n = options.i18n ?? createSDKI18n();
+  const sourceTrack = sourceStream.getVideoTracks()[0];
+  if (!sourceTrack) {
+    throw new Error(i18n.t("errors.videoTrackMissing"));
+  }
+  const videoEl = document.createElement("video");
+  videoEl.playsInline = true;
+  videoEl.muted = true;
+  videoEl.autoplay = true;
+  videoEl.srcObject = sourceStream;
+  mountCaptureVideo(videoEl);
+  await new Promise((resolve, reject) => {
+    const onOk = () => {
+      cleanup();
+      resolve();
+    };
+    const onErr = () => {
+      cleanup();
+      reject(new Error(`failed to load video metadata`));
+    };
+    const cleanup = () => {
+      videoEl.removeEventListener("loadedmetadata", onOk);
+      videoEl.removeEventListener("error", onErr);
+    };
+    videoEl.addEventListener("loadedmetadata", onOk, { once: true });
+    videoEl.addEventListener("error", onErr, { once: true });
+  });
+  const playResult = videoEl.play();
+  if (playResult && typeof playResult.then === "function") {
+    await playResult;
+  }
+  const width = videoEl.videoWidth || 0;
+  const height = videoEl.videoHeight || 0;
+  if (!width || !height) {
+    throw new Error(i18n.t("errors.videoTrackMissing"));
+  }
+  const destroy = () => {
+    try {
+      videoEl.pause();
+    } catch {
+    }
+    try {
+      videoTrack.stop();
+    } catch {
+    }
+    try {
+      sourceStream.getTracks().forEach((track) => {
+        if (track.readyState !== "ended") {
+          track.stop();
+        }
+      });
+    } catch {
+    }
+    try {
+      videoEl.srcObject = null;
+      videoEl.remove();
+    } catch {
+    }
+  };
+  const videoTrack = sourceTrack;
+  return {
+    sourceStream,
+    previewStream: sourceStream,
+    // No canvas mirror, preview is the raw stream
+    videoTrack,
+    videoEl,
+    width,
+    height,
+    destroy
+  };
+}
+
+// src/drag/map-viewport.ts
+function clamp(n, min, max) {
+  return Math.min(Math.max(n, min), max);
+}
+function getFitContentRect(rect, targetSize, fitMode = "contain") {
+  const [targetWidth, targetHeight] = targetSize;
+  if (!targetWidth || !targetHeight || !rect.width || !rect.height) {
+    return {
+      left: rect.left,
+      top: rect.top,
+      width: rect.width,
+      height: rect.height
+    };
+  }
+  const scale = fitMode === "cover" ? Math.max(rect.width / targetWidth, rect.height / targetHeight) : Math.min(rect.width / targetWidth, rect.height / targetHeight);
+  const width = targetWidth * scale;
+  const height = targetHeight * scale;
+  return {
+    left: rect.left + (rect.width - width) / 2,
+    top: rect.top + (rect.height - height) / 2,
+    width,
+    height
+  };
+}
+function getContentRect(rect, targetSize) {
+  return getFitContentRect(rect, targetSize, "contain");
+}
+function findDragMediaElement(dragSurface) {
+  const root = dragSurface.parentElement ?? dragSurface;
+  if (typeof root.querySelector !== "function") {
+    return null;
+  }
+  const videoHost = root.querySelector("[data-xmax-remote-video]") ?? root;
+  if (typeof videoHost.querySelector !== "function") {
+    return null;
+  }
+  const media = videoHost.querySelector("video, canvas");
+  return media ?? null;
+}
+function toContentRect(rect) {
+  return {
+    left: rect.left,
+    top: rect.top,
+    width: rect.width,
+    height: rect.height
+  };
+}
+function isMediaInsetInContainer(mediaRect, containerRect) {
+  if (!mediaRect.width || !mediaRect.height || !containerRect.width || !containerRect.height) {
+    return false;
+  }
+  const widthRatio = mediaRect.width / containerRect.width;
+  const heightRatio = mediaRect.height / containerRect.height;
+  return widthRatio < 0.98 || heightRatio < 0.98;
+}
+function resolveMappingContext(dragSurface, targetSize, fitMode = "cover") {
+  const containerRect = dragSurface.getBoundingClientRect();
+  const media = findDragMediaElement(dragSurface);
+  if (media) {
+    const mediaRect = media.getBoundingClientRect();
+    if (mediaRect.width > 0 && mediaRect.height > 0 && isMediaInsetInContainer(mediaRect, containerRect)) {
+      const content2 = toContentRect(mediaRect);
+      return { content: content2, hitRect: content2, source: "media" };
+    }
+  }
+  const content = getFitContentRect(containerRect, targetSize, fitMode);
+  return {
+    content,
+    hitRect: toContentRect(containerRect),
+    source: "fit"
+  };
+}
+function mapViewportPointToCoordinateSpace(e, container, targetSize, options = {}) {
+  const fitMode = options.fitMode ?? "cover";
+  const mirrored = options.mirrored ?? false;
+  const [targetWidth, targetHeight] = targetSize;
+  if (!targetWidth || !targetHeight) {
+    return null;
+  }
+  const { content, hitRect } = resolveMappingContext(container, targetSize, fitMode);
+  if (!content.width || !content.height) {
+    return null;
+  }
+  if (e.clientX < hitRect.left || e.clientY < hitRect.top || e.clientX > hitRect.left + hitRect.width || e.clientY > hitRect.top + hitRect.height) {
+    return null;
+  }
+  const x = Math.round((e.clientX - content.left) * targetWidth / content.width);
+  const y = Math.round((e.clientY - content.top) * targetHeight / content.height);
+  const normalizedX = mirrored ? targetWidth - 1 - x : x;
+  return [
+    clamp(normalizedX, 0, targetWidth - 1),
+    clamp(y, 0, targetHeight - 1)
+  ];
+}
+function mapTargetPointToCanvas(point, container, targetSize, dpr, options = {}) {
+  const fitMode = options.fitMode ?? "cover";
+  const mirrored = options.mirrored ?? false;
+  const containerRect = container.getBoundingClientRect();
+  const [targetWidth, targetHeight] = targetSize;
+  const { content } = resolveMappingContext(container, targetSize, fitMode);
+  if (!targetWidth || !targetHeight || !content.width || !content.height) {
+    return null;
+  }
+  const displayX = mirrored ? targetWidth - 1 - point[0] : point[0];
+  const originX = (content.left - containerRect.left) * dpr;
+  const originY = (content.top - containerRect.top) * dpr;
+  const contentW = content.width * dpr;
+  const contentH = content.height * dpr;
+  return [
+    originX + displayX / targetWidth * contentW,
+    originY + point[1] / targetHeight * contentH
+  ];
+}
+
+// src/drag/drag-track-controller.ts
+function fadeCanvas(ctx) {
+  ctx.save();
+  ctx.globalCompositeOperation = "destination-out";
+  ctx.fillStyle = "rgba(0,0,0,0.06)";
+  ctx.fillRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+  ctx.restore();
+}
+function drawNeon(ctx, segs, container, targetSize, dpr, fitMode, mirrored) {
+  if (segs.length === 0) {
+    return;
+  }
+  const coreW = 3.6 * dpr;
+  const lineW = 10 * dpr;
+  const glowRadius = 28 * dpr;
+  const color = { r: 20, g: 255, b: 80 };
+  const rgba = (a) => `rgba(${color.r},${color.g},${color.b},${a})`;
+  const strokeSegs = (opts) => {
+    ctx.save();
+    ctx.globalCompositeOperation = opts.composite;
+    ctx.lineCap = "round";
+    ctx.lineJoin = "round";
+    ctx.lineWidth = opts.width;
+    ctx.strokeStyle = rgba(opts.alpha);
+    ctx.shadowBlur = opts.shadowBlur;
+    ctx.shadowColor = rgba(opts.shadowAlpha);
+    ctx.beginPath();
+    for (const seg of segs) {
+      const start = mapTargetPointToCanvas(seg.a, container, targetSize, dpr, { fitMode, mirrored });
+      const end = mapTargetPointToCanvas(seg.b, container, targetSize, dpr, { fitMode, mirrored });
+      if (!start || !end) {
+        continue;
+      }
+      ctx.moveTo(start[0], start[1]);
+      ctx.lineTo(end[0], end[1]);
+    }
+    ctx.stroke();
+    ctx.restore();
+  };
+  strokeSegs({
+    width: lineW,
+    shadowBlur: glowRadius,
+    shadowAlpha: 0.9,
+    alpha: 0.45,
+    composite: "lighter"
+  });
+  strokeSegs({
+    width: lineW,
+    shadowBlur: 12 * dpr,
+    shadowAlpha: 0.9,
+    alpha: 0.9,
+    composite: "lighter"
+  });
+  strokeSegs({
+    width: coreW,
+    shadowBlur: 6 * dpr,
+    shadowAlpha: 0.8,
+    alpha: 1,
+    composite: "source-over"
+  });
+  ctx.save();
+  ctx.globalCompositeOperation = "lighter";
+  ctx.fillStyle = rgba(1);
+  ctx.shadowBlur = 10 * dpr;
+  ctx.shadowColor = rgba(0.8);
+  const head = segs[segs.length - 1];
+  if (head) {
+    const headPoint = mapTargetPointToCanvas(head.b, container, targetSize, dpr, { fitMode, mirrored });
+    if (headPoint) {
+      ctx.beginPath();
+      ctx.arc(headPoint[0], headPoint[1], 3.2 * dpr, 0, Math.PI * 2);
+      ctx.fill();
+    }
+  }
+  ctx.restore();
+}
+var DragTrackController = class {
+  constructor(container, options) {
+    this.activePointers = /* @__PURE__ */ new Map();
+    this.lastTargetPoints = /* @__PURE__ */ new Map();
+    this.segQueue = [];
+    this.sampleTimer = null;
+    this.sampleInFlight = false;
+    this.rafId = null;
+    this.resizeObserver = null;
+    this.container = container;
+    this.onTracks = options.onTracks;
+    this.targetSize = options.targetSize;
+    this.fitMode = options.fitMode ?? "cover";
+    this.mirrored = options.mirrored ?? false;
+    this.enabled = options.enabled ?? true;
+    this.emitEmptyTracksWhenIdle = options.emitEmptyTracksWhenIdle ?? false;
+    this.canvas = document.createElement("canvas");
+    this.canvas.className = "Xmax-drag-track-canvas";
+    this.canvas.style.cssText = "position:absolute;inset:0;z-index:21;width:100%;height:100%;pointer-events:none;";
+    container.appendChild(this.canvas);
+    this.onWindowResize = () => this.resizeCanvas();
+    this.onPointerDown = (e) => this.handlePointerDown(e);
+    this.onPointerMove = (e) => this.handlePointerMove(e);
+    this.onPointerUp = (e) => this.handlePointerUp(e);
+    this.onPointerCancel = (e) => this.handlePointerCancel(e);
+    this.resizeCanvas();
+    this.bindResizeObserver();
+    this.bindPointerEvents();
+    this.applyInteractionStyle();
+    if (this.enabled && this.emitEmptyTracksWhenIdle) {
+      this.startSampling();
+    }
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+    this.applyInteractionStyle();
+    if (!enabled) {
+      this.finishStroke({ stopIdleSampling: true });
+      return;
+    }
+    if (this.emitEmptyTracksWhenIdle && this.activePointers.size === 0) {
+      this.startSampling();
+    }
+  }
+  setEmitEmptyTracksWhenIdle(emitEmptyTracksWhenIdle) {
+    if (this.emitEmptyTracksWhenIdle === emitEmptyTracksWhenIdle) {
+      return;
+    }
+    this.emitEmptyTracksWhenIdle = emitEmptyTracksWhenIdle;
+    if (emitEmptyTracksWhenIdle && this.enabled && this.activePointers.size === 0) {
+      this.startSampling();
+      return;
+    }
+    if (!emitEmptyTracksWhenIdle && this.activePointers.size === 0) {
+      this.stopSampling();
+    }
+  }
+  setTargetSize(targetSize) {
+    this.targetSize = targetSize;
+  }
+  setFitMode(fitMode) {
+    this.fitMode = fitMode;
+  }
+  setMirrored(mirrored) {
+    this.mirrored = mirrored;
+  }
+  destroy() {
+    this.finishStroke({ stopIdleSampling: true });
+    this.unbindPointerEvents();
+    this.unbindResizeObserver();
+    this.canvas.remove();
+  }
+  applyInteractionStyle() {
+    this.container.style.pointerEvents = this.enabled ? "auto" : "none";
+    this.container.style.touchAction = this.enabled ? "none" : "auto";
+  }
+  bindResizeObserver() {
+    const ResizeObserverCtor = globalThis.ResizeObserver;
+    if (ResizeObserverCtor) {
+      this.resizeObserver = new ResizeObserverCtor(() => this.resizeCanvas());
+      this.resizeObserver.observe(this.container);
+      return;
+    }
+    window.addEventListener("resize", this.onWindowResize);
+  }
+  unbindResizeObserver() {
+    this.resizeObserver?.disconnect();
+    this.resizeObserver = null;
+    window.removeEventListener("resize", this.onWindowResize);
+  }
+  bindPointerEvents() {
+    this.container.addEventListener("pointerdown", this.onPointerDown);
+    this.container.addEventListener("pointermove", this.onPointerMove);
+    this.container.addEventListener("pointerup", this.onPointerUp);
+    this.container.addEventListener("pointercancel", this.onPointerCancel);
+  }
+  unbindPointerEvents() {
+    this.container.removeEventListener("pointerdown", this.onPointerDown);
+    this.container.removeEventListener("pointermove", this.onPointerMove);
+    this.container.removeEventListener("pointerup", this.onPointerUp);
+    this.container.removeEventListener("pointercancel", this.onPointerCancel);
+    this.activePointers.clear();
+    this.lastTargetPoints.clear();
+    this.sampleInFlight = false;
+  }
+  clearCanvas() {
+    const ctx = this.canvas.getContext("2d");
+    if (!ctx) {
+      return;
+    }
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.clearRect(0, 0, this.canvas.width, this.canvas.height);
+    ctx.restore();
+  }
+  resizeCanvas() {
+    const rect = this.container.getBoundingClientRect();
+    const dpr = window.devicePixelRatio || 1;
+    const cssW = Math.max(1, Math.round(rect.width));
+    const cssH = Math.max(1, Math.round(rect.height));
+    const nextW = Math.max(1, Math.round(cssW * dpr));
+    const nextH = Math.max(1, Math.round(cssH * dpr));
+    if (this.canvas.width !== nextW || this.canvas.height !== nextH) {
+      this.canvas.width = nextW;
+      this.canvas.height = nextH;
+      this.canvas.style.width = `${cssW}px`;
+      this.canvas.style.height = `${cssH}px`;
+      this.clearCanvas();
+    }
+  }
+  toTargetPoint(e) {
+    return mapViewportPointToCoordinateSpace(e, this.container, this.targetSize, {
+      fitMode: this.fitMode,
+      mirrored: this.mirrored
+    });
+  }
+  stopDrawLoop() {
+    if (this.rafId !== null) {
+      window.cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+  }
+  startDrawLoop() {
+    if (this.rafId !== null) {
+      return;
+    }
+    const tick = () => {
+      const ctx = this.canvas.getContext("2d");
+      if (!ctx) {
+        this.rafId = null;
+        return;
+      }
+      const dpr = window.devicePixelRatio || 1;
+      fadeCanvas(ctx);
+      drawNeon(ctx, this.segQueue.splice(0), this.container, this.targetSize, dpr, this.fitMode, this.mirrored);
+      if (this.activePointers.size > 0) {
+        this.rafId = window.requestAnimationFrame(tick);
+      } else {
+        this.rafId = null;
+      }
+    };
+    this.rafId = window.requestAnimationFrame(tick);
+  }
+  stopSampling() {
+    if (this.sampleTimer !== null) {
+      window.clearInterval(this.sampleTimer);
+      this.sampleTimer = null;
+    }
+  }
+  collectCurrentTracks() {
+    const tracks = [];
+    for (const pointer of Array.from(this.activePointers.values())) {
+      const point = this.toTargetPoint(pointer);
+      if (point) {
+        tracks.push(point);
+      }
+    }
+    return tracks;
+  }
+  flushTracks() {
+    if (this.sampleInFlight) {
+      return;
+    }
+    const tracks = this.collectCurrentTracks();
+    if (!tracks.length && !this.emitEmptyTracksWhenIdle) {
+      return;
+    }
+    this.sampleInFlight = true;
+    Promise.resolve(this.onTracks(tracks)).catch(() => {
+    }).finally(() => {
+      this.sampleInFlight = false;
+    });
+  }
+  startSampling() {
+    if (this.sampleTimer !== null) {
+      return;
+    }
+    this.flushTracks();
+    this.sampleTimer = window.setInterval(() => {
+      this.flushTracks();
+    }, 30);
+  }
+  finishStroke(options) {
+    const stopIdleSampling = options?.stopIdleSampling ?? !this.emitEmptyTracksWhenIdle;
+    if (stopIdleSampling) {
+      this.stopSampling();
+    }
+    this.stopDrawLoop();
+    this.segQueue.length = 0;
+    this.clearCanvas();
+  }
+  handlePointerDown(e) {
+    if (!this.enabled) {
+      return;
+    }
+    try {
+      this.container.setPointerCapture(e.pointerId);
+    } catch {
+    }
+    this.resizeCanvas();
+    if (this.activePointers.size === 0) {
+      this.segQueue.length = 0;
+      this.clearCanvas();
+    }
+    this.activePointers.set(e.pointerId, {
+      pointerId: e.pointerId,
+      clientX: e.clientX,
+      clientY: e.clientY
+    });
+    const targetPoint = this.toTargetPoint(e);
+    if (targetPoint) {
+      this.lastTargetPoints.set(e.pointerId, targetPoint);
+    }
+    this.startDrawLoop();
+    this.startSampling();
+  }
+  handlePointerMove(e) {
+    if (!this.enabled || !this.activePointers.has(e.pointerId)) {
+      return;
+    }
+    const nextTargetPoint = this.toTargetPoint(e);
+    const last = this.lastTargetPoints.get(e.pointerId);
+    if (last && nextTargetPoint) {
+      this.segQueue.push({ a: last, b: nextTargetPoint });
+    }
+    if (nextTargetPoint) {
+      this.lastTargetPoints.set(e.pointerId, nextTargetPoint);
+    }
+    this.activePointers.set(e.pointerId, {
+      pointerId: e.pointerId,
+      clientX: e.clientX,
+      clientY: e.clientY
+    });
+  }
+  handlePointerUp(e) {
+    if (!this.activePointers.has(e.pointerId)) {
+      return;
+    }
+    this.activePointers.delete(e.pointerId);
+    this.lastTargetPoints.delete(e.pointerId);
+    try {
+      this.container.releasePointerCapture(e.pointerId);
+    } catch {
+    }
+    if (this.activePointers.size === 0) {
+      this.finishStroke();
+    }
+  }
+  handlePointerCancel(e) {
+    if (!this.activePointers.has(e.pointerId)) {
+      return;
+    }
+    this.activePointers.delete(e.pointerId);
+    this.lastTargetPoints.delete(e.pointerId);
+    if (this.activePointers.size === 0) {
+      this.finishStroke();
+    }
+  }
+};
+function createDragTrackController(container, options) {
+  return new DragTrackController(container, options);
+}
+
+// src/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
+    };
+  }
+};
+
+export { ACTIVE_STATUS, PREVIEW_CONTAIN_ATTR, PREVIEW_COVER_ATTR, PREVIEW_OUTPUT_LAYOUT_ATTR, PREVIEW_UPLOAD_FIT_ATTR, PREVIEW_UPLOAD_LAYOUT_ATTR, PUBLISH_COLD_FRAME_TIMEOUT_MS, PUBLISH_COLD_MIN_FRAMES, PUBLISH_COLD_WARMUP_MS, PUBLISH_START_FRAME_TIMEOUT_MS, PUBLISH_START_MIN_FRAMES, PUBLISH_WARM_SKIP_MS, RtcManager, XMAX_OPEN_API_BASE_URLS, XMAX_OPEN_API_PRODUCTION_BASE_URL, XmaxOpenClient, applyUploadPreviewMediaLayout, browserToast, classifyCameraAccessError, createDragTrackController, createNativeCameraStream, createStartRtcRoomEvent, createStopRtcRoomEvent, createTaskUid, createTracksRtcRoomEvent, getCameraEnvironmentIssue, getContentRect, getFitContentRect, isCameraAccessError, mapTargetPointToCanvas, mapViewportPointToCoordinateSpace, models, notifyError, observeUploadPreviewMediaLayout, openNativeCameraStream, requestCameraMediaStream, stabilizeCameraVideoTrack };
+//# sourceMappingURL=chunk-67XSD3QJ.js.map
+//# sourceMappingURL=chunk-67XSD3QJ.js.map