@cuekit-ai/react 1.3.2 → 1.3.4

package/dist/{chunk-H44FBEX3.mjs → chunk-ZGHSIEXZ.mjs}

@@ -1,3 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
 // node_modules/livekit-client/dist/livekit-client.esm.mjs
 function _mergeNamespaces(n, m) {
   m.forEach(function(e2) {
@@ -5685,34 +5721,6 @@ function getLogger(name) {
   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(extension, 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) {
-          extension(logLevel, msg, context);
-        }
-      };
-    };
-    logR.setLevel(logR.getLevel());
-  });
-}
 var workerLogger = loglevelExports.getLogger("lk-e2ee");
 var maxRetryDelay = 7e3;
 var DEFAULT_RETRY_DELAYS_IN_MS = [0, 300, 2 * 2 * 300, 3 * 3 * 300, 4 * 4 * 300, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay, maxRetryDelay];
@@ -8676,7 +8684,6 @@ function adapterFactory() {
 adapterFactory({
   window: typeof window === "undefined" ? void 0 : window
 });
-var ENCRYPTION_ALGORITHM = "AES-GCM";
 var DECRYPTION_FAILURE_TOLERANCE = 10;
 var E2EE_FLAG = "lk_e2ee";
 var SALT = "LKFrameEncryptionKey";
@@ -8716,120 +8723,6 @@ 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 i = 0; i < frameData.length - 3; i++) {
-    if (frameData[i] == 0 && frameData[i + 1] == 0 && frameData[i + 2] == 3) return true;
-  }
-  return false;
-}
-function parseRbsp(stream) {
-  const dataOut = [];
-  var length = stream.length;
-  for (var i = 0; i < stream.length; ) {
-    if (length - i >= 3 && !stream[i] && !stream[i + 1] && stream[i + 2] == 3) {
-      dataOut.push(stream[i++]);
-      dataOut.push(stream[i++]);
-      i++;
-    } else {
-      dataOut.push(stream[i++]);
-    }
-  }
-  return new Uint8Array(dataOut);
-}
-var kZerosInStartSequence = 2;
-var kEmulationByte = 3;
-function writeRbsp(data_in) {
-  const dataOut = [];
-  var numConsecutiveZeros = 0;
-  for (var i = 0; i < data_in.length; ++i) {
-    var byte = data_in[i];
-    if (byte <= kEmulationByte && numConsecutiveZeros >= kZerosInStartSequence) {
-      dataOut.push(kEmulationByte);
-      numConsecutiveZeros = 0;
-    }
-    dataOut.push(byte);
-    if (byte == 0) {
-      ++numConsecutiveZeros;
-    } else {
-      numConsecutiveZeros = 0;
-    }
-  }
-  return new Uint8Array(dataOut);
-}
 var BaseKeyProvider = class extends eventsExports.EventEmitter {
   constructor() {
     let options = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
@@ -8873,32 +8766,6 @@ var BaseKeyProvider = class extends eventsExports.EventEmitter {
     this.emit(KeyProviderEvent.RatchetRequest, participantIdentity, keyIndex);
   }
 };
-var 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);
-    });
-  }
-};
 var LivekitError = class extends Error {
   constructor(code, message) {
     super(message || "an error has occured");
@@ -8955,12 +8822,6 @@ var NegotiationError = class extends LivekitError {
     this.name = "NegotiationError";
   }
 };
-var PublishDataError = class extends LivekitError {
-  constructor(message) {
-    super(14, message !== null && message !== void 0 ? message : "unable to publish data");
-    this.name = "PublishDataError";
-  }
-};
 var PublishTrackError = class extends LivekitError {
   constructor(message, status) {
     super(15, message);
@@ -9005,15 +8866,6 @@ var CryptorErrorReason;
   CryptorErrorReason2[CryptorErrorReason2["MissingKey"] = 1] = "MissingKey";
   CryptorErrorReason2[CryptorErrorReason2["InternalError"] = 2] = "InternalError";
 })(CryptorErrorReason || (CryptorErrorReason = {}));
-var 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;
-  }
-};
 var RoomEvent;
 (function(RoomEvent2) {
   RoomEvent2["Connected"] = "connected";
@@ -9705,12 +9557,6 @@ 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;
@@ -9827,8 +9673,8 @@ function isWeb() {
 function isReactNative() {
   return navigator.product == "ReactNative";
 }
-function isCloud(serverUrl) {
-  return serverUrl.hostname.endsWith(".livekit.cloud") || serverUrl.hostname.endsWith(".livekit.run");
+function isCloud(serverUrl2) {
+  return serverUrl2.hostname.endsWith(".livekit.cloud") || serverUrl2.hostname.endsWith(".livekit.run");
 }
 function getLKReactNativeInfo() {
   if (global && global.LiveKitReactNativeGlobal) {
@@ -9913,13 +9759,6 @@ function getClientInfo() {
   }
   return info;
 }
-var emptyVideoStreamTrack;
-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;
@@ -10153,9 +9992,6 @@ 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);
@@ -10530,14 +10366,14 @@ var E2EEManager = class extends eventsExports.EventEmitter {
   /**
    * @internal
    */
-  setup(room) {
+  setup(room2) {
     if (!isE2EESupported()) {
       throw new DeviceUnsupportedError("tried to setup end-to-end encryption on an unsupported browser");
     }
     livekitLogger.info("setting up e2ee");
-    if (room !== this.room) {
-      this.room = room;
-      this.setupEventListeners(room, this.keyProvider);
+    if (room2 !== this.room) {
+      this.room = room2;
+      this.setupEventListeners(room2, this.keyProvider);
       const msg = {
         kind: "init",
         data: {
@@ -10577,11 +10413,11 @@ var E2EEManager = class extends eventsExports.EventEmitter {
       this.postRTPMap(rtpMap);
     });
   }
-  setupEventListeners(room, keyProvider) {
-    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
-    room.on(RoomEvent.ConnectionStateChanged, (state) => {
+  setupEventListeners(room2, keyProvider) {
+    room2.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
+    room2.on(RoomEvent.ConnectionStateChanged, (state) => {
       if (state === ConnectionState.Connected) {
-        room.remoteParticipants.forEach((participant) => {
+        room2.remoteParticipants.forEach((participant) => {
           participant.trackPublications.forEach((pub) => {
             this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity);
           });
@@ -10608,7 +10444,7 @@ var E2EEManager = class extends eventsExports.EventEmitter {
       });
       this.setParticipantCryptorEnabled(this.room.localParticipant.isE2EEEnabled, this.room.localParticipant.identity);
     });
-    room.localParticipant.on(ParticipantEvent.LocalSenderCreated, (sender, track) => __awaiter(this, void 0, void 0, function* () {
+    room2.localParticipant.on(ParticipantEvent.LocalSenderCreated, (sender, track) => __awaiter(this, void 0, void 0, function* () {
       this.setupE2EESender(track, sender);
     }));
     keyProvider.on(KeyProviderEvent.SetKey, (keyInfo) => this.postKey(keyInfo)).on(KeyProviderEvent.RatchetRequest, (participantId, keyIndex) => this.postRatchetRequest(participantId, keyIndex));
@@ -11017,15 +10853,15 @@ var SignalClient = class {
     var _a, _b;
     return (_b = (_a = this.loggerContextCb) === null || _a === void 0 ? void 0 : _a.call(this)) !== null && _b !== void 0 ? _b : {};
   }
-  join(url, token, opts, abortSignal) {
+  join(url, token2, opts, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
       this.state = SignalConnectionState.CONNECTING;
       this.options = opts;
-      const res = yield this.connect(url, token, opts, abortSignal);
+      const res = yield this.connect(url, token2, opts, abortSignal);
       return res;
     });
   }
-  reconnect(url, token, sid, reason) {
+  reconnect(url, token2, sid, reason) {
     return __awaiter(this, void 0, void 0, function* () {
       if (!this.options) {
         this.log.warn("attempted to reconnect without signal options being set, ignoring", this.logContext);
@@ -11033,7 +10869,7 @@ var SignalClient = class {
       }
       this.state = SignalConnectionState.RECONNECTING;
       this.clearPingInterval();
-      const res = yield this.connect(url, token, Object.assign(Object.assign({}, this.options), {
+      const res = yield this.connect(url, token2, Object.assign(Object.assign({}, this.options), {
         reconnect: true,
         sid,
         reconnectReason: reason
@@ -11041,10 +10877,10 @@ var SignalClient = class {
       return res;
     });
   }
-  connect(url, token, opts, abortSignal) {
+  connect(url, token2, opts, abortSignal) {
     this.connectOptions = opts;
     const clientInfo = getClientInfo();
-    const params = createConnectionParams(token, clientInfo, opts);
+    const params = createConnectionParams(token2, clientInfo, opts);
     const rtcUrl = createRtcUrl(url, params);
     const validateUrl = createValidateUrl(rtcUrl);
     return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -11586,10 +11422,10 @@ function toProtoSessionDescription(rsd, id) {
   });
   return sd;
 }
-function createConnectionParams(token, info, opts) {
+function createConnectionParams(token2, info, opts) {
   var _a;
   const params = new URLSearchParams();
-  params.set("access_token", token);
+  params.set("access_token", token2);
   if (opts.reconnect) {
     params.set("reconnect", "1");
     if (opts.sid) {
@@ -15445,16 +15281,16 @@ var RTCEngine = class extends eventsExports.EventEmitter {
       pID: this.participantSid
     };
   }
-  join(url, token, opts, abortSignal) {
+  join(url, token2, opts, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
       this.url = url;
-      this.token = token;
+      this.token = token2;
       this.signalOpts = opts;
       this.maxJoinAttempts = opts.maxRetries;
       try {
         this.joinAttempts += 1;
         this.setupSignalClientCallbacks();
-        const joinResponse = yield this.client.join(url, token, opts, abortSignal);
+        const joinResponse = yield this.client.join(url, token2, opts, abortSignal);
         this._isClosed = false;
         this.latestJoinResponse = joinResponse;
         this.subscriberPrimary = joinResponse.subscriberPrimary;
@@ -15472,7 +15308,7 @@ var RTCEngine = class extends eventsExports.EventEmitter {
           if (e2.reason === ConnectionErrorReason.ServerUnreachable) {
             this.log.warn("Couldn't connect to server, attempt ".concat(this.joinAttempts, " of ").concat(this.maxJoinAttempts), this.logContext);
             if (this.joinAttempts < this.maxJoinAttempts) {
-              return this.join(url, token, opts, abortSignal);
+              return this.join(url, token2, opts, abortSignal);
             }
           }
         }
@@ -15702,8 +15538,8 @@ var RTCEngine = class extends eventsExports.EventEmitter {
     this.client.onLocalTrackSubscribed = (trackSid) => {
       this.emit(EngineEvent.LocalTrackSubscribed, trackSid);
     };
-    this.client.onTokenRefresh = (token) => {
-      this.token = token;
+    this.client.onTokenRefresh = (token2) => {
+      this.token = token2;
     };
     this.client.onRemoteMuteChanged = (trackSid, muted) => {
       this.emit(EngineEvent.RemoteMute, trackSid, muted);
@@ -16390,15 +16226,15 @@ function applyUserDataCompat(newObj, oldObj) {
   oldObj.destinationIdentities = destinationIdentities;
 }
 var RegionUrlProvider = class {
-  constructor(url, token) {
+  constructor(url, token2) {
     this.lastUpdateAt = 0;
     this.settingsCacheTime = 3e3;
     this.attemptedRegions = [];
     this.serverUrl = new URL(url);
-    this.token = token;
+    this.token = token2;
   }
-  updateToken(token) {
-    this.token = token;
+  updateToken(token2) {
+    this.token = token2;
   }
   isCloud() {
     return isCloud(this.serverUrl);
@@ -16451,8 +16287,8 @@ var RegionUrlProvider = class {
     this.lastUpdateAt = Date.now();
   }
 };
-function getCloudConfigUrl(serverUrl) {
-  return "".concat(serverUrl.protocol.replace("ws", "http"), "//").concat(serverUrl.host, "/settings");
+function getCloudConfigUrl(serverUrl2) {
+  return "".concat(serverUrl2.protocol.replace("ws", "http"), "//").concat(serverUrl2.host, "/settings");
 }
 var BaseStreamReader = class {
   get info() {
@@ -17615,34 +17451,6 @@ 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;
-  });
-}
 var ConnectionQuality;
 (function(ConnectionQuality2) {
   ConnectionQuality2["Excellent"] = "excellent";
@@ -20319,7 +20127,7 @@ var Room = class _Room extends eventsExports.EventEmitter {
     this.byteStreamHandlers = /* @__PURE__ */ new Map();
     this.textStreamHandlers = /* @__PURE__ */ new Map();
     this.rpcHandlers = /* @__PURE__ */ new Map();
-    this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
+    this.connect = (url, token2, opts) => __awaiter(this, void 0, void 0, function* () {
       var _a2;
       if (!isBrowserSupported()) {
         if (isReactNative()) {
@@ -20345,9 +20153,9 @@ var Room = class _Room extends eventsExports.EventEmitter {
       }
       if (isCloud(new URL(url))) {
         if (this.regionUrlProvider === void 0) {
-          this.regionUrlProvider = new RegionUrlProvider(url, token);
+          this.regionUrlProvider = new RegionUrlProvider(url, token2);
         } else {
-          this.regionUrlProvider.updateToken(token);
+          this.regionUrlProvider.updateToken(token2);
         }
         this.regionUrlProvider.fetchRegionSettings().then((settings) => {
           var _a3;
@@ -20367,7 +20175,7 @@ var Room = class _Room extends eventsExports.EventEmitter {
         this.abortController = abortController;
         unlockDisconnect === null || unlockDisconnect === void 0 ? void 0 : unlockDisconnect();
         try {
-          yield this.attemptConnection(regionUrl2 !== null && regionUrl2 !== void 0 ? regionUrl2 : url, token, opts, abortController);
+          yield this.attemptConnection(regionUrl2 !== null && regionUrl2 !== void 0 ? regionUrl2 : url, token2, opts, abortController);
           this.abortController = void 0;
           resolve();
         } catch (e2) {
@@ -20409,9 +20217,9 @@ var Room = class _Room extends eventsExports.EventEmitter {
       });
       return this.connectFuture.promise;
     });
-    this.connectSignal = (url, token, engine, connectOptions, roomOptions, abortController) => __awaiter(this, void 0, void 0, function* () {
+    this.connectSignal = (url, token2, engine, connectOptions, roomOptions, abortController) => __awaiter(this, void 0, void 0, function* () {
       var _a2, _b2, _c2;
-      const joinResponse = yield engine.join(url, token, {
+      const joinResponse = yield engine.join(url, token2, {
         autoSubscribe: connectOptions.autoSubscribe,
         adaptiveStream: typeof roomOptions.adaptiveStream === "object" ? true : roomOptions.adaptiveStream,
         maxRetries: connectOptions.maxRetries,
@@ -20462,7 +20270,7 @@ var Room = class _Room extends eventsExports.EventEmitter {
         this.handleRoomUpdate(joinResponse.room);
       }
     };
-    this.attemptConnection = (url, token, opts, abortController) => __awaiter(this, void 0, void 0, function* () {
+    this.attemptConnection = (url, token2, opts, abortController) => __awaiter(this, void 0, void 0, function* () {
       var _a2, _b2;
       if (this.state === ConnectionState.Reconnecting || this.isResuming || ((_a2 = this.engine) === null || _a2 === void 0 ? void 0 : _a2.pendingReconnect)) {
         this.log.info("Reconnection attempt replaced by new connection attempt", this.logContext);
@@ -20482,7 +20290,7 @@ var Room = class _Room extends eventsExports.EventEmitter {
         this.engine.peerConnectionTimeout = this.connOptions.peerConnectionTimeout;
       }
       try {
-        const joinResponse = yield this.connectSignal(url, token, this.engine, this.connOptions, this.options, abortController);
+        const joinResponse = yield this.connectSignal(url, token2, this.engine, this.connOptions, this.options, abortController);
         this.applyJoinResponse(joinResponse);
         this.setupLocalParticipantEvents();
         this.emit(RoomEvent.SignalConnected);
@@ -20878,14 +20686,14 @@ var Room = class _Room extends eventsExports.EventEmitter {
       }
       this.emit(RoomEvent.MediaDevicesChanged);
     });
-    this.handleRoomUpdate = (room) => {
+    this.handleRoomUpdate = (room2) => {
       const oldRoom = this.roomInfo;
-      this.roomInfo = room;
-      if (oldRoom && oldRoom.metadata !== room.metadata) {
-        this.emitWhenConnected(RoomEvent.RoomMetadataChanged, room.metadata);
+      this.roomInfo = room2;
+      if (oldRoom && oldRoom.metadata !== room2.metadata) {
+        this.emitWhenConnected(RoomEvent.RoomMetadataChanged, room2.metadata);
       }
-      if ((oldRoom === null || oldRoom === void 0 ? void 0 : oldRoom.activeRecording) !== room.activeRecording) {
-        this.emitWhenConnected(RoomEvent.RecordingStatusChanged, room.activeRecording);
+      if ((oldRoom === null || oldRoom === void 0 ? void 0 : oldRoom.activeRecording) !== room2.activeRecording) {
+        this.emitWhenConnected(RoomEvent.RecordingStatusChanged, room2.activeRecording);
       }
     };
     this.handleConnectionQualityUpdate = (update) => {
@@ -21282,15 +21090,15 @@ var Room = class _Room extends eventsExports.EventEmitter {
    * With LiveKit Cloud, it will also determine the best edge data center for
    * the current client to connect to if a token is provided.
    */
-  prepareConnection(url, token) {
+  prepareConnection(url, token2) {
     return __awaiter(this, void 0, void 0, function* () {
       if (this.state !== ConnectionState.Disconnected) {
         return;
       }
       this.log.debug("prepareConnection to ".concat(url), this.logContext);
       try {
-        if (isCloud(new URL(url)) && token) {
-          this.regionUrlProvider = new RegionUrlProvider(url, token);
+        if (isCloud(new URL(url)) && token2) {
+          this.regionUrlProvider = new RegionUrlProvider(url, token2);
           const regionUrl = yield this.regionUrlProvider.getNextBestRegionUrl();
           if (regionUrl && this.state === ConnectionState.Disconnected) {
             this.regionUrl = regionUrl;
@@ -22148,24 +21956,6 @@ function mapArgs(args) {
     return arg;
   });
 }
-var 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);
-  }
-};
-var attributeTypings = /* @__PURE__ */ Object.freeze({
-  __proto__: null,
-  Convert
-});
 var CheckStatus;
 (function(CheckStatus2) {
   CheckStatus2[CheckStatus2["IDLE"] = 0] = "IDLE";
@@ -22175,14 +21965,14 @@ var CheckStatus;
   CheckStatus2[CheckStatus2["FAILED"] = 4] = "FAILED";
 })(CheckStatus || (CheckStatus = {}));
 var Checker = class extends eventsExports.EventEmitter {
-  constructor(url, token) {
+  constructor(url, token2) {
     let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
     super();
     this.status = CheckStatus.IDLE;
     this.logs = [];
     this.options = {};
     this.url = url;
-    this.token = token;
+    this.token = token2;
     this.name = this.constructor.name;
     this.room = new Room(options.roomOptions);
     this.connectOptions = options.connectOptions;
@@ -22494,14 +22284,14 @@ var PublishAudioCheck = class extends Checker {
   perform() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const room = yield this.connect();
+      const room2 = yield this.connect();
       const track = yield createLocalAudioTrack();
       const trackIsSilent = yield detectSilence(track, 1e3);
       if (trackIsSilent) {
         throw new Error("unable to detect audio from microphone");
       }
       this.appendMessage("detected audio from microphone");
-      room.localParticipant.publishTrack(track);
+      room2.localParticipant.publishTrack(track);
       yield new Promise((resolve) => setTimeout(resolve, 3e3));
       const stats = yield (_a = track.sender) === null || _a === void 0 ? void 0 : _a.getStats();
       if (!stats) {
@@ -22527,10 +22317,10 @@ var PublishVideoCheck = class extends Checker {
   perform() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const room = yield this.connect();
+      const room2 = yield this.connect();
       const track = yield createLocalVideoTrack();
       yield this.checkForVideo(track.mediaStreamTrack);
-      room.localParticipant.publishTrack(track);
+      room2.localParticipant.publishTrack(track);
       yield new Promise((resolve) => setTimeout(resolve, 5e3));
       const stats = yield (_a = track.sender) === null || _a === void 0 ? void 0 : _a.getStats();
       if (!stats) {
@@ -22598,30 +22388,30 @@ var ReconnectCheck = class extends Checker {
   perform() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const room = yield this.connect();
+      const room2 = yield this.connect();
       let reconnectingTriggered = false;
       let reconnected = false;
       let reconnectResolver;
-      const reconnectTimeout = new Promise((resolve) => {
+      const reconnectTimeout2 = new Promise((resolve) => {
         setTimeout(resolve, 5e3);
         reconnectResolver = resolve;
       });
       const handleReconnecting = () => {
         reconnectingTriggered = true;
       };
-      room.on(RoomEvent.SignalReconnecting, handleReconnecting).on(RoomEvent.Reconnecting, handleReconnecting).on(RoomEvent.Reconnected, () => {
+      room2.on(RoomEvent.SignalReconnecting, handleReconnecting).on(RoomEvent.Reconnecting, handleReconnecting).on(RoomEvent.Reconnected, () => {
         reconnected = true;
         reconnectResolver(true);
       });
-      (_a = room.engine.client.ws) === null || _a === void 0 ? void 0 : _a.close();
-      const onClose = room.engine.client.onClose;
+      (_a = room2.engine.client.ws) === null || _a === void 0 ? void 0 : _a.close();
+      const onClose = room2.engine.client.onClose;
       if (onClose) {
         onClose("");
       }
-      yield reconnectTimeout;
+      yield reconnectTimeout2;
       if (!reconnectingTriggered) {
         throw new Error("Did not attempt to reconnect");
-      } else if (!reconnected || room.state !== ConnectionState.Connected) {
+      } else if (!reconnected || room2.state !== ConnectionState.Connected) {
         this.appendWarning("reconnection is only possible in Redis-based configurations");
         throw new Error("Not able to reconnect");
       }
@@ -22778,13 +22568,13 @@ var WebSocketCheck = class extends Checker {
   }
 };
 var ConnectionCheck = class extends eventsExports.EventEmitter {
-  constructor(url, token) {
+  constructor(url, token2) {
     let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
     super();
     this.options = {};
     this.checkResults = /* @__PURE__ */ new Map();
     this.url = url;
-    this.token = token;
+    this.token = token2;
     this.options = options;
   }
   getNextCheckId() {
@@ -22866,172 +22656,722 @@ var ConnectionCheck = class extends eventsExports.EventEmitter {
     });
   }
 };
-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"
-      };
+
+// src/core/globals.ts
+var _apiKey = "";
+var _appId = "";
+var setApiKey = (key) => _apiKey = key;
+var setAppId = (id) => _appId = id;
+var _webRTCConfig = null;
+var _webRTCConnectionState = {
+  isConnected: false,
+  isConnecting: false,
+  participants: []
+};
+var setWebRTCConfig = (config) => _webRTCConfig = config;
+var setWebRTCConnectionState = (state) => {
+  _webRTCConnectionState = { ..._webRTCConnectionState, ...state };
+};
+
+// src/constants/index.ts
+var WEBRTC_BACKEND_SERVER_URL = "https://api-webrtc-dev.ansyr.ai";
+
+// src/core/intent-store.ts
+var store = {
+  screenMetadata: {},
+  allElementsData: []
+};
+var GlobalStore = {
+  // 🔹 Screen Metadata Methods
+  setMetadata(screen, metadata) {
+    store.screenMetadata[screen] = metadata;
+  },
+  getMetadata(screen) {
+    return store.screenMetadata[screen];
+  },
+  clearMetadata(screen) {
+    delete store.screenMetadata[screen];
+  },
+  // 🔹 Generic Store Access Methods
+  setData(key, value) {
+    store[key] = value;
+  },
+  getData(key) {
+    return store[key];
+  },
+  clearData(key) {
+    delete store[key];
+  },
+  // 🔹 Element Data Management
+  setElement(elementData) {
+    const index = store.allElementsData.findIndex((e2) => e2.elementId === elementData.elementId);
+    if (index >= 0) {
+      store.allElementsData[index] = elementData;
+    } else {
+      store.allElementsData.push(elementData);
+    }
+  },
+  getElementById(elementId) {
+    const match = store.allElementsData.find((e2) => e2.elementId === elementId);
+    if (!match) {
     }
+    return match;
+  },
+  deleteElementById(id) {
+    store.allElementsData = store.allElementsData.filter((e2) => e2.elementId !== id);
+  },
+  clearAllElements() {
+    store.allElementsData = [];
   }
-  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;
+};
+
+// src/core/navigation.ts
+var navigation;
+var navigationHandler = null;
+function setNavigationHandler(handler) {
+  navigationHandler = handler;
+}
+function navigate(path, params) {
+  const safeParams = params || {};
+  const absolutePath = path.startsWith("/") ? path : `/${path}`;
+  if (navigationHandler) {
+    try {
+      navigationHandler(absolutePath, safeParams);
+    } catch (error) {
+    }
+    return;
+  }
+  let fullPath = absolutePath;
+  if (safeParams) {
+    const searchParams = new URLSearchParams(safeParams).toString();
+    if (searchParams) {
+      fullPath += `?${searchParams}`;
+    }
+  }
+  if (navigation) {
+    navigation.push(fullPath);
+  } else {
+    if (typeof window !== "undefined") {
+      window.location.href = fullPath;
     }
   }
+}
+var getCurrentPath = () => {
+  if (typeof window === "undefined") return "";
+  return window.location.pathname;
+};
+var getSearchParams = () => {
+  if (typeof window === "undefined") return new URLSearchParams();
+  return new URLSearchParams(window.location.search);
+};
+var safeNavigate = (name, params = {}) => {
+  if (name) {
+    navigate(name, params);
+  } else {
+  }
+};
+function getCurrentScreenName() {
+  try {
+    const path = getCurrentPath();
+    return path || "UnknownScreen";
+  } catch (e2) {
+    return "UnknownScreen";
+  }
+}
+function getCurrentRouteParams() {
+  try {
+    const params = {};
+    const searchParams = getSearchParams();
+    if (searchParams instanceof URLSearchParams) {
+      searchParams.forEach((value, key) => {
+        params[key] = value;
+      });
+    } else {
+      return searchParams;
+    }
+    return params;
+  } catch (e2) {
+    return {};
+  }
+}
+function onStateChange() {
+  const routeName = getCurrentScreenName();
+  const params = getCurrentRouteParams();
+  if (params && params.metadata) {
+    try {
+      const metadata = JSON.parse(params.metadata);
+      GlobalStore.setMetadata(routeName, metadata);
+    } catch (error) {
+    }
+  }
+}
+var handleNavigationAndClick = (routeName, elementHash) => {
+  safeNavigate(routeName);
+  if (typeof MutationObserver === "undefined" || typeof document === "undefined") return;
+  const observer = new MutationObserver((mutationsList, observer2) => {
+    setTimeout(() => {
+      const allElements = document.querySelectorAll("*");
+      let elementToClick = null;
+      for (const element of allElements) {
+        if (element instanceof HTMLElement) {
+          const tagName = element.tagName.toLowerCase();
+          const text = (element.textContent || "").trim().substring(0, 50);
+          let sibling = element.previousElementSibling;
+          let position = 1;
+          while (sibling) {
+            if (sibling.tagName === element.tagName) {
+              position++;
+            }
+            sibling = sibling.previousElementSibling;
+          }
+          const path = getElementPath(element);
+          const idString = `${tagName}[${position}]_(${text})_${path}`;
+          let hash = 0;
+          for (let i = 0; i < idString.length; i++) {
+            const char = idString.charCodeAt(i);
+            hash = (hash << 5) - hash + char;
+            hash |= 0;
+          }
+          const elementHashValue = hash.toString(36);
+          if (elementHashValue === elementHash) {
+            elementToClick = element;
+            break;
+          }
+        }
+      }
+      if (elementToClick) {
+        elementToClick.click();
+        observer2.disconnect();
+      }
+    }, 100);
+  });
+  observer.observe(document.body, { childList: true, subtree: true });
+};
+function getElementPath(element) {
+  if (element.id) {
+    return `id(${element.id})`;
+  }
+  const path = [];
+  let current = element;
+  while (current && current !== document.body) {
+    let index = 1;
+    let sibling = current.previousElementSibling;
+    while (sibling) {
+      if (sibling.tagName === current.tagName) {
+        index++;
+      }
+      sibling = sibling.previousElementSibling;
+    }
+    path.unshift(`${current.tagName.toLowerCase()}[${index}]`);
+    current = current.parentElement;
+  }
+  return path.join("/");
+}
+
+// src/utils/jsx-encoder.ts
+function generateStableDOMId(element) {
+  const tagName = element.tagName.toLowerCase();
+  const text = (element.textContent || "").trim().substring(0, 50);
+  let sibling = element.previousElementSibling;
+  let position = 1;
+  while (sibling) {
+    if (sibling.tagName === element.tagName) {
+      position++;
+    }
+    sibling = sibling.previousElementSibling;
+  }
+  const path = getElementPath2(element);
+  const idString = `${tagName}[${position}]_(${text})_${path}`;
+  let hash = 0;
+  for (let i = 0; i < idString.length; i++) {
+    const char = idString.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash |= 0;
+  }
+  return hash.toString(36);
+}
+function getElementPath2(element) {
+  if (element.id) {
+    return `id(${element.id})`;
+  }
+  if (element.tagName.toLowerCase() === "body") {
+    return "/body";
+  }
+  let ix = 0;
+  const siblings = element.parentNode?.children || new HTMLCollection();
+  for (let i = 0; i < siblings.length; i++) {
+    const sibling = siblings[i];
+    if (sibling === element) {
+      return `${getElementPath2(element.parentNode)}/${element.tagName}[${ix + 1}]`;
+    }
+    if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {
+      ix++;
+    }
+  }
+  return "not_found";
+}
+
+// src/utils/element-service.ts
+var INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick], [data-ansyr-static], [data-ansyr-dynamic]';
+function getInteractiveElements() {
+  const elements = document.querySelectorAll(INTERACTIVE_ELEMENT_SELECTOR);
+  return Array.from(new Set(Array.from(elements)));
+}
+function getImmediateText(element) {
+  let text = "";
+  if (element.childNodes) {
+    for (const node of Array.from(element.childNodes)) {
+      if (node.nodeType === 3) {
+        text += node.textContent || "";
+      }
+    }
+  }
+  return text.trim();
+}
+function captureFullDOMStructure() {
+  console.log("\u{1F333} Capturing full DOM structure for Cuekit...");
+  const interactiveElements = [];
+  const descriptionsMap = /* @__PURE__ */ new Map();
+  document.querySelectorAll("[data-for]").forEach((el) => {
+    const targetId = el.getAttribute("data-for");
+    if (!targetId) return;
+    const tags = [];
+    const description = el.getAttribute("data-ansyr-description");
+    if (description) {
+      tags.push(description);
+    }
+    if (el.textContent) {
+      tags.push(el.textContent.trim());
+    }
+    if (tags.length > 0) {
+      const existingTags = descriptionsMap.get(targetId) || [];
+      descriptionsMap.set(targetId, [...existingTags, ...tags]);
+    }
+  });
+  const allElements = getInteractiveElements();
+  allElements.forEach((element) => {
+    const style = getComputedStyle(element);
+    if (element.closest("[data-cuekit-ignore]") || !isElementClickable(element) || element.tagName.toLowerCase() === "script" || style.display === "none" || style.visibility === "hidden") {
+      return;
+    }
+    const staticId = element.getAttribute("data-ansyr-static");
+    const dynamicId = element.getAttribute("data-ansyr-dynamic");
+    const id = staticId || dynamicId;
+    const tags = [];
+    const directDescription = element.getAttribute("data-ansyr-description");
+    if (directDescription) {
+      tags.push(directDescription);
+    }
+    if (id && descriptionsMap.has(id)) {
+      tags.push(...descriptionsMap.get(id) || []);
+    }
+    const dto = {
+      testID: id || generateStableDOMId(element),
+      type: element.tagName.toLowerCase(),
+      textContent: getImmediateText(element) || element.textContent?.trim() || "",
+      tags
+    };
+    interactiveElements.push(dto);
+  });
+  const result = {
+    components: interactiveElements
+  };
+  console.log("\u{1F333} Full DOM structure captured:", result);
   return result;
 }
-var knownDeviceLabels = /* @__PURE__ */ new Map([["obs virtual camera", {
-  facingMode: "environment",
-  confidence: "medium"
-}]]);
-var knownDeviceLabelSections = /* @__PURE__ */ new Map([["iphone", {
-  facingMode: "environment",
-  confidence: "medium"
-}], ["ipad", {
-  facingMode: "environment",
-  confidence: "medium"
-}]]);
-function facingModeFromDeviceLabel(deviceLabel) {
-  var _a;
-  const label = deviceLabel.trim().toLowerCase();
-  if (label === "") {
-    return void 0;
+function isElementClickable(element) {
+  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 (element.matches(selector)) {
+      return true;
+    }
+  }
+  const hasClickEvents = element.onclick !== null || element.getAttribute("onclick") !== null;
+  const hasInteractiveEvents = element.ontouchstart !== null || element.getAttribute("ontouchstart") !== null || element.ontouchend !== null || element.getAttribute("ontouchend") !== null || element.onkeydown !== null || element.getAttribute("onkeydown") !== null || element.onkeyup !== null || element.getAttribute("onkeyup") !== null || element.onkeypress !== null || element.getAttribute("onkeypress") !== null;
+  const hasPointerCursor = element.style.cursor === "pointer" || getComputedStyle(element).cursor === "pointer";
+  const hasTabIndex = element.hasAttribute("tabindex") && parseInt(element.getAttribute("tabindex") || "0") >= 0;
+  const hasInteractiveDataAttrs = element.hasAttribute("data-clickable") || element.hasAttribute("data-interactive") || element.hasAttribute("data-action") || element.hasAttribute("data-handler");
+  const hasInteractiveAria = element.hasAttribute("aria-pressed") || element.hasAttribute("aria-expanded") || element.hasAttribute("aria-selected") || element.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() {
+  return captureFullDOMStructure();
+}
+function clickElement(elementId) {
+  if (!elementId) {
+    return false;
+  }
+  const domElement = findDOMElementById(elementId);
+  if (domElement) {
+    domElement.click();
+    return true;
+  }
+  return false;
+}
+function navigateToElement(target) {
+  if (!target) {
+    return false;
+  }
+  if (target.includes("/") || target.startsWith("http")) {
+    safeNavigate(target, {});
+  } else {
+    handleNavigationAndClick(target, target);
+  }
+  return true;
+}
+function focusElement(elementId) {
+  if (!elementId) {
+    return false;
+  }
+  const domElement = findDOMElementById(elementId);
+  if (domElement instanceof HTMLInputElement || domElement instanceof HTMLTextAreaElement || domElement instanceof HTMLSelectElement) {
+    domElement.focus();
+    return true;
+  } else {
+    return false;
+  }
+}
+function toggleElement(elementId) {
+  if (!elementId) {
+    return false;
+  }
+  const domElement = findDOMElementById(elementId);
+  if (domElement instanceof HTMLElement) {
+    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 {
+    return false;
   }
-  if (knownDeviceLabels.has(label)) {
-    return knownDeviceLabels.get(label);
+}
+function findDOMElementById(elementId) {
+  if (!elementId) {
+    return null;
+  }
+  const interactiveElements = getInteractiveElements();
+  for (const element of interactiveElements) {
+    if (element instanceof HTMLElement) {
+      const staticId = element.getAttribute("data-ansyr-static");
+      const dynamicId = element.getAttribute("data-ansyr-dynamic");
+      const currentElementId = staticId || dynamicId || generateStableDOMId(element);
+      if (currentElementId === elementId) {
+        return element;
+      }
+    }
   }
-  return (_a = Array.from(knownDeviceLabelSections.entries()).find((_ref) => {
-    let [section] = _ref;
-    return label.includes(section);
-  })) === null || _a === void 0 ? void 0 : _a[1];
+  return null;
+}
+
+// src/utils/webrtc-service.ts
+var room = null;
+var reconnectTimeout = null;
+var serverUrl = WEBRTC_BACKEND_SERVER_URL || "https://bdd4c945f073.ngrok-free.app";
+var callbacks = {};
+var audioContainerRef = null;
+var livekitUrl = null;
+var token = null;
+var roomName = null;
+function setServerUrl(url) {
+  serverUrl = url;
+}
+function setAudioContainer(newAudioContainerRef) {
+  audioContainerRef = newAudioContainerRef;
+}
+function setWebRTCCallbacks(newCallbacks) {
+  callbacks = newCallbacks;
+}
+async function authenticate(userIdentity, apiKey, appId) {
+  try {
+    const authPayload = {
+      user_identity: userIdentity,
+      app_id: appId || _appId
+    };
+    const response = await fetch(`${serverUrl}/auth/login`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-API-Key": apiKey
+      },
+      body: JSON.stringify(authPayload)
+    });
+    if (!response.ok) {
+      const errorData = await response.json();
+      throw new Error(errorData.detail || "Authentication failed");
+    }
+    const authData = await response.json();
+    livekitUrl = authData.livekit_url;
+    token = authData.livekit_token;
+    roomName = authData.room_name;
+    userIdentity = authData.user_identity;
+    return authData;
+  } catch (error) {
+    throw error;
+  }
+}
+async function connectToRoom(newLivekitUrl, newToken) {
+  const url = newLivekitUrl || livekitUrl;
+  const authToken = newToken || token;
+  if (!url || !authToken) {
+    throw new Error("Missing LiveKit URL or token. Please authenticate first.");
+  }
+  try {
+    setWebRTCConnectionState({ isConnected: false, isConnecting: true });
+    room = new Room({
+      adaptiveStream: true,
+      dynacast: true
+    });
+    setupEventListeners();
+    await room.connect(url, authToken);
+    setWebRTCConnectionState({ isConnected: true, isConnecting: false });
+    try {
+      await room.localParticipant.setMicrophoneEnabled(true);
+    } catch (micError) {
+    }
+    return { success: true };
+  } catch (error) {
+    setWebRTCConnectionState({ isConnected: false, isConnecting: false });
+    throw error;
+  }
+}
+function setupEventListeners() {
+  if (!room) return;
+  room.on(RoomEvent.ConnectionStateChanged, (state) => {
+    callbacks.onConnectionStateChange?.(state);
+    if (state === ConnectionState.Connected) {
+      setWebRTCConnectionState({ isConnected: true, isConnecting: false });
+    } else if (state === ConnectionState.Disconnected) {
+      setWebRTCConnectionState({ isConnected: false, isConnecting: false });
+    } else if (state === ConnectionState.Connecting) {
+      setWebRTCConnectionState({ isConnected: false, isConnecting: true });
+    }
+  }).on(RoomEvent.ParticipantConnected, (participant) => {
+    updateParticipantsList();
+  }).on(RoomEvent.ParticipantDisconnected, (participant) => {
+    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 element = track.attach();
+        if (audioContainerRef?.current) {
+          audioContainerRef.current.appendChild(element);
+          if (element instanceof HTMLAudioElement) {
+            const trackId = track.sid || `track_${Date.now()}_${Math.random()}`;
+            callbacks.onAISpeechStart?.(trackId);
+            element.play().catch((error) => {
+            });
+            element.addEventListener("ended", () => callbacks.onAISpeechEnd?.(trackId));
+            element.addEventListener("pause", () => callbacks.onAISpeechEnd?.(trackId));
+          }
+        }
+      }
+    }
+  }).on(RoomEvent.TrackUnsubscribed, (track) => {
+    track.detach().forEach((element) => element.remove());
+  }).on(RoomEvent.DataReceived, (payload, participant) => {
+    const decodedPayload = new TextDecoder().decode(payload);
+    try {
+      const message = JSON.parse(decodedPayload);
+      callbacks.onNavigationCommand?.(message);
+    } catch (error) {
+      const message = decodedPayload;
+      callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
+    }
+  }).on(RoomEvent.Disconnected, () => {
+    setWebRTCConnectionState({ isConnected: false, isConnecting: false });
+  });
+}
+function updateParticipantsList() {
+  if (!room) return;
+  const participants = [
+    room.localParticipant.identity,
+    ...Array.from(room.remoteParticipants.values()).map((p) => p.identity)
+  ];
+  setWebRTCConnectionState({ participants });
+  callbacks.onParticipantUpdate?.(participants);
+}
+async function sendData(data, reliable = true) {
+  if (!room) throw new Error("Not connected to room");
+  try {
+    console.log("\u2B06\uFE0F Sending data to backend [DataChannel]:", data);
+    const encoder = new TextEncoder();
+    const encodedData = encoder.encode(data);
+    await room.localParticipant.publishData(encodedData, {
+      reliable
+    });
+  } catch (error) {
+    throw error;
+  }
+}
+async function sendScreenStatus(screenData) {
+  try {
+    console.log("\u2B06\uFE0F Sending to backend [/ai/data]:", JSON.stringify(screenData, null, 2));
+    await fetch(`${serverUrl}/ai/data`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(screenData)
+    });
+  } catch (error) {
+    throw error;
+  }
+}
+function isConnected() {
+  return room?.state === ConnectionState.Connected;
+}
+function getRoomName() {
+  return roomName;
+}
+function getParticipants() {
+  return Array.from(room?.remoteParticipants.values() ?? []);
+}
+async function sendUserCommand(command) {
+  if (!room) return;
+  await sendData(command);
+}
+async function sendRuntimeData() {
+  if (!room) {
+    return;
+  }
+  try {
+    const domStructure = captureFullDOMStructure();
+    const screenName = getCurrentScreenName();
+    const response = {
+      type: "runtime_data_response",
+      data: {
+        components: domStructure.components,
+        current_screen: screenName
+      }
+    };
+    await sendData(JSON.stringify(response));
+  } catch (error) {
+  }
+}
+async function sendStaticData(componentData, appId = "default") {
+  try {
+    const staticDataPayload = {
+      type: "dashboard_data",
+      app_id: appId,
+      data: componentData
+    };
+    console.log("\u2B06\uFE0F Sending to backend [/ai/data]:", JSON.stringify(staticDataPayload, null, 2));
+    const response = await fetch(`${serverUrl}/ai/data`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(staticDataPayload)
+    });
+    if (response.ok) {
+      const result = await response.json();
+      console.log("\u2B07\uFE0F Received from backend [/ai/data]:", JSON.stringify(result, null, 2));
+      return { success: true, data: result };
+    } else {
+      const errorText = await response.text();
+      return { success: false, error: `HTTP ${response.status}: ${errorText}` };
+    }
+  } catch (error) {
+    return { success: false, error: error instanceof Error ? error.message : "Network error" };
+  }
+}
+async function disconnectFromRoom() {
+  if (room) {
+    await room.disconnect();
+    room = null;
+  }
+  if (reconnectTimeout) {
+    clearTimeout(reconnectTimeout);
+    reconnectTimeout = null;
+  }
+  setWebRTCConnectionState({
+    isConnected: false,
+    isConnecting: false,
+    participants: []
+  });
 }
-function isFacingModeValue(item) {
-  const allowedValues = ["user", "environment", "left", "right"];
-  return item === void 0 || allowedValues.includes(item);
+function getRoom() {
+  return room;
 }
 
 export {
-  _,
-  TrackType,
-  DisconnectReason,
-  SubscriptionError,
-  ParticipantInfo_Kind,
-  DataPacket_Kind,
-  LogLevel,
-  LoggerNames,
-  getLogger,
-  setLogLevel,
-  setLogExtension,
-  DefaultReconnectPolicy,
-  KeyProviderEvent,
-  KeyHandlerEvent,
-  EncryptionEvent,
-  CryptorEvent,
-  isE2EESupported,
-  isScriptTransformSupported,
-  isInsertableStreamSupported,
-  isVideoFrame,
-  importKey,
-  createKeyMaterialFromString,
-  createKeyMaterialFromBuffer,
-  deriveKeys,
-  createE2EEKey,
-  ratchet,
-  needsRbspUnescaping,
-  parseRbsp,
-  writeRbsp,
-  BaseKeyProvider,
-  ExternalE2EEKeyProvider,
-  LivekitError,
-  ConnectionErrorReason,
-  ConnectionError,
-  DeviceUnsupportedError,
-  TrackInvalidError,
-  UnsupportedServer,
-  UnexpectedConnectionState,
-  NegotiationError,
-  PublishDataError,
-  PublishTrackError,
-  SignalRequestError,
-  MediaDeviceFailure,
-  CryptorErrorReason,
-  CryptorError,
+  __require,
+  __commonJS,
+  __export,
+  __toESM,
+  _apiKey,
+  _appId,
+  setApiKey,
+  setAppId,
+  setWebRTCConfig,
+  GlobalStore,
+  setNavigationHandler,
+  onStateChange,
+  WEBRTC_BACKEND_SERVER_URL,
   RoomEvent,
   ParticipantEvent,
-  EngineEvent,
-  TrackEvent,
-  getBrowser,
-  version,
-  protocolVersion,
-  CriticalTimers,
-  VideoQuality,
   Track,
-  attachToElement,
-  detachTrack,
-  VideoPreset,
-  videoCodecs,
-  isBackupCodec,
-  BackupCodecPolicy,
-  AudioPresets,
-  VideoPresets,
-  VideoPresets43,
-  ScreenSharePresets,
-  supportsAdaptiveStream,
-  supportsDynacast,
-  supportsAV1,
-  supportsVP9,
-  isBrowserSupported,
-  compareVersions,
-  getEmptyVideoStreamTrack,
-  getEmptyAudioStreamTrack,
   createAudioAnalyser,
-  isLocalTrack,
-  isAudioTrack,
-  isVideoTrack,
-  isRemoteTrack,
-  isLocalParticipant,
-  isRemoteParticipant,
-  RpcError,
-  LocalTrackRecorder,
-  LocalTrack,
-  LocalAudioTrack,
-  LocalVideoTrack,
-  RemoteTrack,
-  RemoteAudioTrack,
-  RemoteVideoTrack,
-  TrackPublication,
-  LocalTrackPublication,
-  createLocalTracks,
-  createLocalVideoTrack,
-  createLocalAudioTrack,
-  createLocalScreenTracks,
-  ConnectionQuality,
-  Participant,
-  LocalParticipant,
-  RemoteTrackPublication,
-  RemoteParticipant,
   ConnectionState,
-  Room,
-  attributeTypings,
-  CheckStatus,
-  Checker,
-  ConnectionCheck,
-  facingModeFromLocalTrack,
-  facingModeFromDeviceLabel
+  captureFullDOMStructure,
+  executeAction,
+  getFullDOMStructure,
+  setServerUrl,
+  setAudioContainer,
+  setWebRTCCallbacks,
+  authenticate,
+  connectToRoom,
+  sendData,
+  sendScreenStatus,
+  isConnected,
+  getRoomName,
+  getParticipants,
+  sendUserCommand,
+  sendRuntimeData,
+  sendStaticData,
+  disconnectFromRoom,
+  getRoom
 };