@cuekit-ai/react 1.3.1 → 1.3.2

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

@@ -1,33 +1,3 @@
-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 __commonJS = (cb, mod) => function __require() {
-  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) {
@@ -5715,6 +5685,34 @@ 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];
@@ -8678,6 +8676,7 @@ 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";
@@ -8717,6 +8716,120 @@ 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] : {};
@@ -8760,6 +8873,32 @@ 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");
@@ -8816,6 +8955,12 @@ 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);
@@ -8860,6 +9005,15 @@ 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";
@@ -9551,6 +9705,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;
@@ -9667,8 +9827,8 @@ function isWeb() {
 function isReactNative() {
   return navigator.product == "ReactNative";
 }
-function isCloud(serverUrl2) {
-  return serverUrl2.hostname.endsWith(".livekit.cloud") || serverUrl2.hostname.endsWith(".livekit.run");
+function isCloud(serverUrl) {
+  return serverUrl.hostname.endsWith(".livekit.cloud") || serverUrl.hostname.endsWith(".livekit.run");
 }
 function getLKReactNativeInfo() {
   if (global && global.LiveKitReactNativeGlobal) {
@@ -9753,6 +9913,13 @@ 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;
@@ -9986,6 +10153,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);
@@ -10360,14 +10530,14 @@ var E2EEManager = class extends eventsExports.EventEmitter {
   /**
    * @internal
    */
-  setup(room2) {
+  setup(room) {
     if (!isE2EESupported()) {
       throw new DeviceUnsupportedError("tried to setup end-to-end encryption on an unsupported browser");
     }
     livekitLogger.info("setting up e2ee");
-    if (room2 !== this.room) {
-      this.room = room2;
-      this.setupEventListeners(room2, this.keyProvider);
+    if (room !== this.room) {
+      this.room = room;
+      this.setupEventListeners(room, this.keyProvider);
       const msg = {
         kind: "init",
         data: {
@@ -10407,11 +10577,11 @@ var E2EEManager = class extends eventsExports.EventEmitter {
       this.postRTPMap(rtpMap);
     });
   }
-  setupEventListeners(room2, keyProvider) {
-    room2.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
-    room2.on(RoomEvent.ConnectionStateChanged, (state) => {
+  setupEventListeners(room, keyProvider) {
+    room.on(RoomEvent.TrackPublished, (pub, participant) => this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity));
+    room.on(RoomEvent.ConnectionStateChanged, (state) => {
       if (state === ConnectionState.Connected) {
-        room2.remoteParticipants.forEach((participant) => {
+        room.remoteParticipants.forEach((participant) => {
           participant.trackPublications.forEach((pub) => {
             this.setParticipantCryptorEnabled(pub.trackInfo.encryption !== Encryption_Type.NONE, participant.identity);
           });
@@ -10438,7 +10608,7 @@ var E2EEManager = class extends eventsExports.EventEmitter {
       });
       this.setParticipantCryptorEnabled(this.room.localParticipant.isE2EEEnabled, this.room.localParticipant.identity);
     });
-    room2.localParticipant.on(ParticipantEvent.LocalSenderCreated, (sender, track) => __awaiter(this, void 0, void 0, function* () {
+    room.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));
@@ -10847,15 +11017,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, token2, opts, abortSignal) {
+  join(url, token, opts, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
       this.state = SignalConnectionState.CONNECTING;
       this.options = opts;
-      const res = yield this.connect(url, token2, opts, abortSignal);
+      const res = yield this.connect(url, token, opts, abortSignal);
       return res;
     });
   }
-  reconnect(url, token2, sid, reason) {
+  reconnect(url, token, 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);
@@ -10863,7 +11033,7 @@ var SignalClient = class {
       }
       this.state = SignalConnectionState.RECONNECTING;
       this.clearPingInterval();
-      const res = yield this.connect(url, token2, Object.assign(Object.assign({}, this.options), {
+      const res = yield this.connect(url, token, Object.assign(Object.assign({}, this.options), {
         reconnect: true,
         sid,
         reconnectReason: reason
@@ -10871,10 +11041,10 @@ var SignalClient = class {
       return res;
     });
   }
-  connect(url, token2, opts, abortSignal) {
+  connect(url, token, opts, abortSignal) {
     this.connectOptions = opts;
     const clientInfo = getClientInfo();
-    const params = createConnectionParams(token2, clientInfo, opts);
+    const params = createConnectionParams(token, clientInfo, opts);
     const rtcUrl = createRtcUrl(url, params);
     const validateUrl = createValidateUrl(rtcUrl);
     return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -11416,10 +11586,10 @@ function toProtoSessionDescription(rsd, id) {
   });
   return sd;
 }
-function createConnectionParams(token2, info, opts) {
+function createConnectionParams(token, info, opts) {
   var _a;
   const params = new URLSearchParams();
-  params.set("access_token", token2);
+  params.set("access_token", token);
   if (opts.reconnect) {
     params.set("reconnect", "1");
     if (opts.sid) {
@@ -15275,16 +15445,16 @@ var RTCEngine = class extends eventsExports.EventEmitter {
       pID: this.participantSid
     };
   }
-  join(url, token2, opts, abortSignal) {
+  join(url, token, opts, abortSignal) {
     return __awaiter(this, void 0, void 0, function* () {
       this.url = url;
-      this.token = token2;
+      this.token = token;
       this.signalOpts = opts;
       this.maxJoinAttempts = opts.maxRetries;
       try {
         this.joinAttempts += 1;
         this.setupSignalClientCallbacks();
-        const joinResponse = yield this.client.join(url, token2, opts, abortSignal);
+        const joinResponse = yield this.client.join(url, token, opts, abortSignal);
         this._isClosed = false;
         this.latestJoinResponse = joinResponse;
         this.subscriberPrimary = joinResponse.subscriberPrimary;
@@ -15302,7 +15472,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, token2, opts, abortSignal);
+              return this.join(url, token, opts, abortSignal);
             }
           }
         }
@@ -15532,8 +15702,8 @@ var RTCEngine = class extends eventsExports.EventEmitter {
     this.client.onLocalTrackSubscribed = (trackSid) => {
       this.emit(EngineEvent.LocalTrackSubscribed, trackSid);
     };
-    this.client.onTokenRefresh = (token2) => {
-      this.token = token2;
+    this.client.onTokenRefresh = (token) => {
+      this.token = token;
     };
     this.client.onRemoteMuteChanged = (trackSid, muted) => {
       this.emit(EngineEvent.RemoteMute, trackSid, muted);
@@ -16220,15 +16390,15 @@ function applyUserDataCompat(newObj, oldObj) {
   oldObj.destinationIdentities = destinationIdentities;
 }
 var RegionUrlProvider = class {
-  constructor(url, token2) {
+  constructor(url, token) {
     this.lastUpdateAt = 0;
     this.settingsCacheTime = 3e3;
     this.attemptedRegions = [];
     this.serverUrl = new URL(url);
-    this.token = token2;
+    this.token = token;
   }
-  updateToken(token2) {
-    this.token = token2;
+  updateToken(token) {
+    this.token = token;
   }
   isCloud() {
     return isCloud(this.serverUrl);
@@ -16281,8 +16451,8 @@ var RegionUrlProvider = class {
     this.lastUpdateAt = Date.now();
   }
 };
-function getCloudConfigUrl(serverUrl2) {
-  return "".concat(serverUrl2.protocol.replace("ws", "http"), "//").concat(serverUrl2.host, "/settings");
+function getCloudConfigUrl(serverUrl) {
+  return "".concat(serverUrl.protocol.replace("ws", "http"), "//").concat(serverUrl.host, "/settings");
 }
 var BaseStreamReader = class {
   get info() {
@@ -17445,6 +17615,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;
+  });
+}
 var ConnectionQuality;
 (function(ConnectionQuality2) {
   ConnectionQuality2["Excellent"] = "excellent";
@@ -20121,7 +20319,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, token2, opts) => __awaiter(this, void 0, void 0, function* () {
+    this.connect = (url, token, opts) => __awaiter(this, void 0, void 0, function* () {
       var _a2;
       if (!isBrowserSupported()) {
         if (isReactNative()) {
@@ -20147,9 +20345,9 @@ var Room = class _Room extends eventsExports.EventEmitter {
       }
       if (isCloud(new URL(url))) {
         if (this.regionUrlProvider === void 0) {
-          this.regionUrlProvider = new RegionUrlProvider(url, token2);
+          this.regionUrlProvider = new RegionUrlProvider(url, token);
         } else {
-          this.regionUrlProvider.updateToken(token2);
+          this.regionUrlProvider.updateToken(token);
         }
         this.regionUrlProvider.fetchRegionSettings().then((settings) => {
           var _a3;
@@ -20169,7 +20367,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, token2, opts, abortController);
+          yield this.attemptConnection(regionUrl2 !== null && regionUrl2 !== void 0 ? regionUrl2 : url, token, opts, abortController);
           this.abortController = void 0;
           resolve();
         } catch (e2) {
@@ -20211,9 +20409,9 @@ var Room = class _Room extends eventsExports.EventEmitter {
       });
       return this.connectFuture.promise;
     });
-    this.connectSignal = (url, token2, engine, connectOptions, roomOptions, abortController) => __awaiter(this, void 0, void 0, function* () {
+    this.connectSignal = (url, token, engine, connectOptions, roomOptions, abortController) => __awaiter(this, void 0, void 0, function* () {
       var _a2, _b2, _c2;
-      const joinResponse = yield engine.join(url, token2, {
+      const joinResponse = yield engine.join(url, token, {
         autoSubscribe: connectOptions.autoSubscribe,
         adaptiveStream: typeof roomOptions.adaptiveStream === "object" ? true : roomOptions.adaptiveStream,
         maxRetries: connectOptions.maxRetries,
@@ -20264,7 +20462,7 @@ var Room = class _Room extends eventsExports.EventEmitter {
         this.handleRoomUpdate(joinResponse.room);
       }
     };
-    this.attemptConnection = (url, token2, opts, abortController) => __awaiter(this, void 0, void 0, function* () {
+    this.attemptConnection = (url, token, 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);
@@ -20284,7 +20482,7 @@ var Room = class _Room extends eventsExports.EventEmitter {
         this.engine.peerConnectionTimeout = this.connOptions.peerConnectionTimeout;
       }
       try {
-        const joinResponse = yield this.connectSignal(url, token2, this.engine, this.connOptions, this.options, abortController);
+        const joinResponse = yield this.connectSignal(url, token, this.engine, this.connOptions, this.options, abortController);
         this.applyJoinResponse(joinResponse);
         this.setupLocalParticipantEvents();
         this.emit(RoomEvent.SignalConnected);
@@ -20680,14 +20878,14 @@ var Room = class _Room extends eventsExports.EventEmitter {
       }
       this.emit(RoomEvent.MediaDevicesChanged);
     });
-    this.handleRoomUpdate = (room2) => {
+    this.handleRoomUpdate = (room) => {
       const oldRoom = this.roomInfo;
-      this.roomInfo = room2;
-      if (oldRoom && oldRoom.metadata !== room2.metadata) {
-        this.emitWhenConnected(RoomEvent.RoomMetadataChanged, room2.metadata);
+      this.roomInfo = room;
+      if (oldRoom && oldRoom.metadata !== room.metadata) {
+        this.emitWhenConnected(RoomEvent.RoomMetadataChanged, room.metadata);
       }
-      if ((oldRoom === null || oldRoom === void 0 ? void 0 : oldRoom.activeRecording) !== room2.activeRecording) {
-        this.emitWhenConnected(RoomEvent.RecordingStatusChanged, room2.activeRecording);
+      if ((oldRoom === null || oldRoom === void 0 ? void 0 : oldRoom.activeRecording) !== room.activeRecording) {
+        this.emitWhenConnected(RoomEvent.RecordingStatusChanged, room.activeRecording);
       }
     };
     this.handleConnectionQualityUpdate = (update) => {
@@ -21084,15 +21282,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, token2) {
+  prepareConnection(url, token) {
     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)) && token2) {
-          this.regionUrlProvider = new RegionUrlProvider(url, token2);
+        if (isCloud(new URL(url)) && token) {
+          this.regionUrlProvider = new RegionUrlProvider(url, token);
           const regionUrl = yield this.regionUrlProvider.getNextBestRegionUrl();
           if (regionUrl && this.state === ConnectionState.Disconnected) {
             this.regionUrl = regionUrl;
@@ -21950,6 +22148,24 @@ 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";
@@ -21959,14 +22175,14 @@ var CheckStatus;
   CheckStatus2[CheckStatus2["FAILED"] = 4] = "FAILED";
 })(CheckStatus || (CheckStatus = {}));
 var Checker = class extends eventsExports.EventEmitter {
-  constructor(url, token2) {
+  constructor(url, token) {
     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 = token2;
+    this.token = token;
     this.name = this.constructor.name;
     this.room = new Room(options.roomOptions);
     this.connectOptions = options.connectOptions;
@@ -22278,14 +22494,14 @@ var PublishAudioCheck = class extends Checker {
   perform() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const room2 = yield this.connect();
+      const room = 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");
-      room2.localParticipant.publishTrack(track);
+      room.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) {
@@ -22311,10 +22527,10 @@ var PublishVideoCheck = class extends Checker {
   perform() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const room2 = yield this.connect();
+      const room = yield this.connect();
       const track = yield createLocalVideoTrack();
       yield this.checkForVideo(track.mediaStreamTrack);
-      room2.localParticipant.publishTrack(track);
+      room.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) {
@@ -22382,30 +22598,30 @@ var ReconnectCheck = class extends Checker {
   perform() {
     return __awaiter(this, void 0, void 0, function* () {
       var _a;
-      const room2 = yield this.connect();
+      const room = yield this.connect();
       let reconnectingTriggered = false;
       let reconnected = false;
       let reconnectResolver;
-      const reconnectTimeout2 = new Promise((resolve) => {
+      const reconnectTimeout = new Promise((resolve) => {
         setTimeout(resolve, 5e3);
         reconnectResolver = resolve;
       });
       const handleReconnecting = () => {
         reconnectingTriggered = true;
       };
-      room2.on(RoomEvent.SignalReconnecting, handleReconnecting).on(RoomEvent.Reconnecting, handleReconnecting).on(RoomEvent.Reconnected, () => {
+      room.on(RoomEvent.SignalReconnecting, handleReconnecting).on(RoomEvent.Reconnecting, handleReconnecting).on(RoomEvent.Reconnected, () => {
         reconnected = true;
         reconnectResolver(true);
       });
-      (_a = room2.engine.client.ws) === null || _a === void 0 ? void 0 : _a.close();
-      const onClose = room2.engine.client.onClose;
+      (_a = room.engine.client.ws) === null || _a === void 0 ? void 0 : _a.close();
+      const onClose = room.engine.client.onClose;
       if (onClose) {
         onClose("");
       }
-      yield reconnectTimeout2;
+      yield reconnectTimeout;
       if (!reconnectingTriggered) {
         throw new Error("Did not attempt to reconnect");
-      } else if (!reconnected || room2.state !== ConnectionState.Connected) {
+      } else if (!reconnected || room.state !== ConnectionState.Connected) {
         this.appendWarning("reconnection is only possible in Redis-based configurations");
         throw new Error("Not able to reconnect");
       }
@@ -22562,13 +22778,13 @@ var WebSocketCheck = class extends Checker {
   }
 };
 var ConnectionCheck = class extends eventsExports.EventEmitter {
-  constructor(url, token2) {
+  constructor(url, token) {
     let options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
     super();
     this.options = {};
     this.checkResults = /* @__PURE__ */ new Map();
     this.url = url;
-    this.token = token2;
+    this.token = token;
     this.options = options;
   }
   getNextCheckId() {
@@ -22650,758 +22866,172 @@ var ConnectionCheck = class extends eventsExports.EventEmitter {
     });
   }
 };
-
-// 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/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 = 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;
-  }
-  return hash.toString(36);
-}
-function getElementPath(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 `${getElementPath(element.parentNode)}/${element.tagName}[${ix + 1}]`;
-    }
-    if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {
-      ix++;
-    }
-  }
-  return "not_found";
-}
-
-// 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) {
-      console.log("Updating existing element");
-      store.allElementsData[index] = elementData;
-    } else {
-      console.log("Adding new element");
-      store.allElementsData.push(elementData);
-    }
-  },
-  getElementById(elementId) {
-    const match = store.allElementsData.find((e2) => e2.elementId === elementId);
-    if (!match) {
-      console.warn(`[GlobalStore] No element found for ID: ${elementId}`);
-      console.log("All elements in store:", store.allElementsData);
-    }
-    return match;
-  },
-  deleteElementById(id) {
-    store.allElementsData = store.allElementsData.filter((e2) => e2.elementId !== id);
-  },
-  clearAllElements() {
-    store.allElementsData = [];
-  }
-};
-
-// 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) {
-      console.error("[CueKit] navigation handler failed, falling back to default:", 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 {
-    console.warn("[CueKit] route name not provided");
-  }
-};
-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) {
-      console.error("Failed to parse metadata from URL:", 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 = 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;
-          }
-          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 getElementPath2(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/element-service.ts
-var INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick]';
-function getInteractiveElements() {
-  return document.querySelectorAll(INTERACTIVE_ELEMENT_SELECTOR);
-}
-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...");
-  const components = [];
-  const interactiveElements = getInteractiveElements();
-  interactiveElements.forEach((element) => {
-    if (element instanceof HTMLElement && !element.closest("[data-cuekit-ignore]")) {
-      const nodeData = buildFlatDOMNode(element);
-      if (nodeData) {
-        components.push(nodeData);
-      }
-    }
-  });
-  const result = { components };
-  console.log("\u{1F333} Full DOM structure captured:", result);
-  return result;
-}
-function buildFlatDOMNode(element) {
-  if (element.tagName.toLowerCase() === "script" || element.hasAttribute("data-cuekit-ignore") || element.style.display === "none" || element.style.visibility === "hidden") {
-    return null;
-  }
-  const hash = generateStableDOMId(element);
-  const text = getImmediateText(element).substring(0, 100);
-  const isClickable = isElementClickable(element);
-  const componentType = element.tagName.toLowerCase();
-  return {
-    hash,
-    text,
-    isClickable,
-    componentType,
-    children: []
-    // No children in a flat structure
-  };
-}
-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() {
-  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;
+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"
   };
-  return searchInComponents(domStructure.components);
-}
-function findDOMElementById(elementId) {
-  const interactiveElements = getInteractiveElements();
-  for (const element of interactiveElements) {
-    if (element instanceof HTMLElement) {
-      console.log("\u{1F50D} Checking element:", element);
-      const hash = generateStableDOMId(element);
-      console.log("\u{1F50D} Generated hash:", hash);
-      if (hash === elementId) {
-        console.log("\u{1F50D} Found element:", element);
-        return element;
-      }
+  if ("facingMode" in trackSettings) {
+    const rawFacingMode = trackSettings.facingMode;
+    livekitLogger.trace("rawFacingMode", {
+      rawFacingMode
+    });
+    if (rawFacingMode && typeof rawFacingMode === "string" && isFacingModeValue(rawFacingMode)) {
+      result = {
+        facingMode: rawFacingMode,
+        confidence: "high"
+      };
     }
   }
-  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 {
-    console.log("\u{1F3A4} WebRTCService: Authenticating user...", { userIdentity });
-    const response = await fetch(`${serverUrl}/auth/login`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-API-Key": apiKey
-      },
-      body: JSON.stringify({
-        user_identity: userIdentity,
-        app_id: appId || _appId
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json();
-      throw new Error(errorData.detail || "Authentication failed");
-    }
-    const authData = await response.json();
-    console.log("\u{1F3A4} WebRTCService: Authentication successful:", authData);
-    livekitUrl = authData.livekit_url;
-    token = authData.livekit_token;
-    roomName = authData.room_name;
-    userIdentity = authData.user_identity;
-    return authData;
-  } catch (error) {
-    console.error("\u{1F3A4} WebRTCService: Authentication failed:", 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.");
-  }
-  console.log("\u{1F3A4} WebRTCService: Connecting to room...", { url, hasToken: !!authToken });
-  try {
-    setWebRTCConnectionState({ isConnected: false, isConnecting: true });
-    room = new Room({
-      adaptiveStream: true,
-      dynacast: true
-    });
-    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);
-      console.log("\u{1F3A4} WebRTCService: Microphone enabled");
-    } catch (micError) {
-      console.warn("\u{1F3A4} WebRTCService: Failed to enable microphone:", micError);
-    }
-    return { success: true };
-  } catch (error) {
-    console.error("\u{1F3A4} WebRTCService: Failed to connect to room:", error);
-    setWebRTCConnectionState({ isConnected: false, isConnecting: false });
-    throw error;
-  }
-}
-function setupEventListeners() {
-  if (!room) return;
-  room.on(RoomEvent.ConnectionStateChanged, (state) => {
-    console.log("\u{1F3A4} WebRTCService: Connection state changed:", state);
-    callbacks.onConnectionStateChange?.(state);
-    if (state === ConnectionState.Connected) {
-      console.log("\u{1F3A4} WebRTCService: Successfully connected to room");
-      setWebRTCConnectionState({ isConnected: true, isConnecting: false });
-    } else if (state === ConnectionState.Disconnected) {
-      console.log("\u{1F3A4} WebRTCService: Disconnected from room");
-      setWebRTCConnectionState({ isConnected: false, isConnecting: false });
-    } else if (state === ConnectionState.Connecting) {
-      console.log("\u{1F3A4} WebRTCService: Connecting to room...");
-      setWebRTCConnectionState({ isConnected: false, isConnecting: true });
-    }
-  }).on(RoomEvent.ParticipantConnected, (participant) => {
-    console.log("\u{1F3A4} WebRTCService: Participant connected:", participant.identity);
-    updateParticipantsList();
-  }).on(RoomEvent.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 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) => console.warn("\u{1F3A4} WebRTCService: Failed to auto-play audio:", error)
-            );
-            element.addEventListener("ended", () => callbacks.onAISpeechEnd?.(trackId));
-            element.addEventListener("pause", () => callbacks.onAISpeechEnd?.(trackId));
-          }
-        }
-      }
+  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;
     }
-  }).on(RoomEvent.TrackUnsubscribed, (track) => {
-    track.detach().forEach((element) => element.remove());
-  }).on(RoomEvent.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, () => {
-    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("\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;
-  }
-}
-async function sendScreenStatus(screenData) {
-  try {
-    await fetch(`${serverUrl}/ai/data`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(screenData)
-    });
-  } catch (error) {
-    console.error("Error sending screen status:", 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;
-  console.log(`\u{1F4AC} Sending user command: "${command}"`);
-  await sendData(command);
-}
-async function sendRuntimeData() {
-  if (!room) {
-    console.error("\u274C Cannot send runtime data without a room connection");
-    return;
-  }
-  try {
-    const domStructure = captureFullDOMStructure();
-    const screenName = getCurrentScreenName();
-    const response = {
-      type: "runtime_data_response",
-      data: {
-        components: domStructure.components,
-        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) {
-    console.error("\u274C Failed to send runtime data:", error);
-  }
-}
-async function sendStaticData(componentData, appId = "default") {
-  try {
-    const response = await fetch(`${serverUrl}/ai/data`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        type: "dashboard_data",
-        app_id: appId,
-        data: componentData
-      })
-    });
-    if (response.ok) {
-      const result = await response.json();
-      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" };
   }
+  return result;
 }
-async function disconnectFromRoom() {
-  if (room) {
-    await room.disconnect();
-    room = null;
+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;
   }
-  if (reconnectTimeout) {
-    clearTimeout(reconnectTimeout);
-    reconnectTimeout = null;
+  if (knownDeviceLabels.has(label)) {
+    return knownDeviceLabels.get(label);
   }
-  setWebRTCConnectionState({
-    isConnected: false,
-    isConnecting: false,
-    participants: []
-  });
+  return (_a = Array.from(knownDeviceLabelSections.entries()).find((_ref) => {
+    let [section] = _ref;
+    return label.includes(section);
+  })) === null || _a === void 0 ? void 0 : _a[1];
 }
-function getRoom() {
-  return room;
+function isFacingModeValue(item) {
+  const allowedValues = ["user", "environment", "left", "right"];
+  return item === void 0 || allowedValues.includes(item);
 }
 
 export {
-  __commonJS,
-  __export,
-  __toESM,
-  _apiKey,
-  _appId,
-  setApiKey,
-  setAppId,
-  setWebRTCConfig,
-  GlobalStore,
-  setNavigationHandler,
-  onStateChange,
-  WEBRTC_BACKEND_SERVER_URL,
+  _,
+  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,
   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,
-  captureFullDOMStructure,
-  executeAction,
-  getFullDOMStructure,
-  setServerUrl,
-  setAudioContainer,
-  setWebRTCCallbacks,
-  authenticate,
-  connectToRoom,
-  sendData,
-  sendScreenStatus,
-  isConnected,
-  getRoomName,
-  getParticipants,
-  sendUserCommand,
-  sendRuntimeData,
-  sendStaticData,
-  disconnectFromRoom,
-  getRoom
+  Room,
+  attributeTypings,
+  CheckStatus,
+  Checker,
+  ConnectionCheck,
+  facingModeFromLocalTrack,
+  facingModeFromDeviceLabel
 };