@cuekit-ai/react 1.3.1 → 1.3.3

package/dist/index.js

@@ -89,18 +89,14 @@ var init_intent_store = __esm({
       setElement(elementData) {
         const index2 = store.allElementsData.findIndex((e3) => e3.elementId === elementData.elementId);
         if (index2 >= 0) {
-          console.log("Updating existing element");
           store.allElementsData[index2] = elementData;
         } else {
-          console.log("Adding new element");
           store.allElementsData.push(elementData);
         }
       },
       getElementById(elementId) {
         const match = store.allElementsData.find((e3) => e3.elementId === elementId);
         if (!match) {
-          console.warn(`[GlobalStore] No element found for ID: ${elementId}`);
-          console.log("All elements in store:", store.allElementsData);
         }
         return match;
       },
@@ -125,7 +121,6 @@ function navigate(path2, params) {
     try {
       navigationHandler(absolutePath, safeParams);
     } catch (error) {
-      console.error("[CueKit] navigation handler failed, falling back to default:", error);
     }
     return;
   }
@@ -176,7 +171,6 @@ function onStateChange() {
       const metadata = JSON.parse(params.metadata);
       GlobalStore.setMetadata(routeName, metadata);
     } catch (error) {
-      console.error("Failed to parse metadata from URL:", error);
     }
   }
 }
@@ -218,7 +212,6 @@ var init_navigation = __esm({
       if (name2) {
         navigate(name2, params);
       } else {
-        console.warn("[CueKit] route name not provided");
       }
     };
     handleNavigationAndClick = (routeName, elementHash) => {
@@ -22918,7 +22911,8 @@ var init_jsx_encoder = __esm({
 
 // src/utils/element-service.ts
 function getInteractiveElements() {
-  return document.querySelectorAll(INTERACTIVE_ELEMENT_SELECTOR);
+  const elements = document.querySelectorAll(INTERACTIVE_ELEMENT_SELECTOR);
+  return Array.from(new Set(Array.from(elements)));
 }
 function getImmediateText(element3) {
   let text7 = "";
@@ -22932,38 +22926,56 @@ function getImmediateText(element3) {
   return text7.trim();
 }
 function captureFullDOMStructure() {
-  console.log("\u{1F333} Capturing full DOM structure...");
-  const components = [];
-  const interactiveElements = getInteractiveElements();
-  interactiveElements.forEach((element3) => {
-    if (element3 instanceof HTMLElement && !element3.closest("[data-cuekit-ignore]")) {
-      const nodeData = buildFlatDOMNode(element3);
-      if (nodeData) {
-        components.push(nodeData);
-      }
+  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((element3) => {
+    const style = getComputedStyle(element3);
+    if (element3.closest("[data-cuekit-ignore]") || !isElementClickable(element3) || element3.tagName.toLowerCase() === "script" || style.display === "none" || style.visibility === "hidden") {
+      return;
     }
+    const staticId = element3.getAttribute("data-ansyr-static");
+    const dynamicId = element3.getAttribute("data-ansyr-dynamic");
+    const id = staticId || dynamicId;
+    const tags = [];
+    const directDescription = element3.getAttribute("data-ansyr-description");
+    if (directDescription) {
+      tags.push(directDescription);
+    }
+    if (id && descriptionsMap.has(id)) {
+      tags.push(...descriptionsMap.get(id) || []);
+    }
+    const dto = {
+      testID: id || generateStableDOMId(element3),
+      type: element3.tagName.toLowerCase(),
+      textContent: getImmediateText(element3) || element3.textContent?.trim() || "",
+      tags
+    };
+    interactiveElements.push(dto);
   });
-  const result = { components };
+  const result = {
+    components: interactiveElements
+  };
   console.log("\u{1F333} Full DOM structure captured:", result);
   return result;
 }
-function buildFlatDOMNode(element3) {
-  if (element3.tagName.toLowerCase() === "script" || element3.hasAttribute("data-cuekit-ignore") || element3.style.display === "none" || element3.style.visibility === "hidden") {
-    return null;
-  }
-  const hash = generateStableDOMId(element3);
-  const text7 = getImmediateText(element3).substring(0, 100);
-  const isClickable = isElementClickable(element3);
-  const componentType = element3.tagName.toLowerCase();
-  return {
-    hash,
-    text: text7,
-    isClickable,
-    componentType,
-    children: []
-    // No children in a flat structure
-  };
-}
 function isElementClickable(element3) {
   const interactiveSelectors = [
     "button",
@@ -23017,34 +23029,23 @@ function executeAction(action) {
   }
 }
 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}`);
+  const domElement = findDOMElementById(elementId);
+  if (domElement) {
+    domElement.click();
+    return true;
   }
   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 {
@@ -23054,27 +23055,22 @@ function navigateToElement(target) {
 }
 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;
@@ -23087,34 +23083,20 @@ function toggleElement(elementId) {
     }
     return true;
   } else {
-    console.warn(`\u26A0\uFE0F Toggleable element not found: ${elementId}`);
     return false;
   }
 }
-function findElementById(domStructure, elementId) {
-  const searchInComponents = (components) => {
-    for (const component of components) {
-      if (component.hash === elementId) {
-        return component;
-      }
-      if (component.children.length > 0) {
-        const found = searchInComponents(component.children);
-        if (found) return found;
-      }
-    }
-    return null;
-  };
-  return searchInComponents(domStructure.components);
-}
 function findDOMElementById(elementId) {
+  if (!elementId) {
+    return null;
+  }
   const interactiveElements = getInteractiveElements();
   for (const element3 of interactiveElements) {
     if (element3 instanceof HTMLElement) {
-      console.log("\u{1F50D} Checking element:", element3);
-      const hash = generateStableDOMId(element3);
-      console.log("\u{1F50D} Generated hash:", hash);
-      if (hash === elementId) {
-        console.log("\u{1F50D} Found element:", element3);
+      const staticId = element3.getAttribute("data-ansyr-static");
+      const dynamicId = element3.getAttribute("data-ansyr-dynamic");
+      const currentElementId = staticId || dynamicId || generateStableDOMId(element3);
+      if (currentElementId === elementId) {
         return element3;
       }
     }
@@ -23125,9 +23107,9 @@ var INTERACTIVE_ELEMENT_SELECTOR;
 var init_element_service = __esm({
   "src/utils/element-service.ts"() {
     "use strict";
-    init_jsx_encoder();
     init_navigation();
-    INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick]';
+    init_jsx_encoder();
+    INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick], [data-ansyr-static], [data-ansyr-dynamic]';
   }
 });
 
@@ -23161,31 +23143,29 @@ function setWebRTCCallbacks(newCallbacks) {
 }
 async function authenticate(userIdentity, apiKey, appId) {
   try {
-    console.log("\u{1F3A4} WebRTCService: Authenticating user...", { userIdentity });
+    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({
-        user_identity: userIdentity,
-        app_id: appId || _appId
-      })
+      body: JSON.stringify(authPayload)
     });
     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;
   }
 }
@@ -23195,7 +23175,6 @@ async function connectToRoom(newLivekitUrl, newToken) {
   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({
@@ -23204,17 +23183,13 @@ async function connectToRoom(newLivekitUrl, newToken) {
     });
     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;
   }
@@ -23222,23 +23197,17 @@ async function connectToRoom(newLivekitUrl, newToken) {
 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) {
@@ -23250,9 +23219,8 @@ function setupEventListeners() {
           if (element3 instanceof HTMLAudioElement) {
             const trackId = track.sid || `track_${Date.now()}_${Math.random()}`;
             callbacks.onAISpeechStart?.(trackId);
-            element3.play().catch(
-              (error) => console.warn("\u{1F3A4} WebRTCService: Failed to auto-play audio:", error)
-            );
+            element3.play().catch((error) => {
+            });
             element3.addEventListener("ended", () => callbacks.onAISpeechEnd?.(trackId));
             element3.addEventListener("pause", () => callbacks.onAISpeechEnd?.(trackId));
           }
@@ -23262,13 +23230,12 @@ function setupEventListeners() {
   }).on(RoomEvent.TrackUnsubscribed, (track) => {
     track.detach().forEach((element3) => element3.remove());
   }).on(RoomEvent.DataReceived, (payload, participant) => {
-    console.log("\u{1F4E1} LiveKit data received:", new TextDecoder().decode(payload));
+    const decodedPayload = new TextDecoder().decode(payload);
     try {
-      const message = JSON.parse(new TextDecoder().decode(payload));
-      console.log("\u{1F4E1} LiveKit data received:", message);
+      const message = JSON.parse(decodedPayload);
       callbacks.onNavigationCommand?.(message);
     } catch (error) {
-      const message = new TextDecoder().decode(payload);
+      const message = decodedPayload;
       callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
     }
   }).on(RoomEvent.Disconnected, () => {
@@ -23287,26 +23254,25 @@ function updateParticipantsList() {
 async function sendData(data, reliable = true) {
   if (!room) throw new Error("Not connected to room");
   try {
-    console.log("\u{1F4E1} LiveKit data sending:", data);
+    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) {
-    console.error("Error sending data:", 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) {
-    console.error("Error sending screen status:", error);
     throw error;
   }
 }
@@ -23321,12 +23287,10 @@ function getParticipants() {
 }
 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 {
@@ -23339,28 +23303,28 @@ async function sendRuntimeData() {
         current_screen: screenName
       }
     };
-    console.log("\u{1F4E6} Sending runtime data response");
     await sendData(JSON.stringify(response));
-    console.log("\u{1F4E6} Runtime data sent successfully");
   } catch (error) {
-    console.error("\u274C Failed to send runtime data:", 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({
-        type: "dashboard_data",
-        app_id: appId,
-        data: componentData
-      })
+      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();
@@ -23738,6 +23702,802 @@ var require_extend = __commonJS({
   }
 });
 
+// (disabled):crypto
+var require_crypto = __commonJS({
+  "(disabled):crypto"() {
+    "use strict";
+  }
+});
+
+// node_modules/crypto-js/core.js
+var require_core = __commonJS({
+  "node_modules/crypto-js/core.js"(exports, module2) {
+    "use strict";
+    (function(root4, factory) {
+      if (typeof exports === "object") {
+        module2.exports = exports = factory();
+      } else if (typeof define === "function" && define.amd) {
+        define([], factory);
+      } else {
+        root4.CryptoJS = factory();
+      }
+    })(exports, function() {
+      var CryptoJS = CryptoJS || function(Math2, undefined2) {
+        var crypto2;
+        if (typeof window !== "undefined" && window.crypto) {
+          crypto2 = window.crypto;
+        }
+        if (typeof self !== "undefined" && self.crypto) {
+          crypto2 = self.crypto;
+        }
+        if (typeof globalThis !== "undefined" && globalThis.crypto) {
+          crypto2 = globalThis.crypto;
+        }
+        if (!crypto2 && typeof window !== "undefined" && window.msCrypto) {
+          crypto2 = window.msCrypto;
+        }
+        if (!crypto2 && typeof global !== "undefined" && global.crypto) {
+          crypto2 = global.crypto;
+        }
+        if (!crypto2 && typeof require === "function") {
+          try {
+            crypto2 = require_crypto();
+          } catch (err) {
+          }
+        }
+        var cryptoSecureRandomInt = function() {
+          if (crypto2) {
+            if (typeof crypto2.getRandomValues === "function") {
+              try {
+                return crypto2.getRandomValues(new Uint32Array(1))[0];
+              } catch (err) {
+              }
+            }
+            if (typeof crypto2.randomBytes === "function") {
+              try {
+                return crypto2.randomBytes(4).readInt32LE();
+              } catch (err) {
+              }
+            }
+          }
+          throw new Error("Native crypto module could not be used to get secure random number.");
+        };
+        var create2 = Object.create || /* @__PURE__ */ function() {
+          function F2() {
+          }
+          return function(obj) {
+            var subtype;
+            F2.prototype = obj;
+            subtype = new F2();
+            F2.prototype = null;
+            return subtype;
+          };
+        }();
+        var C = {};
+        var C_lib = C.lib = {};
+        var Base = C_lib.Base = /* @__PURE__ */ function() {
+          return {
+            /**
+             * Creates a new object that inherits from this object.
+             *
+             * @param {Object} overrides Properties to copy into the new object.
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         field: 'value',
+             *
+             *         method: function () {
+             *         }
+             *     });
+             */
+            extend: function(overrides) {
+              var subtype = create2(this);
+              if (overrides) {
+                subtype.mixIn(overrides);
+              }
+              if (!subtype.hasOwnProperty("init") || this.init === subtype.init) {
+                subtype.init = function() {
+                  subtype.$super.init.apply(this, arguments);
+                };
+              }
+              subtype.init.prototype = subtype;
+              subtype.$super = this;
+              return subtype;
+            },
+            /**
+             * Extends this object and runs the init method.
+             * Arguments to create() will be passed to init().
+             *
+             * @return {Object} The new object.
+             *
+             * @static
+             *
+             * @example
+             *
+             *     var instance = MyType.create();
+             */
+            create: function() {
+              var instance = this.extend();
+              instance.init.apply(instance, arguments);
+              return instance;
+            },
+            /**
+             * Initializes a newly created object.
+             * Override this method to add some logic when your objects are created.
+             *
+             * @example
+             *
+             *     var MyType = CryptoJS.lib.Base.extend({
+             *         init: function () {
+             *             // ...
+             *         }
+             *     });
+             */
+            init: function() {
+            },
+            /**
+             * Copies properties into this object.
+             *
+             * @param {Object} properties The properties to mix in.
+             *
+             * @example
+             *
+             *     MyType.mixIn({
+             *         field: 'value'
+             *     });
+             */
+            mixIn: function(properties) {
+              for (var propertyName in properties) {
+                if (properties.hasOwnProperty(propertyName)) {
+                  this[propertyName] = properties[propertyName];
+                }
+              }
+              if (properties.hasOwnProperty("toString")) {
+                this.toString = properties.toString;
+              }
+            },
+            /**
+             * Creates a copy of this object.
+             *
+             * @return {Object} The clone.
+             *
+             * @example
+             *
+             *     var clone = instance.clone();
+             */
+            clone: function() {
+              return this.init.prototype.extend(this);
+            }
+          };
+        }();
+        var WordArray = C_lib.WordArray = Base.extend({
+          /**
+           * Initializes a newly created word array.
+           *
+           * @param {Array} words (Optional) An array of 32-bit words.
+           * @param {number} sigBytes (Optional) The number of significant bytes in the words.
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.lib.WordArray.create();
+           *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+           *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+           */
+          init: function(words, sigBytes) {
+            words = this.words = words || [];
+            if (sigBytes != undefined2) {
+              this.sigBytes = sigBytes;
+            } else {
+              this.sigBytes = words.length * 4;
+            }
+          },
+          /**
+           * Converts this word array to a string.
+           *
+           * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+           *
+           * @return {string} The stringified word array.
+           *
+           * @example
+           *
+           *     var string = wordArray + '';
+           *     var string = wordArray.toString();
+           *     var string = wordArray.toString(CryptoJS.enc.Utf8);
+           */
+          toString: function(encoder) {
+            return (encoder || Hex).stringify(this);
+          },
+          /**
+           * Concatenates a word array to this word array.
+           *
+           * @param {WordArray} wordArray The word array to append.
+           *
+           * @return {WordArray} This word array.
+           *
+           * @example
+           *
+           *     wordArray1.concat(wordArray2);
+           */
+          concat: function(wordArray) {
+            var thisWords = this.words;
+            var thatWords = wordArray.words;
+            var thisSigBytes = this.sigBytes;
+            var thatSigBytes = wordArray.sigBytes;
+            this.clamp();
+            if (thisSigBytes % 4) {
+              for (var i2 = 0; i2 < thatSigBytes; i2++) {
+                var thatByte = thatWords[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+                thisWords[thisSigBytes + i2 >>> 2] |= thatByte << 24 - (thisSigBytes + i2) % 4 * 8;
+              }
+            } else {
+              for (var j2 = 0; j2 < thatSigBytes; j2 += 4) {
+                thisWords[thisSigBytes + j2 >>> 2] = thatWords[j2 >>> 2];
+              }
+            }
+            this.sigBytes += thatSigBytes;
+            return this;
+          },
+          /**
+           * Removes insignificant bits.
+           *
+           * @example
+           *
+           *     wordArray.clamp();
+           */
+          clamp: function() {
+            var words = this.words;
+            var sigBytes = this.sigBytes;
+            words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+            words.length = Math2.ceil(sigBytes / 4);
+          },
+          /**
+           * Creates a copy of this word array.
+           *
+           * @return {WordArray} The clone.
+           *
+           * @example
+           *
+           *     var clone = wordArray.clone();
+           */
+          clone: function() {
+            var clone = Base.clone.call(this);
+            clone.words = this.words.slice(0);
+            return clone;
+          },
+          /**
+           * Creates a word array filled with random bytes.
+           *
+           * @param {number} nBytes The number of random bytes to generate.
+           *
+           * @return {WordArray} The random word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.lib.WordArray.random(16);
+           */
+          random: function(nBytes) {
+            var words = [];
+            for (var i2 = 0; i2 < nBytes; i2 += 4) {
+              words.push(cryptoSecureRandomInt());
+            }
+            return new WordArray.init(words, nBytes);
+          }
+        });
+        var C_enc = C.enc = {};
+        var Hex = C_enc.Hex = {
+          /**
+           * Converts a word array to a hex string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The hex string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var hexChars = [];
+            for (var i2 = 0; i2 < sigBytes; i2++) {
+              var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+              hexChars.push((bite >>> 4).toString(16));
+              hexChars.push((bite & 15).toString(16));
+            }
+            return hexChars.join("");
+          },
+          /**
+           * Converts a hex string to a word array.
+           *
+           * @param {string} hexStr The hex string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+           */
+          parse: function(hexStr) {
+            var hexStrLength = hexStr.length;
+            var words = [];
+            for (var i2 = 0; i2 < hexStrLength; i2 += 2) {
+              words[i2 >>> 3] |= parseInt(hexStr.substr(i2, 2), 16) << 24 - i2 % 8 * 4;
+            }
+            return new WordArray.init(words, hexStrLength / 2);
+          }
+        };
+        var Latin1 = C_enc.Latin1 = {
+          /**
+           * Converts a word array to a Latin1 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The Latin1 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            var words = wordArray.words;
+            var sigBytes = wordArray.sigBytes;
+            var latin1Chars = [];
+            for (var i2 = 0; i2 < sigBytes; i2++) {
+              var bite = words[i2 >>> 2] >>> 24 - i2 % 4 * 8 & 255;
+              latin1Chars.push(String.fromCharCode(bite));
+            }
+            return latin1Chars.join("");
+          },
+          /**
+           * Converts a Latin1 string to a word array.
+           *
+           * @param {string} latin1Str The Latin1 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+           */
+          parse: function(latin1Str) {
+            var latin1StrLength = latin1Str.length;
+            var words = [];
+            for (var i2 = 0; i2 < latin1StrLength; i2++) {
+              words[i2 >>> 2] |= (latin1Str.charCodeAt(i2) & 255) << 24 - i2 % 4 * 8;
+            }
+            return new WordArray.init(words, latin1StrLength);
+          }
+        };
+        var Utf8 = C_enc.Utf8 = {
+          /**
+           * Converts a word array to a UTF-8 string.
+           *
+           * @param {WordArray} wordArray The word array.
+           *
+           * @return {string} The UTF-8 string.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+           */
+          stringify: function(wordArray) {
+            try {
+              return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+            } catch (e3) {
+              throw new Error("Malformed UTF-8 data");
+            }
+          },
+          /**
+           * Converts a UTF-8 string to a word array.
+           *
+           * @param {string} utf8Str The UTF-8 string.
+           *
+           * @return {WordArray} The word array.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+           */
+          parse: function(utf8Str) {
+            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+          }
+        };
+        var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+          /**
+           * Resets this block algorithm's data buffer to its initial state.
+           *
+           * @example
+           *
+           *     bufferedBlockAlgorithm.reset();
+           */
+          reset: function() {
+            this._data = new WordArray.init();
+            this._nDataBytes = 0;
+          },
+          /**
+           * Adds new data to this block algorithm's buffer.
+           *
+           * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+           *
+           * @example
+           *
+           *     bufferedBlockAlgorithm._append('data');
+           *     bufferedBlockAlgorithm._append(wordArray);
+           */
+          _append: function(data) {
+            if (typeof data == "string") {
+              data = Utf8.parse(data);
+            }
+            this._data.concat(data);
+            this._nDataBytes += data.sigBytes;
+          },
+          /**
+           * Processes available data blocks.
+           *
+           * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+           *
+           * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+           *
+           * @return {WordArray} The processed data.
+           *
+           * @example
+           *
+           *     var processedData = bufferedBlockAlgorithm._process();
+           *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+           */
+          _process: function(doFlush) {
+            var processedWords;
+            var data = this._data;
+            var dataWords = data.words;
+            var dataSigBytes = data.sigBytes;
+            var blockSize = this.blockSize;
+            var blockSizeBytes = blockSize * 4;
+            var nBlocksReady = dataSigBytes / blockSizeBytes;
+            if (doFlush) {
+              nBlocksReady = Math2.ceil(nBlocksReady);
+            } else {
+              nBlocksReady = Math2.max((nBlocksReady | 0) - this._minBufferSize, 0);
+            }
+            var nWordsReady = nBlocksReady * blockSize;
+            var nBytesReady = Math2.min(nWordsReady * 4, dataSigBytes);
+            if (nWordsReady) {
+              for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+                this._doProcessBlock(dataWords, offset);
+              }
+              processedWords = dataWords.splice(0, nWordsReady);
+              data.sigBytes -= nBytesReady;
+            }
+            return new WordArray.init(processedWords, nBytesReady);
+          },
+          /**
+           * Creates a copy of this object.
+           *
+           * @return {Object} The clone.
+           *
+           * @example
+           *
+           *     var clone = bufferedBlockAlgorithm.clone();
+           */
+          clone: function() {
+            var clone = Base.clone.call(this);
+            clone._data = this._data.clone();
+            return clone;
+          },
+          _minBufferSize: 0
+        });
+        var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
+          /**
+           * Configuration options.
+           */
+          cfg: Base.extend(),
+          /**
+           * Initializes a newly created hasher.
+           *
+           * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+           *
+           * @example
+           *
+           *     var hasher = CryptoJS.algo.SHA256.create();
+           */
+          init: function(cfg) {
+            this.cfg = this.cfg.extend(cfg);
+            this.reset();
+          },
+          /**
+           * Resets this hasher to its initial state.
+           *
+           * @example
+           *
+           *     hasher.reset();
+           */
+          reset: function() {
+            BufferedBlockAlgorithm.reset.call(this);
+            this._doReset();
+          },
+          /**
+           * Updates this hasher with a message.
+           *
+           * @param {WordArray|string} messageUpdate The message to append.
+           *
+           * @return {Hasher} This hasher.
+           *
+           * @example
+           *
+           *     hasher.update('message');
+           *     hasher.update(wordArray);
+           */
+          update: function(messageUpdate) {
+            this._append(messageUpdate);
+            this._process();
+            return this;
+          },
+          /**
+           * Finalizes the hash computation.
+           * Note that the finalize operation is effectively a destructive, read-once operation.
+           *
+           * @param {WordArray|string} messageUpdate (Optional) A final message update.
+           *
+           * @return {WordArray} The hash.
+           *
+           * @example
+           *
+           *     var hash = hasher.finalize();
+           *     var hash = hasher.finalize('message');
+           *     var hash = hasher.finalize(wordArray);
+           */
+          finalize: function(messageUpdate) {
+            if (messageUpdate) {
+              this._append(messageUpdate);
+            }
+            var hash = this._doFinalize();
+            return hash;
+          },
+          blockSize: 512 / 32,
+          /**
+           * Creates a shortcut function to a hasher's object interface.
+           *
+           * @param {Hasher} hasher The hasher to create a helper for.
+           *
+           * @return {Function} The shortcut function.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+           */
+          _createHelper: function(hasher) {
+            return function(message, cfg) {
+              return new hasher.init(cfg).finalize(message);
+            };
+          },
+          /**
+           * Creates a shortcut function to the HMAC's object interface.
+           *
+           * @param {Hasher} hasher The hasher to use in this HMAC helper.
+           *
+           * @return {Function} The shortcut function.
+           *
+           * @static
+           *
+           * @example
+           *
+           *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+           */
+          _createHmacHelper: function(hasher) {
+            return function(message, key) {
+              return new C_algo.HMAC.init(hasher, key).finalize(message);
+            };
+          }
+        });
+        var C_algo = C.algo = {};
+        return C;
+      }(Math);
+      return CryptoJS;
+    });
+  }
+});
+
+// node_modules/crypto-js/md5.js
+var require_md5 = __commonJS({
+  "node_modules/crypto-js/md5.js"(exports, module2) {
+    "use strict";
+    (function(root4, factory) {
+      if (typeof exports === "object") {
+        module2.exports = exports = factory(require_core());
+      } else if (typeof define === "function" && define.amd) {
+        define(["./core"], factory);
+      } else {
+        factory(root4.CryptoJS);
+      }
+    })(exports, function(CryptoJS) {
+      (function(Math2) {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var WordArray = C_lib.WordArray;
+        var Hasher = C_lib.Hasher;
+        var C_algo = C.algo;
+        var T = [];
+        (function() {
+          for (var i2 = 0; i2 < 64; i2++) {
+            T[i2] = Math2.abs(Math2.sin(i2 + 1)) * 4294967296 | 0;
+          }
+        })();
+        var MD52 = C_algo.MD5 = Hasher.extend({
+          _doReset: function() {
+            this._hash = new WordArray.init([
+              1732584193,
+              4023233417,
+              2562383102,
+              271733878
+            ]);
+          },
+          _doProcessBlock: function(M3, offset) {
+            for (var i2 = 0; i2 < 16; i2++) {
+              var offset_i = offset + i2;
+              var M_offset_i = M3[offset_i];
+              M3[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+            }
+            var H3 = this._hash.words;
+            var M_offset_0 = M3[offset + 0];
+            var M_offset_1 = M3[offset + 1];
+            var M_offset_2 = M3[offset + 2];
+            var M_offset_3 = M3[offset + 3];
+            var M_offset_4 = M3[offset + 4];
+            var M_offset_5 = M3[offset + 5];
+            var M_offset_6 = M3[offset + 6];
+            var M_offset_7 = M3[offset + 7];
+            var M_offset_8 = M3[offset + 8];
+            var M_offset_9 = M3[offset + 9];
+            var M_offset_10 = M3[offset + 10];
+            var M_offset_11 = M3[offset + 11];
+            var M_offset_12 = M3[offset + 12];
+            var M_offset_13 = M3[offset + 13];
+            var M_offset_14 = M3[offset + 14];
+            var M_offset_15 = M3[offset + 15];
+            var a = H3[0];
+            var b2 = H3[1];
+            var c = H3[2];
+            var d = H3[3];
+            a = FF(a, b2, c, d, M_offset_0, 7, T[0]);
+            d = FF(d, a, b2, c, M_offset_1, 12, T[1]);
+            c = FF(c, d, a, b2, M_offset_2, 17, T[2]);
+            b2 = FF(b2, c, d, a, M_offset_3, 22, T[3]);
+            a = FF(a, b2, c, d, M_offset_4, 7, T[4]);
+            d = FF(d, a, b2, c, M_offset_5, 12, T[5]);
+            c = FF(c, d, a, b2, M_offset_6, 17, T[6]);
+            b2 = FF(b2, c, d, a, M_offset_7, 22, T[7]);
+            a = FF(a, b2, c, d, M_offset_8, 7, T[8]);
+            d = FF(d, a, b2, c, M_offset_9, 12, T[9]);
+            c = FF(c, d, a, b2, M_offset_10, 17, T[10]);
+            b2 = FF(b2, c, d, a, M_offset_11, 22, T[11]);
+            a = FF(a, b2, c, d, M_offset_12, 7, T[12]);
+            d = FF(d, a, b2, c, M_offset_13, 12, T[13]);
+            c = FF(c, d, a, b2, M_offset_14, 17, T[14]);
+            b2 = FF(b2, c, d, a, M_offset_15, 22, T[15]);
+            a = GG(a, b2, c, d, M_offset_1, 5, T[16]);
+            d = GG(d, a, b2, c, M_offset_6, 9, T[17]);
+            c = GG(c, d, a, b2, M_offset_11, 14, T[18]);
+            b2 = GG(b2, c, d, a, M_offset_0, 20, T[19]);
+            a = GG(a, b2, c, d, M_offset_5, 5, T[20]);
+            d = GG(d, a, b2, c, M_offset_10, 9, T[21]);
+            c = GG(c, d, a, b2, M_offset_15, 14, T[22]);
+            b2 = GG(b2, c, d, a, M_offset_4, 20, T[23]);
+            a = GG(a, b2, c, d, M_offset_9, 5, T[24]);
+            d = GG(d, a, b2, c, M_offset_14, 9, T[25]);
+            c = GG(c, d, a, b2, M_offset_3, 14, T[26]);
+            b2 = GG(b2, c, d, a, M_offset_8, 20, T[27]);
+            a = GG(a, b2, c, d, M_offset_13, 5, T[28]);
+            d = GG(d, a, b2, c, M_offset_2, 9, T[29]);
+            c = GG(c, d, a, b2, M_offset_7, 14, T[30]);
+            b2 = GG(b2, c, d, a, M_offset_12, 20, T[31]);
+            a = HH(a, b2, c, d, M_offset_5, 4, T[32]);
+            d = HH(d, a, b2, c, M_offset_8, 11, T[33]);
+            c = HH(c, d, a, b2, M_offset_11, 16, T[34]);
+            b2 = HH(b2, c, d, a, M_offset_14, 23, T[35]);
+            a = HH(a, b2, c, d, M_offset_1, 4, T[36]);
+            d = HH(d, a, b2, c, M_offset_4, 11, T[37]);
+            c = HH(c, d, a, b2, M_offset_7, 16, T[38]);
+            b2 = HH(b2, c, d, a, M_offset_10, 23, T[39]);
+            a = HH(a, b2, c, d, M_offset_13, 4, T[40]);
+            d = HH(d, a, b2, c, M_offset_0, 11, T[41]);
+            c = HH(c, d, a, b2, M_offset_3, 16, T[42]);
+            b2 = HH(b2, c, d, a, M_offset_6, 23, T[43]);
+            a = HH(a, b2, c, d, M_offset_9, 4, T[44]);
+            d = HH(d, a, b2, c, M_offset_12, 11, T[45]);
+            c = HH(c, d, a, b2, M_offset_15, 16, T[46]);
+            b2 = HH(b2, c, d, a, M_offset_2, 23, T[47]);
+            a = II(a, b2, c, d, M_offset_0, 6, T[48]);
+            d = II(d, a, b2, c, M_offset_7, 10, T[49]);
+            c = II(c, d, a, b2, M_offset_14, 15, T[50]);
+            b2 = II(b2, c, d, a, M_offset_5, 21, T[51]);
+            a = II(a, b2, c, d, M_offset_12, 6, T[52]);
+            d = II(d, a, b2, c, M_offset_3, 10, T[53]);
+            c = II(c, d, a, b2, M_offset_10, 15, T[54]);
+            b2 = II(b2, c, d, a, M_offset_1, 21, T[55]);
+            a = II(a, b2, c, d, M_offset_8, 6, T[56]);
+            d = II(d, a, b2, c, M_offset_15, 10, T[57]);
+            c = II(c, d, a, b2, M_offset_6, 15, T[58]);
+            b2 = II(b2, c, d, a, M_offset_13, 21, T[59]);
+            a = II(a, b2, c, d, M_offset_4, 6, T[60]);
+            d = II(d, a, b2, c, M_offset_11, 10, T[61]);
+            c = II(c, d, a, b2, M_offset_2, 15, T[62]);
+            b2 = II(b2, c, d, a, M_offset_9, 21, T[63]);
+            H3[0] = H3[0] + a | 0;
+            H3[1] = H3[1] + b2 | 0;
+            H3[2] = H3[2] + c | 0;
+            H3[3] = H3[3] + d | 0;
+          },
+          _doFinalize: function() {
+            var data = this._data;
+            var dataWords = data.words;
+            var nBitsTotal = this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+            dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+            var nBitsTotalH = Math2.floor(nBitsTotal / 4294967296);
+            var nBitsTotalL = nBitsTotal;
+            dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+            dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+            data.sigBytes = (dataWords.length + 1) * 4;
+            this._process();
+            var hash = this._hash;
+            var H3 = hash.words;
+            for (var i2 = 0; i2 < 4; i2++) {
+              var H_i = H3[i2];
+              H3[i2] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+            }
+            return hash;
+          },
+          clone: function() {
+            var clone = Hasher.clone.call(this);
+            clone._hash = this._hash.clone();
+            return clone;
+          }
+        });
+        function FF(a, b2, c, d, x, s, t) {
+          var n = a + (b2 & c | ~b2 & d) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        function GG(a, b2, c, d, x, s, t) {
+          var n = a + (b2 & d | c & ~d) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        function HH(a, b2, c, d, x, s, t) {
+          var n = a + (b2 ^ c ^ d) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        function II(a, b2, c, d, x, s, t) {
+          var n = a + (c ^ (b2 | ~d)) + x + t;
+          return (n << s | n >>> 32 - s) + b2;
+        }
+        C.MD5 = Hasher._createHelper(MD52);
+        C.HmacMD5 = Hasher._createHmacHelper(MD52);
+      })(Math);
+      return CryptoJS.MD5;
+    });
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -23750,6 +24510,7 @@ __export(index_exports, {
   captureFullDOMStructure: () => captureFullDOMStructure,
   configureWebRTCServer: () => configureWebRTCServer,
   executeAction: () => executeAction,
+  generateDynamicId: () => generateDynamicId,
   getFullDOMStructure: () => getFullDOMStructure,
   getWebRTCServerConfig: () => getWebRTCServerConfig,
   initWebRTC: () => initWebRTC,
@@ -23874,16 +24635,10 @@ var CuekitProvider = ({
   (0, import_react.useEffect)(() => {
     if (apiKey) {
       try {
-        console.log("\u{1F3A4} CuekitProvider: Starting WebRTC initialization...", {
-          apiKey: apiKey.substring(0, 10) + "..."
-        });
         initWebRTC(apiKey);
-        console.log("\u{1F3A4} CuekitProvider: WebRTC initialized successfully");
       } catch (error) {
-        console.error("\u{1F3A4} CuekitProvider: Failed to initialize WebRTC:", error);
       }
     } else {
-      console.warn("\u{1F3A4} CuekitProvider: No API key provided, skipping WebRTC initialization");
     }
   }, [apiKey]);
   (0, import_react.useEffect)(() => {
@@ -23896,15 +24651,11 @@ var CuekitProvider = ({
     Promise.resolve().then(() => (init_webrtc_service(), webrtc_service_exports)).then(({ setWebRTCCallbacks: setWebRTCCallbacks2 }) => {
       setWebRTCCallbacks2({
         onNavigationCommand: (command) => {
-          console.log("\u{1F9ED} Processing navigation command:", command);
           switch (command.type) {
             case "static_data_ready":
-              console.log("\u{1F4E6} Static data ready:", command.data);
               break;
             case "ai_intent":
-              console.log("\u{1F3AF} AI Intent:", command.text, "->", command.actionType);
               if (command.actionType === "navigate" && command.current_page) {
-                console.log(`\u{1F9ED} Navigating to: ${command.current_page}`);
                 if (navigationHandler2) {
                   navigationHandler2(command.current_page, {
                     intent: command.intent,
@@ -23915,13 +24666,10 @@ var CuekitProvider = ({
               }
               break;
             case "user_speech_text":
-              console.log("\u{1F464} User said:", command.text);
               break;
             case "ai_speech_text":
-              console.log("\u{1F916} AI said:", command.text);
               break;
             default:
-              console.log("\u{1F50D} Unknown command type:", command.type);
           }
         },
         onConnectionStateChange: (state) => {
@@ -24061,7 +24809,6 @@ var useWebRTC = (options) => {
       setIsConnected(true);
       return authData;
     } catch (err) {
-      console.error("Connection failed:", err);
       setError(err.message || "Failed to connect");
       setIsConnected(false);
     } finally {
@@ -24148,7 +24895,7 @@ var useCuekit = (options) => {
   const [micState, setMicState] = (0, import_react3.useState)("idle");
   const [status, setStatus] = (0, import_react3.useState)("");
   const handleNavigationCommand = (event) => {
-    console.log(`\u{1F9E0} Processing event in useCuekit: ${event.type}`, event);
+    console.log(`\u2B07\uFE0F Received event from backend: ${event.type}`, event);
     switch (event.type) {
       case "user_speech_chunk":
       case "ai_speech_chunk": {
@@ -28031,9 +28778,9 @@ function factoryTitle(effects, ok3, nok, type, markerType, stringType) {
       return atBreak(code4);
     }
     effects.consume(code4);
-    return code4 === 92 ? escape : inside;
+    return code4 === 92 ? escape2 : inside;
   }
-  function escape(code4) {
+  function escape2(code4) {
     if (code4 === marker || code4 === 92) {
       effects.consume(code4);
       return inside;
@@ -36929,9 +37676,9 @@ var SunIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -36960,9 +37707,9 @@ var MoonIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -36983,9 +37730,9 @@ var CloseIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -37007,9 +37754,9 @@ var PhoneOffIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -39636,19 +40383,6 @@ var VoiceIntensityBars = ({
     return null;
   }
   let trackRef = null;
-  console.log("VoiceIntensityVisualizer Debug:", {
-    participants: participants.length,
-    localParticipant: !!localParticipant,
-    isActive
-  });
-  console.log(
-    "All participants:",
-    participants.map((p) => ({
-      identity: p.identity,
-      isLocal: p instanceof Participant,
-      hasAudio: p.getTrackPublication(Track.Source.Microphone)?.track !== void 0
-    }))
-  );
   let speakingParticipant = null;
   let highestAudioLevel = 0;
   participants.forEach((participant) => {
@@ -39661,15 +40395,8 @@ var VoiceIntensityBars = ({
   if (!speakingParticipant || highestAudioLevel === 0) {
     speakingParticipant = participants.find((p) => p.isSpeaking) || (participants.length > 0 ? participants[0] : null);
     if (speakingParticipant) {
-      console.log("Fallback to speaking status or first participant:", speakingParticipant.identity);
     }
   } else {
-    console.log(
-      "Using participant with highest audio level:",
-      speakingParticipant.identity,
-      "level:",
-      highestAudioLevel
-    );
   }
   if (speakingParticipant) {
     const audioTrack = speakingParticipant.getTrackPublication(Track.Source.Microphone);
@@ -39736,9 +40463,9 @@ var MicIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -39761,9 +40488,9 @@ var LoaderIcon = ({ width = 24, height = 24, className, ...props }) => {
       viewBox: "0 0 24 24",
       fill: "none",
       stroke: "currentColor",
-      "stroke-width": "2",
-      "stroke-linecap": "round",
-      "stroke-linejoin": "round",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
       className,
       ...props
     },
@@ -39842,9 +40569,6 @@ var MicButton = ({
     onAISpeechEnd: (trackId) => handleAISpeech(false, trackId),
     appId
   });
-  (0, import_react15.useEffect)(() => {
-    console.log("\u{1F3A4} MicButton received messages:", JSON.stringify(messageManagerMessages, null, 2));
-  }, [messageManagerMessages]);
   (0, import_react15.useEffect)(() => {
     const checkTheme = () => {
       if (typeof document !== "undefined") {
@@ -39894,74 +40618,27 @@ var MicButton = ({
   }, [showBorderGlow]);
   const handleAISpeech = (0, import_react15.useCallback)(
     (isSpeaking, trackId) => {
-      console.log("\u{1F3A4} MicButton: ===== AI SPEECH EVENT START =====");
-      console.log("\u{1F3A4} MicButton: Event type:", isSpeaking ? "START" : "END");
-      console.log("\u{1F3A4} MicButton: Track ID:", trackId);
-      console.log("\u{1F3A4} MicButton: Current AI speaking state:", aiSpeakingRef.current);
-      console.log("\u{1F3A4} MicButton: Current active AI tracks:", Array.from(activeAITracksRef.current));
-      console.log("\u{1F3A4} MicButton: Current status:", status);
-      console.log("\u{1F3A4} MicButton: Current mic state:", micState);
-      console.log("\u{1F3A4} MicButton: Is listening:", isConnected2);
-      console.log("\u{1F3A4} MicButton: Is connected:", isConnected2);
       if (isSpeaking && trackId) {
-        console.log("\u{1F3A4} MicButton: ===== AI SPEECH START =====");
-        console.log("\u{1F3A4} MicButton: Adding track to active set:", trackId);
         activeAITracksRef.current.add(trackId);
         aiSpeakingRef.current = true;
-        console.log("\u{1F3A4} MicButton: After adding track:");
-        console.log("\u{1F3A4} MicButton: - Active tracks:", Array.from(activeAITracksRef.current));
-        console.log("\u{1F3A4} MicButton: - AI speaking state:", aiSpeakingRef.current);
-        console.log("\u{1F3A4} MicButton: - Status set to: AI is speaking...");
         if (aiSpeechTimeoutRef.current) {
-          console.log("\u{1F3A4} MicButton: Clearing existing AI speech timeout");
           clearTimeout(aiSpeechTimeoutRef.current);
         }
-        console.log(
-          "\u{1F3A4} MicButton: AI speech started, active tracks:",
-          Array.from(activeAITracksRef.current)
-        );
       } else if (!isSpeaking && trackId) {
-        console.log("\u{1F3A4} MicButton: ===== AI SPEECH END =====");
-        console.log("\u{1F3A4} MicButton: Removing track from active set:", trackId);
         activeAITracksRef.current.delete(trackId);
-        console.log("\u{1F3A4} MicButton: After removing track:");
-        console.log("\u{1F3A4} MicButton: - Active tracks:", Array.from(activeAITracksRef.current));
-        console.log("\u{1F3A4} MicButton: - Active tracks size:", activeAITracksRef.current.size);
         if (activeAITracksRef.current.size === 0) {
-          console.log("\u{1F3A4} MicButton: ===== ALL AI TRACKS ENDED =====");
-          console.log("\u{1F3A4} MicButton: No more active tracks, resetting AI speaking state");
           aiSpeakingRef.current = false;
-          console.log("\u{1F3A4} MicButton: After reset:");
-          console.log("\u{1F3A4} MicButton: - AI speaking state:", aiSpeakingRef.current);
-          console.log("\u{1F3A4} MicButton: - Status set to: Listening");
-          console.log("\u{1F3A4} MicButton: All AI tracks ended, voice recognition re-enabled");
         } else {
-          console.log("\u{1F3A4} MicButton: Still have active tracks, keeping AI speaking state");
-          console.log("\u{1F3A4} MicButton: Remaining tracks:", Array.from(activeAITracksRef.current));
         }
       } else if (!isSpeaking && !trackId) {
-        console.log("\u{1F3A4} MicButton: ===== MANUAL RESET =====");
-        console.log("\u{1F3A4} MicButton: Manual reset triggered");
         activeAITracksRef.current.clear();
         aiSpeakingRef.current = false;
-        console.log("\u{1F3A4} MicButton: After manual reset:");
-        console.log("\u{1F3A4} MicButton: - Active tracks cleared");
-        console.log("\u{1F3A4} MicButton: - AI speaking state:", aiSpeakingRef.current);
-        console.log("\u{1F3A4} MicButton: - Status set to: Listening");
-        console.log("\u{1F3A4} MicButton: AI speech manually reset");
-      }
-      console.log("\u{1F3A4} MicButton: ===== AI SPEECH EVENT END =====");
-      console.log("\u{1F3A4} MicButton: Final state:");
-      console.log("\u{1F3A4} MicButton: - AI speaking:", aiSpeakingRef.current);
-      console.log("\u{1F3A4} MicButton: - Active tracks:", Array.from(activeAITracksRef.current));
-      console.log("\u{1F3A4} MicButton: - Status:", status);
-      console.log("\u{1F3A4} MicButton: ================================");
+      }
     },
     [status, micState, isConnected2]
   );
   (0, import_react15.useEffect)(() => {
     if (audioContainerRef2.current) {
-      console.log("\u{1F3A4} MicButton: Setting up audio container on mount");
       setAudioContainer(audioContainerRef2);
     }
     return () => {
@@ -39989,49 +40666,33 @@ var MicButton = ({
   };
   (0, import_react15.useEffect)(() => {
     if (isConnected2) {
-      console.log("\u{1F3A4} MicButton: WebRTC and SSE connections established - ready for commands");
     } else {
-      console.log("\u{1F3A4} MicButton: WebRTC not yet connected - ignoring speech");
     }
   }, [isConnected2]);
   (0, import_react15.useEffect)(() => {
-    console.log("\u{1F3A4} MicButton: Auto-open check:", {
-      isConnected: isConnected2,
-      chatIsOpen: isChatOpen
-    });
     if (isConnected2 && !isChatOpen) {
-      console.log("\u{1F3A4} MicButton: Auto-opening chat popup");
       openChat();
     }
   }, [isConnected2, isChatOpen, openChat]);
   (0, import_react15.useEffect)(() => {
     if (messageManagerMessages.length > 0 && !isChatOpen) {
-      console.log("\u{1F3A4} MicButton: Auto-opening chat popup due to messages");
       openChat();
     }
   }, [messageManagerMessages.length, isChatOpen, openChat]);
   const handleMicClick = (0, import_react15.useCallback)(() => {
     const shouldStop = micState === "listening" && isConnected2;
     if (shouldStop) {
-      console.log("\u{1F3A4} MicButton: User wants to stop - closing everything");
       voiceDisconnect().then(() => {
-        console.log("\u{1F3A4} MicButton: Stopped and disconnected");
       }).catch((error) => {
-        console.error("\u{1F3A4} MicButton: Error during disconnect:", error);
       });
     } else {
-      console.log("\u{1F3A4} MicButton: User wants to start - connecting everything");
       voiceConnect(`user_${Date.now()}`, apiKey, appId).then(() => {
-        console.log("\u{1F3A4} MicButton: WebRTC and SSE connections started");
         if (showBorderGlow) setShowBodyGlow(true);
         openChat();
-        console.log("\u{1F3A4} MicButton: Started listening");
         setTimeout(() => {
-          console.log("\u{1F3A4} MicButton: Force opening chat popup after connection");
           openChat();
         }, 500);
       }).catch((error) => {
-        console.error("\u{1F3A4} MicButton: Failed to start connections:", error);
       });
     }
   }, [
@@ -40045,14 +40706,12 @@ var MicButton = ({
     showBorderGlow
   ]);
   const handleSendText = async (textToSend) => {
-    console.log("\u{1F3A4} MicButton: handleSendText called with:", textToSend);
     setMicState("thinking");
     if (showBorderGlow) setShowBodyGlow(true);
     if (!isChatOpen) {
       openChat();
     }
     if (isConnected2) {
-      console.log("\u{1F3A4} MicButton: Sending via WebRTC");
       try {
         await sendUserCommand2(textToSend);
         setMicState("replying");
@@ -40061,27 +40720,21 @@ var MicButton = ({
           if (showBorderGlow) setShowBodyGlow(true);
         }, 1e3);
       } catch (error) {
-        console.error("\u{1F3A4} MicButton: Failed to send text:", error);
       } finally {
         setMicState("listening");
         if (showBorderGlow) setShowBodyGlow(true);
       }
     } else {
-      console.log("\u{1F3A4} MicButton: WebRTC not connected, cannot send message");
       setMicState("listening");
       if (showBorderGlow) setShowBodyGlow(true);
     }
-    console.log("\u{1F3A4} MicButton: Text sent via WebRTC");
   };
   const handleEndCall = async () => {
-    console.log("\u{1F3A4} MicButton: Ending call completely...");
     try {
       await voiceDisconnect();
       await voiceDisconnect();
       closeChat();
-      console.log("\u{1F3A4} MicButton: Call ended successfully");
     } catch (error) {
-      console.error("\u{1F3A4} MicButton: Error ending call:", error);
     }
   };
   const getIcon = () => {
@@ -40284,4 +40937,14 @@ var MicButton = ({
 
 // src/index.ts
 init_element_service();
+
+// src/utils/instrumentation.ts
+var import_md5 = __toESM(require_md5());
+function generateDynamicId(routePath, elementIdentifier) {
+  const combinedString = `${routePath}:${elementIdentifier}`;
+  const hash = (0, import_md5.default)(combinedString).toString();
+  return hash.substring(0, 8);
+}
+
+// src/index.ts
 init_element_service();