@cuekit-ai/react 1.3.4 → 1.4.0

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

@@ -22729,15 +22729,24 @@ var GlobalStore = {
 var navigation;
 var navigationHandler = null;
 function setNavigationHandler(handler) {
+  console.log("\u{1F9ED} setNavigationHandler called with:", !!handler);
   navigationHandler = handler;
 }
 function navigate(path, params) {
   const safeParams = params || {};
   const absolutePath = path.startsWith("/") ? path : `/${path}`;
+  console.log("\u{1F9ED} navigate() called with:", {
+    path,
+    absolutePath,
+    safeParams,
+    hasNavigationHandler: !!navigationHandler
+  });
   if (navigationHandler) {
     try {
+      console.log("\u{1F9ED} Using navigationHandler:", absolutePath, safeParams);
       navigationHandler(absolutePath, safeParams);
     } catch (error) {
+      console.error("\u{1F9ED} NavigationHandler error:", error);
     }
     return;
   }
@@ -22752,27 +22761,46 @@ function navigate(path, params) {
     navigation.push(fullPath);
   } else {
     if (typeof window !== "undefined") {
-      window.location.href = fullPath;
+      if (window.location.hash && window.location.hash.startsWith("#")) {
+        window.location.hash = fullPath;
+      } else {
+        window.location.href = fullPath;
+      }
     }
   }
 }
 var getCurrentPath = () => {
   if (typeof window === "undefined") return "";
+  if (window.location.hash && window.location.hash.startsWith("#")) {
+    const hashPath = window.location.hash.substring(1);
+    return hashPath.split("?")[0];
+  }
   return window.location.pathname;
 };
 var getSearchParams = () => {
   if (typeof window === "undefined") return new URLSearchParams();
+  if (window.location.hash && window.location.hash.includes("?")) {
+    const queryString = window.location.hash.split("?")[1];
+    return new URLSearchParams(queryString);
+  }
   return new URLSearchParams(window.location.search);
 };
 var safeNavigate = (name, params = {}) => {
+  console.log("\u{1F9ED} safeNavigate called with:", { name, params });
   if (name) {
     navigate(name, params);
   } else {
+    console.log("\u{1F9ED} safeNavigate: no name provided, skipping navigation");
   }
 };
 function getCurrentScreenName() {
   try {
     const path = getCurrentPath();
+    const pathParams = getCurrentPathParams();
+    if (path && Object.keys(pathParams).length > 0) {
+      const paramString = Object.entries(pathParams).map(([key, value]) => `${key}=${value}`).join(",");
+      return `${path}?${paramString}`;
+    }
     return path || "UnknownScreen";
   } catch (e2) {
     return "UnknownScreen";
@@ -22794,6 +22822,45 @@ function getCurrentRouteParams() {
     return {};
   }
 }
+function getCurrentPathParams() {
+  try {
+    const currentPath = getCurrentPath();
+    const params = {};
+    const numericIdMatch = currentPath.match(/\/(\d+)(?:\/|$)/);
+    if (numericIdMatch) {
+      params.id = numericIdMatch[1];
+    }
+    const uuidMatch = currentPath.match(
+      /\/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})(?:\/|$)/i
+    );
+    if (uuidMatch) {
+      params.uuid = uuidMatch[1];
+    }
+    const slugMatch = currentPath.match(/\/([a-z0-9-]+)(?:\/|$)/i);
+    if (slugMatch && !numericIdMatch && !uuidMatch) {
+      params.slug = slugMatch[1];
+    }
+    return params;
+  } catch (e2) {
+    return {};
+  }
+}
+function resolveRoutePath(routePath, params) {
+  try {
+    let resolvedPath = routePath;
+    Object.entries(params).forEach(([key, value]) => {
+      const placeholder = `:${key}`;
+      if (resolvedPath.includes(placeholder)) {
+        resolvedPath = resolvedPath.replace(placeholder, value);
+      }
+    });
+    resolvedPath = resolvedPath.replace(/:\w+/g, "");
+    resolvedPath = resolvedPath.replace(/\/+/g, "/");
+    return resolvedPath;
+  } catch (e2) {
+    return routePath;
+  }
+}
 function onStateChange() {
   const routeName = getCurrentScreenName();
   const params = getCurrentRouteParams();
@@ -22912,13 +22979,23 @@ function getElementPath2(element) {
 }
 
 // src/utils/element-service.ts
-var INTERACTIVE_ELEMENT_SELECTOR = 'a, button, input, textarea, select, [role="button"], [onclick], [data-ansyr-static], [data-ansyr-dynamic]';
+var INTERACTIVE_ELEMENT_SELECTOR = 'a, button, select, [role="button"], [role="link"], [role="tab"], [onclick], [onmousedown], [onmouseup], [ontouchstart], [ontouchend], [onkeydown], [onkeyup], [onkeypress], [onchange], [onsubmit], [onfocus], [onblur], [data-ansyr-static], [data-ansyr-dynamic]';
+var elementCache = /* @__PURE__ */ new Map();
+var cacheTimestamp = 0;
+var CACHE_TTL = 5e3;
 function getInteractiveElements() {
   const elements = document.querySelectorAll(INTERACTIVE_ELEMENT_SELECTOR);
   return Array.from(new Set(Array.from(elements)));
 }
 function getImmediateText(element) {
   let text = "";
+  const textAttributes = ["label", "text", "placeholder", "title", "alt", "aria-label"];
+  for (const attr of textAttributes) {
+    const value = element.getAttribute(attr);
+    if (value) {
+      text += value + " ";
+    }
+  }
   if (element.childNodes) {
     for (const node of Array.from(element.childNodes)) {
       if (node.nodeType === 3) {
@@ -22928,12 +23005,30 @@ function getImmediateText(element) {
   }
   return text.trim();
 }
-function captureFullDOMStructure() {
-  console.log("\u{1F333} Capturing full DOM structure for Cuekit...");
-  const interactiveElements = [];
+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 captureAllInteractiveElements() {
+  console.log("\u{1F333} Capturing ALL interactive elements for Cuekit...");
+  const interactiveElements = {};
   const descriptionsMap = /* @__PURE__ */ new Map();
-  document.querySelectorAll("[data-for]").forEach((el) => {
-    const targetId = el.getAttribute("data-for");
+  document.querySelectorAll("[data-ansyr-for]").forEach((el) => {
+    const targetId = el.getAttribute("data-ansyr-for");
     if (!targetId) return;
     const tags = [];
     const description = el.getAttribute("data-ansyr-description");
@@ -22948,110 +23043,115 @@ function captureFullDOMStructure() {
       descriptionsMap.set(targetId, [...existingTags, ...tags]);
     }
   });
-  const allElements = getInteractiveElements();
-  allElements.forEach((element) => {
+  const allInteractiveElements = getInteractiveElements();
+  console.log("\u{1F333} Found", allInteractiveElements.length, "interactive elements");
+  allInteractiveElements.forEach((element) => {
+    if (!(element instanceof HTMLElement)) return;
     const style = getComputedStyle(element);
-    if (element.closest("[data-cuekit-ignore]") || !isElementClickable(element) || element.tagName.toLowerCase() === "script" || style.display === "none" || style.visibility === "hidden") {
+    if (element.closest("[data-cuekit-ignore]") || element.tagName.toLowerCase() === "script" || style.display === "none" || style.visibility === "hidden") {
       return;
     }
+    let elementId = null;
     const staticId = element.getAttribute("data-ansyr-static");
     const dynamicId = element.getAttribute("data-ansyr-dynamic");
-    const id = staticId || dynamicId;
+    if (staticId) {
+      elementId = staticId;
+      console.log("\u{1F333} Using pre-assigned static ID:", elementId);
+    } else if (dynamicId) {
+      elementId = dynamicId;
+      console.log("\u{1F333} Using pre-assigned dynamic ID:", elementId);
+    } else {
+      elementId = generateStableDOMId(element);
+      console.log("\u{1F333} Calculated stable DOM ID:", elementId);
+    }
+    if (!elementId) {
+      console.log("\u{1F333} No ID could be determined for element:", element);
+      return;
+    }
     const tags = [];
     const directDescription = element.getAttribute("data-ansyr-description");
     if (directDescription) {
       tags.push(directDescription);
     }
-    if (id && descriptionsMap.has(id)) {
-      tags.push(...descriptionsMap.get(id) || []);
+    if (descriptionsMap.has(elementId)) {
+      tags.push(...descriptionsMap.get(elementId) || []);
     }
-    const dto = {
-      testID: id || generateStableDOMId(element),
-      type: element.tagName.toLowerCase(),
-      textContent: getImmediateText(element) || element.textContent?.trim() || "",
-      tags
-    };
-    interactiveElements.push(dto);
+    const textContent = getImmediateText(element) || element.textContent?.trim() || "";
+    interactiveElements[elementId] = [textContent, ...tags];
+    console.log("\u{1F333} Captured element:", {
+      id: elementId,
+      tagName: element.tagName,
+      textContent: textContent.substring(0, 50),
+      hasStaticId: !!staticId,
+      hasDynamicId: !!dynamicId,
+      isCalculated: !staticId && !dynamicId
+    });
   });
   const result = {
     components: interactiveElements
   };
-  console.log("\u{1F333} Full DOM structure captured:", result);
+  console.log("\u{1F333} All interactive elements captured:", result);
   return result;
 }
-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 clearElementCache() {
+  elementCache.clear();
+  cacheTimestamp = 0;
 }
-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 validateDynamicElements() {
+  if (false) {
+    const elements = document.querySelectorAll("[data-ansyr-dynamic]");
+    const ids = /* @__PURE__ */ new Set();
+    const duplicates = [];
+    elements.forEach((element) => {
+      const id = element.getAttribute("data-ansyr-dynamic");
+      if (id) {
+        if (ids.has(id)) {
+          duplicates.push(id);
+        }
+        ids.add(id);
+      }
+    });
+    if (duplicates.length > 0) {
+      console.warn("\u{1F6A8} CueKit: Duplicate dynamic IDs found:", duplicates);
+      console.warn(
+        "This can cause incorrect element targeting. Ensure each dynamic element has a unique identifier."
+      );
+    }
   }
 }
-function getFullDOMStructure() {
-  return captureFullDOMStructure();
-}
 function clickElement(elementId) {
+  console.log("\u{1F5B1}\uFE0F clickElement called with:", elementId);
   if (!elementId) {
+    console.log("\u{1F5B1}\uFE0F clickElement: no elementId provided");
     return false;
   }
   const domElement = findDOMElementById(elementId);
+  console.log("\u{1F5B1}\uFE0F clickElement: found DOM element:", domElement);
   if (domElement) {
+    console.log("\u{1F5B1}\uFE0F clickElement: attempting to click element:", {
+      tagName: domElement.tagName,
+      id: domElement.id,
+      className: domElement.className,
+      textContent: domElement.textContent?.substring(0, 50)
+    });
     domElement.click();
+    console.log("\u{1F5B1}\uFE0F clickElement: click() called successfully");
     return true;
   }
+  console.log("\u{1F5B1}\uFE0F clickElement: element not found");
   return false;
 }
 function navigateToElement(target) {
+  console.log("\u{1F9ED} navigateToElement called with:", target);
   if (!target) {
+    console.log("\u{1F9ED} navigateToElement: no target provided");
     return false;
   }
   if (target.includes("/") || target.startsWith("http")) {
+    console.log("\u{1F9ED} navigateToElement: using safeNavigate for path:", target);
     safeNavigate(target, {});
   } else {
+    console.log("\u{1F9ED} navigateToElement: using handleNavigationAndClick for element:", target);
     handleNavigationAndClick(target, target);
   }
   return true;
@@ -23090,21 +23190,82 @@ function toggleElement(elementId) {
   }
 }
 function findDOMElementById(elementId) {
+  console.log("\u{1F50D} findDOMElementById called with:", elementId);
   if (!elementId) {
+    console.log("\u{1F50D} findDOMElementById: no elementId provided");
     return null;
   }
-  const interactiveElements = getInteractiveElements();
-  for (const element of interactiveElements) {
-    if (element instanceof HTMLElement) {
+  const now = Date.now();
+  if (now - cacheTimestamp < CACHE_TTL && elementCache.has(elementId)) {
+    const cachedElement = elementCache.get(elementId);
+    console.log("\u{1F50D} findDOMElementById: found in cache:", cachedElement);
+    if (document.contains(cachedElement)) {
+      console.log("\u{1F50D} findDOMElementById: returning cached element");
+      return cachedElement;
+    } else {
+      console.log("\u{1F50D} findDOMElementById: cached element no longer in DOM, removing from cache");
+      elementCache.delete(elementId);
+    }
+  }
+  let foundElement = null;
+  console.log(
+    "\u{1F50D} findDOMElementById: checking for static element with selector:",
+    `[data-ansyr-static="${elementId}"]`
+  );
+  const staticElement = document.querySelector(`[data-ansyr-static="${elementId}"]`);
+  if (staticElement instanceof HTMLElement) {
+    console.log("\u{1F50D} findDOMElementById: found static element:", staticElement);
+    foundElement = staticElement;
+  } else {
+    console.log(
+      "\u{1F50D} findDOMElementById: checking for dynamic element with selector:",
+      `[data-ansyr-dynamic="${elementId}"]`
+    );
+    const dynamicElement = document.querySelector(`[data-ansyr-dynamic="${elementId}"]`);
+    if (dynamicElement instanceof HTMLElement) {
+      console.log("\u{1F50D} findDOMElementById: found dynamic element:", dynamicElement);
+      foundElement = dynamicElement;
+    }
+  }
+  if (!foundElement) {
+    console.log(
+      "\u{1F50D} findDOMElementById: no pre-assigned element found, scanning all interactive elements"
+    );
+    const interactiveElements = getInteractiveElements();
+    console.log("\u{1F50D} findDOMElementById: found", interactiveElements.length, "interactive elements");
+    for (const element of interactiveElements) {
+      if (!(element instanceof HTMLElement)) continue;
       const staticId = element.getAttribute("data-ansyr-static");
       const dynamicId = element.getAttribute("data-ansyr-dynamic");
-      const currentElementId = staticId || dynamicId || generateStableDOMId(element);
+      let currentElementId = null;
+      if (staticId) {
+        currentElementId = staticId;
+      } else if (dynamicId) {
+        currentElementId = dynamicId;
+      } else {
+        currentElementId = generateStableDOMId(element);
+      }
       if (currentElementId === elementId) {
-        return element;
+        console.log("\u{1F50D} findDOMElementById: found element by ID match:", {
+          element,
+          id: currentElementId,
+          hasStaticId: !!staticId,
+          hasDynamicId: !!dynamicId,
+          isCalculated: !staticId && !dynamicId
+        });
+        foundElement = element;
+        break;
       }
     }
+    if (!foundElement) {
+      console.log("\u{1F50D} findDOMElementById: element not found in interactive elements scan");
+    }
+  }
+  if (foundElement) {
+    elementCache.set(elementId, foundElement);
+    cacheTimestamp = now;
   }
-  return null;
+  return foundElement;
 }
 
 // src/utils/webrtc-service.ts
@@ -23123,8 +23284,16 @@ function setAudioContainer(newAudioContainerRef) {
   audioContainerRef = newAudioContainerRef;
 }
 function setWebRTCCallbacks(newCallbacks) {
+  console.log("\u{1F4E1} setWebRTCCallbacks called with:", {
+    hasOnNavigationCommand: !!newCallbacks.onNavigationCommand,
+    hasOnConnectionStateChange: !!newCallbacks.onConnectionStateChange,
+    hasOnParticipantUpdate: !!newCallbacks.onParticipantUpdate
+  });
   callbacks = newCallbacks;
 }
+function getCurrentCallbacks() {
+  return callbacks;
+}
 async function authenticate(userIdentity, apiKey, appId) {
   try {
     const authPayload = {
@@ -23215,12 +23384,34 @@ function setupEventListeners() {
     track.detach().forEach((element) => element.remove());
   }).on(RoomEvent.DataReceived, (payload, participant) => {
     const decodedPayload = new TextDecoder().decode(payload);
-    try {
-      const message = JSON.parse(decodedPayload);
-      callbacks.onNavigationCommand?.(message);
-    } catch (error) {
-      const message = decodedPayload;
-      callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
+    console.log("\u{1F4E1} WebRTC DataReceived:", { decodedPayload, participant: participant?.identity });
+    if (decodedPayload.includes("|")) {
+      const parts = decodedPayload.split("|");
+      const textPart = parts[0];
+      const jsonPart = parts[1];
+      console.log("\u{1F4E1} WebRTC Pipe-separated message:", { textPart, jsonPart });
+      if (textPart) {
+        callbacks.onNavigationCommand?.({ type: "speech_text", data: textPart });
+      }
+      if (jsonPart) {
+        try {
+          const message = JSON.parse(jsonPart);
+          console.log("\u{1F4E1} WebRTC Parsed JSON message:", message);
+          callbacks.onNavigationCommand?.(message);
+        } catch (error) {
+          console.log("\u{1F4E1} WebRTC JSON parse error for JSON part:", error, "JSON part:", jsonPart);
+        }
+      }
+    } else {
+      try {
+        const message = JSON.parse(decodedPayload);
+        console.log("\u{1F4E1} WebRTC Parsed message:", message);
+        callbacks.onNavigationCommand?.(message);
+      } catch (error) {
+        console.log("\u{1F4E1} WebRTC JSON parse error:", error, "Raw payload:", decodedPayload);
+        const message = decodedPayload;
+        callbacks.onNavigationCommand?.({ type: "raw_text", data: message });
+      }
     }
   }).on(RoomEvent.Disconnected, () => {
     setWebRTCConnectionState({ isConnected: false, isConnecting: false });
@@ -23274,17 +23465,19 @@ async function sendUserCommand(command) {
   await sendData(command);
 }
 async function sendRuntimeData() {
+  console.log("\u{1F9E0} checking room:", room);
   if (!room) {
     return;
   }
+  console.log("\u{1F9E0} Sending runtime data", room);
   try {
-    const domStructure = captureFullDOMStructure();
+    const allInteractiveElements = captureAllInteractiveElements();
     const screenName = getCurrentScreenName();
     const response = {
       type: "runtime_data_response",
       data: {
-        components: domStructure.components,
-        current_screen: screenName
+        components: allInteractiveElements.components,
+        currentRoute: screenName
       }
     };
     await sendData(JSON.stringify(response));
@@ -23349,6 +23542,8 @@ export {
   setWebRTCConfig,
   GlobalStore,
   setNavigationHandler,
+  getCurrentPathParams,
+  resolveRoutePath,
   onStateChange,
   WEBRTC_BACKEND_SERVER_URL,
   RoomEvent,
@@ -23356,12 +23551,14 @@ export {
   Track,
   createAudioAnalyser,
   ConnectionState,
-  captureFullDOMStructure,
   executeAction,
-  getFullDOMStructure,
+  captureAllInteractiveElements,
+  clearElementCache,
+  validateDynamicElements,
   setServerUrl,
   setAudioContainer,
   setWebRTCCallbacks,
+  getCurrentCallbacks,
   authenticate,
   connectToRoom,
   sendData,

package/dist/index.d.mts

@@ -129,25 +129,15 @@ interface ServerConfig {
     token_ttl_seconds: number;
     server_version: string;
 }
+interface AIIntentData {
+    actionType: 'navigate' | 'click' | 'input' | 'scroll';
+    routeName?: string;
+    elementId?: string;
+}
 interface NavigationCommand {
-    type: 'static_data_ready' | 'ai_intent' | 'user_speech_text' | 'ai_speech_text';
-    data?: {
-        app_id?: string;
-        components?: any[];
-        intents?: any[];
-        pages_count?: number;
-        elements_count?: number;
-    };
-    intent?: string;
-    actionType?: string;
-    text?: string;
-    confidence?: number;
-    target_element?: string;
-    current_page?: string;
-    user_input?: string;
-    speaker?: 'user' | 'ai';
-    duration?: number;
+    type: 'ai_intent';
     timestamp?: number;
+    data: AIIntentData;
 }
 declare function sendData(data: string, reliable?: boolean): Promise<void>;
 declare function sendScreenStatus(screenData: any): Promise<void>;
@@ -254,20 +244,13 @@ declare const initWebRTCWithDeployedBackend: (apiKey: string, customConfig?: Par
  */
 declare const initWebRTC: (apiKey: string) => WebRTCServerConfig;
 
-interface InteractiveElementDto {
-    testID: string;
-    type: string;
-    textContent: string;
-    tags: string[];
-}
+type InteractiveElement = {
+    [btnId: string]: string[];
+};
 interface DOMStructurePayload {
-    components: InteractiveElementDto[];
+    components: InteractiveElement;
 }
 
-/**
- * Capture the full DOM structure as a flat list of interactive elements
- */
-declare function captureFullDOMStructure(): DOMStructurePayload;
 interface ElementAction {
     action_type: 'click' | 'navigate' | 'input' | 'focus' | 'toggle';
     target_element?: string;
@@ -275,7 +258,23 @@ interface ElementAction {
     instruction?: string;
 }
 declare function executeAction(action: ElementAction): boolean;
-declare function getFullDOMStructure(): DOMStructurePayload;
+/**
+ * Captures ALL interactive elements on the page.
+ * Uses pre-assigned IDs (data-ansyr-static, data-ansyr-dynamic) when available,
+ * otherwise calculates stable DOM IDs for elements without pre-assigned IDs.
+ *
+ * This ensures comprehensive coverage of all interactive elements for AI interaction.
+ */
+declare function captureAllInteractiveElements(): DOMStructurePayload;
+/**
+ * Clears the element cache. Call this when the DOM structure changes significantly.
+ */
+declare function clearElementCache(): void;
+/**
+ * Validates dynamic elements in development mode.
+ * Checks for duplicate IDs and provides warnings.
+ */
+declare function validateDynamicElements(): void;
 
 /**
  * Generates a stable, unique 8-character ID for an interactive element.
@@ -287,4 +286,15 @@ declare function getFullDOMStructure(): DOMStructurePayload;
  */
 declare function generateDynamicId(routePath: string, elementIdentifier: string): string;
 
-export { BorderGlow, ChatPopup, type ChatPopupProps, CuekitProvider, type DOMStructurePayload, type ElementAction, InitCuekit, type InteractiveElementDto, MicButton, type MicButtonProps, type MicState$1 as MicState, type NavigationCommand, type ServerConfig, type TokenRequest, type TokenResponse, VoiceIntensityVisualizer, type WebRTCServerConfig, captureFullDOMStructure, configureWebRTCServer, executeAction, generateDynamicId, getFullDOMStructure, getWebRTCServerConfig, initWebRTC, initWebRTCWithDeployedBackend, useCuekit, useQubeContext, useWebRTC };
+/**
+ * Extracts route parameters from the current URL path.
+ * For routes like /form/:id, extracts { id: "123" } from /form/123
+ */
+declare function getCurrentPathParams(): Record<string, string>;
+/**
+ * Resolves a route path with parameters.
+ * Example: resolveRoutePath('/form/:id', { id: '123' }) -> '/form/123'
+ */
+declare function resolveRoutePath(routePath: string, params: Record<string, string>): string;
+
+export { BorderGlow, ChatPopup, type ChatPopupProps, CuekitProvider, type DOMStructurePayload, type ElementAction, InitCuekit, type InteractiveElement, MicButton, type MicButtonProps, type MicState$1 as MicState, type NavigationCommand, type ServerConfig, type TokenRequest, type TokenResponse, VoiceIntensityVisualizer, type WebRTCServerConfig, captureAllInteractiveElements, clearElementCache, configureWebRTCServer, executeAction, generateDynamicId, getCurrentPathParams, getWebRTCServerConfig, initWebRTC, initWebRTCWithDeployedBackend, resolveRoutePath, useCuekit, useQubeContext, useWebRTC, validateDynamicElements };