@limrun/ui 0.17.0-rc.2 → 0.17.0-rc.4

package/dist/remote-control-DBTJWzfs.mjs

@@ -0,0 +1,2671 @@
+import { jsx as k, jsxs as ce, Fragment as Lr } from "react/jsx-runtime";
+import { memo as er, useState as X, useEffect as de, useMemo as Re, useCallback as Nn, lazy as In, forwardRef as Yn, useRef as _, useImperativeHandle as Kn, Suspense as kn } from "react";
+import { createPortal as Pn } from "react-dom";
+import './index.css';function Fr(r) {
+  var t, c, a = "";
+  if (typeof r == "string" || typeof r == "number") a += r;
+  else if (typeof r == "object") if (Array.isArray(r)) {
+    var E = r.length;
+    for (t = 0; t < E; t++) r[t] && (c = Fr(r[t])) && (a && (a += " "), a += c);
+  } else for (c in r) r[c] && (a && (a += " "), a += c);
+  return a;
+}
+function Ne() {
+  for (var r, t, c = 0, a = "", E = arguments.length; c < E; c++) (r = arguments[c]) && (t = Fr(r)) && (a && (a += " "), a += t);
+  return a;
+}
+const Yi = { width: 164.6, height: 117.8, depth: 5.2 };
+function Ki(r, t, c) {
+  return r = Math.max(0, Math.min(1, r)), t = Math.max(0, Math.min(1, t)), c === 1 ? { x: t, y: 1 - r } : c === 2 ? { x: 1 - r, y: 1 - t } : c === 3 ? { x: 1 - t, y: r } : { x: r, y: t };
+}
+function Un(r) {
+  return Number.isFinite(r) && r >= 0 && r <= 180;
+}
+function ki(r, t) {
+  return { x: Math.max(0, Math.min(1, r)), y: Math.max(0, Math.min(1, 1 - t)) };
+}
+function Pi(r, t, c) {
+  return t && (r || !c) ? "touch" : r ? "ignore" : "orbit";
+}
+function Ln(r, t, c, a) {
+  if (!Number.isInteger(r) || r < 0 || r > 3 || !Number.isInteger(t) || t < 1 || t > 255 || !Number.isFinite(c) || !Number.isFinite(a) || c < 0 || c > 1 || a < 0 || a > 1)
+    throw new RangeError("Invalid display touch coordinates");
+  const E = new ArrayBuffer(12), m = new DataView(E);
+  return m.setUint8(0, 19), m.setUint8(1, r), m.setUint8(2, t), m.setFloat32(4, c, !0), m.setFloat32(8, a, !0), E;
+}
+class Ui {
+  constructor(t, c) {
+    this.send = t, this.failed = c;
+  }
+  send;
+  failed;
+  latest;
+  running = !1;
+  stopped = !1;
+  set(t) {
+    this.stopped || !Un(t) || (this.latest = t, this.flush());
+  }
+  stop() {
+    this.stopped = !0, this.latest = void 0;
+  }
+  async flush() {
+    if (!(this.running || this.stopped)) {
+      this.running = !0;
+      try {
+        for (; this.latest !== void 0 && !this.stopped; ) {
+          const t = this.latest;
+          this.latest = void 0, await this.send(t);
+        }
+      } catch (t) {
+        this.latest = void 0, this.stopped || this.failed(t);
+      } finally {
+        this.running = !1;
+      }
+    }
+  }
+}
+const Li = {
+  side: "Sleep/Wake",
+  volumeUp: "Volume Up",
+  volumeDown: "Volume Down"
+};
+class Fi {
+  constructor(t, c) {
+    this.send = t, this.failed = c;
+  }
+  send;
+  failed;
+  held;
+  tail = Promise.resolve();
+  timeout;
+  press(t) {
+    this.held || (this.held = t, this.enqueue(t, !0), this.timeout = setTimeout(() => this.release(), 1e4));
+  }
+  release() {
+    if (!this.held) return;
+    clearTimeout(this.timeout);
+    const t = this.held;
+    this.held = void 0, this.enqueue(t, !1);
+  }
+  enqueue(t, c) {
+    this.tail = this.tail.then(() => this.send(t, c)).catch(this.failed);
+  }
+}
+const Pt = {
+  INJECT_KEYCODE: 0,
+  INJECT_TOUCH_EVENT: 2,
+  // iOS-specific: send two touch points in one message (Option/Alt+drag pinch)
+  INJECT_TWO_FINGER_TOUCH_EVENT: 18,
+  SET_CLIPBOARD: 9
+}, U = {
+  ACTION_DOWN: 0,
+  ACTION_UP: 1,
+  ACTION_MOVE: 2,
+  ACTION_CANCEL: 3,
+  ACTION_POINTER_DOWN: 5,
+  ACTION_POINTER_UP: 6,
+  BUTTON_PRIMARY: 1,
+  BUTTON_SECONDARY: 2,
+  BUTTON_TERTIARY: 4
+}, s = {
+  // Actions
+  ACTION_DOWN: 0,
+  ACTION_UP: 1,
+  // Meta state flags (from android.view.KeyEvent)
+  META_NONE: 0,
+  META_SHIFT_ON: 1,
+  META_ALT_ON: 2,
+  META_CTRL_ON: 4096,
+  // META_CTRL_LEFT_ON | META_CTRL_RIGHT_ON
+  META_META_ON: 65536,
+  KEYCODE_0: 7,
+  KEYCODE_1: 8,
+  KEYCODE_2: 9,
+  KEYCODE_3: 10,
+  KEYCODE_4: 11,
+  KEYCODE_5: 12,
+  KEYCODE_6: 13,
+  KEYCODE_7: 14,
+  KEYCODE_8: 15,
+  KEYCODE_9: 16,
+  DPAD_UP: 19,
+  // KEYCODE_DPAD_UP
+  DPAD_DOWN: 20,
+  // KEYCODE_DPAD_DOWN
+  DPAD_LEFT: 21,
+  // KEYCODE_DPAD_LEFT
+  DPAD_RIGHT: 22,
+  KEYCODE_A: 29,
+  KEYCODE_B: 30,
+  KEYCODE_C: 31,
+  KEYCODE_D: 32,
+  KEYCODE_E: 33,
+  KEYCODE_F: 34,
+  KEYCODE_G: 35,
+  KEYCODE_H: 36,
+  KEYCODE_I: 37,
+  KEYCODE_J: 38,
+  KEYCODE_K: 39,
+  KEYCODE_L: 40,
+  KEYCODE_M: 41,
+  KEYCODE_N: 42,
+  KEYCODE_O: 43,
+  KEYCODE_P: 44,
+  KEYCODE_Q: 45,
+  KEYCODE_R: 46,
+  KEYCODE_S: 47,
+  KEYCODE_T: 48,
+  KEYCODE_U: 49,
+  KEYCODE_V: 50,
+  KEYCODE_W: 51,
+  KEYCODE_X: 52,
+  KEYCODE_Y: 53,
+  KEYCODE_Z: 54,
+  KEYCODE_COMMA: 55,
+  KEYCODE_PERIOD: 56,
+  KEYCODE_ALT_LEFT: 57,
+  KEYCODE_ALT_RIGHT: 58,
+  KEYCODE_SHIFT_LEFT: 59,
+  KEYCODE_SHIFT_RIGHT: 60,
+  KEYCODE_TAB: 61,
+  KEYCODE_SPACE: 62,
+  ENTER: 66,
+  // KEYCODE_ENTER
+  DEL: 67,
+  // KEYCODE_DEL (Backspace)
+  KEYCODE_GRAVE: 68,
+  // `
+  KEYCODE_MINUS: 69,
+  // -
+  KEYCODE_EQUALS: 70,
+  // =
+  KEYCODE_LEFT_BRACKET: 71,
+  // [
+  KEYCODE_RIGHT_BRACKET: 72,
+  // ]
+  KEYCODE_BACKSLASH: 73,
+  // \
+  KEYCODE_SEMICOLON: 74,
+  // ;
+  KEYCODE_APOSTROPHE: 75,
+  // '
+  KEYCODE_SLASH: 76,
+  MENU: 82,
+  KEYCODE_PAGE_UP: 92,
+  KEYCODE_PAGE_DOWN: 93,
+  KEYCODE_ESCAPE: 111,
+  FORWARD_DEL: 112,
+  // KEYCODE_FORWARD_DEL (Delete key)
+  KEYCODE_CTRL_LEFT: 113,
+  KEYCODE_CTRL_RIGHT: 114,
+  KEYCODE_META_LEFT: 117,
+  KEYCODE_META_RIGHT: 118,
+  KEYCODE_MOVE_HOME: 122,
+  KEYCODE_MOVE_END: 123,
+  KEYCODE_INSERT: 124,
+  KEYCODE_F1: 131,
+  KEYCODE_F2: 132,
+  KEYCODE_F3: 133,
+  KEYCODE_F4: 134,
+  KEYCODE_F5: 135,
+  KEYCODE_F6: 136,
+  KEYCODE_F7: 137,
+  KEYCODE_F8: 138,
+  KEYCODE_F9: 139,
+  KEYCODE_F10: 140,
+  KEYCODE_F11: 141,
+  KEYCODE_F12: 142,
+  KEYCODE_NUMPAD_0: 144,
+  KEYCODE_NUMPAD_1: 145,
+  KEYCODE_NUMPAD_2: 146,
+  KEYCODE_NUMPAD_3: 147,
+  KEYCODE_NUMPAD_4: 148,
+  KEYCODE_NUMPAD_5: 149,
+  KEYCODE_NUMPAD_6: 150,
+  KEYCODE_NUMPAD_7: 151,
+  KEYCODE_NUMPAD_8: 152,
+  KEYCODE_NUMPAD_9: 153,
+  KEYCODE_NUMPAD_DIVIDE: 154,
+  KEYCODE_NUMPAD_MULTIPLY: 155,
+  KEYCODE_NUMPAD_SUBTRACT: 156,
+  KEYCODE_NUMPAD_ADD: 157,
+  KEYCODE_NUMPAD_DOT: 158,
+  KEYCODE_NUMPAD_COMMA: 159,
+  KEYCODE_NUMPAD_ENTER: 160,
+  KEYCODE_NUMPAD_EQUALS: 161
+}, xr = {
+  KeyA: s.KEYCODE_A,
+  KeyB: s.KEYCODE_B,
+  KeyC: s.KEYCODE_C,
+  KeyD: s.KEYCODE_D,
+  KeyE: s.KEYCODE_E,
+  KeyF: s.KEYCODE_F,
+  KeyG: s.KEYCODE_G,
+  KeyH: s.KEYCODE_H,
+  KeyI: s.KEYCODE_I,
+  KeyJ: s.KEYCODE_J,
+  KeyK: s.KEYCODE_K,
+  KeyL: s.KEYCODE_L,
+  KeyM: s.KEYCODE_M,
+  KeyN: s.KEYCODE_N,
+  KeyO: s.KEYCODE_O,
+  KeyP: s.KEYCODE_P,
+  KeyQ: s.KEYCODE_Q,
+  KeyR: s.KEYCODE_R,
+  KeyS: s.KEYCODE_S,
+  KeyT: s.KEYCODE_T,
+  KeyU: s.KEYCODE_U,
+  KeyV: s.KEYCODE_V,
+  KeyW: s.KEYCODE_W,
+  KeyX: s.KEYCODE_X,
+  KeyY: s.KEYCODE_Y,
+  KeyZ: s.KEYCODE_Z,
+  Digit0: s.KEYCODE_0,
+  Digit1: s.KEYCODE_1,
+  Digit2: s.KEYCODE_2,
+  Digit3: s.KEYCODE_3,
+  Digit4: s.KEYCODE_4,
+  Digit5: s.KEYCODE_5,
+  Digit6: s.KEYCODE_6,
+  Digit7: s.KEYCODE_7,
+  Digit8: s.KEYCODE_8,
+  Digit9: s.KEYCODE_9,
+  Backquote: s.KEYCODE_GRAVE,
+  Minus: s.KEYCODE_MINUS,
+  Equal: s.KEYCODE_EQUALS,
+  BracketLeft: s.KEYCODE_LEFT_BRACKET,
+  BracketRight: s.KEYCODE_RIGHT_BRACKET,
+  Backslash: s.KEYCODE_BACKSLASH,
+  Semicolon: s.KEYCODE_SEMICOLON,
+  Quote: s.KEYCODE_APOSTROPHE,
+  Comma: s.KEYCODE_COMMA,
+  Period: s.KEYCODE_PERIOD,
+  Slash: s.KEYCODE_SLASH,
+  Space: s.KEYCODE_SPACE,
+  Tab: s.KEYCODE_TAB,
+  Escape: s.KEYCODE_ESCAPE,
+  ArrowUp: s.DPAD_UP,
+  ArrowDown: s.DPAD_DOWN,
+  ArrowLeft: s.DPAD_LEFT,
+  ArrowRight: s.DPAD_RIGHT,
+  Enter: s.ENTER,
+  Backspace: s.DEL,
+  Delete: s.FORWARD_DEL,
+  Home: s.KEYCODE_MOVE_HOME,
+  End: s.KEYCODE_MOVE_END,
+  PageUp: s.KEYCODE_PAGE_UP,
+  PageDown: s.KEYCODE_PAGE_DOWN,
+  Insert: s.KEYCODE_INSERT,
+  F1: s.KEYCODE_F1,
+  F2: s.KEYCODE_F2,
+  F3: s.KEYCODE_F3,
+  F4: s.KEYCODE_F4,
+  F5: s.KEYCODE_F5,
+  F6: s.KEYCODE_F6,
+  F7: s.KEYCODE_F7,
+  F8: s.KEYCODE_F8,
+  F9: s.KEYCODE_F9,
+  F10: s.KEYCODE_F10,
+  F11: s.KEYCODE_F11,
+  F12: s.KEYCODE_F12,
+  ShiftLeft: s.KEYCODE_SHIFT_LEFT,
+  ShiftRight: s.KEYCODE_SHIFT_RIGHT,
+  ControlLeft: s.KEYCODE_CTRL_LEFT,
+  ControlRight: s.KEYCODE_CTRL_RIGHT,
+  AltLeft: s.KEYCODE_ALT_LEFT,
+  AltRight: s.KEYCODE_ALT_RIGHT,
+  MetaLeft: s.KEYCODE_META_LEFT,
+  MetaRight: s.KEYCODE_META_RIGHT,
+  // Windows/Command key
+  ContextMenu: s.MENU,
+  // Often the Menu key
+  // Numpad mappings
+  Numpad0: s.KEYCODE_NUMPAD_0,
+  Numpad1: s.KEYCODE_NUMPAD_1,
+  Numpad2: s.KEYCODE_NUMPAD_2,
+  Numpad3: s.KEYCODE_NUMPAD_3,
+  Numpad4: s.KEYCODE_NUMPAD_4,
+  Numpad5: s.KEYCODE_NUMPAD_5,
+  Numpad6: s.KEYCODE_NUMPAD_6,
+  Numpad7: s.KEYCODE_NUMPAD_7,
+  Numpad8: s.KEYCODE_NUMPAD_8,
+  Numpad9: s.KEYCODE_NUMPAD_9,
+  NumpadDivide: s.KEYCODE_NUMPAD_DIVIDE,
+  NumpadMultiply: s.KEYCODE_NUMPAD_MULTIPLY,
+  NumpadSubtract: s.KEYCODE_NUMPAD_SUBTRACT,
+  NumpadAdd: s.KEYCODE_NUMPAD_ADD,
+  NumpadDecimal: s.KEYCODE_NUMPAD_DOT,
+  NumpadComma: s.KEYCODE_NUMPAD_COMMA,
+  // Some numpads have comma
+  NumpadEnter: s.KEYCODE_NUMPAD_ENTER,
+  NumpadEqual: s.KEYCODE_NUMPAD_EQUALS
+};
+function Yt(r, t, c, a, E, m, C = 1, v = 0, b = 0) {
+  const D = new ArrayBuffer(32), R = new DataView(D);
+  let M = 0;
+  return R.setUint8(M, Pt.INJECT_TOUCH_EVENT), M += 1, R.setUint8(M, r), M += 1, R.setBigInt64(M, BigInt(t), !0), M += 8, R.setInt32(M, Math.round(E), !0), M += 4, R.setInt32(M, Math.round(m), !0), M += 4, R.setUint16(M, c, !0), M += 2, R.setUint16(M, a, !0), M += 2, R.setInt16(M, Math.round(C * 65535), !0), M += 2, R.setInt32(M, v, !0), M += 4, R.setInt32(M, b, !0), D;
+}
+function Fn(r, t, c, a, E, m, C) {
+  const v = new ArrayBuffer(24), b = new DataView(v);
+  let D = 0;
+  return b.setUint8(D, Pt.INJECT_TWO_FINGER_TOUCH_EVENT), D += 1, b.setUint8(D, r), D += 1, b.setInt32(D, Math.round(a), !0), D += 4, b.setInt32(D, Math.round(E), !0), D += 4, b.setInt32(D, Math.round(m), !0), D += 4, b.setInt32(D, Math.round(C), !0), D += 4, b.setUint16(D, t, !0), D += 2, b.setUint16(D, c, !0), D += 2, b.setUint16(D, 0, !0), v;
+}
+function xn(r, t = !0) {
+  const a = new TextEncoder().encode(r), E = new ArrayBuffer(14 + a.length), m = new DataView(E);
+  let C = 0;
+  return m.setUint8(C, Pt.SET_CLIPBOARD), C += 1, m.setBigInt64(C, BigInt(0), !1), C += 8, m.setUint8(C, t ? 1 : 0), C += 1, m.setUint32(C, a.length, !1), C += 4, new Uint8Array(E, C).set(a), E;
+}
+function pt(r, t, c = 0, a = 0) {
+  const E = new ArrayBuffer(14), m = new DataView(E);
+  let C = 0;
+  return m.setUint8(C, Pt.INJECT_KEYCODE), C += 1, m.setUint8(C, r), C += 1, m.setInt32(C, t, !0), C += 4, m.setInt32(C, c, !0), C += 4, m.setInt32(C, a, !0), E;
+}
+const Qt = "Accessibility unavailable on this device.", kt = 500, Wr = (r, t) => Math.abs(r.x - t.x) < 0.5 && Math.abs(r.y - t.y) < 0.5 && Math.abs(r.width - t.width) < 0.5 && Math.abs(r.height - t.height) < 0.5, Wn = (r) => Math.max(0, r.width) * Math.max(0, r.height), Hn = (r) => {
+  const t = r.find((c) => c.frame && c.frame.width > 0 && c.frame.height > 0);
+  return t?.frame ? ((Math.abs(t.frame.x) > 0.5 || Math.abs(t.frame.y) > 0.5) && console.warn(
+    `[ax-tree] iOS root frame is not anchored at (0,0): (${t.frame.x},${t.frame.y}). Element positions may be slightly off from the rendered video.`
+  ), { x: 0, y: 0, width: t.frame.width, height: t.frame.height }) : { x: 0, y: 0, width: 1, height: 1 };
+}, $n = (r) => {
+  const t = {};
+  return typeof r.AXUniqueId == "string" && r.AXUniqueId.length > 0 && (t.AXUniqueId = r.AXUniqueId), typeof r.AXLabel == "string" && r.AXLabel.length > 0 && (t.AXLabel = r.AXLabel), typeof r.type == "string" && r.type.length > 0 && (t.className = r.type), t;
+}, Xn = (r) => {
+  const t = {};
+  for (const [c, a] of Object.entries(r))
+    c !== "children" && (t[c] = a);
+  return t;
+};
+function Bn(r) {
+  const t = Array.isArray(r) ? r : [r], c = Hn(t), a = [], E = (m, C) => {
+    if (a.length >= kt) return;
+    const v = m.frame;
+    if (v && v.width > 0 && v.height > 0 && !Wr(v, c)) {
+      const D = m.role_description || m.role || "", R = (typeof m.AXLabel == "string" ? m.AXLabel : "") || (typeof m.title == "string" ? m.title : "") || "";
+      a.push({
+        id: typeof m.AXUniqueId == "string" && m.AXUniqueId.length > 0 ? m.AXUniqueId : C,
+        path: C,
+        label: R,
+        value: typeof m.AXValue == "string" ? m.AXValue : "",
+        role: D,
+        type: typeof m.type == "string" ? m.type : "",
+        enabled: m.enabled !== !1,
+        focused: m.focused === !0,
+        frame: { x: v.x, y: v.y, width: v.width, height: v.height },
+        selectors: $n(m),
+        raw: Xn(m)
+      });
+    }
+    const b = Array.isArray(m.children) ? m.children : [];
+    for (let D = 0; D < b.length && a.length < kt; D++)
+      E(b[D], `${C}.${D}`);
+  };
+  for (let m = 0; m < t.length && a.length < kt; m++)
+    E(t[m], String(m));
+  return {
+    platform: "ios",
+    screen: { width: c.width, height: c.height },
+    elements: a,
+    capturedAt: Date.now()
+  };
+}
+const qn = (r) => {
+  let t = { x: 0, y: 0, width: 1, height: 1 }, c = 0;
+  for (const a of r) {
+    const E = a.parsedBounds;
+    if (!E) continue;
+    const m = E.right - E.left, C = E.bottom - E.top, v = Math.max(0, m) * Math.max(0, C);
+    v > c && (c = v, t = { x: 0, y: 0, width: m, height: C });
+  }
+  return t;
+}, Vn = (r) => {
+  const t = {};
+  return typeof r.resourceId == "string" && r.resourceId.length > 0 && (t.resourceId = r.resourceId), typeof r.contentDesc == "string" && r.contentDesc.length > 0 && (t.contentDesc = r.contentDesc), typeof r.text == "string" && r.text.length > 0 && (t.text = r.text), typeof r.className == "string" && r.className.length > 0 && (t.className = r.className), t;
+};
+function Gn(r) {
+  const t = qn(r), c = [];
+  for (let a = 0; a < r.length && c.length < kt; a++) {
+    const E = r[a], m = E.parsedBounds;
+    if (!m) continue;
+    const C = Math.max(0, m.right - m.left), v = Math.max(0, m.bottom - m.top);
+    if (C <= 0 || v <= 0) continue;
+    const b = { x: m.left, y: m.top, width: C, height: v };
+    if (Wr(b, { x: 0, y: 0, width: t.width, height: t.height })) continue;
+    const D = E.contentDesc || E.text || "", R = E.className || "";
+    c.push({
+      id: E.resourceId && E.resourceId.length > 0 ? E.resourceId : E.contentDesc && E.contentDesc.length > 0 ? `cd:${E.contentDesc}` : String(a),
+      path: String(a),
+      label: D,
+      value: typeof E.text == "string" ? E.text : "",
+      role: R,
+      type: R,
+      enabled: E.enabled !== !1,
+      focused: E.focused === !0,
+      frame: b,
+      selectors: Vn(E),
+      raw: { ...E }
+    });
+  }
+  return {
+    platform: "android",
+    screen: { width: t.width, height: t.height },
+    elements: c,
+    capturedAt: Date.now()
+  };
+}
+function Jn(r, t) {
+  const c = Math.max(0, r.x), a = Math.max(0, r.y), E = Math.min(t.width, r.x + r.width), m = Math.min(t.height, r.y + r.height), C = Math.max(0, E - c), v = Math.max(0, m - a);
+  return C > 0 && v > 0 ? { x: c, y: a, width: C, height: v } : null;
+}
+function Hr(r, t) {
+  if (r === t) return !0;
+  if (r.id !== t.id || r.path !== t.path || r.label !== t.label || r.value !== t.value || r.role !== t.role || r.type !== t.type || r.enabled !== t.enabled || r.focused !== t.focused) return !1;
+  const c = r.frame, a = t.frame;
+  return c.x === a.x && c.y === a.y && c.width === a.width && c.height === a.height;
+}
+function $r(r, t) {
+  if (r === t) return !0;
+  if (!r || !t || r.platform !== t.platform || r.screen.width !== t.screen.width || r.screen.height !== t.screen.height || r.elements.length !== t.elements.length) return !1;
+  for (let c = 0; c < r.elements.length; c++)
+    if (!Hr(r.elements[c], t.elements[c])) return !1;
+  return !0;
+}
+function zn(r, t, c) {
+  let a = null, E = 1 / 0;
+  for (const m of r.elements) {
+    const C = m.frame;
+    if (t < C.x || c < C.y || t > C.x + C.width || c > C.y + C.height) continue;
+    const v = Wn(C);
+    v < E && (E = v, a = m);
+  }
+  return a;
+}
+function jn(r, t) {
+  if (t === "ios") {
+    if (r.selectors.AXUniqueId)
+      return `client.tapElement({ AXUniqueId: ${JSON.stringify(r.selectors.AXUniqueId)} })`;
+    if (r.selectors.AXLabel) {
+      const c = r.selectors.className ? `, type: ${JSON.stringify(r.selectors.className)}` : "";
+      return `client.tapElement({ AXLabel: ${JSON.stringify(r.selectors.AXLabel)}${c} })`;
+    }
+    return null;
+  }
+  return r.selectors.resourceId ? `client.tap({ selector: { resourceId: ${JSON.stringify(r.selectors.resourceId)} } })` : r.selectors.contentDesc ? `client.tap({ selector: { contentDesc: ${JSON.stringify(r.selectors.contentDesc)} } })` : r.selectors.text ? `client.tap({ selector: { text: ${JSON.stringify(r.selectors.text)} } })` : null;
+}
+function Xr(r) {
+  const t = r.role || r.type || "";
+  if (!t) return "element";
+  let c = t.replace(/^AX/, "");
+  return c.includes(".") && (c = c.split(".").pop()), c === "GenericElement" ? "Element" : (c = c.replace(/([a-z])([A-Z])/g, "$1 $2"), c);
+}
+const Yr = 80;
+function Br(r) {
+  const t = Xr(r), c = r.label || r.value || "";
+  if (!c) return t;
+  const a = c.length > Yr ? c.slice(0, Yr).trimEnd() + "…" : c;
+  return `${t} · ${a}`;
+}
+const Qn = 500, Zn = 2e3, Kr = 5e3, ei = 8e3, ti = 1200, ri = 250, ni = () => `ax-rc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+class ii {
+  platform;
+  send;
+  onSnapshot;
+  onStatusChange;
+  baseIntervalMs;
+  maxBackoffMs;
+  androidElementTreeOptions;
+  pending = /* @__PURE__ */ new Map();
+  running = !1;
+  timer;
+  currentInterval;
+  lastSnapshot = null;
+  // Single-flight: only one outstanding request at a time. Avoids piling
+  // identical requests on a slow server.
+  inflight = !1;
+  // Rate-limit floor for bumpActivity so high-frequency input (drags,
+  // typing) doesn't trigger a request storm.
+  lastBumpAtMs = 0;
+  // Wall-clock timestamp until which we're in "activity boost" mode and
+  // schedule fetches at ACTIVITY_BOOST_INTERVAL_MS instead of the normal
+  // backed-off interval. Set by bumpActivity().
+  boostUntilMs = 0;
+  // Coarse-grained current status; deduplicated before emission so
+  // identical-to-current transitions are no-ops.
+  status = "idle";
+  constructor(t) {
+    this.platform = t.platform, this.send = t.send, this.onSnapshot = t.onSnapshot, this.onStatusChange = t.onStatusChange, this.baseIntervalMs = t.baseIntervalMs ?? Qn, this.maxBackoffMs = t.maxBackoffMs ?? Zn, this.androidElementTreeOptions = t.androidElementTreeOptions, this.currentInterval = this.baseIntervalMs;
+  }
+  start() {
+    this.running || (this.running = !0, this.currentInterval = this.baseIntervalMs, this.boostUntilMs = 0, this.setStatus("starting"), this.runOnce());
+  }
+  stop() {
+    this.running && (this.running = !1, this.timer !== void 0 && (window.clearTimeout(this.timer), this.timer = void 0), this.failAllPending("Inspector stopped"), this.lastSnapshot = null, this.setStatus("idle"), this.onSnapshot(null));
+  }
+  getStatus() {
+    return this.status;
+  }
+  setStatus(t, c) {
+    if (this.status !== t && (this.status = t, !!this.onStatusChange))
+      try {
+        this.onStatusChange(t, c);
+      } catch (a) {
+        console.error("[AxFetcher] onStatusChange threw:", a);
+      }
+  }
+  // Called after any user-driven action that's likely to change the UI
+  // (taps, scrolls, key events, openUrl, app termination, orientation
+  // change, etc.). Has two effects:
+  //
+  //   1. Resets the polling interval to base and triggers an immediate
+  //      fetch (rate-limited so drags / rapid typing don't request-storm).
+  //   2. Enters a brief "boost" window during which scheduleNext() uses a
+  //      shorter interval (ACTIVITY_BOOST_INTERVAL_MS), so we capture the
+  //      mid- and post-animation tree without waiting for the next
+  //      back-off cycle.
+  bumpActivity() {
+    if (!this.running) return;
+    const t = Date.now();
+    this.boostUntilMs = t + ti;
+    const c = Math.max(150, Math.floor(this.baseIntervalMs / 2));
+    if (t - this.lastBumpAtMs < c) {
+      this.currentInterval = this.baseIntervalMs;
+      return;
+    }
+    this.lastBumpAtMs = t, this.currentInterval = this.baseIntervalMs, this.timer !== void 0 && (window.clearTimeout(this.timer), this.timer = void 0), this.inflight || this.runOnce();
+  }
+  // Fire a one-shot fetch independent of the poll loop. Useful for the
+  // imperative refresh() ref method customers may call.
+  //
+  // Goes through the same change-detect path as the regular poll loop —
+  // identical-to-last-snapshot responses do NOT re-emit via onSnapshot, so
+  // a customer calling refresh() in a tight loop doesn't see a stream of
+  // duplicate snapshots. The returned promise still resolves with the
+  // (possibly identical) snapshot for the caller's own use.
+  async refresh() {
+    const t = await this.requestOnce();
+    return this.running && this.deliver(t), t;
+  }
+  // Returns the latest snapshot delivered to onSnapshot. May be stale.
+  getLatest() {
+    return this.lastSnapshot;
+  }
+  // Called by RemoteControl's ws.onmessage when it sees a message type we own.
+  // Returns true when the message was a response we were waiting for.
+  handleMessage(t) {
+    if (!t || typeof t.id != "string") return !1;
+    const c = t.id;
+    if (!this.pending.get(c)) return !1;
+    if (this.platform === "ios") {
+      if (t.type !== "elementTreeResult") return !1;
+      const v = typeof t.error == "string" ? t.error : null;
+      if (v)
+        return this.settleReject(c, new Error(v)), !0;
+      const b = typeof t.json == "string" ? t.json : "";
+      try {
+        const D = JSON.parse(b), R = Bn(D);
+        this.settleResolve(c, R);
+      } catch (D) {
+        this.settleReject(c, D instanceof Error ? D : new Error(String(D)));
+      }
+      return !0;
+    }
+    if (t.type !== "getElementTreeResult") return !1;
+    const E = t.error;
+    if (E && typeof E == "object") {
+      const v = typeof E.message == "string" ? E.message : "getElementTree failed";
+      return this.settleReject(c, new Error(v)), !0;
+    }
+    const m = t.payload, C = Array.isArray(m?.nodes) ? m.nodes : [];
+    try {
+      const v = Gn(C);
+      this.settleResolve(c, v);
+    } catch (v) {
+      this.settleReject(c, v instanceof Error ? v : new Error(String(v)));
+    }
+    return !0;
+  }
+  buildRequest(t) {
+    return this.platform === "ios" ? { type: "elementTree", id: t } : { type: "getElementTree", id: t, ...this.androidElementTreeOptions };
+  }
+  async requestOnce() {
+    const t = ni();
+    return new Promise((c, a) => {
+      const E = window.setTimeout(
+        () => {
+          this.pending.delete(t), a(new Error("elementTree request timed out"));
+        },
+        ei + (this.androidElementTreeOptions?.waitForIdleTimeoutMs ?? 0)
+      );
+      this.pending.set(t, { resolve: c, reject: a, timer: E }), this.send(this.buildRequest(t)) || (window.clearTimeout(E), this.pending.delete(t), a(new Error("elementTree send failed (WebSocket not open)")));
+    });
+  }
+  async runOnce() {
+    if (this.running && !this.inflight) {
+      this.inflight = !0;
+      try {
+        const t = await this.requestOnce();
+        if (!this.running) return;
+        this.deliver(t);
+      } catch (t) {
+        if (!this.running) return;
+        const c = t instanceof Error ? t.message : String(t), a = /unavailable|not (yet )?running|failed|timeout/i.test(c);
+        this.currentInterval = a ? Kr : Math.min(this.currentInterval * 2, this.maxBackoffMs), this.setStatus(a ? "unavailable" : "error", c);
+      } finally {
+        this.inflight = !1, this.scheduleNext();
+      }
+    }
+  }
+  deliver(t) {
+    const c = this.lastSnapshot;
+    if ($r(c, t)) {
+      this.currentInterval = Math.min(this.currentInterval * 2, this.maxBackoffMs), this.lastSnapshot = t, t.errors?.includes(Qt) || this.setStatus("ready");
+      return;
+    }
+    this.lastSnapshot = t, this.currentInterval = this.baseIntervalMs, t.errors?.includes(Qt) ? (this.currentInterval = Kr, this.setStatus("unavailable", Qt)) : this.setStatus("ready"), this.onSnapshot(t);
+  }
+  scheduleNext() {
+    if (!this.running) return;
+    this.timer !== void 0 && window.clearTimeout(this.timer);
+    const t = Date.now() < this.boostUntilMs ? Math.min(ri, this.currentInterval) : this.currentInterval;
+    this.timer = window.setTimeout(() => {
+      this.timer = void 0, this.runOnce();
+    }, t);
+  }
+  settleResolve(t, c) {
+    const a = this.pending.get(t);
+    a && (window.clearTimeout(a.timer), this.pending.delete(t), a.resolve(c));
+  }
+  settleReject(t, c) {
+    const a = this.pending.get(t);
+    a && (window.clearTimeout(a.timer), this.pending.delete(t), a.reject(c));
+  }
+  failAllPending(t) {
+    for (const [c, a] of this.pending.entries())
+      window.clearTimeout(a.timer), a.reject(new Error(t)), this.pending.delete(c);
+  }
+}
+class oi {
+  generation = 0;
+  tail = Promise.resolve();
+  get currentGeneration() {
+    return this.generation;
+  }
+  enqueue(t) {
+    const c = ++this.generation;
+    return this.append(c, t);
+  }
+  /**
+   * Queues related work without superseding an already queued request.
+   *
+   * The operation retains the generation current at enqueue time and becomes
+   * stale if a later camera request increments it before this work starts.
+   */
+  enqueueCurrent(t) {
+    return this.append(this.generation, t);
+  }
+  append(t, c) {
+    const a = {
+      generation: t,
+      isCurrent: () => t === this.generation
+    }, E = this.tail.then(() => c(a));
+    return this.tail = E.catch(() => {
+    }), E;
+  }
+  invalidate() {
+    ++this.generation;
+  }
+}
+function ci(r) {
+  if (!r || typeof r != "object") return null;
+  const t = r;
+  if (t.type !== "cameraRequest" || typeof t.active != "boolean") return null;
+  const c = { active: t.active };
+  return (t.facingMode === "user" || t.facingMode === "environment") && (c.facingMode = t.facingMode), c;
+}
+function si(r) {
+  const t = {
+    frameRate: { ideal: 30, max: 30 }
+  };
+  return r?.facingMode && (t.facingMode = { ideal: r.facingMode }), t;
+}
+function ai(r, t) {
+  return !r || r.facingMode !== t.facingMode;
+}
+function ui(r) {
+  const t = r.getSettings();
+  return {
+    width: t.width,
+    height: t.height,
+    frameRate: t.frameRate,
+    deviceId: t.deviceId,
+    label: r.label || void 0,
+    facingMode: t.facingMode
+  };
+}
+function li(r) {
+  return {
+    type: "cameraResult",
+    granted: !0,
+    camera: ui(r)
+  };
+}
+const di = async (r) => {
+  if (!r) return !1;
+  try {
+    if (typeof navigator < "u" && navigator.clipboard?.writeText)
+      return await navigator.clipboard.writeText(r), !0;
+  } catch {
+  }
+  try {
+    const t = document.createElement("textarea");
+    t.value = r, t.style.position = "fixed", t.style.opacity = "0", document.body.appendChild(t), t.select();
+    const c = document.execCommand("copy");
+    return document.body.removeChild(t), c;
+  } catch {
+    return !1;
+  }
+}, fi = er(
+  function({ element: t, screen: c, highlighted: a, selected: E, selectable: m, onClick: C }) {
+    const v = Jn(t.frame, c);
+    if (!v) return null;
+    const b = Br(t);
+    return /* @__PURE__ */ k(
+      "button",
+      {
+        type: "button",
+        className: Ne("rc-inspect-box", !t.enabled && "rc-inspect-box-disabled"),
+        "data-ax-id": t.id,
+        "data-ax-path": t.path,
+        "data-ax-label": t.label || void 0,
+        "data-ax-role": t.role || void 0,
+        "data-highlighted": a ? "true" : "false",
+        "data-selected": E ? "true" : "false",
+        "aria-label": b,
+        onClick: (D) => {
+          m && (D.preventDefault(), D.stopPropagation(), C(t, { x: D.clientX, y: D.clientY }));
+        },
+        style: {
+          left: `${v.x / c.width * 100}%`,
+          top: `${v.y / c.height * 100}%`,
+          width: `${v.width / c.width * 100}%`,
+          height: `${v.height / c.height * 100}%`
+        }
+      }
+    );
+  },
+  (r, t) => r.highlighted === t.highlighted && r.selected === t.selected && r.selectable === t.selectable && r.screen.width === t.screen.width && r.screen.height === t.screen.height && r.onClick === t.onClick && Hr(r.element, t.element)
+), hi = 260, pi = 220, mi = 6, Ei = 8, gi = er(function({
+  element: t,
+  platform: c,
+  anchor: a,
+  cursorAnchored: E,
+  showActions: m,
+  onTap: C
+}) {
+  const [v, b] = X(null);
+  de(() => {
+    if (!v) return;
+    const B = window.setTimeout(() => b(null), 1100);
+    return () => window.clearTimeout(B);
+  }, [v]);
+  const D = Re(() => {
+    const B = hi, fe = pi, ne = mi, H = Ei, he = typeof window < "u" ? window.innerWidth : 1024, mt = typeof window < "u" ? window.innerHeight : 768, Ye = a.x + ne + B <= he - H, pe = a.y - ne - fe >= H;
+    let x = Ye ? a.x + ne : a.x - ne, Ke = pe ? a.y - ne : a.y + ne;
+    const se = `translate(${Ye ? "0" : "-100%"}, ${pe ? "-100%" : "0"})`;
+    return x = Math.max(H + (Ye ? 0 : B), Math.min(he - H - (Ye ? B : 0), x)), Ke = Math.max(H + (pe ? fe : 0), Math.min(mt - H - (pe ? 0 : fe), Ke)), { left: `${x}px`, top: `${Ke}px`, transform: se };
+  }, [a.x, a.y]), R = Re(() => jn(t, c), [t, c]), M = c === "ios" ? t.selectors.AXUniqueId : t.selectors.resourceId, Z = c === "ios" ? "AXUniqueId" : "resourceId", ge = Nn(async (B, fe) => {
+    if (!B) return;
+    await di(B) && b(fe);
+  }, []), Ce = Xr(t), Ze = t.label || t.value || Ce, Ie = Br(t);
+  return Pn(
+    /* @__PURE__ */ ce(
+      "div",
+      {
+        className: "rc-inspect-card",
+        "data-cursor-anchored": E ? "true" : "false",
+        style: D,
+        onClick: (B) => B.stopPropagation(),
+        onMouseDown: (B) => B.stopPropagation(),
+        onMouseMove: (B) => B.stopPropagation(),
+        children: [
+          /* @__PURE__ */ ce("div", { className: "rc-inspect-card-header", children: [
+            /* @__PURE__ */ k("span", { className: "rc-inspect-card-role", children: Ce }),
+            !t.enabled && /* @__PURE__ */ k("span", { className: "rc-inspect-card-tag", children: "disabled" }),
+            t.focused && /* @__PURE__ */ k("span", { className: "rc-inspect-card-tag rc-inspect-card-tag-blue", children: "focused" })
+          ] }),
+          /* @__PURE__ */ k("p", { className: "rc-inspect-card-title", title: Ie, children: Ze }),
+          M && /* @__PURE__ */ ce("div", { className: "rc-inspect-card-row", children: [
+            /* @__PURE__ */ ce("span", { className: "rc-inspect-card-row-label", children: [
+              Z,
+              ":"
+            ] }),
+            /* @__PURE__ */ k("span", { className: "rc-inspect-card-row-value", children: M })
+          ] }),
+          t.value && t.value !== t.label && /* @__PURE__ */ ce("div", { className: "rc-inspect-card-row", children: [
+            /* @__PURE__ */ k("span", { className: "rc-inspect-card-row-label", children: "value:" }),
+            /* @__PURE__ */ k("span", { className: "rc-inspect-card-row-value", children: t.value })
+          ] }),
+          /* @__PURE__ */ ce("div", { className: "rc-inspect-card-row", children: [
+            /* @__PURE__ */ k("span", { className: "rc-inspect-card-row-label", children: "frame:" }),
+            /* @__PURE__ */ ce("span", { className: "rc-inspect-card-row-value", children: [
+              Math.round(t.frame.width),
+              "×",
+              Math.round(t.frame.height),
+              " @ ",
+              Math.round(t.frame.x),
+              ",",
+              Math.round(t.frame.y)
+            ] })
+          ] }),
+          m && /* @__PURE__ */ ce("div", { className: "rc-inspect-card-actions", children: [
+            /* @__PURE__ */ k(
+              "button",
+              {
+                type: "button",
+                className: "rc-inspect-card-btn rc-inspect-card-btn-primary",
+                onClick: () => C(t, a),
+                children: "Tap"
+              }
+            ),
+            /* @__PURE__ */ k(
+              "button",
+              {
+                type: "button",
+                className: Ne("rc-inspect-card-btn", v === "selector" && "rc-inspect-card-btn-copied"),
+                disabled: !R,
+                title: R ?? "No usable selector for this element",
+                onClick: () => ge(R ?? void 0, "selector"),
+                children: v === "selector" ? "Copied!" : "Copy selector"
+              }
+            ),
+            /* @__PURE__ */ k(
+              "button",
+              {
+                type: "button",
+                className: Ne("rc-inspect-card-btn", v === "id" && "rc-inspect-card-btn-copied"),
+                disabled: !M,
+                title: M ?? `No ${Z}`,
+                onClick: () => ge(M, "id"),
+                children: v === "id" ? "Copied!" : `Copy ${Z}`
+              }
+            )
+          ] })
+        ]
+      }
+    ),
+    document.body
+  );
+}), Ci = er(function({
+  snapshot: t,
+  geometry: c,
+  highlightedId: a,
+  selectedId: E,
+  mode: m,
+  cursorPosition: C,
+  frozenCursorPosition: v,
+  onSelectChange: b,
+  onTapElement: D
+}) {
+  const R = m === "select", M = R ? a !== null && a !== E : a !== null, Z = R ? a ?? E : a, ge = Re(() => {
+    const H = /* @__PURE__ */ new Map();
+    if (!t) return H;
+    for (const he of t.elements) H.set(he.id, he);
+    return H;
+  }, [t]), Ce = Re(() => Z ? ge.get(Z) ?? null : null, [Z, ge]);
+  if (!(!!t && !!c && t.screen.width > 0 && t.screen.height > 0 && t.elements.length > 0)) return null;
+  const Ie = M ? C : v ?? C, B = M, fe = R && !M && E !== null, ne = (H) => {
+    R && H.target === H.currentTarget && b(null, null);
+  };
+  return /* @__PURE__ */ ce(Lr, { children: [
+    /* @__PURE__ */ k(
+      "div",
+      {
+        className: Ne("rc-inspect-overlay", R && "rc-inspect-overlay-select"),
+        style: {
+          left: `${c.left}px`,
+          top: `${c.top}px`,
+          width: `${c.width}px`,
+          height: `${c.height}px`
+        },
+        onClick: ne,
+        children: t.elements.map((H) => /* @__PURE__ */ k(
+          fi,
+          {
+            element: H,
+            screen: t.screen,
+            highlighted: H.id === a,
+            selected: H.id === E,
+            selectable: R,
+            onClick: b
+          },
+          H.id
+        ))
+      }
+    ),
+    Ce && Ie && /* @__PURE__ */ k(
+      gi,
+      {
+        element: Ce,
+        platform: t.platform,
+        anchor: Ie,
+        cursorAnchored: B,
+        showActions: fe,
+        onTap: D
+      }
+    )
+  ] });
+}), yi = In(() => import("./duo-view-BEkVGxom.mjs").then((r) => r.d)), F = (...r) => {
+  window.debugRemoteControl && console.log(...r);
+}, w = (...r) => {
+  window.debugRemoteControl && console.warn(...r);
+}, L = (r, t, ...c) => {
+  if (t)
+    try {
+      t(...c);
+    } catch (a) {
+      console.error(`[RemoteControl] customer callback "${r}" threw:`, a);
+    }
+}, Kt = (r) => Object.entries(U).find(
+  ([c, a]) => c.startsWith("ACTION_") && a === r
+)?.[0] ?? String(r), vi = (r) => r.includes("/android_") ? "android" : "ios", kr = (r, t) => {
+  const c = new URL(r);
+  return c.searchParams.set("token", t), c.toString();
+}, Pr = 1920, Ur = 1200, Zt = 3, Oi = 1e3, _i = 15e3, Di = 3e3, Ti = 4e3, wi = (r, t) => r === Pr && t === Ur || r === Ur && t === Pr, Ai = {
+  ios: {
+    videoBorderRadiusMultiplier: 0.15,
+    loadingLogoSize: "20%",
+    // Video position as percentage of frame dimensions
+    videoPosition: {
+      portrait: { heightMultiplier: 0.9678 },
+      landscape: { widthMultiplier: 0.9678 }
+    }
+  },
+  android: {
+    videoBorderRadiusMultiplier: 0.13,
+    loadingLogoSize: "40%",
+    // Video position as percentage of frame dimensions
+    videoPosition: {
+      portrait: { heightMultiplier: 0.967 },
+      landscape: { widthMultiplier: 0.962 }
+    }
+  }
+};
+function Si(r) {
+  const t = r.code, c = xr[t];
+  if (!c)
+    return w(`Unknown event.code: ${t}, key: ${r.key}`), null;
+  let a = s.META_NONE;
+  const E = t >= "KeyA" && t <= "KeyZ", m = r.getModifierState("CapsLock"), C = r.shiftKey;
+  let v = C;
+  return E && (v = C !== m), v && (a |= s.META_SHIFT_ON), r.ctrlKey && (a |= s.META_CTRL_ON), r.altKey && (a |= s.META_ALT_ON), r.metaKey && (a |= s.META_META_ON), { keycode: c, metaState: a };
+}
+const xi = Yn(
+  ({
+    className: r,
+    url: t,
+    token: c,
+    sessionId: a,
+    openUrl: E,
+    showFrame: m = !0,
+    deviceModel: C,
+    duoModelUrl: v,
+    autoReconnect: b = !1,
+    onTerminated: D,
+    assets: R,
+    onConnectionStateChange: M,
+    inspectMode: Z,
+    onAxSnapshotChange: ge,
+    onInspectSelectionChange: Ce,
+    onAxStatusChange: Ze,
+    axPollIntervalMs: Ie,
+    axMaxBackoffMs: B,
+    androidElementTreeOptions: fe,
+    onCameraDemandChange: ne,
+    onCameraStats: H,
+    microphoneEnabled: he = !1,
+    onMicrophoneStateChange: mt
+  }, Ye) => {
+    const pe = _(null), x = _(null), Ke = _(null), [tr, rr] = X(!1), se = C === "iphone-duo" || tr, et = _(null), [nr, ir] = X(null), [or, cr] = X(), ke = _(
+      /* @__PURE__ */ new Map()
+    ), Ut = (e, o) => new Promise((i, n) => {
+      const l = T.current;
+      if (!l || l.readyState !== WebSocket.OPEN) {
+        n(new Error("Simulator disconnected"));
+        return;
+      }
+      const u = crypto.randomUUID(), f = setTimeout(() => {
+        ke.current.delete(u), n(new Error("Device control timed out"));
+      }, 5e3);
+      ke.current.set(u, { resolve: i, reject: n, timer: f }), l.send(JSON.stringify({ type: e, id: u, ...o }));
+    }), [qr, Lt] = X(!1), [Vr, Et] = X(!1), [Gr, sr] = X(!1), Pe = _(!1), Ft = _(!1), [ar, Jr] = X(!1), [zr, jr] = X(!1), [Qr, Zr] = X(!0), [en, ur] = X({}), T = _(null), W = _(null), P = _(null), Ue = _(void 0), tt = _(void 0), rt = _(void 0), gt = _(void 0), Le = _(void 0), Oe = _(0), Ct = _(0), Fe = _(!1), xt = _(b);
+    xt.current = b;
+    const _e = _(null), ee = _(null), De = _(void 0), Wt = Re(() => new oi(), []), me = _(ne);
+    me.current = ne;
+    const yt = _(H);
+    yt.current = H;
+    const nt = _(null), vt = _(null), Ht = _(he);
+    Ht.current = he;
+    const $t = _(!1), it = _(mt);
+    it.current = mt;
+    const ot = _(null), le = _(null), Ot = _(0), lr = _(Promise.resolve()), xe = _(null), ct = _(!1), ye = _(/* @__PURE__ */ new Map()), Ee = _(/* @__PURE__ */ new Map()), Te = _(/* @__PURE__ */ new Map()), we = _(/* @__PURE__ */ new Map()), J = _(/* @__PURE__ */ new Map()), Ae = _(!1), [tn, rn] = X(!1), q = _(null), We = _(null), st = _({
+      handle: () => {
+      },
+      end: () => {
+      }
+    }), [Se, _t] = X(null), z = _(null), [dr, fr] = X(null), [Xt, at] = X(null), [Bt, Dt] = X(null), [nn, hr] = X(null), [on, pr] = X(null), Tt = _(null), ie = _(void 0), mr = (e) => {
+      Tt.current = e, ie.current === void 0 && (ie.current = window.requestAnimationFrame(() => {
+        ie.current = void 0, pr(Tt.current);
+      }));
+    }, [cn, He] = X(null), $e = _(Z);
+    $e.current = Z;
+    const Xe = _(null);
+    Xe.current = dr;
+    const qt = _(ge);
+    qt.current = ge;
+    const Be = _(Ce);
+    Be.current = Ce;
+    const Er = _(Ze);
+    Er.current = Ze;
+    const gr = _(D);
+    gr.current = D;
+    const Cr = _(M);
+    Cr.current = M;
+    const Vt = _(null), qe = (e) => {
+      Vt.current !== e && (Vt.current = e, L("onConnectionStateChange", Cr.current, e));
+    }, ut = Z === !0 || Z === "hover-only", sn = Z === "hover-only" ? "hover-only" : "select", ae = Re(
+      () => a || Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
+      [a]
+    ), oe = Re(() => vi(t), [t]), Ve = Ai[oe], lt = R?.[oe], yr = oe === "android" && zr ? ar ? lt?.tabletFrameLandscape : lt?.tabletFrame : ar ? lt?.frameLandscape : lt?.frame, vr = lt?.loadingLogo, wt = !se && m && !!yr && (oe !== "ios" || Qr), Y = (e) => {
+      F(e);
+    }, ue = (e) => {
+      !P.current || P.current.readyState !== "open" || (P.current.send(e), z.current?.bumpActivity());
+    }, Or = -10, _r = (e, o) => {
+      const i = dt();
+      if (!i) return;
+      const n = Je(i, e, o);
+      if (!n) return;
+      const { videoX: l, videoY: u, videoWidth: f, videoHeight: p } = n, g = Yt(
+        U.ACTION_DOWN,
+        Or,
+        f,
+        p,
+        l,
+        u,
+        1,
+        U.BUTTON_PRIMARY,
+        U.BUTTON_PRIMARY
+      );
+      g && ue(g), window.setTimeout(() => {
+        const h = Yt(
+          U.ACTION_UP,
+          Or,
+          f,
+          p,
+          l,
+          u,
+          0,
+          U.BUTTON_PRIMARY,
+          U.BUTTON_PRIMARY
+        );
+        h && ue(h);
+      }, 60);
+    }, an = (e, o) => {
+      const i = dt();
+      if (!i || o.screen.width <= 0 || o.screen.height <= 0) return;
+      const n = e.frame.x + e.frame.width / 2, l = e.frame.y + e.frame.height / 2, u = n / o.screen.width * i.actualWidth, f = l / o.screen.height * i.actualHeight, p = i.videoRect.left + i.offsetX + u, g = i.videoRect.top + i.offsetY + f;
+      _r(p, g);
+    }, At = -1, St = -2, Me = -3, Ge = (e, o, i, n, l, u) => {
+      const f = Yt(
+        e,
+        o,
+        i,
+        n,
+        l,
+        u,
+        1,
+        // pressure
+        U.BUTTON_PRIMARY,
+        U.BUTTON_PRIMARY
+      );
+      f && (F("[rc-touch] sendSingleTouch", {
+        action: e,
+        actionName: Kt(e),
+        pointerId: o,
+        x: l,
+        y: u,
+        video: { width: i, height: n }
+      }), ue(f));
+    }, be = (e, o, i) => {
+      if (!i) return;
+      const { videoX: n, videoY: l, videoWidth: u, videoHeight: f } = i;
+      let p = null, g = null, h = 1;
+      const I = U.BUTTON_PRIMARY;
+      switch (o) {
+        case "down":
+          e !== Me && st.current.end(), p = J.current.size === 0 ? U.ACTION_DOWN : U.ACTION_POINTER_DOWN, g = { x: n, y: l }, J.current.set(e, g), e === -1 && x.current?.focus();
+          break;
+        case "move":
+          J.current.has(e) && (p = U.ACTION_MOVE, g = { x: n, y: l }, J.current.set(e, g));
+          break;
+        case "up":
+        case "cancel":
+          J.current.has(e) && (g = J.current.get(e), J.current.delete(e), o === "cancel" ? p = U.ACTION_CANCEL : p = J.current.size === 0 ? U.ACTION_UP : U.ACTION_POINTER_UP);
+          break;
+      }
+      if (p !== null && g !== null) {
+        F("[rc-touch][mouse->touch] sending", {
+          pointerId: e,
+          eventType: o,
+          action: p,
+          actionName: Kt(p),
+          positionToSend: g,
+          video: { width: u, height: f },
+          altHeld: Ae.current,
+          activePointersAfter: Array.from(J.current.entries()).map(([S, $]) => ({
+            id: S,
+            x: $.x,
+            y: $.y
+          }))
+        });
+        const O = Yt(
+          p,
+          e,
+          u,
+          f,
+          g.x,
+          g.y,
+          h,
+          I,
+          I
+        );
+        O && (F("[rc-touch][mouse->touch] buffer", {
+          pointerId: e,
+          actionName: Kt(p),
+          byteLength: O.byteLength
+        }), ue(O));
+      } else (o === "up" || o === "cancel") && J.current.delete(e);
+    }, Gt = (e) => {
+      if (Ae.current !== e && (Ae.current = e, rn(e), e || _t(null), F("[rc-touch][alt] updateAltHeld", {
+        nextHeld: e,
+        activePointerIds: Array.from(J.current.keys())
+      }), oe === "ios" && P.current && P.current.readyState === "open")) {
+        const o = e ? s.ACTION_DOWN : s.ACTION_UP, i = pt(
+          o,
+          s.KEYCODE_ALT_LEFT,
+          0,
+          s.META_NONE
+        );
+        F("[rc-touch][alt] sending Indigo modifier keycode", {
+          action: o,
+          keycode: s.KEYCODE_ALT_LEFT
+        }), i && ue(i);
+      }
+    }, dt = () => {
+      const e = x.current, o = pe.current;
+      if (!e || !o) return null;
+      const i = e.videoWidth, n = e.videoHeight;
+      if (!i || !n) return null;
+      const l = e.getBoundingClientRect(), u = o.getBoundingClientRect(), f = l.width, p = l.height, g = i / n, h = f / p;
+      let I = f, O = p;
+      g > h ? O = f / g : I = p * g;
+      const S = (f - I) / 2, $ = (p - O) / 2;
+      return {
+        videoWidth: i,
+        videoHeight: n,
+        videoRect: l,
+        containerRect: u,
+        actualWidth: I,
+        actualHeight: O,
+        offsetX: S,
+        offsetY: $
+      };
+    }, Je = (e, o, i) => {
+      const n = o - e.videoRect.left - e.offsetX, l = i - e.videoRect.top - e.offsetY, u = Math.max(0, Math.min(e.actualWidth, n)), f = Math.max(0, Math.min(e.actualHeight, l)), p = Math.max(
+        0,
+        Math.min(e.videoWidth, u / e.actualWidth * e.videoWidth)
+      ), g = Math.max(
+        0,
+        Math.min(e.videoHeight, f / e.actualHeight * e.videoHeight)
+      );
+      return {
+        videoX: p,
+        videoY: g,
+        videoWidth: e.videoWidth,
+        videoHeight: e.videoHeight
+      };
+    }, un = (e, o, i) => {
+      const n = o - e.videoRect.left - e.offsetX, l = i - e.videoRect.top - e.offsetY, u = Math.max(0, Math.min(e.actualWidth, n)), f = Math.max(0, Math.min(e.actualHeight, l)), p = Math.max(
+        0,
+        Math.min(e.videoWidth, u / e.actualWidth * e.videoWidth)
+      ), g = Math.max(
+        0,
+        Math.min(e.videoHeight, f / e.actualHeight * e.videoHeight)
+      ), h = e.videoWidth - p, I = e.videoHeight - g, O = e.videoRect.left + e.offsetX, S = e.videoRect.top + e.offsetY, $ = O - e.containerRect.left + u, te = S - e.containerRect.top + f, G = O - e.containerRect.left + (e.actualWidth - u), y = S - e.containerRect.top + (e.actualHeight - f);
+      return {
+        containerX: $,
+        containerY: te,
+        mirrorContainerX: G,
+        mirrorContainerY: y,
+        videoX: p,
+        videoY: g,
+        mirrorVideoX: h,
+        mirrorVideoY: I,
+        videoWidth: e.videoWidth,
+        videoHeight: e.videoHeight
+      };
+    }, ln = (e, o, i, n, l, u, f) => {
+      const p = Fn(e, o, i, n, l, u, f);
+      F("[rc-touch2] sendTwoFingerMessage (iOS)", {
+        actionName: Kt(e),
+        video: { width: o, height: i },
+        p0: { x: n, y: l },
+        p1: { x: u, y: f },
+        byteLength: p.byteLength
+      }), ue(p);
+    }, ze = (e, o, i, n, l, u, f, p, g) => {
+      if (F("[rc-touch2] applyTwoFingerEvent", {
+        platform: oe,
+        eventType: e,
+        video: { width: o, height: i },
+        p0: { x: n, y: l, id: p },
+        p1: { x: u, y: f, id: g }
+      }), e === "down" && st.current.end(), oe === "ios") {
+        const h = e === "down" ? U.ACTION_DOWN : e === "move" ? U.ACTION_MOVE : U.ACTION_UP;
+        ln(h, o, i, n, l, u, f);
+      } else
+        e === "down" ? (Ge(U.ACTION_DOWN, p, o, i, n, l), Ge(U.ACTION_POINTER_DOWN, g, o, i, u, f)) : e === "move" ? (Ge(U.ACTION_MOVE, p, o, i, n, l), Ge(U.ACTION_MOVE, g, o, i, u, f)) : (Ge(U.ACTION_POINTER_UP, g, o, i, u, f), Ge(U.ACTION_UP, p, o, i, n, l));
+    }, dn = (e, o, i) => {
+      if (!Ae.current) {
+        Se !== null && _t(null);
+        return;
+      }
+      const n = un(e, o, i);
+      _t(n);
+    }, fn = (e, o, i) => {
+      const n = Xe.current;
+      if (!n || n.screen.width <= 0 || n.screen.height <= 0) return null;
+      const l = o - e.videoRect.left - e.offsetX, u = i - e.videoRect.top - e.offsetY;
+      if (l < 0 || u < 0 || l > e.actualWidth || u > e.actualHeight) return null;
+      const f = l / e.actualWidth * n.screen.width, p = u / e.actualHeight * n.screen.height;
+      return zn(n, f, p);
+    }, ve = (e) => {
+      if (se) return;
+      e.preventDefault(), e.stopPropagation();
+      const o = dt();
+      if (($e.current === !0 || $e.current === "hover-only") && !("touches" in e))
+        if (e.type === "mousemove") {
+          if (mr({ x: e.clientX, y: e.clientY }), o) {
+            const n = fn(o, e.clientX, e.clientY);
+            at(n?.id ?? null);
+          }
+        } else e.type === "mouseleave" && (mr(null), at(null));
+      if ($e.current !== !0 && (!("touches" in e) && o && (e.type === "mousemove" ? dn(o, e.clientX, e.clientY) : e.type === "mouseleave" && _t(null)), !(!P.current || P.current.readyState !== "open" || !x.current || !o)))
+        if ("touches" in e) {
+          const n = e.touches, l = e.changedTouches;
+          let u;
+          switch (e.type) {
+            case "touchstart":
+              u = "down";
+              break;
+            case "touchmove":
+              u = "move";
+              break;
+            case "touchend":
+              u = "up";
+              break;
+            case "touchcancel":
+              u = "cancel";
+              break;
+            default:
+              return;
+          }
+          if (n.length === 2) {
+            const f = n[0], p = n[1], g = Je(o, f.clientX, f.clientY), h = Je(o, p.clientX, p.clientY);
+            if (!g || !h) return;
+            q.current ? q.current.source === "real-touch" && (q.current.finger0 = { x: g.videoX, y: g.videoY }, q.current.finger1 = { x: h.videoX, y: h.videoY }, ze(
+              "move",
+              g.videoWidth,
+              g.videoHeight,
+              g.videoX,
+              g.videoY,
+              h.videoX,
+              h.videoY,
+              q.current.pointerId0,
+              q.current.pointerId1
+            )) : (q.current = {
+              finger0: { x: g.videoX, y: g.videoY },
+              finger1: { x: h.videoX, y: h.videoY },
+              videoSize: { width: g.videoWidth, height: g.videoHeight },
+              source: "real-touch",
+              pointerId0: f.identifier,
+              pointerId1: p.identifier
+            }, ze(
+              "down",
+              g.videoWidth,
+              g.videoHeight,
+              g.videoX,
+              g.videoY,
+              h.videoX,
+              h.videoY,
+              f.identifier,
+              p.identifier
+            ));
+          } else if (n.length < 2 && q.current?.source === "real-touch") {
+            const f = q.current;
+            ze(
+              "up",
+              f.videoSize.width,
+              f.videoSize.height,
+              f.finger0.x,
+              f.finger0.y,
+              f.finger1.x,
+              f.finger1.y,
+              f.pointerId0,
+              f.pointerId1
+            ), q.current = null;
+            return;
+          } else {
+            if (n.length > 2)
+              return;
+            {
+              const f = l[0];
+              if (f) {
+                const p = Je(o, f.clientX, f.clientY);
+                be(f.identifier, u, p);
+              }
+            }
+          }
+        } else {
+          let l = null;
+          const u = q.current?.source === "alt-mouse";
+          switch (e.type) {
+            case "mousedown":
+              e.button === 0 && (l = "down");
+              break;
+            case "mousemove":
+              (u || J.current.has(-1)) && (l = "move");
+              break;
+            case "mouseup":
+              e.button === 0 && (l = "up");
+              break;
+            case "mouseleave":
+              (u || J.current.has(-1)) && (l = "up");
+              break;
+          }
+          if (l) {
+            const f = Je(o, e.clientX, e.clientY);
+            if (!f)
+              return;
+            F("[rc-touch][mouse] event", {
+              domType: e.type,
+              eventType: l,
+              button: e.button,
+              buttons: e.buttons,
+              client: { x: e.clientX, y: e.clientY },
+              altHeldRef: Ae.current,
+              inTwoFingerMode: u,
+              geometry: {
+                videoX: f.videoX,
+                videoY: f.videoY,
+                videoWidth: f.videoWidth,
+                videoHeight: f.videoHeight
+              },
+              activePointerIds: Array.from(J.current.keys())
+            }), Ae.current || u ? hn(l, f) : be(-1, l, f);
+          }
+        }
+    }, hn = (e, o) => {
+      const { videoX: i, videoY: n, videoWidth: l, videoHeight: u } = o, f = l - i, p = u - n;
+      if (e === "down") {
+        q.current = {
+          finger0: { x: i, y: n },
+          finger1: { x: f, y: p },
+          videoSize: { width: l, height: u },
+          source: "alt-mouse",
+          pointerId0: At,
+          pointerId1: St
+        }, x.current?.focus(), ze(
+          "down",
+          l,
+          u,
+          i,
+          n,
+          f,
+          p,
+          At,
+          St
+        );
+        return;
+      }
+      if (e === "move") {
+        q.current?.source === "alt-mouse" && (q.current.finger0 = { x: i, y: n }, q.current.finger1 = { x: f, y: p }, ze(
+          "move",
+          l,
+          u,
+          i,
+          n,
+          f,
+          p,
+          At,
+          St
+        ));
+        return;
+      }
+      if (e === "up" || e === "cancel") {
+        const g = q.current;
+        if (g?.source === "alt-mouse") {
+          const { finger0: h, finger1: I, videoSize: O } = g;
+          ze(
+            "up",
+            O.width,
+            O.height,
+            h.x,
+            h.y,
+            I.x,
+            I.y,
+            At,
+            St
+          ), q.current = null;
+        }
+        return;
+      }
+    }, pn = 150, Dr = () => {
+      const e = We.current;
+      e && (window.clearTimeout(e.endTimer), be(Me, "up", e.pos), We.current = null);
+    }, mn = (e) => {
+      if (e.ctrlKey || Ae.current || q.current) return;
+      const o = J.current.size;
+      if (o > 1 || o === 1 && !J.current.has(Me)) return;
+      const i = dt();
+      if (!i) return;
+      const n = e.clientX - i.videoRect.left - i.offsetX, l = e.clientY - i.videoRect.top - i.offsetY;
+      if (n < 0 || n > i.actualWidth || l < 0 || l > i.actualHeight)
+        return;
+      const u = Je(i, e.clientX, e.clientY);
+      if (!u) return;
+      e.preventDefault();
+      const f = (e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? i.actualWidth : 1) * (i.videoWidth / i.actualWidth), p = (e.deltaMode === 1 ? 16 : e.deltaMode === 2 ? i.actualHeight : 1) * (i.videoHeight / i.actualHeight), g = -e.deltaX * f, h = -e.deltaY * p, I = (y) => {
+        window.clearTimeout(y.endTimer), y.endTimer = window.setTimeout(Dr, pn);
+      };
+      if (g === 0 && h === 0) {
+        We.current && I(We.current);
+        return;
+      }
+      const O = () => ({
+        videoWidth: u.videoWidth,
+        videoHeight: u.videoHeight,
+        videoX: Math.abs(g) > Math.abs(h) ? Math.min(Math.max(u.videoX, u.videoWidth * 0.2), u.videoWidth * 0.8) : u.videoX,
+        videoY: Math.abs(h) >= Math.abs(g) ? Math.min(Math.max(u.videoY, u.videoHeight * 0.2), u.videoHeight * 0.8) : u.videoY
+      }), S = (y) => ({
+        ...y,
+        videoX: Math.min(Math.max(y.videoX + g, 0), y.videoWidth),
+        videoY: Math.min(Math.max(y.videoY + h, 0), y.videoHeight)
+      });
+      let $ = We.current;
+      if ($)
+        window.clearTimeout($.endTimer);
+      else {
+        const y = O();
+        be(Me, "down", y), $ = { pos: y, endTimer: 0 }, We.current = $;
+      }
+      let te = $.pos, G = S(te);
+      G.videoX === te.videoX && G.videoY === te.videoY && (be(Me, "up", te), te = O(), be(Me, "down", te), G = S(te)), be(Me, "move", G), $.pos = G, I($);
+    };
+    de(() => {
+      st.current = { handle: mn, end: Dr };
+    }), de(() => {
+      const e = pe.current;
+      if (!e) return;
+      const o = (i) => st.current.handle(i);
+      return e.addEventListener("wheel", o, { passive: !1 }), () => {
+        st.current.end(), e.removeEventListener("wheel", o);
+      };
+    }, []), de(() => {
+      const e = (n) => {
+        n.key === "Alt" && Gt(!0);
+      }, o = (n) => {
+        n.key === "Alt" && Gt(!1);
+      }, i = () => {
+        Gt(!1);
+      };
+      return window.addEventListener("keydown", e, !0), window.addEventListener("keyup", o, !0), window.addEventListener("blur", i), () => {
+        window.removeEventListener("keydown", e, !0), window.removeEventListener("keyup", o, !0), window.removeEventListener("blur", i);
+      };
+    }, []);
+    const Mt = (e) => {
+      e.preventDefault(), e.stopPropagation();
+      const o = document.activeElement === x.current || se && document.activeElement === e.currentTarget;
+      if (F("Keyboard event:", {
+        type: e.type,
+        key: e.key,
+        keyCode: e.keyCode,
+        code: e.code,
+        target: e.target.tagName,
+        focused: o
+      }), !o) {
+        w("Simulator input not focused, skipping keyboard event");
+        return;
+      }
+      if (!P.current || P.current.readyState !== "open") {
+        w("Data channel not ready for keyboard event:", P.current?.readyState);
+        return;
+      }
+      if (e.type === "keydown") {
+        if (e.key.toLowerCase() === "v" && (e.metaKey || e.ctrlKey)) {
+          F("Paste shortcut detected"), navigator.clipboard.readText().then((n) => {
+            if (n) {
+              F(
+                "Pasting text via SET_CLIPBOARD:",
+                n.substring(0, 20) + (n.length > 20 ? "..." : "")
+              );
+              const l = xn(n, !0);
+              ue(l);
+            }
+          }).catch((n) => {
+            console.error("Failed to read clipboard contents: ", n);
+          });
+          return;
+        }
+        if (e.key.toLowerCase() === "m" && (e.metaKey || e.ctrlKey)) {
+          F("Menu shortcut detected");
+          const n = pt(
+            s.ACTION_DOWN,
+            s.MENU,
+            0,
+            s.META_NONE
+            // Modifiers are handled by the shortcut check, not passed down
+          );
+          ue(n);
+          const l = pt(
+            s.ACTION_UP,
+            s.MENU,
+            0,
+            s.META_NONE
+          );
+          ue(l);
+          return;
+        }
+      }
+      const i = Si(e);
+      if (i) {
+        const { keycode: n, metaState: l } = i, u = e.type === "keydown" ? s.ACTION_DOWN : s.ACTION_UP;
+        F(`Sending Keycode: key=${e.key}, code=${n}, action=${u}, meta=${l}`);
+        const f = pt(
+          u,
+          n,
+          0,
+          // repeat count, typically 0 for single presses
+          l
+        );
+        ue(f);
+      } else
+        F(`Ignoring unhandled key event: type=${e.type}, key=${e.key}`);
+    }, En = () => {
+      T.current && T.current.readyState === WebSocket.OPEN && T.current.send(
+        JSON.stringify({
+          type: "keepAlive",
+          sessionId: ae
+        })
+      );
+    }, Tr = () => {
+      Ue.current && window.clearInterval(Ue.current), Ue.current = window.setInterval(En, 1e4);
+    }, wr = () => {
+      Ue.current && (window.clearInterval(Ue.current), Ue.current = void 0);
+    }, bt = () => {
+      tt.current && (window.clearTimeout(tt.current), tt.current = void 0);
+    }, Rt = () => {
+      rt.current && (window.clearTimeout(rt.current), rt.current = void 0);
+    }, ft = () => {
+      gt.current && (window.clearInterval(gt.current), gt.current = void 0);
+    }, ht = () => {
+      Le.current !== void 0 && (window.clearTimeout(Le.current), Le.current = void 0);
+    }, gn = () => {
+      ct.current || (ct.current = !0, ft(), Lt(!0), qe("connected"));
+    }, j = (e) => {
+      for (const o of e.getTracks())
+        try {
+          o.stop();
+        } catch (i) {
+          w("track.stop() failed:", i);
+        }
+    }, Cn = () => {
+      const e = ee.current;
+      e && (ee.current = null, j(e));
+    }, Ar = (e) => {
+      const o = lr.current.then(e).catch((i) => {
+        w("microphone operation failed:", i);
+      });
+      return lr.current = o, o;
+    }, Jt = () => Ht.current || $t.current, Sr = (e) => {
+      const o = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+      xe.current = o, e.send(JSON.stringify({ type: "microphoneStart", id: o }));
+    }, zt = () => Ar(() => yn()), yn = async () => {
+      const e = Ot.current, o = () => e === Ot.current && Jt(), i = (p) => {
+        L("onMicrophoneStateChange", it.current, {
+          active: !1,
+          error: p
+        });
+      };
+      if (!o()) return;
+      const n = T.current, l = ot.current;
+      if (!n || n.readyState !== WebSocket.OPEN || !l || le.current) return;
+      if (!navigator.mediaDevices || typeof navigator.mediaDevices.getUserMedia != "function") {
+        console.warn(
+          "[RemoteControl] navigator.mediaDevices.getUserMedia unavailable. getUserMedia requires a secure context (https or http://localhost)."
+        ), i("Microphone capture requires a secure context (https)");
+        return;
+      }
+      let u = null;
+      try {
+        u = await navigator.mediaDevices.getUserMedia({ audio: !0, video: !1 });
+      } catch (p) {
+        console.warn("[RemoteControl] microphone getUserMedia denied/failed:", p);
+      }
+      if (!o()) {
+        u && j(u);
+        return;
+      }
+      if (!u) {
+        i("Microphone permission denied or no device available");
+        return;
+      }
+      const f = u.getAudioTracks()[0] ?? null;
+      if (!f) {
+        j(u), i("Captured stream has no audio track");
+        return;
+      }
+      try {
+        await l.replaceTrack(f);
+      } catch (p) {
+        w("replaceTrack(audioTrack) failed:", p), j(u), i("Failed to attach the microphone track to the connection");
+        return;
+      }
+      if (!o()) {
+        try {
+          await l.replaceTrack(null);
+        } catch (p) {
+          w("replaceTrack(null) on stale mic attach failed:", p);
+        }
+        j(u);
+        return;
+      }
+      le.current = u, f.onended = () => {
+        le.current === u && Nt("microphone capture ended by the browser");
+      }, Sr(n), L("onMicrophoneStateChange", it.current, {
+        active: !0,
+        label: f.label || void 0
+      });
+    }, Nt = (e) => (++Ot.current, xe.current = null, Ar(async () => {
+      const o = ot.current, i = le.current;
+      if (le.current = null, o && i)
+        try {
+          await o.replaceTrack(null);
+        } catch (l) {
+          w("replaceTrack(null) on mic detach failed:", l);
+        }
+      i && j(i);
+      const n = T.current;
+      if (i && n && n.readyState === WebSocket.OPEN) {
+        const l = `ui-mic-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+        n.send(JSON.stringify({ type: "microphoneStop", id: l }));
+      }
+      (i || e) && L("onMicrophoneStateChange", it.current, {
+        active: !1,
+        ...e !== void 0 && { error: e }
+      });
+    })), Mr = (e, o) => {
+      let i;
+      try {
+        i = li(o), console.info(
+          `[RemoteControl] camera capture: ${i.camera?.width}x${i.camera?.height} @ ${i.camera?.frameRate ?? "?"}fps` + (i.camera?.label ? ` — ${i.camera.label}` : "")
+        );
+      } catch (n) {
+        w("getSettings() on outbound camera track failed:", n), i = {
+          type: "cameraResult",
+          granted: !0,
+          camera: {
+            label: o.label || void 0
+          }
+        };
+      }
+      e.send(JSON.stringify(i)), L("onCameraDemandChange", me.current, !0, !0, i.camera);
+    }, vn = (e) => {
+      if (!e) return;
+      const o = e.indexOf("/"), n = (o >= 0 ? e.slice(o + 1) : e).toUpperCase();
+      return n === "HEVC" ? "H265" : n;
+    }, On = async () => {
+      const e = _e.current, o = yt.current;
+      if (!e || !o) return;
+      let i;
+      try {
+        i = await e.getStats();
+      } catch {
+        return;
+      }
+      let n, l, u;
+      if (i.forEach((S) => {
+        S.type === "outbound-rtp" && S.kind === "video" ? n = S : S.type === "remote-inbound-rtp" && S.kind === "video" && (u = S);
+      }), n?.codecId) {
+        const S = i.get(n.codecId);
+        S && (l = S.mimeType);
+      }
+      if (!n) return;
+      const f = n.timestamp ?? Date.now(), p = vt.current;
+      let g, h, I;
+      if (p && f > p.timestamp) {
+        const S = (f - p.timestamp) / 1e3;
+        if (typeof n.framesEncoded == "number" && typeof p.framesEncoded == "number" && (g = Math.max(0, (n.framesEncoded - p.framesEncoded) / S)), typeof n.bytesSent == "number" && typeof p.bytesSent == "number" && (h = Math.max(0, (n.bytesSent - p.bytesSent) * 8 / S)), typeof n.packetsSent == "number" && typeof p.packetsSent == "number" && u && typeof u.packetsLost == "number" && typeof p.packetsLost == "number") {
+          const $ = n.packetsSent - p.packetsSent, te = u.packetsLost - p.packetsLost;
+          $ > 0 && (I = Math.max(0, Math.min(100, te / $ * 100)));
+        }
+      }
+      vt.current = {
+        timestamp: f,
+        framesEncoded: n.framesEncoded,
+        bytesSent: n.bytesSent,
+        packetsSent: n.packetsSent,
+        packetsLost: u?.packetsLost
+      };
+      const O = {
+        codec: vn(l),
+        encoderImplementation: n.encoderImplementation,
+        hardwareAccelerated: typeof n.powerEfficientEncoder == "boolean" ? n.powerEfficientEncoder : void 0,
+        framesPerSecond: g,
+        framesEncoded: n.framesEncoded,
+        bitrateBps: h,
+        width: n.frameWidth,
+        height: n.frameHeight,
+        qualityLimitationReason: n.qualityLimitationReason,
+        rttMs: typeof u?.roundTripTime == "number" ? u.roundTripTime * 1e3 : void 0,
+        packetsLostPct: I
+      };
+      L("onCameraStats", yt.current, O);
+    }, br = () => {
+      nt.current === null && (vt.current = null, nt.current = setInterval(() => {
+        On();
+      }, 1e3));
+    }, It = () => {
+      nt.current !== null && (clearInterval(nt.current), nt.current = null), vt.current = null, L("onCameraStats", yt.current, null);
+    }, _n = (e, o, i, n) => Wt.enqueue(async ({ isCurrent: l }) => {
+      const u = () => l() && n() && T.current === o && _e.current === i;
+      if (!u()) return;
+      if (!e.active) {
+        const O = ee.current;
+        try {
+          await i.replaceTrack(null);
+        } catch (S) {
+          w("replaceTrack(null) on camera detach failed:", S);
+        }
+        if (ee.current === O && (ee.current = null, De.current = void 0, O && j(O)), It(), !u()) return;
+        L("onCameraDemandChange", me.current, !1);
+        return;
+      }
+      L("onCameraDemandChange", me.current, !0);
+      const f = ee.current, p = f?.getVideoTracks()[0], g = De.current;
+      if (p?.readyState === "live" && g && !ai(g, e)) {
+        De.current = e, Mr(o, p), br();
+        return;
+      }
+      if (f) {
+        try {
+          await i.replaceTrack(null);
+        } catch (O) {
+          w("replaceTrack(null) before camera switch failed:", O);
+        }
+        if (ee.current === f && (ee.current = null, De.current = void 0, j(f)), It(), !u()) return;
+      }
+      if (!navigator.mediaDevices || typeof navigator.mediaDevices.getUserMedia != "function") {
+        if (console.warn(
+          "[RemoteControl] navigator.mediaDevices.getUserMedia unavailable. getUserMedia requires a secure context (https or http://localhost). Replying cameraResult granted=false so limulator falls back to black frames."
+        ), !u()) return;
+        o.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", me.current, !0, !1);
+        return;
+      }
+      let h = null;
+      try {
+        h = await navigator.mediaDevices.getUserMedia({
+          video: si(e),
+          audio: !1
+        });
+      } catch (O) {
+        console.warn("[RemoteControl] getUserMedia denied/failed:", O);
+      }
+      if (!u()) {
+        h && j(h);
+        return;
+      }
+      if (!h) {
+        o.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", me.current, !0, !1);
+        return;
+      }
+      const I = h.getVideoTracks()[0] ?? null;
+      if (!I) {
+        if (j(h), !u()) return;
+        o.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", me.current, !0, !1);
+        return;
+      }
+      try {
+        I.contentHint = "motion";
+      } catch {
+      }
+      try {
+        await i.replaceTrack(I);
+      } catch (O) {
+        if (w("replaceTrack(videoTrack) failed:", O), j(h), !u()) return;
+        o.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", me.current, !0, !1);
+        return;
+      }
+      if (!u()) {
+        try {
+          await i.replaceTrack(null);
+        } catch (O) {
+          w("replaceTrack(null) for stale camera attach failed:", O);
+        }
+        j(h);
+        return;
+      }
+      try {
+        const O = i.getParameters();
+        (!O.encodings || O.encodings.length === 0) && (O.encodings = [{}]), O.encodings[0].maxBitrate = 8e6, O.encodings[0].maxFramerate = 30, O.degradationPreference = "maintain-framerate", await i.setParameters(O);
+      } catch (O) {
+        w("setParameters on outbound camera failed:", O);
+      }
+      if (!u()) {
+        try {
+          await i.replaceTrack(null);
+        } catch (O) {
+          w("replaceTrack(null) for stale camera finalize failed:", O);
+        }
+        j(h);
+        return;
+      }
+      ee.current = h, De.current = e, I.onended = () => {
+        ee.current === h && Wt.enqueueCurrent(async ({ isCurrent: O }) => {
+          if (!(!O() || ee.current !== h || !n() || T.current !== o || _e.current !== i)) {
+            try {
+              await i.replaceTrack(null);
+            } catch (S) {
+              w("replaceTrack(null) after camera ended failed:", S);
+            }
+            !O() || ee.current !== h || !n() || T.current !== o || _e.current !== i || (ee.current = null, De.current = void 0, j(h), It(), o.send(JSON.stringify({ type: "cameraResult", granted: !1 })), L("onCameraDemandChange", me.current, !0, !1));
+          }
+        }).catch((O) => w("camera ended cleanup failed:", O));
+      }, u() && (Mr(o, I), br());
+    }), je = () => {
+      for (const e of ke.current.values())
+        clearTimeout(e.timer), e.reject(new Error("Simulator disconnected"));
+      ke.current.clear(), ir(null), et.current && (et.current.srcObject = null), Rt(), ht(), ft(), z.current && (z.current.stop(), z.current = null), Wt.invalidate(), It(), Cn(), De.current = void 0, _e.current = null, ++Ot.current, $t.current = !1, xe.current = null, le.current && (j(le.current), le.current = null, L("onMicrophoneStateChange", it.current, {
+        active: !1
+      })), ot.current = null, ie.current !== void 0 && (window.cancelAnimationFrame(ie.current), ie.current = void 0), T.current && (T.current.onopen = null, T.current.onmessage = null, T.current.onerror = null, T.current.onclose = null, T.current.close(), T.current = null), W.current && (W.current.onconnectionstatechange = null, W.current.oniceconnectionstatechange = null, W.current.ontrack = null, W.current.onicecandidate = null, W.current.close(), W.current = null), x.current && (x.current.srcObject = null), P.current && (P.current.onopen = null, P.current.onclose = null, P.current.onerror = null, P.current.close(), P.current = null);
+    }, Rr = () => {
+      document.hidden ? wr() : Tr();
+    }, Dn = async () => {
+      if (typeof navigator < "u" && navigator.onLine === !1)
+        return !1;
+      let e;
+      try {
+        const n = new URL(t);
+        n.protocol = n.protocol === "wss:" ? "https:" : n.protocol === "ws:" ? "http:" : n.protocol, e = kr(n.toString(), c);
+      } catch {
+        return !1;
+      }
+      const o = new AbortController(), i = window.setTimeout(() => o.abort(), Ti);
+      try {
+        return (await fetch(e, { method: "GET", cache: "no-store", signal: o.signal })).status === 404;
+      } catch {
+        return !1;
+      } finally {
+        window.clearTimeout(i);
+      }
+    }, Tn = () => {
+      Pe.current || (Pe.current = !0, sr(!0), Et(!1), Oe.current += 1, bt(), Rt(), ht(), je(), Y("Instance terminated"), qe("terminated"), L("onTerminated", gr.current));
+    }, wn = () => {
+      Pe.current || Ft.current || (Ft.current = !0, Dn().then((e) => {
+        Ft.current = !1, e && Tn();
+      }));
+    }, Qe = (e, o) => {
+      if (Pe.current || o !== Oe.current)
+        return;
+      if (wn(), Fe.current) {
+        if (!xt.current) {
+          Y(`Connection failed after it was established: ${e}`), Et(!0), qe("failed"), je();
+          return;
+        }
+        Y(`Reconnecting after established session dropped: ${e}`), Fe.current = !1, Ct.current = -1;
+      }
+      bt();
+      const i = Ct.current + 1;
+      if (i >= Zt) {
+        Y(`Connection failed after ${Zt} attempts: ${e}`), Et(!0), qe("failed"), je();
+        return;
+      }
+      Y(`Retrying connection (${i + 1}/${Zt})`), qe("reconnecting"), je(), tt.current = window.setTimeout(() => {
+        tt.current = void 0, o === Oe.current && Nr(i);
+      }, Oi);
+    }, Nr = async (e = 0) => {
+      if (Pe.current) return;
+      const o = Oe.current + 1;
+      Oe.current = o, Ct.current = e, Fe.current = !1, Et(!1), e === 0 && Vt.current !== "reconnecting" && qe("connecting"), bt(), Rt(), ft(), ct.current = !1, Lt(!1), je();
+      const i = () => o === Oe.current;
+      rt.current = window.setTimeout(() => {
+        rt.current = void 0, !(!i() || Fe.current) && Qe("Connection did not succeed within 15 seconds", o);
+      }, _i);
+      try {
+        const n = new WebSocket(kr(t, c));
+        if (T.current = n, await new Promise((y, d) => {
+          let K = !1;
+          const Q = window.setTimeout(() => d(new Error("WebSocket connection timeout")), 3e4), A = (N) => {
+            K || (K = !0, window.clearTimeout(Q), N());
+          };
+          n.onopen = () => {
+            !i() || T.current !== n || A(y);
+          }, n.onerror = (N) => {
+            !i() || T.current !== n || (Y("WebSocket error: " + N), A(() => d(new Error("WebSocket connection failed"))));
+          }, n.onclose = () => {
+            !i() || T.current !== n || (Y("WebSocket closed"), A(() => d(new Error("WebSocket closed before connection was established"))));
+          };
+        }), !i() || T.current !== n)
+          return;
+        n.onerror = (y) => {
+          !i() || T.current !== n || Y("WebSocket error: " + y);
+        }, n.onclose = () => {
+          !i() || T.current !== n || Y("WebSocket closed");
+        };
+        const l = new Promise((y, d) => {
+          const K = (N) => {
+            window.clearTimeout(Q), n.removeEventListener("message", A), N();
+          }, Q = window.setTimeout(
+            () => K(() => d(new Error("RTCConfiguration timeout"))),
+            3e4
+          ), A = (N) => {
+            if (!(!i() || T.current !== n))
+              try {
+                const V = JSON.parse(N.data);
+                if (V.type === "signalingError" && V.requestType === "requestRtcConfiguration" && V.sessionId === ae) {
+                  const re = typeof V.error == "string" ? V.error : "Unable to load streaming configuration";
+                  K(() => d(new Error(re)));
+                } else V.type === "rtcConfiguration" && K(
+                  () => y({
+                    rtcConfiguration: V.rtcConfiguration,
+                    cameraSupported: V.cameraSupported === !0,
+                    foldSupported: V.foldSupported === !0
+                  })
+                );
+              } catch (V) {
+                console.error("Error handling RTC configuration:", V), K(() => d(V));
+              }
+          };
+          n.addEventListener("message", A), n.send(
+            JSON.stringify({
+              type: "requestRtcConfiguration",
+              sessionId: ae
+            })
+          );
+        }), {
+          rtcConfiguration: u,
+          cameraSupported: f,
+          foldSupported: p
+        } = await l;
+        if (!i() || T.current !== n)
+          return;
+        const g = C === "iphone-duo" || p;
+        rr(g);
+        const h = new RTCPeerConnection(u);
+        W.current = h, h.addTransceiver("audio", { direction: "recvonly" });
+        const I = h.addTransceiver("video", { direction: "recvonly" }), O = g ? h.addTransceiver("video", { direction: "recvonly" }) : null, S = oe === "ios" || f, $ = S ? h.addTransceiver("video", {
+          direction: "sendonly"
+        }) : null;
+        _e.current = $?.sender ?? null;
+        const te = S ? h.addTransceiver("audio", {
+          direction: "sendonly"
+        }) : null;
+        if (ot.current = te?.sender ?? null, RTCRtpReceiver.getCapabilities) {
+          const y = RTCRtpReceiver.getCapabilities("video");
+          if (y && y.codecs) {
+            const K = y.codecs.sort((Q, A) => {
+              const N = (V) => {
+                const re = V.mimeType.toLowerCase();
+                return re.includes("vp9") ? 1 : re.includes("h265") || re.includes("hevc") ? 2 : re.includes("h264") || re.includes("avc") ? 3 : 4;
+              };
+              return N(Q) - N(A);
+            });
+            I.setCodecPreferences(K), O?.setCodecPreferences(K), F("Set codec preferences:", K.map((Q) => Q.mimeType).join(", "));
+          }
+        }
+        if ($ && RTCRtpSender.getCapabilities) {
+          const y = RTCRtpSender.getCapabilities("video");
+          if (y && y.codecs) {
+            const d = /* @__PURE__ */ new Set(["42e01f", "42e028", "640c1f"]), K = (A) => {
+              const N = A.mimeType.toLowerCase(), re = (A.sdpFmtpLine || "").toLowerCase().match(/profile-level-id=([0-9a-f]{6})/), Rn = re ? re[1] : "";
+              return N === "video/h265" || N === "video/hevc" ? 1 : N === "video/h264" && d.has(Rn) ? 2 : N === "video/h264" ? 3 : N === "video/vp9" ? 4 : N === "video/vp8" ? 5 : N === "video/rtx" || N === "video/red" || N === "video/ulpfec" ? 0 : 6;
+            }, Q = [...y.codecs].sort((A, N) => K(A) - K(N));
+            try {
+              $.setCodecPreferences(Q), F(
+                "Outbound camera codec preferences:",
+                Q.map((A) => `${A.mimeType}${A.sdpFmtpLine ? `[${A.sdpFmtpLine}]` : ""}`).join(", ")
+              );
+            } catch (A) {
+              w("Failed to set outbound camera codec preferences:", A);
+            }
+          }
+        }
+        const G = h.createDataChannel("control", {
+          ordered: !0,
+          negotiated: !0,
+          id: 1
+        });
+        if (P.current = G, G.onopen = () => {
+          if (!i() || P.current !== G || T.current !== n)
+            return;
+          Fe.current = !0, Rt(), Y("Control channel opened"), g && n.send(JSON.stringify({ type: "getFoldState", id: "duo-capabilities" })), z.current || (z.current = new ii({
+            platform: oe,
+            baseIntervalMs: Ie,
+            maxBackoffMs: B,
+            androidElementTreeOptions: fe,
+            send: (d) => {
+              if (!T.current || T.current.readyState !== WebSocket.OPEN) return !1;
+              try {
+                return T.current.send(JSON.stringify(d)), !0;
+              } catch {
+                return !1;
+              }
+            },
+            onSnapshot: (d) => {
+              fr((K) => $r(K, d) ? K : d), queueMicrotask(() => {
+                L("onAxSnapshotChange", qt.current, d);
+              });
+            },
+            onStatusChange: (d, K) => {
+              L("onAxStatusChange", Er.current, d, K);
+            }
+          }), ($e.current === !0 || $e.current === "hover-only") && z.current.start());
+          const y = () => {
+            !i() || ct.current || P.current !== G || T.current !== n || n.readyState !== WebSocket.OPEN || n.send(JSON.stringify({ type: "requestFrame", sessionId: ae }));
+          };
+          if (y(), ft(), gt.current = window.setInterval(() => {
+            if (!i() || ct.current || P.current !== G || T.current !== n || n.readyState !== WebSocket.OPEN) {
+              ft();
+              return;
+            }
+            y();
+          }, 250), E) {
+            try {
+              const d = decodeURIComponent(E);
+              Y("Opening URL"), n.send(
+                JSON.stringify({
+                  type: "openUrl",
+                  url: d,
+                  sessionId: ae
+                })
+              );
+            } catch (d) {
+              console.error({ error: d }, "Error decoding URL, falling back to the original URL"), n.send(
+                JSON.stringify({
+                  type: "openUrl",
+                  url: E,
+                  sessionId: ae
+                })
+              );
+            }
+            z.current?.bumpActivity();
+          }
+        }, G.onclose = () => {
+          !i() || P.current !== G || Y("Control channel closed");
+        }, G.onerror = (y) => {
+          !i() || P.current !== G || (console.error("Control channel error:", y), Y("Control channel error: " + y));
+        }, h.onconnectionstatechange = () => {
+          !i() || W.current !== h || (Y("Connection state: " + h.connectionState), h.connectionState === "failed" && Qe("WebRTC connection entered failed state", o));
+        }, h.oniceconnectionstatechange = () => {
+          if (!i() || W.current !== h)
+            return;
+          const y = h.iceConnectionState;
+          if (Y("ICE state: " + y), y === "connected" || y === "completed") {
+            ht(), Jt() && !le.current && zt();
+            return;
+          }
+          if (y === "failed") {
+            ht(), Qe("ICE connection entered failed state", o);
+            return;
+          }
+          y === "disconnected" && xt.current && Le.current === void 0 && (Le.current = window.setTimeout(() => {
+            Le.current = void 0, !(!i() || W.current !== h) && h.iceConnectionState === "disconnected" && Qe("ICE stayed disconnected past grace period", o);
+          }, Di));
+        }, h.ontrack = (y) => {
+          if (!(!i() || W.current !== h) && (Y("Received remote track: " + y.track.kind), y.track.kind === "video" && x.current)) {
+            F(`[${(/* @__PURE__ */ new Date()).toISOString()}] Video track received:`, y.track);
+            const K = y.track.id === "duo-inner" || y.streams.some((Q) => Q.id === "duo-inner") ? et.current : x.current;
+            K && (K.srcObject = g ? new MediaStream([y.track]) : y.streams[0] ?? new MediaStream([y.track]), K.play().catch(() => {
+            }));
+          }
+        }, h.onicecandidate = (y) => {
+          if (!(!i() || W.current !== h || T.current !== n))
+            if (y.candidate && n.readyState === WebSocket.OPEN) {
+              const d = {
+                type: "candidate",
+                candidate: y.candidate.candidate,
+                sdpMid: y.candidate.sdpMid,
+                sdpMLineIndex: y.candidate.sdpMLineIndex,
+                sessionId: ae
+              };
+              n.send(JSON.stringify(d)), Y("Sent ICE candidate");
+            } else
+              Y("ICE candidate gathering completed");
+        }, n.onmessage = async (y) => {
+          if (!i() || T.current !== n)
+            return;
+          let d;
+          try {
+            d = JSON.parse(y.data);
+          } catch (K) {
+            w("Error parsing message:", K);
+            return;
+          }
+          if (!z.current?.handleMessage(d))
+            switch (Y("Received: " + d.type), d.type) {
+              case "performActionsResult":
+              case "foldStateResult":
+              case "foldStateChanged": {
+                if (!g) break;
+                d.state ? (ir(d.state), cr(void 0)) : d.id === "duo-capabilities" && cr(d.error || "This instance does not support native iPhone Duo displays.");
+                const A = ke.current.get(d.id);
+                A && (clearTimeout(A.timer), ke.current.delete(d.id), d.error ? A.reject(new Error(d.error)) : A.resolve());
+                break;
+              }
+              case "signalingError": {
+                if (d.requestType !== "offer" || d.sessionId !== ae)
+                  break;
+                const A = typeof d.error == "string" ? d.error : "Unable to establish the streaming connection";
+                Y("Error: " + A), Qe(A, o);
+                break;
+              }
+              case "answer":
+                if (!W.current || W.current !== h) {
+                  Y("No peer connection, skipping answer");
+                  break;
+                }
+                if (await h.setRemoteDescription(
+                  new RTCSessionDescription({
+                    type: "answer",
+                    sdp: d.sdp
+                  })
+                ), !i() || W.current !== h)
+                  return;
+                Y("Set remote description");
+                break;
+              case "candidate":
+                if (!W.current || W.current !== h) {
+                  Y("No peer connection, skipping candidate");
+                  break;
+                }
+                if (await h.addIceCandidate(
+                  new RTCIceCandidate({
+                    candidate: d.candidate,
+                    sdpMid: d.sdpMid,
+                    sdpMLineIndex: d.sdpMLineIndex
+                  })
+                ), !i() || W.current !== h)
+                  return;
+                Y("Added ICE candidate");
+                break;
+              case "screenshot":
+              case "screenshotResult": {
+                if (typeof d.id != "string") {
+                  w("Received invalid screenshot success message:", d);
+                  break;
+                }
+                const A = Mi(d);
+                if (A) {
+                  const re = Ee.current.get(d.id);
+                  if (!re) {
+                    w(`Received screenshot error for unknown or handled id: ${d.id}`);
+                    break;
+                  }
+                  w(`Received screenshot error for id ${d.id}: ${A}`), re(new Error(A)), ye.current.delete(d.id), Ee.current.delete(d.id);
+                  break;
+                }
+                const N = bi(d);
+                if (!N) {
+                  w("Received screenshot message without image data:", d);
+                  break;
+                }
+                const V = ye.current.get(d.id);
+                if (!V) {
+                  w(`Received screenshot data for unknown or handled id: ${d.id}`);
+                  break;
+                }
+                F(`Received screenshot data for id ${d.id}`), V(N), ye.current.delete(d.id), Ee.current.delete(d.id);
+                break;
+              }
+              case "screenshotError":
+                if (typeof d.id != "string" || typeof d.message != "string") {
+                  w("Received invalid screenshot error message:", d);
+                  break;
+                }
+                const K = Ee.current.get(d.id);
+                if (!K) {
+                  w(`Received screenshot error for unknown or handled id: ${d.id}`);
+                  break;
+                }
+                w(`Received screenshot error for id ${d.id}: ${d.message}`), K(new Error(d.message)), ye.current.delete(d.id), Ee.current.delete(d.id);
+                break;
+              case "cameraRequest": {
+                const A = _e.current;
+                if (!A)
+                  break;
+                const N = ci(d);
+                if (!N) {
+                  w("Received invalid cameraRequest:", d);
+                  break;
+                }
+                console.info("[RemoteControl] cameraRequest received:", N.active, N.facingMode), await _n(N, n, A, i);
+                break;
+              }
+              case "microphoneRequest": {
+                if (!ot.current)
+                  break;
+                const A = d.active === !0;
+                if ($t.current = A, console.info("[RemoteControl] microphoneRequest received, active=", A), !A) {
+                  Ht.current || await Nt();
+                  break;
+                }
+                if (le.current) {
+                  Sr(n);
+                  break;
+                }
+                await zt();
+                break;
+              }
+              case "microphoneStartResult": {
+                if (xe.current === null || d.id !== xe.current)
+                  break;
+                xe.current = null, typeof d.error == "string" && (console.warn("[RemoteControl] microphoneStart rejected by host:", d.error), Nt(d.error));
+                break;
+              }
+              case "terminateAppResult":
+                if (typeof d.id != "string") {
+                  w("Received invalid terminateApp result message:", d);
+                  break;
+                }
+                if (typeof d.error == "string") {
+                  const A = we.current.get(d.id);
+                  if (!A) {
+                    w(`Received terminateApp error for unknown or handled id: ${d.id}`);
+                    break;
+                  }
+                  w(`Received terminateApp error for id ${d.id}: ${d.error}`), A(new Error(d.error)), Te.current.delete(d.id), we.current.delete(d.id);
+                  break;
+                }
+                const Q = Te.current.get(d.id);
+                if (!Q) {
+                  w(`Received terminateApp result for unknown or handled id: ${d.id}`);
+                  break;
+                }
+                F(`Received terminateApp success for id ${d.id}`), Q(), Te.current.delete(d.id), we.current.delete(d.id);
+                break;
+              default:
+                w(`Received unhandled message type: ${d.type}`, d);
+                break;
+            }
+        }, W.current === h) {
+          const y = await h.createOffer({
+            offerToReceiveVideo: !0,
+            offerToReceiveAudio: !1
+          });
+          if (!i() || W.current !== h || (await h.setLocalDescription(y), !i() || W.current !== h))
+            return;
+          i() && T.current === n && n.readyState === WebSocket.OPEN && n.send(
+            JSON.stringify({
+              type: "offer",
+              ...g ? { displayStreams: !0 } : {},
+              sdp: y.sdp,
+              sessionId: ae
+            })
+          ), Y("Sent offer");
+        }
+      } catch (n) {
+        if (!i())
+          return;
+        const l = n instanceof Error ? n.message : String(n);
+        Y("Error: " + l), Qe(l, o);
+      }
+    }, jt = () => {
+      Pe.current = !1, sr(!1), Nr(0);
+    }, An = () => {
+      Oe.current += 1, Ct.current = 0, Fe.current = !1, bt(), ht(), je(), Y("Stopped");
+    }, Sn = (e) => {
+      e.stopPropagation(), jt();
+    };
+    de(() => {
+      Jt() ? zt() : Nt();
+    }, [he]), de(() => (Lt(!1), jt(), document.hidden || Tr(), document.addEventListener("visibilitychange", Rr), () => {
+      wr(), An(), document.removeEventListener("visibilitychange", Rr);
+    }), [t, c, a, C]);
+    const Ir = () => {
+      const e = dt();
+      if (!e) {
+        hr(null);
+        return;
+      }
+      const o = {
+        left: e.videoRect.left - e.containerRect.left + e.offsetX,
+        top: e.videoRect.top - e.containerRect.top + e.offsetY,
+        width: e.actualWidth,
+        height: e.actualHeight
+      };
+      hr(
+        (i) => i && i.left === o.left && i.top === o.top && i.width === o.width && i.height === o.height ? i : o
+      );
+    };
+    de(() => {
+      const e = x.current, o = Ke.current, i = pe.current;
+      if (!e) return;
+      const n = () => {
+        const { videoWidth: f, videoHeight: p } = e, g = f > p;
+        if (f > 0 && p > 0 && (Jr(g), jr(oe === "android" && wi(f, p)), Zr(Math.min(f, p) / Math.max(f, p) < 0.6)), !wt || !o) {
+          ur({}), Ir();
+          return;
+        }
+        const h = o.clientWidth, I = o.clientHeight;
+        if (h === 0 || I === 0) return;
+        const O = g ? Ve.videoPosition.landscape : Ve.videoPosition.portrait;
+        let S = {};
+        O.heightMultiplier ? (S.height = `${I * O.heightMultiplier}px`, S.width = "auto") : O.widthMultiplier && (S.width = `${h * O.widthMultiplier}px`, S.height = "auto"), S.borderRadius = `${g ? I * Ve.videoBorderRadiusMultiplier : h * Ve.videoBorderRadiusMultiplier}px`, ur(S), Ir();
+      }, l = new ResizeObserver(() => {
+        n();
+      });
+      o && l.observe(o), l.observe(e), i && l.observe(i), o && o.addEventListener("load", n), e.addEventListener("loadedmetadata", n), e.addEventListener("resize", n);
+      const u = () => z.current?.bumpActivity();
+      return e.addEventListener("resize", u), n(), () => {
+        l.disconnect(), e.removeEventListener("loadedmetadata", n), e.removeEventListener("resize", n), e.removeEventListener("resize", u), o && o.removeEventListener("load", n);
+      };
+    }, [Ve, wt, oe]), de(() => {
+      const e = z.current;
+      ut ? e?.start() : (e?.stop(), fr(null), at(null), Dt(null), pr(null), He(null), Tt.current = null, ie.current !== void 0 && (window.cancelAnimationFrame(ie.current), ie.current = void 0), L("onAxSnapshotChange", qt.current, null));
+    }, [ut]), de(() => () => {
+      ie.current !== void 0 && (window.cancelAnimationFrame(ie.current), ie.current = void 0);
+    }, []), de(() => {
+      if (!ut) return;
+      const e = (o) => {
+        o.key === "Escape" && (Bt || Xt) && (Dt(null), at(null), He(null), L("onInspectSelectionChange", Be.current, null));
+      };
+      return window.addEventListener("keydown", e), () => window.removeEventListener("keydown", e);
+    }, [ut, Bt, Xt]);
+    const Mn = () => {
+      x.current && x.current.focus();
+    };
+    Kn(Ye, () => ({
+      openUrl: (e) => {
+        if (!T.current || T.current.readyState !== WebSocket.OPEN) {
+          w("WebSocket not open, cannot send open_url command via ref.");
+          return;
+        }
+        try {
+          const o = decodeURIComponent(e);
+          Y("Opening URL"), T.current.send(
+            JSON.stringify({
+              type: "openUrl",
+              url: o,
+              sessionId: ae
+            })
+          );
+        } catch (o) {
+          w("Error decoding or sending URL via ref:", { error: o, url: e }), T.current.send(
+            JSON.stringify({
+              type: "openUrl",
+              url: e,
+              sessionId: ae
+            })
+          );
+        }
+        z.current?.bumpActivity();
+      },
+      sendKeyEvent: (e) => {
+        if (!P.current || P.current.readyState !== "open") {
+          w("Data channel not ready for imperative key command:", P.current?.readyState);
+          return;
+        }
+        const o = xr[e.code];
+        if (!o) {
+          w(`Unknown event.code for imperative command: ${e.code}`);
+          return;
+        }
+        let i = s.META_NONE;
+        e.shiftKey && (i |= s.META_SHIFT_ON), e.altKey && (i |= s.META_ALT_ON), e.ctrlKey && (i |= s.META_CTRL_ON), e.metaKey && (i |= s.META_META_ON);
+        const n = e.type === "keydown" ? s.ACTION_DOWN : s.ACTION_UP;
+        F(
+          `Sending Imperative Key Command: code=${e.code}, keycode=${o}, action=${n}, meta=${i}`
+        );
+        const l = pt(
+          n,
+          o,
+          0,
+          // repeat count, typically 0 for single presses
+          i
+        );
+        l && ue(l);
+      },
+      screenshot: (e) => new Promise((o, i) => {
+        if (!T.current || T.current.readyState !== WebSocket.OPEN)
+          return w("WebSocket not open, cannot send screenshot command."), i(new Error("WebSocket is not connected or connection is not open."));
+        const n = `ui-ss-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`, l = {
+          type: e ? "screenshotDisplay" : "screenshot",
+          ...e ? { display: e } : {},
+          id: n
+        };
+        ye.current.set(n, o), Ee.current.set(n, i), F("Sending screenshot request:", l);
+        try {
+          T.current.send(JSON.stringify(l));
+        } catch (u) {
+          w("Failed to send screenshot request immediately:", u), ye.current.delete(n), Ee.current.delete(n), i(u);
+          return;
+        }
+        setTimeout(() => {
+          ye.current.has(n) && (w(`Screenshot request timed out for id ${n}`), Ee.current.get(n)?.(new Error("Screenshot request timed out")), ye.current.delete(n), Ee.current.delete(n));
+        }, 3e4);
+      }),
+      terminateApp: (e) => new Promise((o, i) => {
+        if (!T.current || T.current.readyState !== WebSocket.OPEN)
+          return w("WebSocket not open, cannot send terminateApp command."), i(new Error("WebSocket is not connected or connection is not open."));
+        const n = `ui-term-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`, l = {
+          type: "terminateApp",
+          id: n,
+          bundleId: e
+        };
+        Te.current.set(n, o), we.current.set(n, i), F("Sending terminateApp request:", l);
+        try {
+          T.current.send(JSON.stringify(l));
+        } catch (u) {
+          w("Failed to send terminateApp request immediately:", u), Te.current.delete(n), we.current.delete(n), i(u);
+          return;
+        }
+        z.current?.bumpActivity(), setTimeout(() => {
+          Te.current.has(n) && (w(`terminateApp request timed out for id ${n}`), we.current.get(n)?.(new Error("terminateApp request timed out")), Te.current.delete(n), we.current.delete(n));
+        }, 3e4);
+      }),
+      reconnect: () => jt(),
+      refreshAxTree: async () => {
+        const e = z.current;
+        if (!e)
+          throw new Error("Inspect mode is not active");
+        return e.refresh();
+      },
+      getAxSnapshot: () => Xe.current,
+      setInspectHighlight: (e) => {
+        at(e?.id ?? null);
+      },
+      setInspectSelection: (e) => {
+        Dt(e?.id ?? null), He(e ? Tt.current : null);
+        const o = Xe.current;
+        e && o ? L("onInspectSelectionChange", Be.current, { element: e, snapshot: o }) : L("onInspectSelectionChange", Be.current, null);
+      },
+      getAxStatus: () => z.current?.getStatus() ?? "idle"
+    }));
+    const bn = tn && Se !== null;
+    return /* @__PURE__ */ ce(
+      "div",
+      {
+        ref: pe,
+        className: Ne("rc-container", r),
+        style: { touchAction: "none" },
+        onMouseDown: ve,
+        onMouseMove: ve,
+        onMouseUp: ve,
+        onMouseLeave: ve,
+        onTouchStart: ve,
+        onTouchMove: ve,
+        onTouchEnd: ve,
+        onTouchCancel: ve,
+        children: [
+          bn && Se && /* @__PURE__ */ ce(Lr, { children: [
+            /* @__PURE__ */ k(
+              "div",
+              {
+                className: "rc-touch-indicator",
+                style: {
+                  left: `${Se.containerX}px`,
+                  top: `${Se.containerY}px`
+                }
+              }
+            ),
+            /* @__PURE__ */ k(
+              "div",
+              {
+                className: "rc-touch-indicator",
+                style: {
+                  left: `${Se.mirrorContainerX}px`,
+                  top: `${Se.mirrorContainerY}px`
+                }
+              }
+            )
+          ] }),
+          wt && /* @__PURE__ */ k(
+            "img",
+            {
+              ref: Ke,
+              src: yr,
+              alt: "",
+              className: oe === "ios" ? Ne("rc-phone-frame", "rc-phone-frame-ios") : "rc-phone-frame",
+              draggable: !1
+            }
+          ),
+          /* @__PURE__ */ k(
+            "video",
+            {
+              ref: x,
+              className: Ne(
+                "rc-video",
+                !wt && "rc-video-frameless",
+                !qr && "rc-video-loading"
+              ),
+              style: {
+                ...en,
+                ...se ? { opacity: 0, width: 1, height: 1, pointerEvents: "none" } : {},
+                ...vr ? {
+                  backgroundImage: `url("${vr}")`,
+                  backgroundRepeat: "no-repeat",
+                  backgroundPosition: "center",
+                  backgroundSize: Ve.loadingLogoSize
+                } : {}
+              },
+              autoPlay: !0,
+              playsInline: !0,
+              muted: !0,
+              tabIndex: se ? -1 : 0,
+              onKeyDown: Mt,
+              onKeyUp: Mt,
+              onClick: Mn,
+              onLoadedData: gn,
+              onFocus: () => {
+                x.current && (x.current.style.outline = "none");
+              },
+              onBlur: () => {
+                x.current && (x.current.style.outline = "none");
+              }
+            }
+          ),
+          se && /* @__PURE__ */ k(
+            "video",
+            {
+              ref: et,
+              autoPlay: !0,
+              playsInline: !0,
+              muted: !0,
+              style: { position: "absolute", width: 1, height: 1, opacity: 0, pointerEvents: "none" }
+            }
+          ),
+          se && nr && /* @__PURE__ */ k(kn, { fallback: /* @__PURE__ */ k("div", { children: "Loading iPhone Duo…" }), children: /* @__PURE__ */ k(
+            yi,
+            {
+              showFrame: m,
+              modelUrl: v,
+              outer: x.current,
+              inner: et.current,
+              state: nr,
+              setAngle: (e) => Ut("setHingeAngle", { angleDegrees: e }),
+              setOrientation: (e) => Ut("setDuoOrientation", { orientation: e }),
+              button: (e, o) => Ut("performActions", {
+                actions: [{ type: o ? "buttonDown" : "buttonUp", button: e }]
+              }),
+              touch: (e, o, i, n) => {
+                const l = P.current;
+                l?.readyState === "open" && l.send(Ln(e, o, i, n));
+              },
+              onKeyDown: Mt,
+              onKeyUp: Mt
+            }
+          ) }),
+          se && or && /* @__PURE__ */ k("div", { role: "alert", className: "rc-duo-error", children: or }),
+          !se && ut && /* @__PURE__ */ k(
+            Ci,
+            {
+              snapshot: dr,
+              geometry: nn,
+              highlightedId: Xt,
+              selectedId: Bt,
+              mode: sn,
+              cursorPosition: on,
+              frozenCursorPosition: cn,
+              onSelectChange: (e, o) => {
+                Dt(e?.id ?? null), e && o ? He(o) : e || He(null);
+                const i = Xe.current;
+                e && i ? L("onInspectSelectionChange", Be.current, {
+                  element: e,
+                  snapshot: i
+                }) : L("onInspectSelectionChange", Be.current, null);
+              },
+              onTapElement: (e, o) => {
+                if (o) {
+                  _r(o.x, o.y);
+                  return;
+                }
+                const i = Xe.current;
+                i && an(e, i);
+              }
+            }
+          ),
+          Gr ? /* @__PURE__ */ ce("div", { className: "rc-terminated", role: "status", children: [
+            /* @__PURE__ */ k("div", { className: "rc-terminated-title", children: "Instance terminated" }),
+            /* @__PURE__ */ k("div", { className: "rc-terminated-message", children: "This instance no longer exists and can't be reconnected." })
+          ] }) : Vr && /* @__PURE__ */ k("button", { type: "button", className: "rc-retry-button", onClick: Sn, children: "Retry" })
+        ]
+      }
+    );
+  }
+), Mi = (r) => typeof r.message == "string" ? r.message : typeof r.error == "string" ? r.error : null, bi = (r) => typeof r.dataUri == "string" ? { dataUri: r.dataUri } : typeof r.base64 == "string" ? r.base64.startsWith("data:") ? { dataUri: r.base64 } : { dataUri: `data:${r.base64.startsWith("/9j/") ? "image/jpeg" : "image/png"};base64,${r.base64}` } : null;
+export {
+  Qt as A,
+  Yi as D,
+  Ui as H,
+  xi as R,
+  zn as a,
+  jn as b,
+  Br as c,
+  Hr as d,
+  $r as e,
+  Jn as f,
+  Bn as g,
+  Fi as h,
+  Li as i,
+  Ki as j,
+  Pi as k,
+  Gn as n,
+  ki as p
+};