@cuekit-ai/react 1.3.0 → 1.3.2

package/dist/index.js

@@ -181,6 +181,7 @@ function onStateChange() {
   }
 }
 function getElementPath(element3) {
+  if (typeof window === "undefined") return "";
   if (element3.id) {
     return `id(${element3.id})`;
   }
@@ -261,6 +262,7 @@ var init_navigation = __esm({
           }
         }, 100);
       });
+      if (typeof window === "undefined") return;
       observer.observe(document.body, { childList: true, subtree: true });
     };
   }
@@ -271,11 +273,388 @@ var WEBRTC_BACKEND_SERVER_URL;
 var init_constants = __esm({
   "src/constants/index.ts"() {
     "use strict";
-    WEBRTC_BACKEND_SERVER_URL = "https://api-webrtc-dev.cuekit.ai";
+    WEBRTC_BACKEND_SERVER_URL = "https://api-webrtc-dev.ansyr.ai";
+  }
+});
+
+// src/utils/jsx-encoder.ts
+function generateStableDOMId(element3) {
+  const tagName = element3.tagName.toLowerCase();
+  const text7 = (element3.textContent || "").trim().substring(0, 50);
+  let sibling = element3.previousElementSibling;
+  let position3 = 1;
+  while (sibling) {
+    if (sibling.tagName === element3.tagName) {
+      position3++;
+    }
+    sibling = sibling.previousElementSibling;
+  }
+  const path2 = getElementPath2(element3);
+  const idString = `${tagName}[${position3}]_(${text7})_${path2}`;
+  let hash = 0;
+  for (let i2 = 0; i2 < idString.length; i2++) {
+    const char = idString.charCodeAt(i2);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return hash.toString(36);
+}
+function getElementPath2(element3) {
+  if (element3.id) {
+    return `id(${element3.id})`;
+  }
+  if (element3.tagName.toLowerCase() === "body") {
+    return "/body";
+  }
+  let ix = 0;
+  const siblings = element3.parentNode?.children || new HTMLCollection();
+  for (let i2 = 0; i2 < siblings.length; i2++) {
+    const sibling = siblings[i2];
+    if (sibling === element3) {
+      return `${getElementPath2(element3.parentNode)}/${element3.tagName}[${ix + 1}]`;
+    }
+    if (sibling.nodeType === 1 && sibling.tagName === element3.tagName) {
+      ix++;
+    }
+  }
+  return "not_found";
+}
+var init_jsx_encoder = __esm({
+  "src/utils/jsx-encoder.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/element-service.ts
+function getInteractiveElements() {
+  if (typeof document === "undefined") {
+    return new class extends Array {
+    }();
+  }
+  return document.querySelectorAll(INTERACTIVE_ELEMENT_SELECTOR);
+}
+function getImmediateText(element3) {
+  let text7 = "";
+  if (element3.childNodes) {
+    for (const node2 of Array.from(element3.childNodes)) {
+      if (node2.nodeType === 3) {
+        text7 += node2.textContent || "";
+      }
+    }
+  }
+  return text7.trim();
+}
+function captureFullDOMStructure() {
+  console.log("\u{1F333} Capturing full DOM structure...");
+  const components = [];
+  const interactiveElements = getInteractiveElements();
+  interactiveElements.forEach((element3) => {
+    if (element3 instanceof HTMLElement && !element3.closest("[data-cuekit-ignore]")) {
+      const nodeData = buildFlatDOMNode(element3);
+      if (nodeData) {
+        components.push(nodeData);
+      }
+    }
+  });
+  const result = { components };
+  console.log("\u{1F333} Full DOM structure captured:", result);
+  return result;
+}
+function buildFlatDOMNode(element3) {
+  if (element3.tagName.toLowerCase() === "script" || element3.hasAttribute("data-cuekit-ignore") || element3.style.display === "none" || element3.style.visibility === "hidden") {
+    return null;
+  }
+  const hash = generateStableDOMId(element3);
+  const text7 = getImmediateText(element3).substring(0, 100);
+  const isClickable = isElementClickable(element3);
+  const componentType = element3.tagName.toLowerCase();
+  return {
+    hash,
+    text: text7,
+    isClickable,
+    componentType,
+    children: []
+    // No children in a flat structure
+  };
+}
+function isElementClickable(element3) {
+  const interactiveSelectors = [
+    "button",
+    "a",
+    "input",
+    "select",
+    "textarea",
+    '[role="button"]',
+    '[role="link"]',
+    '[role="tab"]',
+    "[data-onclick-id]",
+    "[data-on-press-id]",
+    "[onclick]",
+    "[onmousedown]",
+    "[onmouseup]",
+    "[ontouchstart]",
+    "[ontouchend]",
+    "[onkeydown]",
+    "[onkeyup]",
+    "[onkeypress]"
+  ];
+  for (const selector of interactiveSelectors) {
+    if (element3.matches(selector)) {
+      return true;
+    }
+  }
+  const hasClickEvents = element3.onclick !== null || element3.getAttribute("onclick") !== null;
+  const hasInteractiveEvents = element3.ontouchstart !== null || element3.getAttribute("ontouchstart") !== null || element3.ontouchend !== null || element3.getAttribute("ontouchend") !== null || element3.onkeydown !== null || element3.getAttribute("onkeydown") !== null || element3.onkeyup !== null || element3.getAttribute("onkeyup") !== null || element3.onkeypress !== null || element3.getAttribute("onkeypress") !== null;
+  const hasPointerCursor = element3.style.cursor === "pointer" || getComputedStyle(element3).cursor === "pointer";
+  const hasTabIndex = element3.hasAttribute("tabindex") && parseInt(element3.getAttribute("tabindex") || "0") >= 0;
+  const hasInteractiveDataAttrs = element3.hasAttribute("data-clickable") || element3.hasAttribute("data-interactive") || element3.hasAttribute("data-action") || element3.hasAttribute("data-handler");
+  const hasInteractiveAria = element3.hasAttribute("aria-pressed") || element3.hasAttribute("aria-expanded") || element3.hasAttribute("aria-selected") || element3.hasAttribute("aria-checked");
+  return hasClickEvents || hasInteractiveEvents || hasPointerCursor || hasTabIndex || hasInteractiveDataAttrs || hasInteractiveAria;
+}
+function executeAction(action) {
+  console.log("\u{1F3AF} Executing element action:", action);
+  const { action_type, target_element, target } = action;
+  switch (action_type) {
+    case "click":
+      return clickElement(target_element);
+    case "navigate":
+      return navigateToElement(target_element || target);
+    case "input":
+    case "focus":
+      return focusElement(target_element);
+    case "toggle":
+      return toggleElement(target_element);
+    default:
+      console.warn(`\u26A0\uFE0F Unknown action type: ${action_type}`);
+      return false;
+  }
+}
+function getFullDOMStructure() {
+  console.log("\u{1F333} ElementService: Getting full DOM structure...");
+  return captureFullDOMStructure();
+}
+function clickElement(elementId) {
+  if (!elementId) {
+    console.warn("\u26A0\uFE0F No element ID provided for click action");
+    return false;
+  }
+  const domStructure = getFullDOMStructure();
+  const elementToClick = findElementById(domStructure, elementId);
+  if (elementToClick) {
+    console.log(`\u{1F3AF} Clicking element: ${elementId}`);
+    const domElement = findDOMElementById(elementId);
+    if (domElement) {
+      domElement.click();
+      return true;
+    }
+  } else {
+    console.warn(`\u26A0\uFE0F Element not found: ${elementId}`);
+  }
+  return false;
+}
+function navigateToElement(target) {
+  if (!target) {
+    console.warn("\u26A0\uFE0F No target provided for navigation action");
+    return false;
+  }
+  console.log(`\u{1F9ED} Navigating to: ${target}`);
+  if (target.includes("/") || target.startsWith("http")) {
+    safeNavigate(target, {});
+  } else {
+    handleNavigationAndClick(target, target);
+  }
+  return true;
+}
+function focusElement(elementId) {
+  if (!elementId) {
+    console.warn("\u26A0\uFE0F No element ID provided for focus action");
+    return false;
+  }
+  const domElement = findDOMElementById(elementId);
+  if (domElement instanceof HTMLInputElement || domElement instanceof HTMLTextAreaElement || domElement instanceof HTMLSelectElement) {
+    console.log(`\u{1F4DD} Focusing element: ${elementId}`);
+    domElement.focus();
+    return true;
+  } else {
+    console.warn(`\u26A0\uFE0F Focusable element not found: ${elementId}`);
+    return false;
+  }
+}
+function toggleElement(elementId) {
+  if (!elementId) {
+    console.warn("\u26A0\uFE0F No element ID provided for toggle action");
+    return false;
+  }
+  const domElement = findDOMElementById(elementId);
+  if (domElement instanceof HTMLElement) {
+    console.log(`\u{1F504} Toggling element: ${elementId}`);
+    if (domElement instanceof HTMLInputElement) {
+      if (domElement.type === "checkbox") {
+        domElement.checked = !domElement.checked;
+      } else if (domElement.type === "radio") {
+        domElement.checked = true;
+      }
+      domElement.dispatchEvent(new Event("change", { bubbles: true }));
+    } else {
+      domElement.click();
+    }
+    return true;
+  } else {
+    console.warn(`\u26A0\uFE0F Toggleable element not found: ${elementId}`);
+    return false;
+  }
+}
+function findElementById(domStructure, elementId) {
+  const searchInComponents = (components) => {
+    for (const component of components) {
+      if (component.hash === elementId) {
+        return component;
+      }
+      if (component.children.length > 0) {
+        const found = searchInComponents(component.children);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return searchInComponents(domStructure.components);
+}
+function findDOMElementById(elementId) {
+  const interactiveElements = getInteractiveElements();
+  for (const element3 of interactiveElements) {
+    if (element3 instanceof HTMLElement) {
+      console.log("\u{1F50D} Checking element:", element3);
+      const hash = generateStableDOMId(element3);
+      console.log("\u{1F50D} Generated hash:", hash);
+      if (hash === elementId) {
+        console.log("\u{1F50D} Found element:", element3);
+        return element3;
+      }
+    }
+  }
+  return null;
+}
+var INTERACTIVE_ELEMENT_SELECTOR;
+var init_element_service = __esm({
+  "src/utils/element-service.ts"() {
+    "use strict";
+    init_jsx_encoder();
+    init_navigation();
+    INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick]';
   }
 });
 
 // node_modules/livekit-client/dist/livekit-client.esm.mjs
+var livekit_client_esm_exports = {};
+__export(livekit_client_esm_exports, {
+  AudioPresets: () => AudioPresets,
+  BackupCodecPolicy: () => BackupCodecPolicy,
+  BaseKeyProvider: () => BaseKeyProvider,
+  CheckStatus: () => CheckStatus,
+  Checker: () => Checker,
+  ConnectionCheck: () => ConnectionCheck,
+  ConnectionError: () => ConnectionError,
+  ConnectionErrorReason: () => ConnectionErrorReason,
+  ConnectionQuality: () => ConnectionQuality,
+  ConnectionState: () => ConnectionState,
+  CriticalTimers: () => CriticalTimers,
+  CryptorError: () => CryptorError,
+  CryptorErrorReason: () => CryptorErrorReason,
+  CryptorEvent: () => CryptorEvent,
+  DataPacket_Kind: () => DataPacket_Kind,
+  DefaultReconnectPolicy: () => DefaultReconnectPolicy,
+  DeviceUnsupportedError: () => DeviceUnsupportedError,
+  DisconnectReason: () => DisconnectReason,
+  EncryptionEvent: () => EncryptionEvent,
+  EngineEvent: () => EngineEvent,
+  ExternalE2EEKeyProvider: () => ExternalE2EEKeyProvider,
+  KeyHandlerEvent: () => KeyHandlerEvent,
+  KeyProviderEvent: () => KeyProviderEvent,
+  LivekitError: () => LivekitError,
+  LocalAudioTrack: () => LocalAudioTrack,
+  LocalParticipant: () => LocalParticipant,
+  LocalTrack: () => LocalTrack,
+  LocalTrackPublication: () => LocalTrackPublication,
+  LocalTrackRecorder: () => LocalTrackRecorder,
+  LocalVideoTrack: () => LocalVideoTrack,
+  LogLevel: () => LogLevel,
+  LoggerNames: () => LoggerNames,
+  MediaDeviceFailure: () => MediaDeviceFailure,
+  Mutex: () => _,
+  NegotiationError: () => NegotiationError,
+  Participant: () => Participant,
+  ParticipantEvent: () => ParticipantEvent,
+  ParticipantKind: () => ParticipantInfo_Kind,
+  PublishDataError: () => PublishDataError,
+  PublishTrackError: () => PublishTrackError,
+  RemoteAudioTrack: () => RemoteAudioTrack,
+  RemoteParticipant: () => RemoteParticipant,
+  RemoteTrack: () => RemoteTrack,
+  RemoteTrackPublication: () => RemoteTrackPublication,
+  RemoteVideoTrack: () => RemoteVideoTrack,
+  Room: () => Room,
+  RoomEvent: () => RoomEvent,
+  RpcError: () => RpcError,
+  ScreenSharePresets: () => ScreenSharePresets,
+  SignalRequestError: () => SignalRequestError,
+  SubscriptionError: () => SubscriptionError,
+  Track: () => Track,
+  TrackEvent: () => TrackEvent,
+  TrackInvalidError: () => TrackInvalidError,
+  TrackPublication: () => TrackPublication,
+  TrackType: () => TrackType,
+  UnexpectedConnectionState: () => UnexpectedConnectionState,
+  UnsupportedServer: () => UnsupportedServer,
+  VideoPreset: () => VideoPreset,
+  VideoPresets: () => VideoPresets,
+  VideoPresets43: () => VideoPresets43,
+  VideoQuality: () => VideoQuality,
+  attachToElement: () => attachToElement,
+  attributes: () => attributeTypings,
+  compareVersions: () => compareVersions,
+  createAudioAnalyser: () => createAudioAnalyser,
+  createE2EEKey: () => createE2EEKey,
+  createKeyMaterialFromBuffer: () => createKeyMaterialFromBuffer,
+  createKeyMaterialFromString: () => createKeyMaterialFromString,
+  createLocalAudioTrack: () => createLocalAudioTrack,
+  createLocalScreenTracks: () => createLocalScreenTracks,
+  createLocalTracks: () => createLocalTracks,
+  createLocalVideoTrack: () => createLocalVideoTrack,
+  deriveKeys: () => deriveKeys,
+  detachTrack: () => detachTrack,
+  facingModeFromDeviceLabel: () => facingModeFromDeviceLabel,
+  facingModeFromLocalTrack: () => facingModeFromLocalTrack,
+  getBrowser: () => getBrowser,
+  getEmptyAudioStreamTrack: () => getEmptyAudioStreamTrack,
+  getEmptyVideoStreamTrack: () => getEmptyVideoStreamTrack,
+  getLogger: () => getLogger,
+  importKey: () => importKey,
+  isAudioTrack: () => isAudioTrack,
+  isBackupCodec: () => isBackupCodec,
+  isBrowserSupported: () => isBrowserSupported,
+  isE2EESupported: () => isE2EESupported,
+  isInsertableStreamSupported: () => isInsertableStreamSupported,
+  isLocalParticipant: () => isLocalParticipant,
+  isLocalTrack: () => isLocalTrack,
+  isRemoteParticipant: () => isRemoteParticipant,
+  isRemoteTrack: () => isRemoteTrack,
+  isScriptTransformSupported: () => isScriptTransformSupported,
+  isVideoFrame: () => isVideoFrame,
+  isVideoTrack: () => isVideoTrack,
+  needsRbspUnescaping: () => needsRbspUnescaping,
+  parseRbsp: () => parseRbsp,
+  protocolVersion: () => protocolVersion,
+  ratchet: () => ratchet,
+  setLogExtension: () => setLogExtension,
+  setLogLevel: () => setLogLevel,
+  supportsAV1: () => supportsAV1,
+  supportsAdaptiveStream: () => supportsAdaptiveStream,
+  supportsDynacast: () => supportsDynacast,
+  supportsVP9: () => supportsVP9,
+  version: () => version,
+  videoCodecs: () => videoCodecs,
+  writeRbsp: () => writeRbsp
+});
 function _mergeNamespaces(n, m) {
   m.forEach(function(e3) {
     e3 && typeof e3 !== "string" && !Array.isArray(e3) && Object.keys(e3).forEach(function(k2) {
@@ -2300,6 +2679,34 @@ function getLogger(name2) {
   logger.setDefaultLevel(livekitLogger.getLevel());
   return logger;
 }
+function setLogLevel(level, loggerName) {
+  if (loggerName) {
+    loglevelExports.getLogger(loggerName).setLevel(level);
+  } else {
+    for (const logger of livekitLoggers) {
+      logger.setLevel(level);
+    }
+  }
+}
+function setLogExtension(extension2, logger) {
+  const loggers = logger ? [logger] : livekitLoggers;
+  loggers.forEach((logR) => {
+    const originalFactory = logR.methodFactory;
+    logR.methodFactory = (methodName, configLevel, loggerName) => {
+      const rawMethod = originalFactory(methodName, configLevel, loggerName);
+      const logLevel = LogLevel[methodName];
+      const needLog = logLevel >= configLevel && logLevel < LogLevel.silent;
+      return (msg, context) => {
+        if (context) rawMethod(msg, context);
+        else rawMethod(msg);
+        if (needLog) {
+          extension2(logLevel, msg, context);
+        }
+      };
+    };
+    logR.setLevel(logR.getLevel());
+  });
+}
 function __rest(s, e3) {
   var t = {};
   for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e3.indexOf(p) < 0)
@@ -5192,6 +5599,118 @@ function isInsertableStreamSupported() {
   return typeof window.RTCRtpSender !== "undefined" && // @ts-ignore
   typeof window.RTCRtpSender.prototype.createEncodedStreams !== "undefined";
 }
+function isVideoFrame(frame) {
+  return "type" in frame;
+}
+function importKey(keyBytes_1) {
+  return __awaiter(this, arguments, void 0, function(keyBytes) {
+    let algorithm = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {
+      name: ENCRYPTION_ALGORITHM
+    };
+    let usage = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "encrypt";
+    return function* () {
+      return crypto.subtle.importKey("raw", keyBytes, algorithm, false, usage === "derive" ? ["deriveBits", "deriveKey"] : ["encrypt", "decrypt"]);
+    }();
+  });
+}
+function createKeyMaterialFromString(password) {
+  return __awaiter(this, void 0, void 0, function* () {
+    let enc = new TextEncoder();
+    const keyMaterial = yield crypto.subtle.importKey("raw", enc.encode(password), {
+      name: "PBKDF2"
+    }, false, ["deriveBits", "deriveKey"]);
+    return keyMaterial;
+  });
+}
+function createKeyMaterialFromBuffer(cryptoBuffer) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const keyMaterial = yield crypto.subtle.importKey("raw", cryptoBuffer, "HKDF", false, ["deriveBits", "deriveKey"]);
+    return keyMaterial;
+  });
+}
+function getAlgoOptions(algorithmName, salt) {
+  const textEncoder = new TextEncoder();
+  const encodedSalt = textEncoder.encode(salt);
+  switch (algorithmName) {
+    case "HKDF":
+      return {
+        name: "HKDF",
+        salt: encodedSalt,
+        hash: "SHA-256",
+        info: new ArrayBuffer(128)
+      };
+    case "PBKDF2": {
+      return {
+        name: "PBKDF2",
+        salt: encodedSalt,
+        hash: "SHA-256",
+        iterations: 1e5
+      };
+    }
+    default:
+      throw new Error("algorithm ".concat(algorithmName, " is currently unsupported"));
+  }
+}
+function deriveKeys(material, salt) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+    const encryptionKey = yield crypto.subtle.deriveKey(algorithmOptions, material, {
+      name: ENCRYPTION_ALGORITHM,
+      length: 128
+    }, false, ["encrypt", "decrypt"]);
+    return {
+      material,
+      encryptionKey
+    };
+  });
+}
+function createE2EEKey() {
+  return window.crypto.getRandomValues(new Uint8Array(32));
+}
+function ratchet(material, salt) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const algorithmOptions = getAlgoOptions(material.algorithm.name, salt);
+    return crypto.subtle.deriveBits(algorithmOptions, material, 256);
+  });
+}
+function needsRbspUnescaping(frameData) {
+  for (var i2 = 0; i2 < frameData.length - 3; i2++) {
+    if (frameData[i2] == 0 && frameData[i2 + 1] == 0 && frameData[i2 + 2] == 3) return true;
+  }
+  return false;
+}
+function parseRbsp(stream) {
+  const dataOut = [];
+  var length = stream.length;
+  for (var i2 = 0; i2 < stream.length; ) {
+    if (length - i2 >= 3 && !stream[i2] && !stream[i2 + 1] && stream[i2 + 2] == 3) {
+      dataOut.push(stream[i2++]);
+      dataOut.push(stream[i2++]);
+      i2++;
+    } else {
+      dataOut.push(stream[i2++]);
+    }
+  }
+  return new Uint8Array(dataOut);
+}
+function writeRbsp(data_in) {
+  const dataOut = [];
+  var numConsecutiveZeros = 0;
+  for (var i2 = 0; i2 < data_in.length; ++i2) {
+    var byte = data_in[i2];
+    if (byte <= kEmulationByte && numConsecutiveZeros >= kZerosInStartSequence) {
+      dataOut.push(kEmulationByte);
+      numConsecutiveZeros = 0;
+    }
+    dataOut.push(byte);
+    if (byte == 0) {
+      ++numConsecutiveZeros;
+    } else {
+      numConsecutiveZeros = 0;
+    }
+  }
+  return new Uint8Array(dataOut);
+}
 function cloneDeep(value) {
   if (typeof value === "undefined") {
     return value;
@@ -5299,6 +5818,12 @@ function supportsTransceiver() {
 function supportsAddTrack() {
   return "addTrack" in RTCPeerConnection.prototype;
 }
+function supportsAdaptiveStream() {
+  return typeof ResizeObserver !== void 0 && typeof IntersectionObserver !== void 0;
+}
+function supportsDynacast() {
+  return supportsTransceiver();
+}
 function supportsAV1() {
   if (!("getCapabilities" in RTCRtpSender)) {
     return false;
@@ -5486,6 +6011,12 @@ function getClientInfo() {
   }
   return info;
 }
+function getEmptyVideoStreamTrack() {
+  if (!emptyVideoStreamTrack) {
+    emptyVideoStreamTrack = createDummyVideoStreamTrack();
+  }
+  return emptyVideoStreamTrack.clone();
+}
 function createDummyVideoStreamTrack() {
   let width = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 16;
   let height = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 16;
@@ -5698,6 +6229,9 @@ function isRemoteVideoTrack(track) {
 function isLocalParticipant(p) {
   return p.isLocal;
 }
+function isRemoteParticipant(p) {
+  return !p.isLocal;
+}
 function splitUtf8(s, n) {
   const result = [];
   let encoded = new TextEncoder().encode(s);
@@ -7494,6 +8028,34 @@ function createLocalAudioTrack(options) {
     return tracks[0];
   });
 }
+function createLocalScreenTracks(options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (options === void 0) {
+      options = {};
+    }
+    if (options.resolution === void 0 && !isSafari17Based()) {
+      options.resolution = ScreenSharePresets.h1080fps30.resolution;
+    }
+    if (navigator.mediaDevices.getDisplayMedia === void 0) {
+      throw new DeviceUnsupportedError("getDisplayMedia not supported");
+    }
+    const constraints = screenCaptureToDisplayMediaStreamOptions(options);
+    const stream = yield navigator.mediaDevices.getDisplayMedia(constraints);
+    const tracks = stream.getVideoTracks();
+    if (tracks.length === 0) {
+      throw new TrackInvalidError("no video track found");
+    }
+    const screenVideo = new LocalVideoTrack(tracks[0], void 0, false);
+    screenVideo.source = Track.Source.ScreenShare;
+    const localTracks = [screenVideo];
+    if (stream.getAudioTracks().length > 0) {
+      const screenAudio = new LocalAudioTrack(stream.getAudioTracks()[0], void 0, false);
+      screenAudio.source = Track.Source.ScreenShareAudio;
+      localTracks.push(screenAudio);
+    }
+    return localTracks;
+  });
+}
 function qualityFromProto(q2) {
   switch (q2) {
     case ConnectionQuality$1.EXCELLENT:
@@ -7550,7 +8112,55 @@ function isIPPrivate(address) {
   }
   return false;
 }
-var e, h, o, _, FLOAT32_MAX, FLOAT32_MIN, UINT32_MAX, INT32_MAX, INT32_MIN, enumTypeSymbol, Message, TWO_PWR_32_DBL, decimalFrom1e7WithLeadingZeros, protoInt64, ScalarType, LongType, WireType, BinaryWriter, BinaryReader, encTable, decTable, protoBase64, jsonReadDefaults, jsonWriteDefaults, tokenNull, tokenIgnoredUnknownEnum, unknownFieldsSymbol, readDefaults, writeDefaults, InternalFieldList, fieldJsonName, reservedObjectProperties, reservedMessageProperties, fallback, safeMessageProperty, safeObjectProperty, InternalOneofInfo, proto3, Timestamp, MetricsBatch, TimeSeriesMetric, MetricSample, EventMetric, BackupCodecPolicy$1, TrackType, TrackSource, VideoQuality$1, ConnectionQuality$1, ClientConfigSetting, DisconnectReason, ReconnectReason, SubscriptionError, AudioTrackFeature, Room$1, Codec, ParticipantPermission, ParticipantInfo, ParticipantInfo_State, ParticipantInfo_Kind, ParticipantInfo_KindDetail, Encryption_Type, SimulcastCodecInfo, TrackInfo, VideoLayer, DataPacket, DataPacket_Kind, ActiveSpeakerUpdate, SpeakerInfo, UserPacket, SipDTMF, Transcription, TranscriptionSegment, ChatMessage, RpcRequest, RpcAck, RpcResponse, RpcError$1, ParticipantTracks, ServerInfo, ServerInfo_Edition, ClientInfo, ClientInfo_SDK, ClientConfiguration, VideoConfiguration, DisabledCodecs, TimedVersion, DataStream_OperationType, DataStream_TextHeader, DataStream_ByteHeader, DataStream_Header, DataStream_Chunk, DataStream_Trailer, SignalTarget, StreamState, CandidateProtocol, SignalRequest, SignalResponse, SimulcastCodec, AddTrackRequest, TrickleRequest, MuteTrackRequest, JoinResponse, ReconnectResponse, TrackPublishedResponse, TrackUnpublishedResponse, SessionDescription, ParticipantUpdate, UpdateSubscription, UpdateTrackSettings, UpdateLocalAudioTrack, UpdateLocalVideoTrack, LeaveRequest, LeaveRequest_Action, UpdateVideoLayers, UpdateParticipantMetadata, ICEServer, SpeakersChanged, RoomUpdate, ConnectionQualityInfo, ConnectionQualityUpdate, StreamStateInfo, StreamStateUpdate, SubscribedQuality, SubscribedCodec, SubscribedQualityUpdate, TrackPermission, SubscriptionPermission, SubscriptionPermissionUpdate, RoomMovedResponse, SyncState, DataChannelReceiveState, DataChannelInfo, SimulateScenario, Ping, Pong, RegionSettings, RegionInfo, SubscriptionResponse, RequestResponse, RequestResponse_Reason, TrackSubscribed, loglevel$1, loglevel, hasRequiredLoglevel, loglevelExports, LogLevel, LoggerNames, livekitLogger, livekitLoggers, workerLogger, maxRetryDelay, DEFAULT_RETRY_DELAYS_IN_MS, DefaultReconnectPolicy, events, hasRequiredEvents, eventsExports, logDisabled_, deprecationWarnings_, logging, chromeShim, firefoxShim, safariShim, sdp$1, hasRequiredSdp, sdpExports, SDPUtils, sdp, commonShim, DECRYPTION_FAILURE_TOLERANCE, E2EE_FLAG, SALT, KEY_PROVIDER_DEFAULTS, KeyProviderEvent, KeyHandlerEvent, EncryptionEvent, CryptorEvent, BaseKeyProvider, LivekitError, ConnectionErrorReason, ConnectionError, DeviceUnsupportedError, TrackInvalidError, UnsupportedServer, UnexpectedConnectionState, NegotiationError, PublishTrackError, SignalRequestError, MediaDeviceFailure, CryptorErrorReason, RoomEvent, ParticipantEvent, EngineEvent, TrackEvent, commonVersionIdentifier, browserDetails, browsersList, version$1, version, protocolVersion, CriticalTimers, BACKGROUND_REACTION_DELAY, recycledElements, VideoQuality, Track, VideoPreset, backupCodecs, videoCodecs, BackupCodecPolicy, AudioPresets, VideoPresets, VideoPresets43, ScreenSharePresets, separator, ddExtensionURI, resizeObserver, getResizeObserver, intersectionObserver, getIntersectionObserver, emptyAudioStreamTrack, Future, E2EEManager, defaultId, DeviceManager, QueueTaskStatus, AsyncQueue, passThroughQueueSignals, SignalConnectionState, SignalClient, DataPacketBuffer, TTLMap, lib, parser, grammar, hasRequiredGrammar, hasRequiredParser, writer, hasRequiredWriter, hasRequiredLib, libExports, startBitrateForSVC, debounceInterval, PCEvents, PCTransport, defaultVideoCodec, publishDefaults, audioDefaults, videoDefaults, roomOptionDefaults, roomConnectOptionDefaults, PCTransportState, PCTransportManager, RpcError, MAX_PAYLOAD_BYTES, monitorFrequency, isMediaRecorderAvailable, FallbackRecorder, RecorderBase, LocalTrackRecorder, DEFAULT_DIMENSIONS_TIMEOUT, PRE_CONNECT_BUFFER_TIMEOUT, LocalTrack, LocalAudioTrack, presets169, presets43, presetsScreenShare, defaultSimulcastPresets169, defaultSimulcastPresets43, computeDefaultScreenShareSimulcastPresets, videoRids, ScalabilityMode, refreshSubscribedCodecAfterNewCodec, LocalVideoTrack, lossyDataChannel, reliableDataChannel, minReconnectWait, leaveReconnect, reliabeReceiveStateTTL, PCState, RTCEngine, SignalReconnectError, RegionUrlProvider, BaseStreamReader, ByteStreamReader, TextStreamReader, BaseStreamWriter, TextStreamWriter, ByteStreamWriter, RemoteTrack, RemoteAudioTrack, REACTION_DELAY, RemoteVideoTrack, HTMLElementInfo, TrackPublication, LocalTrackPublication, ConnectionQuality, Participant, STREAM_CHUNK_SIZE, LocalParticipant, RemoteTrackPublication, RemoteParticipant, ConnectionState, connectionReconcileFrequency, Room, CheckStatus, Checker, CloudRegionCheck, TEST_DURATION, ConnectionProtocolCheck, PublishAudioCheck, PublishVideoCheck, ReconnectCheck, TURNCheck, WebRTCCheck, WebSocketCheck, ConnectionCheck;
+function facingModeFromLocalTrack(localTrack) {
+  let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var _a;
+  const track = isLocalTrack(localTrack) ? localTrack.mediaStreamTrack : localTrack;
+  const trackSettings = track.getSettings();
+  let result = {
+    facingMode: (_a = options.defaultFacingMode) !== null && _a !== void 0 ? _a : "user",
+    confidence: "low"
+  };
+  if ("facingMode" in trackSettings) {
+    const rawFacingMode = trackSettings.facingMode;
+    livekitLogger.trace("rawFacingMode", {
+      rawFacingMode
+    });
+    if (rawFacingMode && typeof rawFacingMode === "string" && isFacingModeValue(rawFacingMode)) {
+      result = {
+        facingMode: rawFacingMode,
+        confidence: "high"
+      };
+    }
+  }
+  if (["low", "medium"].includes(result.confidence)) {
+    livekitLogger.trace("Try to get facing mode from device label: (".concat(track.label, ")"));
+    const labelAnalysisResult = facingModeFromDeviceLabel(track.label);
+    if (labelAnalysisResult !== void 0) {
+      result = labelAnalysisResult;
+    }
+  }
+  return result;
+}
+function facingModeFromDeviceLabel(deviceLabel) {
+  var _a;
+  const label = deviceLabel.trim().toLowerCase();
+  if (label === "") {
+    return void 0;
+  }
+  if (knownDeviceLabels.has(label)) {
+    return knownDeviceLabels.get(label);
+  }
+  return (_a = Array.from(knownDeviceLabelSections.entries()).find((_ref) => {
+    let [section] = _ref;
+    return label.includes(section);
+  })) === null || _a === void 0 ? void 0 : _a[1];
+}
+function isFacingModeValue(item) {
+  const allowedValues = ["user", "environment", "left", "right"];
+  return item === void 0 || allowedValues.includes(item);
+}
+var e, h, o, _, FLOAT32_MAX, FLOAT32_MIN, UINT32_MAX, INT32_MAX, INT32_MIN, enumTypeSymbol, Message, TWO_PWR_32_DBL, decimalFrom1e7WithLeadingZeros, protoInt64, ScalarType, LongType, WireType, BinaryWriter, BinaryReader, encTable, decTable, protoBase64, jsonReadDefaults, jsonWriteDefaults, tokenNull, tokenIgnoredUnknownEnum, unknownFieldsSymbol, readDefaults, writeDefaults, InternalFieldList, fieldJsonName, reservedObjectProperties, reservedMessageProperties, fallback, safeMessageProperty, safeObjectProperty, InternalOneofInfo, proto3, Timestamp, MetricsBatch, TimeSeriesMetric, MetricSample, EventMetric, BackupCodecPolicy$1, TrackType, TrackSource, VideoQuality$1, ConnectionQuality$1, ClientConfigSetting, DisconnectReason, ReconnectReason, SubscriptionError, AudioTrackFeature, Room$1, Codec, ParticipantPermission, ParticipantInfo, ParticipantInfo_State, ParticipantInfo_Kind, ParticipantInfo_KindDetail, Encryption_Type, SimulcastCodecInfo, TrackInfo, VideoLayer, DataPacket, DataPacket_Kind, ActiveSpeakerUpdate, SpeakerInfo, UserPacket, SipDTMF, Transcription, TranscriptionSegment, ChatMessage, RpcRequest, RpcAck, RpcResponse, RpcError$1, ParticipantTracks, ServerInfo, ServerInfo_Edition, ClientInfo, ClientInfo_SDK, ClientConfiguration, VideoConfiguration, DisabledCodecs, TimedVersion, DataStream_OperationType, DataStream_TextHeader, DataStream_ByteHeader, DataStream_Header, DataStream_Chunk, DataStream_Trailer, SignalTarget, StreamState, CandidateProtocol, SignalRequest, SignalResponse, SimulcastCodec, AddTrackRequest, TrickleRequest, MuteTrackRequest, JoinResponse, ReconnectResponse, TrackPublishedResponse, TrackUnpublishedResponse, SessionDescription, ParticipantUpdate, UpdateSubscription, UpdateTrackSettings, UpdateLocalAudioTrack, UpdateLocalVideoTrack, LeaveRequest, LeaveRequest_Action, UpdateVideoLayers, UpdateParticipantMetadata, ICEServer, SpeakersChanged, RoomUpdate, ConnectionQualityInfo, ConnectionQualityUpdate, StreamStateInfo, StreamStateUpdate, SubscribedQuality, SubscribedCodec, SubscribedQualityUpdate, TrackPermission, SubscriptionPermission, SubscriptionPermissionUpdate, RoomMovedResponse, SyncState, DataChannelReceiveState, DataChannelInfo, SimulateScenario, Ping, Pong, RegionSettings, RegionInfo, SubscriptionResponse, RequestResponse, RequestResponse_Reason, TrackSubscribed, loglevel$1, loglevel, hasRequiredLoglevel, loglevelExports, LogLevel, LoggerNames, livekitLogger, livekitLoggers, workerLogger, maxRetryDelay, DEFAULT_RETRY_DELAYS_IN_MS, DefaultReconnectPolicy, events, hasRequiredEvents, eventsExports, logDisabled_, deprecationWarnings_, logging, chromeShim, firefoxShim, safariShim, sdp$1, hasRequiredSdp, sdpExports, SDPUtils, sdp, commonShim, ENCRYPTION_ALGORITHM, DECRYPTION_FAILURE_TOLERANCE, E2EE_FLAG, SALT, KEY_PROVIDER_DEFAULTS, KeyProviderEvent, KeyHandlerEvent, EncryptionEvent, CryptorEvent, kZerosInStartSequence, kEmulationByte, BaseKeyProvider, ExternalE2EEKeyProvider, LivekitError, ConnectionErrorReason, ConnectionError, DeviceUnsupportedError, TrackInvalidError, UnsupportedServer, UnexpectedConnectionState, NegotiationError, PublishDataError, PublishTrackError, SignalRequestError, MediaDeviceFailure, CryptorErrorReason, CryptorError, RoomEvent, ParticipantEvent, EngineEvent, TrackEvent, commonVersionIdentifier, browserDetails, browsersList, version$1, version, protocolVersion, CriticalTimers, BACKGROUND_REACTION_DELAY, recycledElements, VideoQuality, Track, VideoPreset, backupCodecs, videoCodecs, BackupCodecPolicy, AudioPresets, VideoPresets, VideoPresets43, ScreenSharePresets, separator, ddExtensionURI, resizeObserver, getResizeObserver, intersectionObserver, getIntersectionObserver, emptyVideoStreamTrack, emptyAudioStreamTrack, Future, E2EEManager, defaultId, DeviceManager, QueueTaskStatus, AsyncQueue, passThroughQueueSignals, SignalConnectionState, SignalClient, DataPacketBuffer, TTLMap, lib, parser, grammar, hasRequiredGrammar, hasRequiredParser, writer, hasRequiredWriter, hasRequiredLib, libExports, startBitrateForSVC, debounceInterval, PCEvents, PCTransport, defaultVideoCodec, publishDefaults, audioDefaults, videoDefaults, roomOptionDefaults, roomConnectOptionDefaults, PCTransportState, PCTransportManager, RpcError, MAX_PAYLOAD_BYTES, monitorFrequency, isMediaRecorderAvailable, FallbackRecorder, RecorderBase, LocalTrackRecorder, DEFAULT_DIMENSIONS_TIMEOUT, PRE_CONNECT_BUFFER_TIMEOUT, LocalTrack, LocalAudioTrack, presets169, presets43, presetsScreenShare, defaultSimulcastPresets169, defaultSimulcastPresets43, computeDefaultScreenShareSimulcastPresets, videoRids, ScalabilityMode, refreshSubscribedCodecAfterNewCodec, LocalVideoTrack, lossyDataChannel, reliableDataChannel, minReconnectWait, leaveReconnect, reliabeReceiveStateTTL, PCState, RTCEngine, SignalReconnectError, RegionUrlProvider, BaseStreamReader, ByteStreamReader, TextStreamReader, BaseStreamWriter, TextStreamWriter, ByteStreamWriter, RemoteTrack, RemoteAudioTrack, REACTION_DELAY, RemoteVideoTrack, HTMLElementInfo, TrackPublication, LocalTrackPublication, ConnectionQuality, Participant, STREAM_CHUNK_SIZE, LocalParticipant, RemoteTrackPublication, RemoteParticipant, ConnectionState, connectionReconcileFrequency, Room, Convert, attributeTypings, CheckStatus, Checker, CloudRegionCheck, TEST_DURATION, ConnectionProtocolCheck, PublishAudioCheck, PublishVideoCheck, ReconnectCheck, TURNCheck, WebRTCCheck, WebSocketCheck, ConnectionCheck, knownDeviceLabels, knownDeviceLabelSections;
 var init_livekit_client_esm = __esm({
   "node_modules/livekit-client/dist/livekit-client.esm.mjs"() {
     "use strict";
@@ -11289,6 +11899,7 @@ var init_livekit_client_esm = __esm({
     adapterFactory({
       window: typeof window === "undefined" ? void 0 : window
     });
+    ENCRYPTION_ALGORITHM = "AES-GCM";
     DECRYPTION_FAILURE_TOLERANCE = 10;
     E2EE_FLAG = "lk_e2ee";
     SALT = "LKFrameEncryptionKey";
@@ -11314,6 +11925,8 @@ var init_livekit_client_esm = __esm({
     (function(CryptorEvent2) {
       CryptorEvent2["Error"] = "cryptorError";
     })(CryptorEvent || (CryptorEvent = {}));
+    kZerosInStartSequence = 2;
+    kEmulationByte = 3;
     BaseKeyProvider = class extends eventsExports.EventEmitter {
       constructor() {
         let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
@@ -11357,6 +11970,32 @@ var init_livekit_client_esm = __esm({
         this.emit(KeyProviderEvent.RatchetRequest, participantIdentity, keyIndex);
       }
     };
+    ExternalE2EEKeyProvider = class extends BaseKeyProvider {
+      constructor() {
+        let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+        const opts = Object.assign(Object.assign({}, options), {
+          sharedKey: true,
+          // for a shared key provider failing to decrypt for a specific participant
+          // should not mark the key as invalid, so we accept wrong keys forever
+          // and won't try to auto-ratchet
+          ratchetWindowSize: 0,
+          failureTolerance: -1
+        });
+        super(opts);
+      }
+      /**
+       * Accepts a passphrase that's used to create the crypto keys.
+       * When passing in a string, PBKDF2 is used.
+       * When passing in an Array buffer of cryptographically random numbers, HKDF is being used. (recommended)
+       * @param key
+       */
+      setKey(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+          const derivedKey = typeof key === "string" ? yield createKeyMaterialFromString(key) : yield createKeyMaterialFromBuffer(key);
+          this.onSetEncryptionKey(derivedKey);
+        });
+      }
+    };
     LivekitError = class extends Error {
       constructor(code4, message) {
         super(message || "an error has occured");
@@ -11412,6 +12051,12 @@ var init_livekit_client_esm = __esm({
         this.name = "NegotiationError";
       }
     };
+    PublishDataError = class extends LivekitError {
+      constructor(message) {
+        super(14, message !== null && message !== void 0 ? message : "unable to publish data");
+        this.name = "PublishDataError";
+      }
+    };
     PublishTrackError = class extends LivekitError {
       constructor(message, status) {
         super(15, message);
@@ -11454,6 +12099,15 @@ var init_livekit_client_esm = __esm({
       CryptorErrorReason2[CryptorErrorReason2["MissingKey"] = 1] = "MissingKey";
       CryptorErrorReason2[CryptorErrorReason2["InternalError"] = 2] = "InternalError";
     })(CryptorErrorReason || (CryptorErrorReason = {}));
+    CryptorError = class extends LivekitError {
+      constructor(message) {
+        let reason = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : CryptorErrorReason.InternalError;
+        let participantIdentity = arguments.length > 2 ? arguments[2] : void 0;
+        super(40, message);
+        this.reason = reason;
+        this.participantIdentity = participantIdentity;
+      }
+    };
     (function(RoomEvent2) {
       RoomEvent2["Connected"] = "connected";
       RoomEvent2["Reconnecting"] = "reconnecting";
@@ -22182,6 +22836,24 @@ var init_livekit_client_esm = __esm({
     Room.cleanupRegistry = typeof FinalizationRegistry !== "undefined" && new FinalizationRegistry((cleanup) => {
       cleanup();
     });
+    Convert = class {
+      static toAgentAttributes(json) {
+        return JSON.parse(json);
+      }
+      static agentAttributesToJson(value) {
+        return JSON.stringify(value);
+      }
+      static toTranscriptionAttributes(json) {
+        return JSON.parse(json);
+      }
+      static transcriptionAttributesToJson(value) {
+        return JSON.stringify(value);
+      }
+    };
+    attributeTypings = /* @__PURE__ */ Object.freeze({
+      __proto__: null,
+      Convert
+    });
     (function(CheckStatus2) {
       CheckStatus2[CheckStatus2["IDLE"] = 0] = "IDLE";
       CheckStatus2[CheckStatus2["RUNNING"] = 1] = "RUNNING";
@@ -22865,142 +23537,17 @@ var init_livekit_client_esm = __esm({
         });
       }
     };
-  }
-});
-
-// src/utils/jsx-encoder.ts
-function generateStableDOMId(element3) {
-  const tagName = element3.tagName.toLowerCase();
-  const text7 = (element3.textContent || "").trim().substring(0, 50);
-  let sibling = element3.previousElementSibling;
-  let position3 = 1;
-  while (sibling) {
-    if (sibling.tagName === element3.tagName) {
-      position3++;
-    }
-    sibling = sibling.previousElementSibling;
-  }
-  const path2 = getElementPath2(element3);
-  const idString = `${tagName}[${position3}]_(${text7})_${path2}`;
-  let hash = 0;
-  for (let i2 = 0; i2 < idString.length; i2++) {
-    const char = idString.charCodeAt(i2);
-    hash = (hash << 5) - hash + char;
-    hash |= 0;
-  }
-  return hash.toString(36);
-}
-function getElementPath2(element3) {
-  if (element3.id) {
-    return `id(${element3.id})`;
-  }
-  if (element3.tagName.toLowerCase() === "body") {
-    return "/body";
-  }
-  let ix = 0;
-  const siblings = element3.parentNode?.children || new HTMLCollection();
-  for (let i2 = 0; i2 < siblings.length; i2++) {
-    const sibling = siblings[i2];
-    if (sibling === element3) {
-      return `${getElementPath2(element3.parentNode)}/${element3.tagName}[${ix + 1}]`;
-    }
-    if (sibling.nodeType === 1 && sibling.tagName === element3.tagName) {
-      ix++;
-    }
-  }
-  return "not_found";
-}
-var init_jsx_encoder = __esm({
-  "src/utils/jsx-encoder.ts"() {
-    "use strict";
-  }
-});
-
-// src/utils/patch-react.ts
-function getImmediateText(element3) {
-  let text7 = "";
-  if (element3.childNodes) {
-    for (const node2 of Array.from(element3.childNodes)) {
-      if (node2.nodeType === 3) {
-        text7 += node2.textContent || "";
-      }
-    }
-  }
-  return text7.trim();
-}
-function captureFullDOMStructure() {
-  console.log("\u{1F333} Capturing full DOM structure...");
-  const components = [];
-  const interactiveElements = document.querySelectorAll(
-    'a, button, input, textarea, select, [role="button"], [onclick]'
-  );
-  interactiveElements.forEach((element3) => {
-    if (element3 instanceof HTMLElement && !element3.closest("[data-cuekit-ignore]")) {
-      const nodeData = buildFlatDOMNode(element3);
-      if (nodeData) {
-        components.push(nodeData);
-      }
-    }
-  });
-  const result = { components };
-  console.log("\u{1F333} Full DOM structure captured:", result);
-  return result;
-}
-function buildFlatDOMNode(element3) {
-  if (element3.tagName.toLowerCase() === "script" || element3.hasAttribute("data-cuekit-ignore") || element3.style.display === "none" || element3.style.visibility === "hidden") {
-    return null;
-  }
-  const hash = generateStableDOMId(element3);
-  const text7 = getImmediateText(element3).substring(0, 100);
-  const isClickable = isElementClickable(element3);
-  const componentType = element3.tagName.toLowerCase();
-  return {
-    hash,
-    text: text7,
-    isClickable,
-    componentType,
-    children: []
-    // No children in a flat structure
-  };
-}
-function isElementClickable(element3) {
-  const interactiveSelectors = [
-    "button",
-    "a",
-    "input",
-    "select",
-    "textarea",
-    '[role="button"]',
-    '[role="link"]',
-    '[role="tab"]',
-    "[data-onclick-id]",
-    "[data-on-press-id]",
-    "[onclick]",
-    "[onmousedown]",
-    "[onmouseup]",
-    "[ontouchstart]",
-    "[ontouchend]",
-    "[onkeydown]",
-    "[onkeyup]",
-    "[onkeypress]"
-  ];
-  for (const selector of interactiveSelectors) {
-    if (element3.matches(selector)) {
-      return true;
-    }
-  }
-  const hasClickEvents = element3.onclick !== null || element3.getAttribute("onclick") !== null;
-  const hasInteractiveEvents = element3.ontouchstart !== null || element3.getAttribute("ontouchstart") !== null || element3.ontouchend !== null || element3.getAttribute("ontouchend") !== null || element3.onkeydown !== null || element3.getAttribute("onkeydown") !== null || element3.onkeyup !== null || element3.getAttribute("onkeyup") !== null || element3.onkeypress !== null || element3.getAttribute("onkeypress") !== null;
-  const hasPointerCursor = element3.style.cursor === "pointer" || getComputedStyle(element3).cursor === "pointer";
-  const hasTabIndex = element3.hasAttribute("tabindex") && parseInt(element3.getAttribute("tabindex") || "0") >= 0;
-  const hasInteractiveDataAttrs = element3.hasAttribute("data-clickable") || element3.hasAttribute("data-interactive") || element3.hasAttribute("data-action") || element3.hasAttribute("data-handler");
-  const hasInteractiveAria = element3.hasAttribute("aria-pressed") || element3.hasAttribute("aria-expanded") || element3.hasAttribute("aria-selected") || element3.hasAttribute("aria-checked");
-  return hasClickEvents || hasInteractiveEvents || hasPointerCursor || hasTabIndex || hasInteractiveDataAttrs || hasInteractiveAria;
-}
-var init_patch_react = __esm({
-  "src/utils/patch-react.ts"() {
-    "use strict";
-    init_jsx_encoder();
+    knownDeviceLabels = /* @__PURE__ */ new Map([["obs virtual camera", {
+      facingMode: "environment",
+      confidence: "medium"
+    }]]);
+    knownDeviceLabelSections = /* @__PURE__ */ new Map([["iphone", {
+      facingMode: "environment",
+      confidence: "medium"
+    }], ["ipad", {
+      facingMode: "environment",
+      confidence: "medium"
+    }]]);
   }
 });
 
@@ -23023,6 +23570,12 @@ __export(webrtc_service_exports, {
   setServerUrl: () => setServerUrl,
   setWebRTCCallbacks: () => setWebRTCCallbacks
 });
+async function getLiveKitClient() {
+  if (!livekitClient) {
+    livekitClient = await Promise.resolve().then(() => (init_livekit_client_esm(), livekit_client_esm_exports));
+  }
+  return livekitClient;
+}
 function setServerUrl(url) {
   serverUrl = url;
 }
@@ -23071,16 +23624,17 @@ async function connectToRoom(newLivekitUrl, newToken) {
   console.log("\u{1F3A4} WebRTCService: Connecting to room...", { url, hasToken: !!authToken });
   try {
     setWebRTCConnectionState({ isConnected: false, isConnecting: true });
-    room = new Room({
+    const { Room: Room3 } = await getLiveKitClient();
+    room = new Room3({
       adaptiveStream: true,
       dynacast: true
     });
-    setupEventListeners();
-    await room.connect(url, authToken);
-    console.log("\u{1F3A4} WebRTCService: Successfully connected to room:", room.name);
+    await setupEventListeners();
+    await room?.connect(url, authToken);
+    console.log("\u{1F3A4} WebRTCService: Successfully connected to room:", room?.name);
     setWebRTCConnectionState({ isConnected: true, isConnecting: false });
     try {
-      await room.localParticipant.setMicrophoneEnabled(true);
+      await room?.localParticipant.setMicrophoneEnabled(true);
       console.log("\u{1F3A4} WebRTCService: Microphone enabled");
     } catch (micError) {
       console.warn("\u{1F3A4} WebRTCService: Failed to enable microphone:", micError);
@@ -23092,57 +23646,63 @@ async function connectToRoom(newLivekitUrl, newToken) {
     throw error;
   }
 }
-function setupEventListeners() {
+async function setupEventListeners() {
   if (!room) return;
-  room.on(RoomEvent.ConnectionStateChanged, (state) => {
+  const { RoomEvent: RoomEvent2, ConnectionState: ConnectionState2, Track: Track2 } = await getLiveKitClient();
+  room.on(RoomEvent2.ConnectionStateChanged, (state) => {
     console.log("\u{1F3A4} WebRTCService: Connection state changed:", state);
     callbacks.onConnectionStateChange?.(state);
-    if (state === ConnectionState.Connected) {
+    if (state === ConnectionState2.Connected) {
       console.log("\u{1F3A4} WebRTCService: Successfully connected to room");
       setWebRTCConnectionState({ isConnected: true, isConnecting: false });
-    } else if (state === ConnectionState.Disconnected) {
+    } else if (state === ConnectionState2.Disconnected) {
       console.log("\u{1F3A4} WebRTCService: Disconnected from room");
       setWebRTCConnectionState({ isConnected: false, isConnecting: false });
-    } else if (state === ConnectionState.Connecting) {
+    } else if (state === ConnectionState2.Connecting) {
       console.log("\u{1F3A4} WebRTCService: Connecting to room...");
       setWebRTCConnectionState({ isConnected: false, isConnecting: true });
     }
-  }).on(RoomEvent.ParticipantConnected, (participant) => {
+  }).on(RoomEvent2.ParticipantConnected, (participant) => {
     console.log("\u{1F3A4} WebRTCService: Participant connected:", participant.identity);
     updateParticipantsList();
-  }).on(RoomEvent.ParticipantDisconnected, (participant) => {
+  }).on(RoomEvent2.ParticipantDisconnected, (participant) => {
     console.log("\u{1F3A4} WebRTCService: Participant disconnected:", participant.identity);
     updateParticipantsList();
-  }).on(RoomEvent.TrackSubscribed, (track, publication, participant) => {
-    if (track.kind === Track.Kind.Audio && !participant.isLocal) {
-      const isAIParticipant = participant.identity.toLowerCase().includes("ai") || participant.identity.toLowerCase().includes("bot") || !participant.identity.startsWith("user_");
-      if (isAIParticipant) {
-        const element3 = track.attach();
-        if (audioContainerRef?.current) {
-          audioContainerRef.current.appendChild(element3);
-          if (element3 instanceof HTMLAudioElement) {
-            const trackId = track.sid || `track_${Date.now()}_${Math.random()}`;
-            callbacks.onAISpeechStart?.(trackId);
-            element3.play().catch(
-              (error) => console.warn("\u{1F3A4} WebRTCService: Failed to auto-play audio:", error)
-            );
-            element3.addEventListener("ended", () => callbacks.onAISpeechEnd?.(trackId));
-            element3.addEventListener("pause", () => callbacks.onAISpeechEnd?.(trackId));
-          }
-        }
-      }
-    }
-  }).on(RoomEvent.TrackUnsubscribed, (track) => {
+  }).on(
+    RoomEvent2.TrackSubscribed,
+    (track, publication, participant) => {
+      if (track.kind === Track2.Kind.Audio && !participant.isLocal) {
+        const isAIParticipant = participant.identity.toLowerCase().includes("ai") || participant.identity.toLowerCase().includes("bot") || !participant.identity.startsWith("user_");
+        if (isAIParticipant) {
+          const element3 = track.attach();
+          if (audioContainerRef?.current) {
+            audioContainerRef.current.appendChild(element3);
+            if (element3 instanceof HTMLAudioElement) {
+              const trackId = track.sid || `track_${Date.now()}_${Math.random()}`;
+              callbacks.onAISpeechStart?.(trackId);
+              element3.play().catch(
+                (error) => console.warn("\u{1F3A4} WebRTCService: Failed to auto-play audio:", error)
+              );
+              element3.addEventListener("ended", () => callbacks.onAISpeechEnd?.(trackId));
+              element3.addEventListener("pause", () => callbacks.onAISpeechEnd?.(trackId));
+            }
+          }
+        }
+      }
+    }
+  ).on(RoomEvent2.TrackUnsubscribed, (track) => {
     track.detach().forEach((element3) => element3.remove());
-  }).on(RoomEvent.DataReceived, (payload, participant) => {
+  }).on(RoomEvent2.DataReceived, (payload, participant) => {
+    console.log("\u{1F4E1} LiveKit data received:", new TextDecoder().decode(payload));
     try {
       const message = JSON.parse(new TextDecoder().decode(payload));
+      console.log("\u{1F4E1} LiveKit data received:", message);
       callbacks.onNavigationCommand?.(message);
     } catch (error) {
       const message = new TextDecoder().decode(payload);
       callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
     }
-  }).on(RoomEvent.Disconnected, () => {
+  }).on(RoomEvent2.Disconnected, () => {
     setWebRTCConnectionState({ isConnected: false, isConnecting: false });
   });
 }
@@ -23158,14 +23718,14 @@ function updateParticipantsList() {
 async function sendData(data, reliable = true) {
   if (!room) throw new Error("Not connected to room");
   try {
+    console.log("\u{1F4E1} LiveKit data sending:", data);
     const encoder = new TextEncoder();
     const encodedData = encoder.encode(data);
     await room.localParticipant.publishData(encodedData, {
       reliable
     });
   } catch (error) {
-    console.error("Error sending data:", error);
-    throw error;
+    console.error("\u274C Failed to send data:", error);
   }
 }
 async function sendScreenStatus(screenData) {
@@ -23180,8 +23740,10 @@ async function sendScreenStatus(screenData) {
     throw error;
   }
 }
-function isConnected() {
-  return room?.state === ConnectionState.Connected;
+async function isConnected() {
+  if (!room) return false;
+  const { ConnectionState: ConnectionState2 } = await getLiveKitClient();
+  return room?.state === ConnectionState2.Connected;
 }
 function getRoomName() {
   return roomName;
@@ -23191,6 +23753,7 @@ function getParticipants() {
 }
 async function sendUserCommand(command) {
   if (!room) return;
+  console.log(`\u{1F4AC} Sending user command: "${command}"`);
   await sendData(command);
 }
 async function sendRuntimeData() {
@@ -23208,6 +23771,7 @@ async function sendRuntimeData() {
         current_screen: screenName
       }
     };
+    console.log("\u{1F4E6} Sending runtime data response");
     await sendData(JSON.stringify(response));
     console.log("\u{1F4E6} Runtime data sent successfully");
   } catch (error) {
@@ -23256,14 +23820,13 @@ async function disconnectFromRoom() {
 function getRoom() {
   return room;
 }
-var room, reconnectTimeout, serverUrl, callbacks, audioContainerRef, livekitUrl, token, roomName;
+var room, reconnectTimeout, serverUrl, callbacks, audioContainerRef, livekitUrl, token, roomName, livekitClient;
 var init_webrtc_service = __esm({
   "src/utils/webrtc-service.ts"() {
     "use strict";
-    init_livekit_client_esm();
     init_globals();
     init_constants();
-    init_patch_react();
+    init_element_service();
     init_navigation();
     room = null;
     reconnectTimeout = null;
@@ -23273,6 +23836,7 @@ var init_webrtc_service = __esm({
     livekitUrl = null;
     token = null;
     roomName = null;
+    livekitClient = null;
   }
 });
 
@@ -23877,11 +24441,10 @@ var import_react3 = require("react");
 
 // src/hooks/use-webrtc.ts
 var import_react2 = require("react");
-init_livekit_client_esm();
 init_webrtc_service();
 init_globals();
 var useWebRTC = (options) => {
-  const [isConnected3, setIsConnected] = (0, import_react2.useState)(false);
+  const [isConnected2, setIsConnected] = (0, import_react2.useState)(false);
   const [isConnecting, setIsConnecting] = (0, import_react2.useState)(false);
   const [connectionState, setConnectionState] = (0, import_react2.useState)(null);
   const [participants, setParticipants] = (0, import_react2.useState)([]);
@@ -23892,9 +24455,10 @@ var useWebRTC = (options) => {
     setAudioContainer(audioContainerRef2);
   }, []);
   (0, import_react2.useEffect)(() => {
-    const handleConnectionStateChange = (state) => {
-      setIsConnected(state === ConnectionState.Connected);
-      setIsConnecting(state === ConnectionState.Connecting);
+    const handleConnectionStateChange = async (state) => {
+      const { ConnectionState: ConnectionState2 } = await Promise.resolve().then(() => (init_livekit_client_esm(), livekit_client_esm_exports));
+      setIsConnected(state === ConnectionState2.Connected);
+      setIsConnecting(state === ConnectionState2.Connecting);
       setConnectionState(state);
       options?.onConnectionStateChange?.(state);
     };
@@ -23941,11 +24505,20 @@ var useWebRTC = (options) => {
     setIsConnected(false);
     setRoom(null);
   }, []);
+  (0, import_react2.useEffect)(() => {
+    const checkConnection = async () => {
+      const connected = await isConnected();
+      setIsConnected(connected);
+    };
+    checkConnection();
+    const interval = setInterval(checkConnection, 5e3);
+    return () => clearInterval(interval);
+  }, []);
   const memoizedParticipants = (0, import_react2.useMemo)(() => {
     return getParticipants().map((p) => p.identity);
   }, [participants]);
   return {
-    isConnected: isConnected3,
+    isConnected: isConnected2,
     isConnecting,
     connectionState,
     room: room2,
@@ -23964,144 +24537,7 @@ var useWebRTC = (options) => {
 
 // src/hooks/use-cuekit.ts
 init_webrtc_service();
-
-// src/utils/element-service.ts
-init_patch_react();
-init_navigation();
-function executeAction(action) {
-  console.log("\u{1F3AF} Executing element action:", action);
-  const { action_type, target_element, target } = action;
-  switch (action_type) {
-    case "click":
-      return clickElement(target_element);
-    case "navigate":
-      return navigateToElement(target_element || target);
-    case "input":
-    case "focus":
-      return focusElement(target_element);
-    case "toggle":
-      return toggleElement(target_element);
-    default:
-      console.warn(`\u26A0\uFE0F Unknown action type: ${action_type}`);
-      return false;
-  }
-}
-function getFullDOMStructure() {
-  console.log("\u{1F333} ElementService: Getting full DOM structure...");
-  return captureFullDOMStructure();
-}
-function clickElement(elementId) {
-  if (!elementId) {
-    console.warn("\u26A0\uFE0F No element ID provided for click action");
-    return false;
-  }
-  const domStructure = getFullDOMStructure();
-  const elementToClick = findElementById(domStructure, elementId);
-  if (elementToClick) {
-    console.log(`\u{1F3AF} Clicking element: ${elementId}`);
-    const domElement = findDOMElementById(elementId);
-    if (domElement) {
-      domElement.click();
-      return true;
-    }
-  } else {
-    console.warn(`\u26A0\uFE0F Element not found: ${elementId}`);
-  }
-  return false;
-}
-function navigateToElement(target) {
-  if (!target) {
-    console.warn("\u26A0\uFE0F No target provided for navigation action");
-    return false;
-  }
-  console.log(`\u{1F9ED} Navigating to: ${target}`);
-  if (target.includes("/") || target.startsWith("http")) {
-    safeNavigate(target, {});
-  } else {
-    handleNavigationAndClick(target, target);
-  }
-  return true;
-}
-function focusElement(elementId) {
-  if (!elementId) {
-    console.warn("\u26A0\uFE0F No element ID provided for focus action");
-    return false;
-  }
-  const domElement = findDOMElementById(elementId);
-  if (domElement instanceof HTMLInputElement || domElement instanceof HTMLTextAreaElement || domElement instanceof HTMLSelectElement) {
-    console.log(`\u{1F4DD} Focusing element: ${elementId}`);
-    domElement.focus();
-    return true;
-  } else {
-    console.warn(`\u26A0\uFE0F Focusable element not found: ${elementId}`);
-    return false;
-  }
-}
-function toggleElement(elementId) {
-  if (!elementId) {
-    console.warn("\u26A0\uFE0F No element ID provided for toggle action");
-    return false;
-  }
-  const domElement = findDOMElementById(elementId);
-  if (domElement instanceof HTMLElement) {
-    console.log(`\u{1F504} Toggling element: ${elementId}`);
-    if (domElement instanceof HTMLInputElement) {
-      if (domElement.type === "checkbox") {
-        domElement.checked = !domElement.checked;
-      } else if (domElement.type === "radio") {
-        domElement.checked = true;
-      }
-      domElement.dispatchEvent(new Event("change", { bubbles: true }));
-    } else {
-      domElement.click();
-    }
-    return true;
-  } else {
-    console.warn(`\u26A0\uFE0F Toggleable element not found: ${elementId}`);
-    return false;
-  }
-}
-function findElementById(domStructure, elementId) {
-  const searchInComponents = (components) => {
-    for (const component of components) {
-      if (component.hash === elementId) {
-        return component;
-      }
-      if (component.children.length > 0) {
-        const found = searchInComponents(component.children);
-        if (found) return found;
-      }
-    }
-    return null;
-  };
-  return searchInComponents(domStructure.components);
-}
-function findDOMElementById(elementId) {
-  const allElements = document.querySelectorAll("*");
-  for (const element3 of allElements) {
-    if (element3 instanceof HTMLElement) {
-      const hash = generateHash(element3);
-      if (hash === elementId) {
-        return element3;
-      }
-    }
-  }
-  return null;
-}
-function generateHash(element3) {
-  const tagName = element3.tagName.toLowerCase();
-  const text7 = (element3.textContent || "").trim().substring(0, 50);
-  const idString = `${tagName}_${text7}_${element3.tagName}`;
-  let hash = 0;
-  for (let i2 = 0; i2 < idString.length; i2++) {
-    const char = idString.charCodeAt(i2);
-    hash = (hash << 5) - hash + char;
-    hash |= 0;
-  }
-  return hash.toString(36);
-}
-
-// src/hooks/use-cuekit.ts
+init_element_service();
 var useCuekit = (options) => {
   const [messages, setMessages] = (0, import_react3.useState)([]);
   const currentUserMessageRef = (0, import_react3.useRef)(null);
@@ -24153,6 +24589,7 @@ var useCuekit = (options) => {
   const [micState, setMicState] = (0, import_react3.useState)("idle");
   const [status, setStatus] = (0, import_react3.useState)("");
   const handleNavigationCommand = (event) => {
+    console.log(`\u{1F9E0} Processing event in useCuekit: ${event.type}`, event);
     switch (event.type) {
       case "user_speech_chunk":
       case "ai_speech_chunk": {
@@ -24203,6 +24640,7 @@ var useCuekit = (options) => {
         break;
       }
       case "request_runtime_data": {
+        console.log("\u{1F9E0} Requesting runtime data");
         sendRuntimeData();
         break;
       }
@@ -37033,7 +37471,7 @@ var ChatPopup = ({
   onSendText,
   onEndCall,
   messages,
-  isConnected: isConnected3,
+  isConnected: isConnected2,
   micState,
   error,
   currentTheme = "dark",
@@ -37620,7 +38058,7 @@ var ChatPopup = ({
             }
           }
         ),
-        isConnected3 && onEndCall && /* @__PURE__ */ import_react9.default.createElement(
+        isConnected2 && onEndCall && /* @__PURE__ */ import_react9.default.createElement(
           "button",
           {
             type: "submit",
@@ -39819,7 +40257,7 @@ var MicButton = ({
   const aiSpeechTimeoutRef = (0, import_react15.useRef)(null);
   const activeAITracksRef = (0, import_react15.useRef)(/* @__PURE__ */ new Set());
   const {
-    isConnected: isConnected3,
+    isConnected: isConnected2,
     isConnecting,
     error: voiceError,
     connect: voiceConnect,
@@ -39849,6 +40287,7 @@ var MicButton = ({
     console.log("\u{1F3A4} MicButton received messages:", JSON.stringify(messageManagerMessages, null, 2));
   }, [messageManagerMessages]);
   (0, import_react15.useEffect)(() => {
+    if (typeof window === "undefined") return;
     const checkTheme = () => {
       if (typeof document !== "undefined") {
         let newTheme;
@@ -39862,6 +40301,7 @@ var MicButton = ({
       }
     };
     checkTheme();
+    if (typeof window === "undefined") return;
     if (defaultTheme === "system") {
       const observer = new MutationObserver(checkTheme);
       observer.observe(document.documentElement, {
@@ -39904,8 +40344,8 @@ var MicButton = ({
       console.log("\u{1F3A4} MicButton: Current active AI tracks:", Array.from(activeAITracksRef.current));
       console.log("\u{1F3A4} MicButton: Current status:", status);
       console.log("\u{1F3A4} MicButton: Current mic state:", micState);
-      console.log("\u{1F3A4} MicButton: Is listening:", isConnected3);
-      console.log("\u{1F3A4} MicButton: Is connected:", isConnected3);
+      console.log("\u{1F3A4} MicButton: Is listening:", isConnected2);
+      console.log("\u{1F3A4} MicButton: Is connected:", isConnected2);
       if (isSpeaking && trackId) {
         console.log("\u{1F3A4} MicButton: ===== AI SPEECH START =====");
         console.log("\u{1F3A4} MicButton: Adding track to active set:", trackId);
@@ -39960,7 +40400,7 @@ var MicButton = ({
       console.log("\u{1F3A4} MicButton: - Status:", status);
       console.log("\u{1F3A4} MicButton: ================================");
     },
-    [status, micState, isConnected3]
+    [status, micState, isConnected2]
   );
   (0, import_react15.useEffect)(() => {
     if (audioContainerRef2.current) {
@@ -39973,9 +40413,9 @@ var MicButton = ({
       }
     };
   }, [handleAISpeech]);
-  const isListening = isConnected3;
-  const getUserFriendlyStatus = (micState2, isConnected4) => {
-    if (!isConnected4) {
+  const isListening = isConnected2;
+  const getUserFriendlyStatus = (micState2, isConnected3) => {
+    if (!isConnected3) {
       return "Connecting...";
     }
     if (status && !status.includes("error") && !status.includes("failed") && !status.includes("Connection error") && !status.includes("Unable to")) {
@@ -39985,28 +40425,28 @@ var MicButton = ({
     if (micState2 === "thinking") return "Thinking...";
     if (micState2 === "replying") return "Responding...";
     if (micState2 === "idle") {
-      if (isConnected4) return "Listening...";
+      if (isConnected3) return "Listening...";
       return "Connecting...";
     }
-    return isConnected4 ? "Ready" : "Connecting...";
+    return isConnected3 ? "Ready" : "Connecting...";
   };
   (0, import_react15.useEffect)(() => {
-    if (isConnected3) {
+    if (isConnected2) {
       console.log("\u{1F3A4} MicButton: WebRTC and SSE connections established - ready for commands");
     } else {
       console.log("\u{1F3A4} MicButton: WebRTC not yet connected - ignoring speech");
     }
-  }, [isConnected3]);
+  }, [isConnected2]);
   (0, import_react15.useEffect)(() => {
     console.log("\u{1F3A4} MicButton: Auto-open check:", {
-      isConnected: isConnected3,
+      isConnected: isConnected2,
       chatIsOpen: isChatOpen
     });
-    if (isConnected3 && !isChatOpen) {
+    if (isConnected2 && !isChatOpen) {
       console.log("\u{1F3A4} MicButton: Auto-opening chat popup");
       openChat();
     }
-  }, [isConnected3, isChatOpen, openChat]);
+  }, [isConnected2, isChatOpen, openChat]);
   (0, import_react15.useEffect)(() => {
     if (messageManagerMessages.length > 0 && !isChatOpen) {
       console.log("\u{1F3A4} MicButton: Auto-opening chat popup due to messages");
@@ -40014,7 +40454,7 @@ var MicButton = ({
     }
   }, [messageManagerMessages.length, isChatOpen, openChat]);
   const handleMicClick = (0, import_react15.useCallback)(() => {
-    const shouldStop = micState === "listening" && isConnected3;
+    const shouldStop = micState === "listening" && isConnected2;
     if (shouldStop) {
       console.log("\u{1F3A4} MicButton: User wants to stop - closing everything");
       voiceDisconnect().then(() => {
@@ -40039,7 +40479,7 @@ var MicButton = ({
     }
   }, [
     micState,
-    isConnected3,
+    isConnected2,
     voiceDisconnect,
     voiceConnect,
     apiKey,
@@ -40054,7 +40494,7 @@ var MicButton = ({
     if (!isChatOpen) {
       openChat();
     }
-    if (isConnected3) {
+    if (isConnected2) {
       console.log("\u{1F3A4} MicButton: Sending via WebRTC");
       try {
         await sendUserCommand2(textToSend);
@@ -40251,13 +40691,13 @@ var MicButton = ({
         text: msg.text,
         sender: msg.role === "ai" ? "assistant" : "user"
       })),
-      isConnected: isConnected3 ?? false,
+      isConnected: isConnected2 ?? false,
       micState,
       participants,
       error: voiceError,
       currentTheme,
       onThemeToggle: setCurrentTheme,
-      status: getUserFriendlyStatus(micState, isConnected3 ?? false),
+      status: getUserFriendlyStatus(micState, isConnected2 ?? false),
       anchor: { position: screenPosition, bottom: bottomSpace, size: buttonSize }
     }
   ), isChatOpen && isChatMinimized && /* @__PURE__ */ import_react15.default.createElement(
@@ -40286,4 +40726,5 @@ var MicButton = ({
 };
 
 // src/index.ts
-init_patch_react();
+init_element_service();
+init_element_service();