@navsi.ai/sdk 1.0.0

package/dist/chunk-EHZXIZIP.js

@@ -0,0 +1,3752 @@
+import { ChatbotContext, useChatbot, useActionExecution, useWebSocket } from './chunk-6FUUG5WB.js';
+import React2, { useMemo, useReducer, useRef, useState, useEffect, useCallback } from 'react';
+import { createLogger, normalizeWidgetConfig, createMessageId } from '@navsi.ai/shared';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+
+var MessageQueue = class {
+  queue = [];
+  maxSize;
+  constructor(maxSize = 100) {
+    this.maxSize = maxSize;
+  }
+  enqueue(message) {
+    if (this.queue.length >= this.maxSize) {
+      this.queue.shift();
+    }
+    this.queue.push(message);
+  }
+  dequeueAll() {
+    const messages = [...this.queue];
+    this.queue = [];
+    return messages;
+  }
+  get length() {
+    return this.queue.length;
+  }
+  clear() {
+    this.queue = [];
+  }
+};
+var WebSocketClient = class {
+  ws = null;
+  config;
+  state = "disconnected";
+  logger = createLogger("SDK.WebSocket");
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  heartbeatInterval = null;
+  lastPongTime = 0;
+  messageQueue = new MessageQueue();
+  sessionId = null;
+  refreshToken = null;
+  tokenExpiresAt = 0;
+  tokenRefreshTimeout = null;
+  // Event listeners
+  listeners = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = {
+      serverUrl: config.serverUrl,
+      apiKey: config.apiKey,
+      autoReconnect: config.autoReconnect ?? true,
+      maxReconnectAttempts: config.maxReconnectAttempts ?? 10,
+      reconnectDelay: config.reconnectDelay ?? 1e3,
+      heartbeatInterval: config.heartbeatInterval ?? 3e4,
+      debug: config.debug ?? false
+    };
+    this.logger = createLogger("SDK.WebSocket", { enabled: this.config.debug, level: "debug" });
+  }
+  // ============================================================================
+  // Public API
+  // ============================================================================
+  /**
+   * Connect to the WebSocket server
+   */
+  connect() {
+    if (this.state === "connecting" || this.state === "connected") {
+      this.log("Already connected or connecting");
+      return;
+    }
+    this.setState("connecting");
+    this.createWebSocket();
+  }
+  /**
+   * Disconnect from the server
+   */
+  disconnect() {
+    this.cleanup();
+    this.setState("disconnected");
+    this.log("Disconnected");
+  }
+  /**
+   * Send a message to the server
+   */
+  send(message) {
+    if (this.state === "connected" && this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(message));
+      this.log("Sent message:", message.type, summarizeClientMessage(message));
+    } else {
+      this.messageQueue.enqueue(message);
+      this.log("Queued message (offline):", message.type, summarizeClientMessage(message));
+    }
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Check if connected
+   */
+  isConnected() {
+    return this.state === "connected";
+  }
+  // ============================================================================
+  // Event Handling
+  // ============================================================================
+  /**
+   * Subscribe to an event
+   */
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return () => {
+      this.listeners.get(event)?.delete(callback);
+    };
+  }
+  /**
+   * Emit an event to all listeners
+   */
+  emit(event, data) {
+    this.listeners.get(event)?.forEach((callback) => {
+      try {
+        callback(data);
+      } catch (error) {
+        this.logger.error(`Error in ${event} listener`, error);
+      }
+    });
+  }
+  // ============================================================================
+  // Connection Management
+  // ============================================================================
+  createWebSocket() {
+    try {
+      const urlObj = new URL(this.config.serverUrl);
+      urlObj.searchParams.set("apiKey", this.config.apiKey);
+      if (this.sessionId) {
+        urlObj.searchParams.set("sessionId", this.sessionId);
+      }
+      const url = urlObj.toString();
+      this.ws = new WebSocket(url);
+      this.ws.onopen = this.handleOpen.bind(this);
+      this.ws.onmessage = this.handleMessage.bind(this);
+      this.ws.onclose = this.handleClose.bind(this);
+      this.ws.onerror = this.handleError.bind(this);
+    } catch (error) {
+      this.logger.error("Failed to create WebSocket", error);
+      this.handleConnectionFailure();
+    }
+  }
+  handleOpen() {
+    this.log("WebSocket connected, authenticating...");
+    this.ws?.send(JSON.stringify({
+      type: "auth",
+      apiKey: this.config.apiKey,
+      sessionId: this.sessionId
+    }));
+  }
+  handleMessage(event) {
+    try {
+      const message = JSON.parse(event.data);
+      this.log("Received message:", message.type);
+      switch (message.type) {
+        case "connected":
+          this.handleConnected();
+          break;
+        case "auth_success":
+          this.handleAuthSuccess(message);
+          break;
+        case "auth_error":
+          this.handleAuthError(message);
+          break;
+        case "pong":
+          this.handlePong(message);
+          break;
+        case "token_refreshed":
+          this.handleTokenRefreshed(message);
+          break;
+        default:
+          this.emit("message", message);
+      }
+    } catch (error) {
+      this.logger.warn("Failed to parse message", error);
+    }
+  }
+  handleClose(event) {
+    this.log("WebSocket closed:", event.code, event.reason);
+    this.stopHeartbeat();
+    if (this.state !== "disconnected") {
+      this.emit("disconnected", { reason: event.reason, code: event.code });
+      if (this.config.autoReconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.setState("disconnected");
+      }
+    }
+  }
+  handleError(event) {
+    this.logger.error("WebSocket error", event);
+    this.emit("error", { error: new Error("WebSocket error") });
+  }
+  // ============================================================================
+  // Authentication
+  // ============================================================================
+  handleConnected() {
+    this.log("Server connection acknowledged");
+  }
+  handleAuthSuccess(message) {
+    this.sessionId = message.sessionId;
+    this.refreshToken = message.refreshToken;
+    this.tokenExpiresAt = message.expiresAt;
+    this.reconnectAttempts = 0;
+    this.setState("connected");
+    this.startHeartbeat();
+    this.scheduleTokenRefresh();
+    this.flushMessageQueue();
+    this.emit("authenticated", {
+      sessionId: message.sessionId,
+      expiresAt: message.expiresAt
+    });
+    this.emit("connected", { sessionId: message.sessionId });
+    this.log("Authenticated successfully, session:", message.sessionId);
+  }
+  handleAuthError(message) {
+    this.logger.warn("Authentication failed", message.error);
+    this.emit("error", { error: new Error(message.error), code: message.code });
+    this.disconnect();
+  }
+  // ============================================================================
+  // Token Refresh
+  // ============================================================================
+  scheduleTokenRefresh() {
+    if (this.tokenRefreshTimeout) {
+      clearTimeout(this.tokenRefreshTimeout);
+    }
+    const refreshIn = Math.max(0, this.tokenExpiresAt - Date.now() - 5 * 60 * 1e3);
+    this.tokenRefreshTimeout = setTimeout(() => {
+      this.refreshAccessToken();
+    }, refreshIn);
+    this.log("Token refresh scheduled in", Math.round(refreshIn / 1e3), "seconds");
+  }
+  refreshAccessToken() {
+    if (!this.refreshToken || this.state !== "connected") {
+      return;
+    }
+    this.log("Refreshing token...");
+    this.ws?.send(JSON.stringify({
+      type: "token_refresh",
+      refreshToken: this.refreshToken
+    }));
+  }
+  handleTokenRefreshed(message) {
+    this.refreshToken = message.refreshToken;
+    this.tokenExpiresAt = message.expiresAt;
+    this.scheduleTokenRefresh();
+    this.emit("token_refreshed", { expiresAt: message.expiresAt });
+    this.log("Token refreshed successfully");
+  }
+  // ============================================================================
+  // Heartbeat
+  // ============================================================================
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.lastPongTime = Date.now();
+    this.heartbeatInterval = setInterval(() => {
+      if (this.state !== "connected") {
+        return;
+      }
+      if (Date.now() - this.lastPongTime > this.config.heartbeatInterval * 2) {
+        this.logger.warn("Heartbeat timeout, reconnecting...");
+        this.ws?.close();
+        return;
+      }
+      this.ws?.send(JSON.stringify({
+        type: "ping",
+        timestamp: Date.now()
+      }));
+      this.log("Sent ping");
+    }, this.config.heartbeatInterval);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  handlePong(message) {
+    this.lastPongTime = Date.now();
+    const latency = Date.now() - message.timestamp;
+    this.log("Received pong, latency:", latency, "ms");
+  }
+  // ============================================================================
+  // Reconnection
+  // ============================================================================
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      this.handleConnectionFailure();
+      return;
+    }
+    this.setState("reconnecting");
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.config.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1),
+      3e4
+    );
+    this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.config.maxReconnectAttempts})`);
+    this.emit("reconnecting", {
+      attempt: this.reconnectAttempts,
+      maxAttempts: this.config.maxReconnectAttempts
+    });
+    this.reconnectTimeout = setTimeout(() => {
+      this.createWebSocket();
+    }, delay);
+  }
+  handleConnectionFailure() {
+    this.setState("failed");
+    this.emit("reconnect_failed", { reason: "Max reconnection attempts reached" });
+    this.logger.error("Connection failed - max reconnection attempts reached");
+  }
+  // ============================================================================
+  // Message Queue
+  // ============================================================================
+  flushMessageQueue() {
+    const messages = this.messageQueue.dequeueAll();
+    if (messages.length > 0) {
+      this.log(`Flushing ${messages.length} queued messages`);
+      messages.forEach((message) => this.send(message));
+    }
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  setState(state) {
+    if (this.state !== state) {
+      this.log("State:", this.state, "->", state);
+      this.state = state;
+    }
+  }
+  cleanup() {
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.tokenRefreshTimeout) {
+      clearTimeout(this.tokenRefreshTimeout);
+      this.tokenRefreshTimeout = null;
+    }
+    this.stopHeartbeat();
+    if (this.ws) {
+      const ws = this.ws;
+      ws.onopen = null;
+      ws.onmessage = null;
+      ws.onclose = null;
+      ws.onerror = null;
+      this.ws = null;
+      if (ws.readyState === WebSocket.CONNECTING || ws.readyState === WebSocket.OPEN) {
+        try {
+          ws.close(1e3, "Client disconnect");
+        } catch {
+        }
+      }
+    }
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+function summarizeClientMessage(message) {
+  switch (message.type) {
+    case "message":
+      return {
+        messageId: message.messageId,
+        mode: message.mode,
+        length: message.content.length,
+        route: message.context?.route
+      };
+    case "context":
+      return {
+        route: message.context?.route,
+        actions: message.context?.actions?.length ?? 0,
+        headings: message.context?.content?.headings?.length ?? 0
+      };
+    case "action_result":
+      return {
+        actionId: message.actionId,
+        success: message.success,
+        commandId: message.commandId
+      };
+    case "server_action_request":
+      return {
+        actionId: message.actionId,
+        requestId: message.requestId
+      };
+    case "auth":
+      return {
+        hasSessionId: Boolean(message.sessionId)
+      };
+    case "token_refresh":
+      return {};
+    case "ping":
+      return { timestamp: message.timestamp };
+    default:
+      return {};
+  }
+}
+function createWebSocketClient(config) {
+  return new WebSocketClient(config);
+}
+
+// src/core/navigation/adapter.ts
+var DEFAULT_ROUTE_TIMEOUT = 1e4;
+function createMemoryAdapter(initialPath = "/") {
+  let currentPath = initialPath;
+  const listeners = /* @__PURE__ */ new Set();
+  return {
+    navigate(path) {
+      currentPath = path;
+      listeners.forEach((callback) => callback(path));
+    },
+    getCurrentPath() {
+      return currentPath;
+    },
+    onRouteChange(callback) {
+      listeners.add(callback);
+      return () => listeners.delete(callback);
+    },
+    async waitForRoute(path, timeout = DEFAULT_ROUTE_TIMEOUT) {
+      return new Promise((resolve) => {
+        if (currentPath === path) {
+          resolve(true);
+          return;
+        }
+        const unsubscribe = this.onRouteChange((newPath) => {
+          if (newPath === path) {
+            unsubscribe();
+            resolve(true);
+          }
+        });
+        setTimeout(() => {
+          unsubscribe();
+          resolve(currentPath === path);
+        }, timeout);
+      });
+    }
+  };
+}
+var NavigationController = class {
+  adapter;
+  config;
+  scanCallback = null;
+  logger = createLogger("SDK.Navigation");
+  constructor(adapter, config = {}) {
+    this.adapter = adapter;
+    this.config = {
+      domStabilityDelay: config.domStabilityDelay ?? 300,
+      domStabilityTimeout: config.domStabilityTimeout ?? 5e3,
+      debug: config.debug ?? false,
+      onDOMStable: config.onDOMStable
+    };
+    this.logger = createLogger("SDK.Navigation", { enabled: this.config.debug, level: "debug" });
+  }
+  /**
+   * Set the page scanner callback
+   */
+  setScanner(scanner) {
+    this.scanCallback = scanner;
+  }
+  /**
+   * Get current route
+   */
+  getCurrentRoute() {
+    return this.adapter.getCurrentPath();
+  }
+  /**
+   * Navigate to a route and wait for it to load
+   */
+  async navigateTo(route, timeout) {
+    const currentRoute = this.adapter.getCurrentPath();
+    if (currentRoute === route) {
+      this.log("Already on route:", route);
+      return true;
+    }
+    this.log("Navigating to:", route);
+    this.adapter.navigate(route);
+    const success = await this.adapter.waitForRoute(route, timeout);
+    if (!success) {
+      this.log("Navigation timeout for route:", route);
+    }
+    return success;
+  }
+  /**
+   * Execute navigation and rescan page context
+   */
+  async executeNavigation(route) {
+    const success = await this.navigateTo(route);
+    if (!success) {
+      this.log("Navigation failed to:", route);
+      return null;
+    }
+    await this.waitForDOMStable();
+    if (this.scanCallback) {
+      const context = await this.scanCallback();
+      this.log("Rescanned context on route:", route);
+      return context;
+    }
+    return null;
+  }
+  /**
+   * Wait for DOM to become stable after navigation
+   * Uses MutationObserver to detect when DOM stops changing
+   */
+  async waitForDOMStable() {
+    this.logger.debug("Waiting for DOM stability", {
+      delayMs: this.config.domStabilityDelay,
+      timeoutMs: this.config.domStabilityTimeout
+    });
+    const done = () => {
+      this.config.onDOMStable?.();
+    };
+    return new Promise((resolve) => {
+      let resolved = false;
+      const resolveOnce = () => {
+        if (resolved) return;
+        resolved = true;
+        done();
+        resolve();
+      };
+      if (typeof document === "undefined" || typeof MutationObserver === "undefined") {
+        resolveOnce();
+        return;
+      }
+      let mutationTimeout;
+      let maxTimeout;
+      const startTime = Date.now();
+      const cleanup = () => {
+        observer.disconnect();
+        clearTimeout(mutationTimeout);
+        clearTimeout(maxTimeout);
+      };
+      const observer = new MutationObserver(() => {
+        clearTimeout(mutationTimeout);
+        if (Date.now() - startTime >= this.config.domStabilityTimeout) {
+          cleanup();
+          this.log("DOM stability timeout reached");
+          resolveOnce();
+          return;
+        }
+        mutationTimeout = setTimeout(() => {
+          cleanup();
+          this.log("DOM is stable");
+          resolveOnce();
+        }, this.config.domStabilityDelay);
+      });
+      observer.observe(document.body, {
+        childList: true,
+        subtree: true,
+        attributes: false
+        // Ignore attribute changes for stability
+      });
+      mutationTimeout = setTimeout(() => {
+        cleanup();
+        this.log("DOM is stable (no initial mutations)");
+        resolveOnce();
+      }, this.config.domStabilityDelay);
+      maxTimeout = setTimeout(() => {
+        cleanup();
+        this.log("DOM stability max timeout reached");
+        resolveOnce();
+      }, this.config.domStabilityTimeout);
+    });
+  }
+  /**
+   * Subscribe to route changes
+   */
+  onRouteChange(callback) {
+    return this.adapter.onRouteChange(callback);
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+function createNavigationController(adapter, config) {
+  return new NavigationController(adapter, config);
+}
+var INTERACTIVE_SELECTORS = [
+  "button:not([disabled])",
+  "a[href]:not([disabled])",
+  'input:not([type="hidden"]):not([disabled])',
+  "select:not([disabled])",
+  "textarea:not([disabled])",
+  '[contenteditable="true"]',
+  '[contenteditable="plaintext-only"]',
+  '[role="textbox"]',
+  '[role="searchbox"]',
+  '[role="combobox"]',
+  '[role="checkbox"]',
+  '[role="switch"]',
+  '[role="radio"]',
+  '[role="button"]:not([disabled])',
+  '[role="link"]',
+  '[role="menuitem"]',
+  '[role="tab"]',
+  "[onclick]",
+  "[data-chatbot-action]"
+];
+var IGNORE_SELECTORS = [
+  "[data-chatbot-ignore]",
+  '[aria-hidden="true"]',
+  "[hidden]",
+  ".chatbot-widget",
+  // Legacy class
+  ".navsi-chatbot-container",
+  // Ignore our own widget
+  '[type="password"]',
+  // Security: don't interact with password fields
+  '[autocomplete*="cc-"]'
+  // Security: credit card fields
+];
+function generateSelector(element) {
+  const chatbotAction = element.getAttribute("data-chatbot-action");
+  if (chatbotAction) {
+    return `[data-chatbot-action="${chatbotAction}"]`;
+  }
+  if (element.id) {
+    return `#${CSS.escape(element.id)}`;
+  }
+  const testId = element.getAttribute("data-testid");
+  if (testId) {
+    return `[data-testid="${CSS.escape(testId)}"]`;
+  }
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel) {
+    const selector = `[aria-label="${CSS.escape(ariaLabel)}"]`;
+    const matches = document.querySelectorAll(selector);
+    if (matches.length === 1) {
+      return selector;
+    }
+  }
+  const name = element.getAttribute?.("name");
+  if (name && /^(input|select|textarea|button)$/i.test(element.tagName)) {
+    const selector = `${element.tagName.toLowerCase()}[name="${CSS.escape(name)}"]`;
+    const matches = document.querySelectorAll(selector);
+    if (matches.length === 1) {
+      return selector;
+    }
+  }
+  if (element.className && typeof element.className === "string") {
+    const classes = element.className.split(/\s+/).filter(Boolean).slice(0, 3);
+    if (classes.length > 0) {
+      const selector = `${element.tagName.toLowerCase()}.${classes.map((c) => CSS.escape(c)).join(".")}`;
+      const matches = document.querySelectorAll(selector);
+      if (matches.length === 1) {
+        return selector;
+      }
+    }
+  }
+  return buildPathSelector(element);
+}
+function buildPathSelector(element) {
+  const path = [];
+  let current = element;
+  while (current && current !== document.body) {
+    let selector = current.tagName.toLowerCase();
+    if (current.id) {
+      selector = `#${CSS.escape(current.id)}`;
+      path.unshift(selector);
+      break;
+    }
+    const parent = current.parentElement;
+    if (parent) {
+      const tagName = current.tagName;
+      const children = parent.children;
+      const sameTagSiblings = [];
+      for (let i = 0; i < children.length; i++) {
+        if (children[i].tagName === tagName) {
+          sameTagSiblings.push(children[i]);
+        }
+      }
+      if (sameTagSiblings.length > 1) {
+        const index = sameTagSiblings.indexOf(current) + 1;
+        selector += `:nth-of-type(${index})`;
+      }
+    }
+    path.unshift(selector);
+    current = parent;
+  }
+  return path.join(" > ");
+}
+function isVisible(element) {
+  const style = window.getComputedStyle(element);
+  if (style.display === "none") return false;
+  if (style.visibility === "hidden") return false;
+  if (style.opacity === "0") return false;
+  const rect = element.getBoundingClientRect();
+  if (rect.width === 0 && rect.height === 0) return false;
+  if (element.closest('[aria-hidden="true"]')) return false;
+  return true;
+}
+function shouldIgnore(element) {
+  for (const selector of IGNORE_SELECTORS) {
+    if (element.matches(selector)) return true;
+    if (element.closest(selector)) return true;
+  }
+  return false;
+}
+function getActionType(element) {
+  const tagName = element.tagName.toLowerCase();
+  const role = element.getAttribute("role")?.toLowerCase();
+  if (tagName === "input") {
+    const type = element.type;
+    if (type === "checkbox" || type === "radio") return "click";
+    return "type";
+  }
+  if (tagName === "textarea") return "type";
+  if (tagName === "select") return "select";
+  if (role === "textbox" || role === "searchbox") return "type";
+  if (role === "combobox") return "click";
+  if (role === "checkbox" || role === "radio" || role === "switch") return "click";
+  return "click";
+}
+function extractLabel(element) {
+  const chatbotAction = element.getAttribute("data-chatbot-action");
+  if (chatbotAction) {
+    return chatbotAction.replace(/-/g, " ");
+  }
+  const ariaLabel = element.getAttribute("aria-label");
+  if (ariaLabel) return ariaLabel;
+  const labelledBy = element.getAttribute("aria-labelledby");
+  if (labelledBy) {
+    const labelText = labelledBy.split(/\s+/).map((id) => document.getElementById(id)?.textContent?.trim()).filter(Boolean).join(" ");
+    if (labelText) return labelText;
+  }
+  const title = element.getAttribute("title");
+  if (title) return title;
+  const textContent = element.textContent?.trim();
+  if (textContent && textContent.length < 50) {
+    return textContent;
+  }
+  const placeholder = element.getAttribute("placeholder");
+  if (placeholder) return placeholder;
+  const name = element.getAttribute("name");
+  if (name) return name.replace(/[-_]/g, " ");
+  if (element.id) {
+    const label = document.querySelector(`label[for="${element.id}"]`);
+    if (label?.textContent) return label.textContent.trim();
+  }
+  return element.tagName.toLowerCase();
+}
+var CONTAINER_SELECTORS = [
+  "tr",
+  '[role="row"]',
+  "article",
+  '[role="listitem"]',
+  "section",
+  '[role="group"]',
+  "main",
+  '[role="region"]'
+];
+var MAX_CONTAINER_TEXT_LENGTH = 120;
+function getContainerText(element) {
+  let current = element;
+  let depth = 0;
+  const maxDepth = 8;
+  while (current && current !== document.body && depth < maxDepth) {
+    for (const sel of CONTAINER_SELECTORS) {
+      try {
+        if (current.matches(sel)) {
+          const text = current.textContent?.trim().replace(/\s+/g, " ");
+          if (text && text.length > 0) {
+            return text.length > MAX_CONTAINER_TEXT_LENGTH ? text.slice(0, MAX_CONTAINER_TEXT_LENGTH) + "\u2026" : text;
+          }
+          break;
+        }
+      } catch {
+      }
+    }
+    current = current.parentElement;
+    depth++;
+  }
+  return void 0;
+}
+function getNearbyHeading(element) {
+  let current = element.parentElement;
+  let depth = 0;
+  const maxDepth = 5;
+  while (current && depth < maxDepth) {
+    const heading = current.querySelector("h1, h2, h3, h4, h5, h6");
+    if (heading?.textContent) {
+      return heading.textContent.trim();
+    }
+    let sibling = current.previousElementSibling;
+    while (sibling) {
+      if (/^H[1-6]$/.test(sibling.tagName)) {
+        return sibling.textContent?.trim();
+      }
+      sibling = sibling.previousElementSibling;
+    }
+    current = current.parentElement;
+    depth++;
+  }
+  return void 0;
+}
+var DOMScanner = class {
+  config;
+  mutationObserver = null;
+  scanTimeout = null;
+  onChangeCallback = null;
+  logger = createLogger("SDK.Scanner");
+  constructor(config = {}) {
+    this.config = {
+      root: config.root ?? (typeof document !== "undefined" ? document.body : null),
+      debug: config.debug ?? false,
+      maxActions: config.maxActions ?? 100,
+      debounceMs: config.debounceMs ?? 300
+    };
+    this.logger = createLogger("SDK.Scanner", { enabled: this.config.debug, level: "debug" });
+  }
+  /**
+   * Scan the DOM for interactive elements
+   */
+  scan() {
+    if (typeof document === "undefined") {
+      return [];
+    }
+    const root = this.config.root ?? document.body;
+    const actions = [];
+    const currentRoute = typeof window !== "undefined" ? window.location.pathname : "/";
+    const selector = INTERACTIVE_SELECTORS.join(", ");
+    const elements = this.collectInteractiveElements(root, selector);
+    this.log(`Found ${elements.length} potential interactive elements`);
+    for (const element of elements) {
+      if (actions.length >= this.config.maxActions) break;
+      if (shouldIgnore(element)) continue;
+      if (!isVisible(element)) continue;
+      const action = this.createElement(element, currentRoute);
+      if (action) {
+        actions.push(action);
+      }
+    }
+    this.log(`Discovered ${actions.length} actions`);
+    return actions;
+  }
+  /**
+   * Create action definition from element
+   */
+  createElement(element, route) {
+    try {
+      const selector = generateSelector(element);
+      const label = extractLabel(element);
+      const type = getActionType(element);
+      const heading = getNearbyHeading(element);
+      const id = `action_${btoa(selector).replace(/[^a-zA-Z0-9]/g, "").slice(0, 16)}`;
+      const action = {
+        id,
+        type,
+        selector,
+        label,
+        route,
+        isAutoDiscovered: true,
+        priority: element.hasAttribute("data-chatbot-action") ? 10 : 1
+      };
+      const containerText = getContainerText(element);
+      if (heading || containerText) {
+        action.metadata = {
+          ...heading ? { context: heading } : {},
+          ...containerText ? { containerText } : {}
+        };
+      }
+      return action;
+    } catch (error) {
+      this.log("Error creating action:", error);
+      return null;
+    }
+  }
+  /**
+   * Collect interactive elements from light DOM and open shadow roots.
+   */
+  collectInteractiveElements(root, selector) {
+    const results = /* @__PURE__ */ new Set();
+    const roots = [root];
+    while (roots.length > 0) {
+      const currentRoot = roots.shift();
+      if (!currentRoot) {
+        break;
+      }
+      const scope = currentRoot instanceof ShadowRoot ? currentRoot : currentRoot;
+      const matches = scope.querySelectorAll(selector);
+      for (const match of matches) {
+        results.add(match);
+      }
+      const hostRoot = currentRoot instanceof ShadowRoot ? currentRoot : currentRoot;
+      const hostElements = hostRoot.querySelectorAll("*");
+      for (const host of hostElements) {
+        const shadowRoot = host.shadowRoot;
+        if (shadowRoot) {
+          roots.push(shadowRoot);
+        }
+      }
+    }
+    return Array.from(results);
+  }
+  /**
+   * Start observing DOM for changes. Disconnects any existing observer first.
+   */
+  observe(callback) {
+    if (typeof MutationObserver === "undefined") return;
+    this.disconnect();
+    this.onChangeCallback = callback;
+    this.mutationObserver = new MutationObserver(() => {
+      this.debouncedScan();
+    });
+    this.mutationObserver.observe(this.config.root ?? document.body, {
+      childList: true,
+      subtree: true,
+      attributes: true,
+      attributeFilter: ["disabled", "hidden", "aria-hidden"]
+    });
+  }
+  /**
+   * Stop observing DOM
+   */
+  disconnect() {
+    if (this.mutationObserver) {
+      this.mutationObserver.disconnect();
+      this.mutationObserver = null;
+    }
+    if (this.scanTimeout) {
+      clearTimeout(this.scanTimeout);
+      this.scanTimeout = null;
+    }
+  }
+  /**
+   * Debounced scan
+   */
+  debouncedScan() {
+    if (this.scanTimeout) {
+      clearTimeout(this.scanTimeout);
+    }
+    this.scanTimeout = setTimeout(() => {
+      const actions = this.scan();
+      this.onChangeCallback?.(actions);
+    }, this.config.debounceMs);
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+var ActionRegistry = class {
+  actionsByRoute = /* @__PURE__ */ new Map();
+  serverActions = /* @__PURE__ */ new Map();
+  manualActions = /* @__PURE__ */ new Map();
+  debug;
+  logger = createLogger("SDK.Registry");
+  constructor(config = {}) {
+    this.debug = config.debug ?? false;
+    this.logger = createLogger("SDK.Registry", { enabled: this.debug, level: "debug" });
+  }
+  // ============================================================================
+  // DOM Actions
+  // ============================================================================
+  /**
+   * Register auto-discovered actions for a route
+   */
+  registerDiscoveredActions(route, actions) {
+    if (!this.actionsByRoute.has(route)) {
+      this.actionsByRoute.set(route, /* @__PURE__ */ new Map());
+    }
+    const routeActions = this.actionsByRoute.get(route);
+    for (const [id, action] of routeActions) {
+      if (action.isAutoDiscovered) {
+        routeActions.delete(id);
+      }
+    }
+    for (const action of actions) {
+      const manualAction = this.manualActions.get(action.id);
+      if (manualAction) {
+        routeActions.set(action.id, { ...action, ...manualAction });
+      } else {
+        routeActions.set(action.id, action);
+      }
+    }
+    this.log(`Registered ${actions.length} discovered actions for route: ${route}`);
+  }
+  /**
+   * Register a manual action definition (takes priority over auto-discovered)
+   */
+  registerManualAction(action) {
+    this.manualActions.set(action.id, action);
+    const routeActions = this.actionsByRoute.get(action.route);
+    if (routeActions?.has(action.id)) {
+      const existing = routeActions.get(action.id);
+      routeActions.set(action.id, { ...existing, ...action, isAutoDiscovered: false });
+    }
+    this.log(`Registered manual action: ${action.id}`);
+  }
+  /**
+   * Get all actions for a route
+   */
+  getActionsForRoute(route) {
+    const routeActions = this.actionsByRoute.get(route);
+    if (!routeActions) return [];
+    return Array.from(routeActions.values()).sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  }
+  /**
+   * Find action by ID
+   */
+  findActionById(id) {
+    for (const routeActions of this.actionsByRoute.values()) {
+      const action = routeActions.get(id);
+      if (action) return action;
+    }
+    return null;
+  }
+  /**
+   * Find action by selector on a specific route
+   */
+  findActionBySelector(route, selector) {
+    const routeActions = this.actionsByRoute.get(route);
+    if (!routeActions) return null;
+    for (const action of routeActions.values()) {
+      if (action.selector === selector) return action;
+    }
+    return null;
+  }
+  /**
+   * Find action by label (fuzzy match). When context is provided, prefer actions
+   * whose metadata.containerText or metadata.context contains the context string.
+   */
+  findActionByLabel(route, label, context) {
+    const routeActions = this.actionsByRoute.get(route);
+    if (!routeActions) return null;
+    const normalizedLabel = label.toLowerCase().trim();
+    const normalizedContext = context?.toLowerCase().trim();
+    const matchesContext = (action) => {
+      if (!normalizedContext) return true;
+      const containerText = action.metadata?.containerText?.toLowerCase();
+      const metaContext = action.metadata?.context?.toLowerCase();
+      return (containerText?.includes(normalizedContext) ?? false) || (metaContext?.includes(normalizedContext) ?? false);
+    };
+    if (normalizedContext) {
+      for (const action of routeActions.values()) {
+        if (action.label.toLowerCase() === normalizedLabel && matchesContext(action)) {
+          return action;
+        }
+      }
+      for (const action of routeActions.values()) {
+        if (action.label.toLowerCase().includes(normalizedLabel) && matchesContext(action)) {
+          return action;
+        }
+      }
+    }
+    for (const action of routeActions.values()) {
+      if (action.label.toLowerCase() === normalizedLabel) {
+        return action;
+      }
+    }
+    for (const action of routeActions.values()) {
+      if (action.label.toLowerCase().includes(normalizedLabel)) {
+        return action;
+      }
+    }
+    return null;
+  }
+  /**
+   * Clear actions for a route
+   */
+  clearRoute(route) {
+    this.actionsByRoute.delete(route);
+  }
+  /**
+   * Clear all actions
+   */
+  clearAll() {
+    this.actionsByRoute.clear();
+  }
+  // ============================================================================
+  // Server Actions
+  // ============================================================================
+  /**
+   * Register a server action
+   */
+  registerServerAction(action) {
+    this.serverActions.set(action.id, action);
+    this.log(`Registered server action: ${action.id}`);
+  }
+  /**
+   * Get all server actions
+   */
+  getServerActions() {
+    return Array.from(this.serverActions.values());
+  }
+  /**
+   * Find server action by ID
+   */
+  findServerActionById(id) {
+    return this.serverActions.get(id) ?? null;
+  }
+  /**
+   * Find server action by name (fuzzy match)
+   */
+  findServerActionByName(name) {
+    const normalizedName = name.toLowerCase().trim();
+    for (const action of this.serverActions.values()) {
+      if (action.name.toLowerCase() === normalizedName) {
+        return action;
+      }
+    }
+    for (const action of this.serverActions.values()) {
+      if (action.name.toLowerCase().includes(normalizedName)) {
+        return action;
+      }
+    }
+    return null;
+  }
+  /**
+   * Remove a server action
+   */
+  removeServerAction(id) {
+    this.serverActions.delete(id);
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  /**
+   * Get statistics
+   */
+  getStats() {
+    let totalActions = 0;
+    for (const routeActions of this.actionsByRoute.values()) {
+      totalActions += routeActions.size;
+    }
+    return {
+      routes: this.actionsByRoute.size,
+      actions: totalActions,
+      serverActions: this.serverActions.size
+    };
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+function normalizeWhitespace(s) {
+  return s.replace(/\s+/g, " ").trim();
+}
+function extractHeadings() {
+  if (typeof document === "undefined") return [];
+  const chatbotKeywords = ["chatbot", "ai assistant", "ask mode", "navigate mode", "navsi", "intelligent agent"];
+  const headings = [];
+  const elements = document.querySelectorAll("h1, h2, h3, h4, h5, h6");
+  for (const element of elements) {
+    if (element.closest(".chatbot-widget") || element.closest(".navsi-chatbot-container")) continue;
+    const text = element.textContent?.trim();
+    if (text && text.length < 200) {
+      const lower = text.toLowerCase();
+      const isChatbotRelated = chatbotKeywords.some((keyword) => lower.includes(keyword));
+      if (!isChatbotRelated) {
+        headings.push(text);
+      }
+    }
+  }
+  return headings.slice(0, 20);
+}
+function extractMainContent(maxLength) {
+  if (typeof document === "undefined") return "";
+  const mainContent = document.querySelector("main") ?? document.querySelector('[role="main"]') ?? document.querySelector("article") ?? document.querySelector(".content") ?? document.body;
+  const walker = document.createTreeWalker(
+    mainContent,
+    NodeFilter.SHOW_TEXT,
+    {
+      acceptNode: (node2) => {
+        const parent = node2.parentElement;
+        if (!parent) return NodeFilter.FILTER_REJECT;
+        const tagName = parent.tagName.toLowerCase();
+        if (["script", "style", "noscript"].includes(tagName)) {
+          return NodeFilter.FILTER_REJECT;
+        }
+        if (parent.closest(".chatbot-widget") || parent.closest(".navsi-chatbot-container")) {
+          return NodeFilter.FILTER_REJECT;
+        }
+        return NodeFilter.FILTER_ACCEPT;
+      }
+    }
+  );
+  let content = "";
+  let node;
+  while ((node = walker.nextNode()) && content.length < maxLength) {
+    const text = node.textContent?.trim();
+    if (text && text.length > 0) {
+      content += text + " ";
+    }
+  }
+  return normalizeWhitespace(content).slice(0, maxLength);
+}
+function extractForms() {
+  if (typeof document === "undefined") return [];
+  const forms = [];
+  const formElements = document.querySelectorAll("form");
+  for (const form of formElements) {
+    if (form.closest(".chatbot-widget") || form.closest(".navsi-chatbot-container")) continue;
+    const fields = [];
+    const inputs = form.querySelectorAll("input, select, textarea");
+    for (const input of inputs) {
+      const element = input;
+      if (element.type === "hidden") continue;
+      let label;
+      if (element.id) {
+        const labelElement = document.querySelector(`label[for="${element.id}"]`);
+        label = labelElement?.textContent?.trim();
+      }
+      if (!label && element.getAttribute("aria-label")) {
+        label = element.getAttribute("aria-label") ?? void 0;
+      }
+      fields.push({
+        name: element.name || element.id || "",
+        type: element.type || element.tagName.toLowerCase(),
+        label,
+        placeholder: "placeholder" in element ? element.placeholder : void 0,
+        required: element.required,
+        value: element.value || void 0
+      });
+    }
+    if (fields.length > 0) {
+      forms.push({
+        id: form.id || `form_${forms.length}`,
+        name: form.name || void 0,
+        action: form.action || void 0,
+        method: form.method || void 0,
+        fields
+      });
+    }
+  }
+  return forms.slice(0, 10);
+}
+function getMetaDescription() {
+  if (typeof document === "undefined") return void 0;
+  const meta = document.querySelector('meta[name="description"]');
+  return meta?.getAttribute("content") ?? void 0;
+}
+var PageContextBuilder = class {
+  config;
+  logger = createLogger("SDK.Context");
+  constructor(config = {}) {
+    this.config = {
+      maxContentLength: config.maxContentLength ?? 2e3,
+      maxActions: config.maxActions ?? 50,
+      debug: config.debug ?? false
+    };
+    this.logger = createLogger("SDK.Context", { enabled: this.config.debug, level: "debug" });
+  }
+  /**
+   * Build page context
+   */
+  build(actions, serverActions, route) {
+    const currentRoute = route ?? (typeof window !== "undefined" ? window.location.pathname : "/");
+    const title = typeof document !== "undefined" ? document.title : "";
+    const content = {
+      headings: extractHeadings(),
+      mainContent: extractMainContent(this.config.maxContentLength),
+      forms: extractForms(),
+      metaDescription: getMetaDescription()
+    };
+    const limitedActions = actions.slice(0, this.config.maxActions);
+    const context = {
+      route: currentRoute,
+      title,
+      actions: limitedActions,
+      serverActions,
+      content,
+      timestamp: Date.now()
+    };
+    this.log("Built page context:", {
+      route: context.route,
+      title: context.title,
+      actions: context.actions.length,
+      serverActions: context.serverActions.length,
+      headings: context.content.headings.length,
+      forms: context.content.forms.length
+    });
+    return context;
+  }
+  /**
+   * Build minimal context (for rapid updates)
+   */
+  buildMinimal(actions, serverActions, route) {
+    const currentRoute = route ?? (typeof window !== "undefined" ? window.location.pathname : "/");
+    return {
+      route: currentRoute,
+      title: typeof document !== "undefined" ? document.title : "",
+      actions: actions.slice(0, this.config.maxActions),
+      serverActions,
+      content: {
+        headings: [],
+        mainContent: "",
+        forms: []
+      },
+      timestamp: Date.now()
+    };
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+function querySelectorDeep(selector, options) {
+  const preferVisible = options?.preferVisible ?? false;
+  const roots = [document];
+  let firstMatch = null;
+  while (roots.length > 0) {
+    const root = roots.shift();
+    const match = root.querySelector(selector);
+    if (match) {
+      if (!preferVisible) return match;
+      if (isElementVisible(match)) return match;
+      if (!firstMatch) firstMatch = match;
+    }
+    const hostRoot = root instanceof Document ? root.body ?? root.documentElement : root;
+    if (!hostRoot) continue;
+    const hosts = hostRoot.querySelectorAll("*");
+    for (const host of hosts) {
+      const shadowRoot = host.shadowRoot;
+      if (shadowRoot) {
+        roots.push(shadowRoot);
+      }
+    }
+  }
+  return preferVisible ? firstMatch : null;
+}
+async function waitForElement(selector, timeout, requireVisible = true) {
+  const startTime = Date.now();
+  const isReady = (element) => {
+    if (!element) return false;
+    return !requireVisible || isElementVisible(element);
+  };
+  return new Promise((resolve) => {
+    const element = querySelectorDeep(selector, { preferVisible: requireVisible });
+    if (isReady(element)) {
+      resolve(element);
+      return;
+    }
+    const observer = new MutationObserver(() => {
+      const el = querySelectorDeep(selector, { preferVisible: requireVisible });
+      if (isReady(el)) {
+        observer.disconnect();
+        resolve(el);
+      }
+    });
+    observer.observe(document.body, {
+      childList: true,
+      subtree: true,
+      attributes: true
+    });
+    const checkInterval = setInterval(() => {
+      const el = querySelectorDeep(selector, { preferVisible: requireVisible });
+      if (isReady(el)) {
+        clearInterval(checkInterval);
+        observer.disconnect();
+        resolve(el);
+      }
+      if (Date.now() - startTime >= timeout) {
+        clearInterval(checkInterval);
+        observer.disconnect();
+        resolve(null);
+      }
+    }, 100);
+    setTimeout(() => {
+      clearInterval(checkInterval);
+      observer.disconnect();
+      const el = querySelectorDeep(selector, { preferVisible: requireVisible });
+      resolve(isReady(el) ? el : null);
+    }, timeout);
+  });
+}
+function isElementVisible(element) {
+  const style = window.getComputedStyle(element);
+  if (style.display === "none") return false;
+  if (style.visibility === "hidden") return false;
+  if (style.opacity === "0") return false;
+  const rect = element.getBoundingClientRect();
+  if (rect.width === 0 && rect.height === 0) return false;
+  const viewportWidth = window.innerWidth || document.documentElement.clientWidth;
+  const viewportHeight = window.innerHeight || document.documentElement.clientHeight;
+  const horizontallyVisible = rect.right > 0 && rect.left < viewportWidth;
+  const verticallyVisible = rect.bottom > 0 && rect.top < viewportHeight;
+  return horizontallyVisible && verticallyVisible;
+}
+function getElementCenter(element) {
+  const rect = element.getBoundingClientRect();
+  return {
+    x: rect.left + rect.width / 2,
+    y: rect.top + rect.height / 2
+  };
+}
+function setNativeInputValue(element, value) {
+  const prototype = element instanceof HTMLInputElement ? HTMLInputElement.prototype : HTMLTextAreaElement.prototype;
+  const setter = Object.getOwnPropertyDescriptor(prototype, "value")?.set;
+  if (setter) {
+    setter.call(element, value);
+  } else {
+    element.value = value;
+  }
+}
+function scrollToElement(element) {
+  element.scrollIntoView({
+    behavior: "smooth",
+    block: "center",
+    inline: "center"
+  });
+}
+function highlightElement(element, duration = 500) {
+  const htmlElement = element;
+  const originalOutline = htmlElement.style.outline;
+  const originalTransition = htmlElement.style.transition;
+  htmlElement.style.transition = "outline 0.2s ease";
+  htmlElement.style.outline = "3px solid #6366f1";
+  setTimeout(() => {
+    htmlElement.style.outline = originalOutline;
+    htmlElement.style.transition = originalTransition;
+  }, duration);
+}
+async function simulateTyping(element, text, delay) {
+  element.focus();
+  setNativeInputValue(element, "");
+  element.dispatchEvent(new Event("input", { bubbles: true }));
+  for (const char of text) {
+    try {
+      if (typeof InputEvent !== "undefined") {
+        element.dispatchEvent(
+          new InputEvent("beforeinput", {
+            bubbles: true,
+            cancelable: true,
+            data: char,
+            inputType: "insertText"
+          })
+        );
+      }
+    } catch {
+    }
+    const nextValue = (element.value ?? "") + char;
+    setNativeInputValue(element, nextValue);
+    element.dispatchEvent(new Event("input", { bubbles: true }));
+    element.dispatchEvent(new KeyboardEvent("keydown", { key: char, bubbles: true }));
+    element.dispatchEvent(new KeyboardEvent("keypress", { key: char, bubbles: true }));
+    element.dispatchEvent(new KeyboardEvent("keyup", { key: char, bubbles: true }));
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+async function simulateContentEditableTyping(element, text, delay) {
+  element.focus();
+  element.textContent = "";
+  element.dispatchEvent(new Event("input", { bubbles: true }));
+  for (const char of text) {
+    try {
+      if (typeof InputEvent !== "undefined") {
+        element.dispatchEvent(
+          new InputEvent("beforeinput", {
+            bubbles: true,
+            cancelable: true,
+            data: char,
+            inputType: "insertText"
+          })
+        );
+      }
+    } catch {
+    }
+    element.textContent = (element.textContent ?? "") + char;
+    element.dispatchEvent(new Event("input", { bubbles: true }));
+    element.dispatchEvent(new KeyboardEvent("keydown", { key: char, bubbles: true }));
+    element.dispatchEvent(new KeyboardEvent("keypress", { key: char, bubbles: true }));
+    element.dispatchEvent(new KeyboardEvent("keyup", { key: char, bubbles: true }));
+    if (delay > 0) {
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  element.dispatchEvent(new Event("change", { bubbles: true }));
+}
+function collectElementMetadata(element) {
+  const rect = element.getBoundingClientRect();
+  const tagName = element.tagName.toLowerCase();
+  const attrs = {};
+  if (element instanceof HTMLElement) {
+    for (const attr of Array.from(element.attributes)) {
+      if (attr.name.startsWith("data-") || attr.name === "aria-label" || attr.name === "name" || attr.name === "id") {
+        attrs[attr.name] = attr.value;
+      }
+    }
+  }
+  return {
+    tagName,
+    text: (element.textContent ?? "").trim().slice(0, 80),
+    rect: {
+      x: rect.x,
+      y: rect.y,
+      width: rect.width,
+      height: rect.height
+    },
+    attributes: attrs
+  };
+}
+var DOMExecutor = class _DOMExecutor {
+  config;
+  logger = createLogger("SDK.Executor");
+  constructor(config = {}) {
+    this.config = {
+      elementTimeout: config.elementTimeout ?? 6e3,
+      typeDelay: config.typeDelay ?? 30,
+      scrollIntoView: config.scrollIntoView ?? true,
+      highlightOnInteract: config.highlightOnInteract ?? true,
+      debug: config.debug ?? false
+    };
+    this.logger = createLogger("SDK.Executor", { enabled: this.config.debug, level: "debug" });
+  }
+  /** Delay before retry on failure (ms) */
+  static RETRY_DELAY_MS = 600;
+  /** Maximum number of retry attempts */
+  static MAX_RETRIES = 2;
+  /**
+   * Click an element (synthetic events + native click fallback; one retry on failure)
+   * Prevents default behavior on links to avoid page reloads
+   */
+  async click(selector) {
+    const startTime = Date.now();
+    const attempt = async () => {
+      const element = await waitForElement(selector, this.config.elementTimeout, true);
+      if (!element) {
+        return this.createResult(
+          selector,
+          "click",
+          startTime,
+          false,
+          "Element not found",
+          "ELEMENT_NOT_FOUND"
+        );
+      }
+      if (this.config.scrollIntoView) {
+        scrollToElement(element);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      if (this.config.highlightOnInteract) {
+        highlightElement(element);
+      }
+      if (!isElementVisible(element)) {
+        return this.createResult(
+          selector,
+          "click",
+          startTime,
+          false,
+          "Element is not visible",
+          "NOT_VISIBLE",
+          collectElementMetadata(element)
+        );
+      }
+      const htmlElement = element;
+      const isDisabled = htmlElement.disabled === true || htmlElement.getAttribute("aria-disabled") === "true";
+      if (isDisabled) {
+        return this.createResult(
+          selector,
+          "click",
+          startTime,
+          false,
+          "Element is disabled",
+          "DISABLED",
+          collectElementMetadata(element)
+        );
+      }
+      htmlElement.focus();
+      const { x, y } = getElementCenter(element);
+      try {
+        if (typeof PointerEvent !== "undefined") {
+          element.dispatchEvent(
+            new PointerEvent("pointerover", { bubbles: true, cancelable: true, clientX: x, clientY: y })
+          );
+          element.dispatchEvent(
+            new PointerEvent("pointerenter", { bubbles: true, cancelable: true, clientX: x, clientY: y })
+          );
+          element.dispatchEvent(
+            new PointerEvent("pointermove", { bubbles: true, cancelable: true, clientX: x, clientY: y })
+          );
+        }
+      } catch {
+      }
+      element.dispatchEvent(new MouseEvent("mouseover", { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+      element.dispatchEvent(new MouseEvent("mouseenter", { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+      element.dispatchEvent(new MouseEvent("mousemove", { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+      try {
+        if (typeof PointerEvent !== "undefined") {
+          element.dispatchEvent(
+            new PointerEvent("pointerdown", {
+              bubbles: true,
+              cancelable: true,
+              button: 0,
+              clientX: x,
+              clientY: y
+            })
+          );
+          element.dispatchEvent(
+            new PointerEvent("pointerup", {
+              bubbles: true,
+              cancelable: true,
+              button: 0,
+              clientX: x,
+              clientY: y
+            })
+          );
+        }
+      } catch {
+      }
+      element.dispatchEvent(new MouseEvent("mousedown", { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+      element.dispatchEvent(new MouseEvent("mouseup", { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+      element.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, clientX: x, clientY: y }));
+      htmlElement.click();
+      this.log("Clicked:", selector);
+      return this.createResult(
+        selector,
+        "click",
+        startTime,
+        true,
+        void 0,
+        void 0,
+        collectElementMetadata(element)
+      );
+    };
+    const executeWithRetries = async () => {
+      let lastResult = null;
+      for (let retry = 0; retry <= _DOMExecutor.MAX_RETRIES; retry++) {
+        if (retry > 0) {
+          this.log(`Click retry ${retry}/${_DOMExecutor.MAX_RETRIES} for:`, selector);
+          await new Promise((r) => setTimeout(r, _DOMExecutor.RETRY_DELAY_MS * retry));
+        }
+        try {
+          lastResult = await attempt();
+          if (lastResult.success) {
+            return lastResult;
+          }
+        } catch (error) {
+          lastResult = this.createResult(
+            selector,
+            "click",
+            startTime,
+            false,
+            String(error),
+            "RUNTIME_ERROR"
+          );
+        }
+      }
+      return lastResult;
+    };
+    return executeWithRetries();
+  }
+  /**
+   * Type text into an element (one retry on failure)
+   */
+  async type(selector, text, clearFirst = true) {
+    const startTime = Date.now();
+    const attempt = async () => {
+      const element = await waitForElement(selector, this.config.elementTimeout, true);
+      if (!element) {
+        return this.createResult(
+          selector,
+          "type",
+          startTime,
+          false,
+          "Element not found",
+          "ELEMENT_NOT_FOUND"
+        );
+      }
+      if (!this.isTypeable(element)) {
+        return this.createResult(
+          selector,
+          "type",
+          startTime,
+          false,
+          "Element is not typeable",
+          "TYPE_MISMATCH",
+          collectElementMetadata(element)
+        );
+      }
+      if (this.config.scrollIntoView) {
+        scrollToElement(element);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      if (this.config.highlightOnInteract) {
+        highlightElement(element);
+      }
+      const metadata = collectElementMetadata(element);
+      if (!isElementVisible(element)) {
+        return this.createResult(
+          selector,
+          "type",
+          startTime,
+          false,
+          "Element is not visible",
+          "NOT_VISIBLE",
+          metadata
+        );
+      }
+      if (element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement) {
+        const inputElement = element;
+        if (inputElement.disabled || inputElement.getAttribute("aria-disabled") === "true") {
+          return this.createResult(
+            selector,
+            "type",
+            startTime,
+            false,
+            "Element is disabled",
+            "DISABLED",
+            metadata
+          );
+        }
+        if (clearFirst) {
+          await simulateTyping(inputElement, text, this.config.typeDelay);
+        } else {
+          inputElement.focus();
+          setNativeInputValue(inputElement, (inputElement.value ?? "") + text);
+          inputElement.dispatchEvent(new Event("input", { bubbles: true }));
+          inputElement.dispatchEvent(new Event("change", { bubbles: true }));
+        }
+      } else if (element instanceof HTMLElement && element.isContentEditable) {
+        if (element.getAttribute("aria-disabled") === "true") {
+          return this.createResult(
+            selector,
+            "type",
+            startTime,
+            false,
+            "Element is disabled",
+            "DISABLED",
+            metadata
+          );
+        }
+        await simulateContentEditableTyping(element, text, this.config.typeDelay);
+      } else {
+        return this.createResult(
+          selector,
+          "type",
+          startTime,
+          false,
+          "Element is not a supported type target",
+          "TYPE_MISMATCH",
+          metadata
+        );
+      }
+      this.log("Typed into:", selector, "text:", text.slice(0, 20) + (text.length > 20 ? "..." : ""));
+      return this.createResult(
+        selector,
+        "type",
+        startTime,
+        true,
+        void 0,
+        void 0,
+        {
+          ...metadata,
+          textLength: text.length
+        }
+      );
+    };
+    const executeWithRetries = async () => {
+      let lastResult = null;
+      for (let retry = 0; retry <= _DOMExecutor.MAX_RETRIES; retry++) {
+        if (retry > 0) {
+          this.log(`Type retry ${retry}/${_DOMExecutor.MAX_RETRIES} for:`, selector);
+          await new Promise((r) => setTimeout(r, _DOMExecutor.RETRY_DELAY_MS * retry));
+        }
+        try {
+          lastResult = await attempt();
+          if (lastResult.success) {
+            return lastResult;
+          }
+        } catch (error) {
+          lastResult = this.createResult(
+            selector,
+            "type",
+            startTime,
+            false,
+            String(error),
+            "RUNTIME_ERROR"
+          );
+        }
+      }
+      return lastResult;
+    };
+    return executeWithRetries();
+  }
+  /**
+   * Select an option from a dropdown (one retry on failure)
+   */
+  async select(selector, value) {
+    const startTime = Date.now();
+    const attempt = async () => {
+      const element = await waitForElement(selector, this.config.elementTimeout, true);
+      if (!element) {
+        return this.createResult(
+          selector,
+          "select",
+          startTime,
+          false,
+          "Element not found",
+          "ELEMENT_NOT_FOUND"
+        );
+      }
+      if (element.tagName.toLowerCase() !== "select") {
+        return this.createResult(
+          selector,
+          "select",
+          startTime,
+          false,
+          "Element is not a select",
+          "TYPE_MISMATCH",
+          collectElementMetadata(element)
+        );
+      }
+      if (this.config.scrollIntoView) {
+        scrollToElement(element);
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      if (this.config.highlightOnInteract) {
+        highlightElement(element);
+      }
+      if (!isElementVisible(element)) {
+        return this.createResult(
+          selector,
+          "select",
+          startTime,
+          false,
+          "Element is not visible",
+          "NOT_VISIBLE",
+          collectElementMetadata(element)
+        );
+      }
+      const selectElement = element;
+      if (selectElement.disabled || selectElement.getAttribute("aria-disabled") === "true") {
+        return this.createResult(
+          selector,
+          "select",
+          startTime,
+          false,
+          "Element is disabled",
+          "DISABLED",
+          collectElementMetadata(element)
+        );
+      }
+      let found = false;
+      for (const option of selectElement.options) {
+        if (option.value === value || option.textContent?.toLowerCase().includes(value.toLowerCase())) {
+          selectElement.value = option.value;
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return this.createResult(
+          selector,
+          "select",
+          startTime,
+          false,
+          `Option not found: ${value}`,
+          "OPTION_NOT_FOUND",
+          {
+            ...collectElementMetadata(element),
+            attemptedValue: value
+          }
+        );
+      }
+      selectElement.dispatchEvent(new Event("input", { bubbles: true }));
+      selectElement.dispatchEvent(new Event("change", { bubbles: true }));
+      this.log("Selected:", selector, "value:", value);
+      return this.createResult(
+        selector,
+        "select",
+        startTime,
+        true,
+        void 0,
+        void 0,
+        {
+          ...collectElementMetadata(element),
+          selectedValue: value
+        }
+      );
+    };
+    const executeWithRetries = async () => {
+      let lastResult = null;
+      for (let retry = 0; retry <= _DOMExecutor.MAX_RETRIES; retry++) {
+        if (retry > 0) {
+          this.log(`Select retry ${retry}/${_DOMExecutor.MAX_RETRIES} for:`, selector);
+          await new Promise((r) => setTimeout(r, _DOMExecutor.RETRY_DELAY_MS * retry));
+        }
+        try {
+          lastResult = await attempt();
+          if (lastResult.success) {
+            return lastResult;
+          }
+        } catch (error) {
+          lastResult = this.createResult(
+            selector,
+            "select",
+            startTime,
+            false,
+            String(error),
+            "RUNTIME_ERROR"
+          );
+        }
+      }
+      return lastResult;
+    };
+    return executeWithRetries();
+  }
+  /**
+   * Scroll to an element or position
+   */
+  async scroll(target) {
+    const startTime = Date.now();
+    const selectorStr = typeof target === "string" ? target : `${target.x},${target.y}`;
+    try {
+      if (typeof target === "string") {
+        const element = await waitForElement(target, this.config.elementTimeout, false);
+        if (!element) {
+          return this.createResult(
+            selectorStr,
+            "scroll",
+            startTime,
+            false,
+            "Element not found",
+            "ELEMENT_NOT_FOUND"
+          );
+        }
+        if (this.config.highlightOnInteract) {
+          highlightElement(element);
+        }
+        scrollToElement(element);
+      } else {
+        window.scrollTo({
+          left: target.x,
+          top: target.y,
+          behavior: "smooth"
+        });
+      }
+      this.log("Scrolled to:", target);
+      return this.createResult(
+        selectorStr,
+        "scroll",
+        startTime,
+        true,
+        void 0,
+        void 0,
+        typeof target === "string" ? (() => {
+          const element = querySelectorDeep(target);
+          return element ? collectElementMetadata(element) : { selector: target };
+        })() : { position: target }
+      );
+    } catch (error) {
+      return this.createResult(
+        selectorStr,
+        "scroll",
+        startTime,
+        false,
+        String(error),
+        "RUNTIME_ERROR"
+      );
+    }
+  }
+  /**
+   * Submit a form
+   */
+  async submit(selector) {
+    const startTime = Date.now();
+    try {
+      const element = await waitForElement(selector, this.config.elementTimeout, true);
+      if (!element) {
+        return this.createResult(
+          selector,
+          "submit",
+          startTime,
+          false,
+          "Element not found",
+          "ELEMENT_NOT_FOUND"
+        );
+      }
+      const form = element.tagName.toLowerCase() === "form" ? element : element.closest("form");
+      if (!form) {
+        const submitButton = element.querySelector('button[type="submit"], input[type="submit"]');
+        if (submitButton) {
+          return this.click(this.generateSelector(submitButton));
+        }
+        return this.createResult(
+          selector,
+          "submit",
+          startTime,
+          false,
+          "No form found",
+          "NO_FORM",
+          collectElementMetadata(element)
+        );
+      }
+      if (this.config.highlightOnInteract) {
+        highlightElement(form);
+      }
+      const submitter = form.querySelector('button[type="submit"], input[type="submit"]');
+      if (typeof form.requestSubmit === "function") {
+        form.requestSubmit(submitter ?? void 0);
+      } else {
+        const submitEvent = new Event("submit", { bubbles: true, cancelable: true });
+        const shouldSubmit = form.dispatchEvent(submitEvent);
+        if (shouldSubmit) {
+          form.submit();
+        }
+      }
+      this.log("Submitted form:", selector);
+      return this.createResult(
+        selector,
+        "submit",
+        startTime,
+        true,
+        void 0,
+        void 0,
+        collectElementMetadata(form)
+      );
+    } catch (error) {
+      return this.createResult(
+        selector,
+        "submit",
+        startTime,
+        false,
+        String(error),
+        "RUNTIME_ERROR"
+      );
+    }
+  }
+  /**
+   * Check if element is typeable
+   */
+  isTypeable(element) {
+    const tagName = element.tagName.toLowerCase();
+    if (tagName === "input") {
+      const type = element.type;
+      return ["text", "email", "password", "search", "tel", "url", "number"].includes(type);
+    }
+    if (tagName === "textarea") return true;
+    if (element.hasAttribute("contenteditable")) return true;
+    return false;
+  }
+  /**
+   * Generate a selector for an element
+   */
+  generateSelector(element) {
+    if (element.id) return `#${element.id}`;
+    const dataTestId = element.getAttribute("data-testid");
+    if (dataTestId) return `[data-testid="${dataTestId}"]`;
+    return element.tagName.toLowerCase();
+  }
+  /**
+   * Create execution result
+   */
+  createResult(selector, action, startTime, success, error, errorCode, metadata) {
+    if (!success) {
+      this.logger.warn("Action failed", {
+        action,
+        selector,
+        error,
+        errorCode,
+        metadata
+      });
+    }
+    return {
+      success,
+      selector,
+      action,
+      duration: Date.now() - startTime,
+      errorCode,
+      error,
+      metadata
+    };
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+var CommandProcessor = class {
+  config;
+  executor;
+  navController;
+  registry;
+  logger = createLogger("SDK.Processor");
+  isExecuting = false;
+  shouldAbort = false;
+  listeners = /* @__PURE__ */ new Map();
+  // Server action handler
+  serverActionHandler = null;
+  constructor(executor, navController, registry, config = {}) {
+    this.executor = executor;
+    this.navController = navController;
+    this.registry = registry;
+    this.config = {
+      commandDelay: config.commandDelay ?? 650,
+      commandTimeout: config.commandTimeout ?? 3e4,
+      debug: config.debug ?? false
+    };
+    this.logger = createLogger("SDK.Processor", { enabled: this.config.debug, level: "debug" });
+  }
+  /**
+   * Set server action handler
+   */
+  setServerActionHandler(handler) {
+    this.serverActionHandler = handler;
+  }
+  /**
+   * Execute a list of commands
+   */
+  async execute(commands) {
+    if (this.isExecuting) {
+      throw new Error("Already executing commands");
+    }
+    this.isExecuting = true;
+    this.shouldAbort = false;
+    const results = [];
+    let previousCommandType = null;
+    try {
+      for (let i = 0; i < commands.length; i++) {
+        if (this.shouldAbort) {
+          this.log("Execution aborted");
+          break;
+        }
+        const command = commands[i];
+        const needsStability = ["click", "type", "select", "scroll"].includes(command.type);
+        const previousWasNavigation = previousCommandType && ["navigate", "wait_for_route"].includes(previousCommandType);
+        if (needsStability && previousWasNavigation) {
+          this.log("Auto-waiting for DOM stability before:", command.type);
+          await this.navController.waitForDOMStable();
+          await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        this.emit("stateChange", {
+          isExecuting: true,
+          currentCommand: command,
+          currentIndex: i,
+          totalCommands: commands.length,
+          description: this.describeCommand(command)
+        });
+        this.emit("commandStart", command, i);
+        const result = await this.executeCommand(command);
+        results.push(result);
+        this.emit("commandComplete", result);
+        previousCommandType = command.type;
+        if (!result.success) {
+          this.logger.warn("Command failed, stopping execution", {
+            type: command.type,
+            error: result.error,
+            result: result.result
+          });
+          break;
+        }
+        if (i < commands.length - 1) {
+          await new Promise((resolve) => setTimeout(resolve, this.config.commandDelay));
+        }
+      }
+      this.emit("complete", results);
+      return results;
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.logger.error("Execution error", err);
+      this.emit("error", err);
+      throw err;
+    } finally {
+      this.isExecuting = false;
+      this.emit("stateChange", {
+        isExecuting: false,
+        currentCommand: void 0,
+        currentIndex: 0,
+        totalCommands: commands.length,
+        description: void 0
+      });
+    }
+  }
+  /**
+   * Abort current execution
+   */
+  abort() {
+    this.shouldAbort = true;
+  }
+  /**
+   * Get execution status
+   */
+  getIsExecuting() {
+    return this.isExecuting;
+  }
+  /**
+   * Execute a single command
+   */
+  async executeCommand(command) {
+    const startTime = Date.now();
+    try {
+      switch (command.type) {
+        case "navigate":
+          return await this.executeNavigate(command, startTime);
+        case "wait_for_route":
+          return await this.executeWaitForRoute(command, startTime);
+        case "wait_for_dom_stable":
+          return await this.executeWaitForDomStable(command, startTime);
+        case "scan_context":
+          return await this.executeScanContext(command, startTime);
+        case "click":
+          return await this.executeClick(command, startTime);
+        case "type":
+          return await this.executeType(command, startTime);
+        case "select":
+          return await this.executeSelect(command, startTime);
+        case "scroll":
+          return await this.executeScroll(command, startTime);
+        case "server_action":
+          return await this.executeServerAction(command, startTime);
+        case "report_result":
+          return await this.executeReportResult(command, startTime);
+        default:
+          return this.createResult(command, startTime, false, `Unknown command type`);
+      }
+    } catch (error) {
+      this.logger.error("Command execution error", {
+        type: command.type,
+        error: String(error)
+      });
+      return this.createResult(command, startTime, false, String(error));
+    }
+  }
+  // ============================================================================
+  // Command Executors
+  // ============================================================================
+  async executeNavigate(command, startTime) {
+    this.log("Navigating to:", command.target);
+    const context = await this.navController.executeNavigation(command.target);
+    if (!context) {
+      return this.createResult(command, startTime, false, "Navigation failed");
+    }
+    return this.createResult(command, startTime, true);
+  }
+  async executeWaitForRoute(command, startTime) {
+    this.log("Waiting for route:", command.target);
+    const success = await this.navController.navigateTo(command.target, command.timeout);
+    return this.createResult(command, startTime, success, success ? void 0 : "Route timeout");
+  }
+  async executeWaitForDomStable(command, startTime) {
+    this.log("Waiting for DOM to stabilize");
+    await this.navController.waitForDOMStable();
+    return this.createResult(command, startTime, true);
+  }
+  async executeScanContext(command, startTime) {
+    this.log("Scanning page context");
+    return this.createResult(command, startTime, true);
+  }
+  async executeClick(command, startTime) {
+    let selector = command.selector;
+    const route = this.navController.getCurrentRoute();
+    if (selector) {
+      this.log("Clicking with selector:", selector);
+      const result = await this.executor.click(selector);
+      if (result.success) {
+        return this.createResult(command, startTime, true);
+      }
+      this.log("Selector failed, trying text fallback:", command.text || selector);
+    }
+    if (command.text) {
+      const action = this.registry.findActionByLabel(route, command.text, command.context);
+      if (action && action.selector !== selector) {
+        this.log("Found action by label, clicking:", action.selector);
+        const result = await this.executor.click(action.selector);
+        if (result.success) {
+          return this.createResult(command, startTime, true);
+        }
+      }
+    }
+    if (command.text) {
+      const actionAttr = command.text.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+      const chatbotSelector = `[data-chatbot-action*="${actionAttr}"]`;
+      this.log("Trying data-chatbot-action selector:", chatbotSelector);
+      const result = await this.executor.click(chatbotSelector);
+      if (result.success) {
+        return this.createResult(command, startTime, true);
+      }
+    }
+    if (command.text) {
+      const ariaSelector = `[aria-label="${command.text}"]`;
+      this.log("Trying aria-label selector:", ariaSelector);
+      const result = await this.executor.click(ariaSelector);
+      if (result.success) {
+        return this.createResult(command, startTime, true);
+      }
+    }
+    if (command.text) {
+      const textToFind = command.text.toLowerCase().trim();
+      const clickables = document.querySelectorAll('button, a, [role="button"], [data-chatbot-action]');
+      for (const el of clickables) {
+        const elText = el.textContent?.toLowerCase().trim() || "";
+        const ariaLabel = el.getAttribute("aria-label")?.toLowerCase().trim() || "";
+        const chatbotAction = el.getAttribute("data-chatbot-action")?.toLowerCase().replace(/-/g, " ") || "";
+        if (elText === textToFind || ariaLabel === textToFind || elText.includes(textToFind) || chatbotAction === textToFind || chatbotAction.includes(textToFind.replace(/\s+/g, "-"))) {
+          let foundSelector = "";
+          if (el.id) {
+            foundSelector = `#${el.id}`;
+          } else if (el.getAttribute("data-chatbot-action")) {
+            foundSelector = `[data-chatbot-action="${el.getAttribute("data-chatbot-action")}"]`;
+          } else if (el.getAttribute("aria-label")) {
+            foundSelector = `[aria-label="${el.getAttribute("aria-label")}"]`;
+          }
+          if (foundSelector) {
+            this.log("Found element by text content, clicking:", foundSelector);
+            const result = await this.executor.click(foundSelector);
+            if (result.success) {
+              return this.createResult(command, startTime, true);
+            }
+          }
+        }
+      }
+    }
+    const errorMsg = selector ? `Element not found or click failed: ${selector}` : `No selector found for: ${command.text || "unknown"}`;
+    return this.createResult(command, startTime, false, errorMsg);
+  }
+  async executeType(command, startTime) {
+    let selector = command.selector;
+    if (!selector && command.text) {
+      const action = this.registry.findActionByLabel(
+        this.navController.getCurrentRoute(),
+        command.text
+      );
+      if (action) selector = action.selector;
+    }
+    if (!selector) {
+      return this.createResult(command, startTime, false, "No selector provided");
+    }
+    this.log("Typing into:", selector, "value:", command.value);
+    let result = await this.executor.type(selector, command.value, command.clear ?? true);
+    if (!result.success && command.text && result.error?.includes("not found")) {
+      const action = this.registry.findActionByLabel(
+        this.navController.getCurrentRoute(),
+        command.text
+      );
+      if (action) {
+        result = await this.executor.type(action.selector, command.value, command.clear ?? true);
+      }
+    }
+    return this.createResult(command, startTime, result.success, result.error);
+  }
+  async executeSelect(command, startTime) {
+    let selector = command.selector;
+    if (!selector && command.text) {
+      const action = this.registry.findActionByLabel(
+        this.navController.getCurrentRoute(),
+        command.text
+      );
+      if (action) selector = action.selector;
+    }
+    if (!selector) {
+      return this.createResult(command, startTime, false, "No selector provided");
+    }
+    this.log("Selecting:", selector, "value:", command.value);
+    let result = await this.executor.select(selector, command.value);
+    if (!result.success && command.text && result.error?.includes("not found")) {
+      const action = this.registry.findActionByLabel(
+        this.navController.getCurrentRoute(),
+        command.text
+      );
+      if (action) {
+        result = await this.executor.select(action.selector, command.value);
+      }
+    }
+    return this.createResult(command, startTime, result.success, result.error);
+  }
+  async executeScroll(command, startTime) {
+    const target = command.selector ?? command.position ?? { x: 0, y: 0 };
+    this.log("Scrolling to:", target);
+    const result = await this.executor.scroll(target);
+    return this.createResult(command, startTime, result.success, result.error);
+  }
+  async executeServerAction(command, startTime) {
+    if (!this.serverActionHandler) {
+      return this.createResult(command, startTime, false, "No server action handler set");
+    }
+    const action = this.registry.findServerActionById(command.actionId);
+    if (!action) {
+      return this.createResult(command, startTime, false, `Server action not found: ${command.actionId}`);
+    }
+    this.log("Executing server action:", command.actionId);
+    try {
+      const result = await this.serverActionHandler(command.actionId, command.params);
+      return this.createResult(command, startTime, true, void 0, result);
+    } catch (error) {
+      return this.createResult(command, startTime, false, String(error));
+    }
+  }
+  async executeReportResult(command, startTime) {
+    this.log("Report result command executed");
+    return this.createResult(command, startTime, true);
+  }
+  // ============================================================================
+  // Utilities
+  // ============================================================================
+  createResult(command, startTime, success, error, result) {
+    return {
+      command,
+      success,
+      result,
+      error,
+      duration: Date.now() - startTime
+    };
+  }
+  /**
+   * Build a simple, human-readable description for the current command.
+   * This is used by the widget to surface clear progress messages.
+   */
+  describeCommand(command) {
+    switch (command.type) {
+      case "click":
+        return command.text ? `Click "${command.text}"` : `Click element${command.selector ? ` (${command.selector})` : ""}`;
+      case "type":
+        return command.text ? `Type into "${command.text}"` : `Type into element${command.selector ? ` (${command.selector})` : ""}`;
+      case "select":
+        return command.text ? `Select "${command.value}" in "${command.text}"` : `Select "${command.value}"${command.selector ? ` (${command.selector})` : ""}`;
+      case "scroll":
+        if (command.selector) return `Scroll to element (${command.selector})`;
+        if (command.position) return `Scroll to (${command.position.x}, ${command.position.y})`;
+        return "Scroll";
+      case "navigate":
+        return `Navigate to "${command.target}"`;
+      case "wait_for_route":
+        return `Wait for route "${command.target}"`;
+      case "wait_for_dom_stable":
+        return "Wait for page to finish loading";
+      case "scan_context":
+        return "Scan page for available actions";
+      case "server_action":
+        return `Execute server action "${command.actionId}"`;
+      case "report_result":
+        return "Report result to server";
+      default:
+        return "Execute action";
+    }
+  }
+  /**
+   * Subscribe to events
+   */
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(callback);
+    return () => {
+      this.listeners.get(event)?.delete(callback);
+    };
+  }
+  emit(event, ...args) {
+    this.listeners.get(event)?.forEach((callback) => {
+      try {
+        callback(...args);
+      } catch (error) {
+        this.logger.error(`Error in ${event} listener`, error);
+      }
+    });
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+var ServerActionBridge = class {
+  config;
+  actions = /* @__PURE__ */ new Map();
+  context = null;
+  logger = createLogger("SDK.ServerAction");
+  constructor(config = {}) {
+    this.config = {
+      defaultTimeout: config.defaultTimeout ?? 3e4,
+      debug: config.debug ?? false,
+      webhookHeaders: config.webhookHeaders ?? {},
+      baseUrl: config.baseUrl ?? ""
+    };
+    this.logger = createLogger("SDK.ServerAction", { enabled: this.config.debug, level: "debug" });
+  }
+  /**
+   * Set the execution context
+   */
+  setContext(context) {
+    this.context = context;
+  }
+  /**
+   * Register a server action
+   */
+  register(action) {
+    this.actions.set(action.id, action);
+    this.log(`Registered server action: ${action.id}`);
+  }
+  /**
+   * Register multiple server actions
+   */
+  registerMany(actions) {
+    for (const action of actions) {
+      this.register(action);
+    }
+  }
+  /**
+   * Unregister a server action
+   */
+  unregister(actionId) {
+    this.actions.delete(actionId);
+  }
+  /**
+   * Get all registered actions
+   */
+  getActions() {
+    return Array.from(this.actions.values());
+  }
+  /**
+   * Get action by ID
+   */
+  getAction(actionId) {
+    return this.actions.get(actionId);
+  }
+  /**
+   * Execute a server action
+   */
+  async execute(actionId, params) {
+    const action = this.actions.get(actionId);
+    if (!action) {
+      return {
+        success: false,
+        error: `Server action not found: ${actionId}`
+      };
+    }
+    if (!this.context) {
+      return {
+        success: false,
+        error: "No execution context set"
+      };
+    }
+    const missingParams = action.parameters.filter((p) => p.required && !(p.name in params)).map((p) => p.name);
+    if (missingParams.length > 0) {
+      return {
+        success: false,
+        error: `Missing required parameters: ${missingParams.join(", ")}`
+      };
+    }
+    const finalParams = { ...params };
+    for (const param of action.parameters) {
+      if (!(param.name in finalParams) && param.defaultValue !== void 0) {
+        finalParams[param.name] = param.defaultValue;
+      }
+    }
+    this.log(`Executing server action: ${actionId}`, finalParams);
+    try {
+      if (action.handler) {
+        return await this.executeHandler(action, finalParams);
+      } else if (action.webhookUrl) {
+        return await this.executeWebhook(action, finalParams);
+      } else {
+        return {
+          success: false,
+          error: "Server action has no handler or webhookUrl"
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      this.log(`Server action error: ${errorMessage}`);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * Execute handler mode action
+   */
+  async executeHandler(action, params) {
+    if (!action.handler) {
+      return { success: false, error: "No handler defined" };
+    }
+    const timeout = action.timeout ?? this.config.defaultTimeout;
+    const result = await Promise.race([
+      action.handler(params, this.context),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Timeout")), timeout)
+      )
+    ]);
+    return result;
+  }
+  /**
+   * Execute webhook mode action
+   */
+  async executeWebhook(action, params) {
+    if (!action.webhookUrl) {
+      return { success: false, error: "No webhookUrl defined" };
+    }
+    const timeout = action.timeout ?? this.config.defaultTimeout;
+    const url = action.webhookUrl.startsWith("http") ? action.webhookUrl : `${this.config.baseUrl}${action.webhookUrl}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...this.config.webhookHeaders
+    };
+    if (action.webhookSecret) {
+      const signature = await this.generateSignature(
+        JSON.stringify(params),
+        action.webhookSecret
+      );
+      headers["X-Signature"] = signature;
+    }
+    if (this.context) {
+      headers["X-Session-Id"] = this.context.sessionId;
+      if (this.context.authToken) {
+        headers["Authorization"] = `Bearer ${this.context.authToken}`;
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          actionId: action.id,
+          params,
+          context: {
+            sessionId: this.context?.sessionId,
+            userId: this.context?.userId,
+            currentRoute: this.context?.currentRoute
+          }
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        this.logger.warn("Webhook failed", { actionId: action.id, status: response.status });
+        return {
+          success: false,
+          error: `Webhook failed with status ${response.status}`
+        };
+      }
+      const data = await response.json();
+      this.logger.debug("Webhook success", { actionId: action.id });
+      return {
+        success: true,
+        data
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        return { success: false, error: "Request timeout" };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Generate HMAC signature for webhook
+   */
+  async generateSignature(payload, secret) {
+    if (typeof crypto !== "undefined" && crypto.subtle) {
+      const encoder = new TextEncoder();
+      const key = await crypto.subtle.importKey(
+        "raw",
+        encoder.encode(secret),
+        { name: "HMAC", hash: "SHA-256" },
+        false,
+        ["sign"]
+      );
+      const signature = await crypto.subtle.sign("HMAC", key, encoder.encode(payload));
+      return btoa(String.fromCharCode(...new Uint8Array(signature)));
+    }
+    return "";
+  }
+  log(...args) {
+    this.logger.debug(...args);
+  }
+};
+var storageLogger = createLogger("SDK.Storage", { enabled: true, level: "warn" });
+var persistDebounceTimer = null;
+function persistMessages(messages, storagePrefix = "chatbot") {
+  if (typeof window !== "undefined") {
+    if (persistDebounceTimer) clearTimeout(persistDebounceTimer);
+    persistDebounceTimer = setTimeout(() => {
+      try {
+        const messagesToSave = messages.slice(-100);
+        localStorage.setItem(`${storagePrefix}-messages`, JSON.stringify(messagesToSave));
+      } catch (e) {
+        storageLogger.warn("Failed to save messages to localStorage", e);
+        try {
+          const messagesToSave = messages.slice(-50);
+          localStorage.setItem(`${storagePrefix}-messages`, JSON.stringify(messagesToSave));
+        } catch (e2) {
+          storageLogger.warn("Failed to save even reduced messages", e2);
+        }
+      }
+    }, 500);
+  }
+}
+function chatbotReducer(state, action) {
+  let newState;
+  switch (action.type) {
+    case "ADD_MESSAGE": {
+      newState = { ...state, messages: [...state.messages, action.message] };
+      persistMessages(newState.messages);
+      return newState;
+    }
+    case "UPDATE_MESSAGE": {
+      newState = {
+        ...state,
+        messages: state.messages.map(
+          (m) => m.id === action.id ? { ...m, ...action.updates } : m
+        )
+      };
+      persistMessages(newState.messages);
+      return newState;
+    }
+    case "SET_MESSAGES": {
+      newState = { ...state, messages: action.messages };
+      persistMessages(newState.messages);
+      return newState;
+    }
+    case "CLEAR_MESSAGES": {
+      newState = { ...state, messages: [] };
+      persistMessages([]);
+      return newState;
+    }
+    case "SET_MODE":
+      return { ...state, mode: action.mode };
+    case "SET_CONNECTION_STATE":
+      return { ...state, connectionState: action.state };
+    case "SET_EXECUTING":
+      return { ...state, isExecuting: action.isExecuting };
+    case "SET_EXECUTION_STATE":
+      return { ...state, executionState: action.state };
+    case "SET_ERROR":
+      return { ...state, error: action.error };
+    case "CLEAR_ERROR":
+      return { ...state, error: null };
+    default:
+      return state;
+  }
+}
+function getInitialState(storagePrefix = "chatbot") {
+  let messages = [];
+  let mode = "ask";
+  if (typeof window !== "undefined") {
+    try {
+      const saved = localStorage.getItem(`${storagePrefix}-messages`);
+      if (saved) {
+        messages = JSON.parse(saved);
+      }
+    } catch (e) {
+      storageLogger.warn("Failed to load messages from localStorage", e);
+    }
+    const savedMode = localStorage.getItem(`${storagePrefix}-mode`);
+    if (savedMode === "ask" || savedMode === "navigate") {
+      mode = savedMode;
+    }
+  }
+  return {
+    messages,
+    mode,
+    connectionState: "disconnected",
+    isExecuting: false,
+    executionState: null,
+    error: null
+  };
+}
+function ChatbotProvider({
+  apiKey,
+  serverUrl,
+  navigationAdapter,
+  serverActions = [],
+  config: configFromApi,
+  options,
+  routes,
+  debug = false,
+  autoConnect = true,
+  children
+}) {
+  const storagePrefix = useMemo(() => `chatbot-${apiKey.slice(0, 8)}`, [apiKey]);
+  const logger = useMemo(() => createLogger("SDK", { enabled: debug, level: "debug" }), [debug]);
+  const normalizedFromApi = useMemo(() => normalizeWidgetConfig(configFromApi ?? void 0), [configFromApi]);
+  const widgetConfig = useMemo(() => {
+    const base = { ...normalizedFromApi };
+    if (options?.theme) {
+      base.theme = { ...base.theme, ...options.theme };
+    }
+    return {
+      ...base,
+      ...options,
+      theme: base.theme
+    };
+  }, [normalizedFromApi, options]);
+  const [state, dispatch] = useReducer(chatbotReducer, storagePrefix, getInitialState);
+  const messagesRef = useRef(state.messages);
+  const [isWidgetOpen, setWidgetOpen] = useState(() => {
+    if (typeof window !== "undefined") {
+      const saved = localStorage.getItem(`${storagePrefix}-widget-open`);
+      if (saved !== null) {
+        return saved === "true";
+      }
+    }
+    return options?.defaultOpen ?? false;
+  });
+  const [selectedVoiceLanguage, setSelectedVoiceLanguage] = useState(null);
+  const effectiveVoiceLanguage = selectedVoiceLanguage ?? widgetConfig?.voiceLanguage ?? void 0;
+  const defaultModeApplied = useRef(false);
+  useEffect(() => {
+    if (defaultModeApplied.current) return;
+    const mode = widgetConfig.defaultMode;
+    if (mode === "ask" || mode === "navigate") {
+      dispatch({ type: "SET_MODE", mode });
+      defaultModeApplied.current = true;
+    }
+  }, [widgetConfig.defaultMode]);
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      localStorage.setItem(`${storagePrefix}-widget-open`, String(isWidgetOpen));
+    }
+  }, [isWidgetOpen, storagePrefix]);
+  useEffect(() => {
+    messagesRef.current = state.messages;
+  }, [state.messages]);
+  useEffect(() => {
+    if (typeof window !== "undefined") {
+      localStorage.setItem(`${storagePrefix}-mode`, state.mode);
+    }
+  }, [state.mode, storagePrefix]);
+  const wsClientRef = useRef(null);
+  const navControllerRef = useRef(null);
+  const serverActionsRef = useRef(/* @__PURE__ */ new Map());
+  const pageContextRef = useRef(null);
+  const scannerRef = useRef(null);
+  const registryRef = useRef(null);
+  const contextBuilderRef = useRef(null);
+  const executorRef = useRef(null);
+  const commandProcessorRef = useRef(null);
+  const serverActionBridgeRef = useRef(null);
+  const routesRef = useRef(void 0);
+  useEffect(() => {
+    routesRef.current = routes;
+  }, [routes]);
+  const adapter = useMemo(() => {
+    return navigationAdapter ?? createMemoryAdapter();
+  }, [navigationAdapter]);
+  useEffect(() => {
+    const client = new WebSocketClient({
+      serverUrl,
+      apiKey,
+      debug
+    });
+    wsClientRef.current = client;
+    client.on("connected", ({ sessionId }) => {
+      log("Connected, session:", sessionId);
+      dispatch({ type: "SET_CONNECTION_STATE", state: "connected" });
+    });
+    client.on("authenticated", ({ sessionId }) => {
+      const bridge = serverActionBridgeRef.current;
+      const currentRoute = adapter.getCurrentPath();
+      if (bridge) {
+        bridge.setContext({
+          sessionId,
+          currentRoute
+        });
+      }
+    });
+    client.on("disconnected", () => {
+      dispatch({ type: "SET_CONNECTION_STATE", state: "disconnected" });
+    });
+    client.on("reconnecting", ({ attempt, maxAttempts }) => {
+      log(`Reconnecting ${attempt}/${maxAttempts}`);
+      dispatch({ type: "SET_CONNECTION_STATE", state: "reconnecting" });
+    });
+    client.on("reconnect_failed", () => {
+      dispatch({ type: "SET_CONNECTION_STATE", state: "failed" });
+      dispatch({ type: "SET_ERROR", error: new Error("Connection failed") });
+    });
+    client.on("error", ({ error }) => {
+      dispatch({ type: "SET_ERROR", error });
+    });
+    client.on("message", (message) => {
+      handleServerMessage(message);
+    });
+    if (autoConnect) {
+      client.connect();
+      dispatch({ type: "SET_CONNECTION_STATE", state: "connecting" });
+    }
+    return () => {
+      client.disconnect();
+      wsClientRef.current = null;
+    };
+  }, [serverUrl, apiKey, debug, autoConnect]);
+  useEffect(() => {
+    const registry = new ActionRegistry({ debug });
+    const scanner = new DOMScanner({ debug });
+    const builder = new PageContextBuilder({ debug });
+    const executor = new DOMExecutor({ debug });
+    const serverBridge = new ServerActionBridge({ debug });
+    registryRef.current = registry;
+    scannerRef.current = scanner;
+    contextBuilderRef.current = builder;
+    executorRef.current = executor;
+    serverActionBridgeRef.current = serverBridge;
+    const sendContext = (context) => {
+      pageContextRef.current = context;
+      wsClientRef.current?.send({ type: "context", context });
+    };
+    const updateBridgeContext = (route) => {
+      serverBridge.setContext({
+        sessionId: wsClientRef.current?.getSessionId() ?? "",
+        currentRoute: route
+      });
+    };
+    const runFullScan = () => {
+      const nav2 = navControllerRef.current;
+      const route = nav2 ? nav2.getCurrentRoute() : typeof window !== "undefined" ? window.location.pathname : "/";
+      const actions = scanner.scan();
+      registry.registerDiscoveredActions(route, actions);
+      const context = {
+        ...builder.build(actions, registry.getServerActions(), route),
+        ...routes?.length ? { routes } : {}
+      };
+      updateBridgeContext(context.route);
+      sendContext(context);
+      return context;
+    };
+    const nav = new NavigationController(adapter, {
+      debug,
+      onDOMStable: () => runFullScan()
+    });
+    navControllerRef.current = nav;
+    nav.setScanner(async () => runFullScan());
+    const processor = new CommandProcessor(executor, nav, registry, { debug });
+    commandProcessorRef.current = processor;
+    processor.setServerActionHandler(async (actionId, params) => {
+      return serverBridge.execute(actionId, params);
+    });
+    const processorUnsubscribes = [];
+    if (debug) {
+      processorUnsubscribes.push(
+        processor.on("commandStart", (command, index) => {
+          log("Command start:", { index, type: command.type, command });
+        })
+      );
+      processorUnsubscribes.push(
+        processor.on("commandComplete", (result) => {
+          log("Command complete:", {
+            type: result.command.type,
+            success: result.success,
+            duration: result.duration,
+            error: result.error
+          });
+        })
+      );
+      processorUnsubscribes.push(
+        processor.on("complete", (results) => {
+          log("Command batch complete:", {
+            total: results.length,
+            failed: results.filter((r) => !r.success).length
+          });
+        })
+      );
+      processorUnsubscribes.push(
+        processor.on("error", (err) => {
+          log("Command processor error:", err);
+        })
+      );
+    }
+    serverActions.forEach((action) => {
+      serverActionsRef.current.set(action.id, action);
+      registry.registerServerAction(action);
+      serverBridge.register(action);
+    });
+    scanner.observe((actions) => {
+      registry.registerDiscoveredActions(nav.getCurrentRoute(), actions);
+      const context = {
+        ...builder.build(actions, registry.getServerActions(), nav.getCurrentRoute()),
+        ...routes?.length ? { routes } : {}
+      };
+      updateBridgeContext(context.route);
+      sendContext(context);
+    });
+    const unsubscribeRoute = nav.onRouteChange(() => {
+      updateBridgeContext(nav.getCurrentRoute());
+      runFullScan();
+    });
+    if (typeof window !== "undefined") {
+      if (document.readyState === "complete") {
+        updateBridgeContext(nav.getCurrentRoute());
+        runFullScan();
+      } else {
+        window.addEventListener("load", () => {
+          updateBridgeContext(nav.getCurrentRoute());
+          runFullScan();
+        }, { once: true });
+      }
+    }
+    return () => {
+      scanner.disconnect();
+      processor.abort();
+      processorUnsubscribes.forEach((fn) => fn());
+      unsubscribeRoute();
+    };
+  }, [adapter, debug, routes]);
+  useEffect(() => {
+    const registry = registryRef.current;
+    const bridge = serverActionBridgeRef.current;
+    if (!registry || !bridge) return;
+    serverActions.forEach((action) => {
+      serverActionsRef.current.set(action.id, action);
+      registry.registerServerAction(action);
+      bridge.register(action);
+    });
+  }, [serverActions]);
+  const executeCommandBatch = useCallback(async (commands, batchId) => {
+    const processor = commandProcessorRef.current;
+    if (!processor) {
+      return;
+    }
+    dispatch({ type: "SET_EXECUTING", isExecuting: true });
+    const unsubscribes = [];
+    unsubscribes.push(
+      processor.on("stateChange", (execState) => {
+        dispatch({ type: "SET_EXECUTION_STATE", state: execState });
+        dispatch({ type: "SET_EXECUTING", isExecuting: execState.isExecuting });
+      })
+    );
+    unsubscribes.push(
+      processor.on("error", (err) => {
+        dispatch({ type: "SET_ERROR", error: err });
+      })
+    );
+    try {
+      const results = await processor.execute(commands);
+      const ws = wsClientRef.current;
+      results.forEach((result) => {
+        if (!ws) return;
+        if (result.command.type === "server_action") {
+          ws.send({
+            type: "action_result",
+            actionId: result.command.actionId,
+            success: result.success,
+            result: result.result,
+            error: result.error,
+            commandId: batchId
+          });
+        } else {
+          ws.send({
+            type: "action_result",
+            actionId: result.command.type,
+            success: result.success,
+            error: result.error,
+            commandId: batchId
+          });
+        }
+      });
+      if (scannerRef.current && registryRef.current && contextBuilderRef.current && navControllerRef.current) {
+        const actions = scannerRef.current.scan();
+        const route = navControllerRef.current.getCurrentRoute();
+        registryRef.current.registerDiscoveredActions(route, actions);
+        const built = contextBuilderRef.current.build(actions, registryRef.current.getServerActions(), route);
+        const context = {
+          ...built,
+          ...routesRef.current?.length ? { routes: routesRef.current } : {}
+        };
+        pageContextRef.current = context;
+        if (wsClientRef.current) {
+          wsClientRef.current.send({ type: "context", context });
+        }
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      dispatch({ type: "SET_ERROR", error: err });
+      const ws = wsClientRef.current;
+      const errorMessage = err.message || "Execution failed";
+      commands.forEach((cmd) => {
+        if (!ws) return;
+        const actionId = cmd.type === "server_action" ? cmd.actionId : cmd.type;
+        ws.send({
+          type: "action_result",
+          actionId,
+          success: false,
+          error: errorMessage,
+          commandId: batchId
+        });
+      });
+    } finally {
+      unsubscribes.forEach((fn) => fn());
+      dispatch({ type: "SET_EXECUTING", isExecuting: false });
+      dispatch({ type: "SET_EXECUTION_STATE", state: null });
+    }
+  }, []);
+  const handleServerMessage = useCallback((message) => {
+    log("Server message received:", message.type, message);
+    switch (message.type) {
+      case "response":
+        {
+          const existing = messagesRef.current.find((m) => m.id === message.messageId);
+          if (existing && existing.role === "assistant") {
+            dispatch({
+              type: "UPDATE_MESSAGE",
+              id: existing.id,
+              updates: {
+                content: message.message,
+                timestamp: Date.now(),
+                status: "sent"
+              }
+            });
+          } else {
+            dispatch({
+              type: "ADD_MESSAGE",
+              message: {
+                id: existing ? createMessageId() : message.messageId,
+                role: "assistant",
+                content: message.message,
+                timestamp: Date.now(),
+                status: "sent"
+              }
+            });
+          }
+        }
+        break;
+      case "command": {
+        log("Received commands:", message.commands);
+        const commands = Array.isArray(message.commands) ? message.commands : [];
+        const batchId = message.batchId ?? createMessageId();
+        if (message.message) {
+          dispatch({
+            type: "ADD_MESSAGE",
+            message: {
+              id: createMessageId(),
+              role: "assistant",
+              content: message.message,
+              timestamp: Date.now(),
+              commands: commands.length > 0 ? commands : void 0
+            }
+          });
+        }
+        if (commands.length === 0) {
+          break;
+        }
+        const processor = commandProcessorRef.current;
+        if (!processor) {
+          dispatch({ type: "SET_ERROR", error: new Error("Action runner not ready") });
+          commands.forEach((cmd) => {
+            const actionId = cmd.type === "server_action" ? cmd.actionId : cmd.type;
+            if (wsClientRef.current) {
+              wsClientRef.current.send({
+                type: "action_result",
+                actionId,
+                success: false,
+                error: "Action runner not ready",
+                commandId: batchId
+              });
+            }
+          });
+          break;
+        }
+        executeCommandBatch(commands, batchId);
+        break;
+      }
+      case "typing":
+        break;
+      case "server_action_result":
+        log("Server action result:", message.actionId, message.result);
+        break;
+      case "error":
+        log("Server error:", message.code, message.error, message.details);
+        dispatch({
+          type: "SET_ERROR",
+          error: new Error(message.error)
+        });
+        break;
+      case "request_context":
+        if (pageContextRef.current && wsClientRef.current) {
+          wsClientRef.current.send({
+            type: "context",
+            context: pageContextRef.current
+          });
+        }
+        break;
+    }
+  }, [executeCommandBatch]);
+  const sendMessage = useCallback((content) => {
+    const messageId = createMessageId();
+    log("Sending message:", {
+      messageId,
+      mode: state.mode,
+      length: content.length,
+      connectionState: state.connectionState,
+      route: pageContextRef.current?.route ?? adapter.getCurrentPath()
+    });
+    dispatch({
+      type: "ADD_MESSAGE",
+      message: {
+        id: messageId,
+        role: "user",
+        content,
+        timestamp: Date.now(),
+        status: "sending"
+      }
+    });
+    const context = pageContextRef.current ?? {
+      route: adapter.getCurrentPath(),
+      title: typeof document !== "undefined" ? document.title : "",
+      actions: [],
+      serverActions: Array.from(serverActionsRef.current.values()),
+      content: { headings: [], mainContent: "", forms: [] },
+      timestamp: Date.now(),
+      ...routesRef.current?.length ? { routes: routesRef.current } : {}
+    };
+    const locale = selectedVoiceLanguage ?? widgetConfig?.voiceLanguage ?? void 0;
+    wsClientRef.current?.send({
+      type: "message",
+      content,
+      context,
+      mode: state.mode,
+      messageId,
+      ...locale != null ? { locale } : {}
+    });
+    dispatch({
+      type: "UPDATE_MESSAGE",
+      id: messageId,
+      updates: { status: "sent" }
+    });
+  }, [state.mode, adapter, selectedVoiceLanguage, widgetConfig?.voiceLanguage]);
+  const setVoiceLanguage = useCallback((lang) => {
+    setSelectedVoiceLanguage(lang ?? null);
+  }, []);
+  const setMode = useCallback((mode) => {
+    dispatch({ type: "SET_MODE", mode });
+  }, []);
+  const executeAction = useCallback(async (actionId, params) => {
+    const bridge = serverActionBridgeRef.current;
+    if (!bridge) {
+      throw new Error("Server action bridge not ready");
+    }
+    if (!bridge.getAction(actionId)) {
+      const action = serverActionsRef.current.get(actionId);
+      if (action) {
+        bridge.register(action);
+      }
+    }
+    const result = await bridge.execute(actionId, params ?? {});
+    if (wsClientRef.current) {
+      wsClientRef.current.send({
+        type: "action_result",
+        actionId,
+        success: result.success,
+        result: result.data,
+        error: result.error
+      });
+    }
+    return result;
+  }, []);
+  const registerServerAction = useCallback((action) => {
+    serverActionsRef.current.set(action.id, action);
+    registryRef.current?.registerServerAction(action);
+    serverActionBridgeRef.current?.register(action);
+    logger.debug("Registered server action:", action.id);
+  }, [logger]);
+  const clearMessages = useCallback(() => {
+    dispatch({ type: "CLEAR_MESSAGES" });
+  }, []);
+  const clearError = useCallback(() => {
+    dispatch({ type: "CLEAR_ERROR" });
+  }, []);
+  const stopExecution = useCallback(() => {
+    commandProcessorRef.current?.abort();
+  }, []);
+  const connect = useCallback(() => {
+    dispatch({ type: "SET_CONNECTION_STATE", state: "connecting" });
+    wsClientRef.current?.connect();
+  }, []);
+  const disconnect = useCallback(() => {
+    wsClientRef.current?.disconnect();
+    dispatch({ type: "SET_CONNECTION_STATE", state: "disconnected" });
+  }, []);
+  function log(...args) {
+    logger.debug(...args);
+  }
+  const contextValue = useMemo(() => ({
+    widgetConfig,
+    // State
+    messages: state.messages,
+    mode: state.mode,
+    connectionState: state.connectionState,
+    isExecuting: state.isExecuting,
+    executionState: state.executionState,
+    error: state.error,
+    // Widget visibility (persists across navigation)
+    isWidgetOpen,
+    setWidgetOpen,
+    voiceLanguage: effectiveVoiceLanguage,
+    setVoiceLanguage,
+    // Actions
+    sendMessage,
+    setMode,
+    executeAction,
+    registerServerAction,
+    clearMessages,
+    clearError,
+    stopExecution,
+    // Connection
+    connect,
+    disconnect,
+    isConnected: state.connectionState === "connected"
+  }), [
+    widgetConfig,
+    state,
+    isWidgetOpen,
+    effectiveVoiceLanguage,
+    setVoiceLanguage,
+    sendMessage,
+    setMode,
+    executeAction,
+    registerServerAction,
+    clearMessages,
+    clearError,
+    stopExecution,
+    connect,
+    disconnect
+  ]);
+  return /* @__PURE__ */ jsx(ChatbotContext.Provider, { value: contextValue, children });
+}
+function renderInlineWithBold(text) {
+  const parts = [];
+  let key = 0;
+  let remaining = text;
+  while (remaining.length > 0) {
+    const i = remaining.indexOf("**");
+    if (i === -1) {
+      parts.push(/* @__PURE__ */ jsx(React2.Fragment, { children: remaining }, key++));
+      break;
+    }
+    const before = remaining.slice(0, i);
+    const after = remaining.slice(i + 2);
+    const j = after.indexOf("**");
+    if (j === -1) {
+      parts.push(/* @__PURE__ */ jsx(React2.Fragment, { children: remaining }, key++));
+      break;
+    }
+    if (before) parts.push(/* @__PURE__ */ jsx(React2.Fragment, { children: before }, key++));
+    parts.push(/* @__PURE__ */ jsx("strong", { children: after.slice(0, j) }, key++));
+    remaining = after.slice(j + 2);
+  }
+  return parts.length === 1 ? parts[0] : /* @__PURE__ */ jsx(Fragment, { children: parts });
+}
+function MessageContent({ content, isUser }) {
+  if (isUser) return /* @__PURE__ */ jsx(Fragment, { children: content });
+  const raw = typeof content === "string" ? content : "";
+  if (!raw.trim()) return /* @__PURE__ */ jsx(Fragment, { children: "\xA0" });
+  const lines = raw.split(/\n/);
+  const nodes = [];
+  let listItems = [];
+  const flushList = () => {
+    if (listItems.length > 0) {
+      nodes.push(
+        /* @__PURE__ */ jsx("ul", { className: "navsi-chatbot-message-list", children: listItems.map((item, i) => /* @__PURE__ */ jsx("li", { className: "navsi-chatbot-message-list-item", children: renderInlineWithBold(item) }, i)) }, nodes.length)
+      );
+      listItems = [];
+    }
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const bulletMatch = trimmed.match(/^[*-]\s+(.*)$/);
+    if (bulletMatch) {
+      flushList();
+      listItems.push(bulletMatch[1].trim());
+    } else {
+      flushList();
+      if (trimmed) {
+        nodes.push(
+          /* @__PURE__ */ jsx("p", { className: "navsi-chatbot-message-paragraph", children: renderInlineWithBold(trimmed) }, nodes.length)
+        );
+      }
+    }
+  }
+  flushList();
+  if (nodes.length === 0) return /* @__PURE__ */ jsx(Fragment, { children: raw });
+  return /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-message-content", children: nodes });
+}
+function getSpeechRecognitionConstructor() {
+  if (typeof window === "undefined") return null;
+  const win = window;
+  const recognition = win.SpeechRecognition ?? win.webkitSpeechRecognition;
+  return recognition ?? null;
+}
+function isBraveBrowser() {
+  return typeof navigator !== "undefined" && "brave" in navigator;
+}
+function describeSpeechError(error) {
+  if (error === "network") {
+    const online = typeof navigator !== "undefined" ? navigator.onLine : true;
+    if (!online) {
+      return "Voice input error: network. You appear to be offline.";
+    }
+    if (isBraveBrowser()) {
+      return "Voice input error: network. Brave may block speech services; disable Shields or try Chrome/Edge.";
+    }
+    const isLocalhost = typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1");
+    const isSecure = typeof window !== "undefined" && window.location.protocol === "https:";
+    if (!isSecure && !isLocalhost) {
+      return "Voice input error: network. Microphone access requires HTTPS.";
+    }
+    return "Voice input error: network. Check microphone permission and reload the page.";
+  }
+  if (error === "not-allowed" || error === "service-not-allowed") {
+    return "Voice input error: microphone permission blocked.";
+  }
+  if (error === "no-speech") {
+    return "Voice input error: no speech detected.";
+  }
+  if (error === "audio-capture") {
+    return "Voice input error: no microphone found.";
+  }
+  return `Voice input error: ${error}`;
+}
+function ChatbotWidget({ className, windowClassName, buttonClassName }) {
+  const [input, setInput] = useState("");
+  const [isListening, setIsListening] = useState(false);
+  const [voiceTranscript, setVoiceTranscript] = useState("");
+  const [voiceError, setVoiceError] = useState(null);
+  const messagesEndRef = useRef(null);
+  const messagesContainerRef = useRef(null);
+  const recognitionRef = useRef(null);
+  const finalTranscriptRef = useRef("");
+  const lastSpokenIdRef = useRef(null);
+  const hasInitializedSpeechRef = useRef(false);
+  const shouldSpeakNextAssistantRef = useRef(false);
+  const { messages, sendMessage, isConnected, mode, setMode, isExecuting, error, clearError, clearMessages, isWidgetOpen, setWidgetOpen, stopExecution, widgetConfig, voiceLanguage, setVoiceLanguage } = useChatbot();
+  const effectiveVoiceLang = voiceLanguage ?? widgetConfig?.voiceLanguage ?? (typeof navigator !== "undefined" ? navigator.language : void 0) ?? "en-US";
+  const { progress } = useActionExecution();
+  const { isReconnecting } = useWebSocket();
+  const speechRecognitionConstructor = useMemo(getSpeechRecognitionConstructor, []);
+  const isVoiceSupported = !!speechRecognitionConstructor;
+  useEffect(() => {
+    if (messages.length > 0 && messagesContainerRef.current && isWidgetOpen) {
+      requestAnimationFrame(() => {
+        if (messagesContainerRef.current) {
+          messagesContainerRef.current.scrollTo({
+            top: messagesContainerRef.current.scrollHeight,
+            behavior: "smooth"
+          });
+        }
+      });
+    }
+  }, [messages, isWidgetOpen]);
+  useEffect(() => {
+    if (!hasInitializedSpeechRef.current) {
+      const lastAssistant = [...messages].reverse().find((msg) => msg.role === "assistant");
+      lastSpokenIdRef.current = lastAssistant?.id ?? null;
+      hasInitializedSpeechRef.current = true;
+    }
+  }, []);
+  useEffect(() => {
+    const lastAssistant = [...messages].reverse().find((msg) => msg.role === "assistant");
+    if (!lastAssistant) return;
+    if (!hasInitializedSpeechRef.current) return;
+    if (lastAssistant.id === lastSpokenIdRef.current) return;
+    if (isListening) return;
+    if (!shouldSpeakNextAssistantRef.current) return;
+    if (typeof window === "undefined" || !("speechSynthesis" in window)) return;
+    const content = lastAssistant.content?.trim();
+    if (!content) return;
+    const ttsContent = content.replace(/\*\*(.*?)\*\*/g, "$1").replace(/[*_~`]/g, "");
+    const ttsLang = effectiveVoiceLang;
+    window.speechSynthesis.cancel();
+    const utterance = new SpeechSynthesisUtterance(ttsContent);
+    utterance.lang = ttsLang;
+    window.speechSynthesis.speak(utterance);
+    lastSpokenIdRef.current = lastAssistant.id;
+    shouldSpeakNextAssistantRef.current = false;
+  }, [messages, isListening, effectiveVoiceLang]);
+  const handleSend = () => {
+    if (input.trim()) {
+      shouldSpeakNextAssistantRef.current = false;
+      sendMessage(input.trim());
+      setInput("");
+    }
+  };
+  const handleKeyDown = (e) => {
+    if (e.key === "Enter" && !e.shiftKey) {
+      e.preventDefault();
+      handleSend();
+    }
+  };
+  const startVoiceInput = useCallback(() => {
+    if (isListening) return;
+    if (!speechRecognitionConstructor) {
+      setVoiceError("Voice input is not supported in this browser.");
+      return;
+    }
+    setVoiceError(null);
+    finalTranscriptRef.current = "";
+    const recognition = new speechRecognitionConstructor();
+    recognitionRef.current = recognition;
+    recognition.continuous = false;
+    recognition.interimResults = true;
+    recognition.maxAlternatives = 1;
+    recognition.lang = effectiveVoiceLang;
+    recognition.onstart = () => {
+      setIsListening(true);
+      setVoiceTranscript("");
+      if (typeof window !== "undefined" && "speechSynthesis" in window) {
+        window.speechSynthesis.cancel();
+      }
+    };
+    recognition.onresult = (event) => {
+      let interimTranscript = "";
+      let finalTranscript = "";
+      for (let i = event.resultIndex; i < event.results.length; i += 1) {
+        const result = event.results[i];
+        const text = result[0]?.transcript ?? "";
+        if (result.isFinal) {
+          finalTranscript += text;
+        } else {
+          interimTranscript += text;
+        }
+      }
+      if (finalTranscript) {
+        finalTranscriptRef.current = `${finalTranscriptRef.current} ${finalTranscript}`.trim();
+        setVoiceTranscript(finalTranscriptRef.current);
+      } else if (interimTranscript) {
+        setVoiceTranscript(interimTranscript.trim());
+      }
+    };
+    recognition.onerror = (event) => {
+      setVoiceError(event.error ? describeSpeechError(event.error) : "Voice input error");
+    };
+    recognition.onend = () => {
+      setIsListening(false);
+      const finalText = finalTranscriptRef.current.trim();
+      finalTranscriptRef.current = "";
+      setVoiceTranscript("");
+      if (finalText) {
+        shouldSpeakNextAssistantRef.current = true;
+        sendMessage(finalText);
+        setInput("");
+      }
+    };
+    recognition.start();
+  }, [isListening, speechRecognitionConstructor, sendMessage, effectiveVoiceLang]);
+  const stopVoiceInput = useCallback(() => {
+    recognitionRef.current?.stop();
+  }, []);
+  useEffect(() => {
+    return () => {
+      recognitionRef.current?.abort();
+      if (typeof window !== "undefined" && "speechSynthesis" in window) {
+        window.speechSynthesis.cancel();
+      }
+    };
+  }, []);
+  const containerStyle = {
+    position: "fixed",
+    zIndex: 9999
+  };
+  const title = widgetConfig?.headerTitle ?? "AI Assistant";
+  const welcomeMessage = widgetConfig?.welcomeMessage ?? "How can I help you today?";
+  const welcomeHint = widgetConfig?.subtitle ?? "Type a message to get started";
+  const askPlaceholder = widgetConfig?.askPlaceholder ?? "Ask a question...";
+  const navigatePlaceholder = widgetConfig?.navigatePlaceholder ?? "What should I do? Try: Go to cart, Add product 1 to cart";
+  const supportedLanguages = widgetConfig?.supportedLanguages ?? [
+    { code: "en-US", label: "EN" },
+    { code: "hi-IN", label: "\u0939\u093F\u0902\u0926\u0940" }
+  ];
+  return /* @__PURE__ */ jsxs("div", { style: containerStyle, className: `navsi-chatbot-container ${className || ""}`, children: [
+    isWidgetOpen && /* @__PURE__ */ jsxs("div", { className: `navsi-chatbot-window ${windowClassName || ""}`, children: [
+      /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-header", children: [
+        /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-header-left", children: /* @__PURE__ */ jsxs("div", { children: [
+          /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-title", children: title }),
+          /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-status", children: isConnected ? "Connected" : isReconnecting ? "Reconnecting" : "Disconnected" }),
+          isListening && /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-voice-indicator", "aria-live": "polite", children: [
+            /* @__PURE__ */ jsxs("svg", { width: "14", height: "14", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+              /* @__PURE__ */ jsx("path", { d: "M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z" }),
+              /* @__PURE__ */ jsx("path", { d: "M19 10v2a7 7 0 0 1-14 0v-2" }),
+              /* @__PURE__ */ jsx("line", { x1: "12", y1: "19", x2: "12", y2: "23" }),
+              /* @__PURE__ */ jsx("line", { x1: "8", y1: "23", x2: "16", y2: "23" })
+            ] }),
+            "Listening\u2026"
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-mode-toggle", children: [
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: `navsi-chatbot-mode-button ${mode === "ask" ? "navsi-chatbot-mode-active" : ""}`,
+              onClick: () => setMode("ask"),
+              children: "Ask"
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              className: `navsi-chatbot-mode-button ${mode === "navigate" ? "navsi-chatbot-mode-active" : ""}`,
+              onClick: () => setMode("navigate"),
+              children: "Action"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-lang-toggle", role: "group", "aria-label": "Voice and response language", children: supportedLanguages.map((lang) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: `navsi-chatbot-lang-button ${effectiveVoiceLang.startsWith(lang.code.split("-")[0]) ? "navsi-chatbot-lang-active" : ""}`,
+            onClick: () => setVoiceLanguage(lang.code),
+            title: lang.label,
+            "aria-pressed": effectiveVoiceLang.startsWith(lang.code.split("-")[0]),
+            children: lang.label
+          },
+          lang.code
+        )) }),
+        messages.length > 0 && /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => clearMessages(),
+            className: "navsi-chatbot-clear",
+            title: "Clear chat",
+            "aria-label": "Clear chat",
+            children: "Clear"
+          }
+        )
+      ] }),
+      isExecuting && /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-banner", children: [
+        /* @__PURE__ */ jsx("span", { children: "\u26A1 Executing actions\u2026" }),
+        progress && /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsxs("span", { className: "navsi-chatbot-pill", children: [
+            progress.current + 1,
+            "/",
+            progress.total
+          ] }),
+          progress.description && /* @__PURE__ */ jsx("span", { className: "navsi-chatbot-step", children: progress.description })
+        ] })
+      ] }),
+      progress && /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-progress-container", children: /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-progress-bar", children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "navsi-chatbot-progress-fill",
+          style: { width: `${progress.percentage ?? 0}%` }
+        }
+      ) }) }),
+      error && /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-error", children: [
+        /* @__PURE__ */ jsx("span", { children: error.message }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "navsi-chatbot-error-close",
+            onClick: clearError,
+            children: "\u2715"
+          }
+        )
+      ] }),
+      voiceError && /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-voice-error", role: "alert", children: voiceError }),
+      /* @__PURE__ */ jsxs(
+        "div",
+        {
+          ref: messagesContainerRef,
+          className: "navsi-chatbot-messages",
+          role: "log",
+          "aria-live": "polite",
+          "aria-label": "Chat messages",
+          children: [
+            messages.length === 0 && /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-welcome", children: [
+              /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-welcome-icon", children: "\u{1F44B}" }),
+              /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-welcome-text", children: welcomeMessage }),
+              /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-welcome-hint", children: welcomeHint })
+            ] }),
+            messages.map((msg) => /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: `navsi-chatbot-message ${msg.role === "user" ? "navsi-chatbot-message-user" : "navsi-chatbot-message-assistant"}`,
+                children: /* @__PURE__ */ jsx(MessageContent, { content: msg.content, isUser: msg.role === "user" })
+              },
+              msg.id
+            )),
+            /* @__PURE__ */ jsx("div", { ref: messagesEndRef })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "navsi-chatbot-input-area", children: [
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            type: "text",
+            value: input,
+            onChange: (e) => setInput(e.target.value),
+            onKeyDown: handleKeyDown,
+            placeholder: mode === "ask" ? askPlaceholder : navigatePlaceholder,
+            className: "navsi-chatbot-input",
+            maxLength: 8e3,
+            "aria-label": mode === "ask" ? askPlaceholder : navigatePlaceholder
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: `navsi-chatbot-voice-button ${isListening ? "navsi-chatbot-voice-button-active" : ""}`,
+            onClick: () => {
+              if (isListening) {
+                stopVoiceInput();
+              } else {
+                startVoiceInput();
+              }
+            },
+            disabled: !isConnected || !isVoiceSupported,
+            "aria-label": !isVoiceSupported ? "Voice input not supported in this browser" : isListening ? "Stop voice input" : "Start voice input",
+            "aria-pressed": isListening,
+            title: !isVoiceSupported ? "Voice input is not available in this browser" : isListening ? "Click to stop and send" : "Click to start listening",
+            type: "button",
+            children: isListening ? /* @__PURE__ */ jsx("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx("circle", { cx: "12", cy: "12", r: "8" }) }) : /* @__PURE__ */ jsxs("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+              /* @__PURE__ */ jsx("path", { d: "M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z" }),
+              /* @__PURE__ */ jsx("path", { d: "M19 10v2a7 7 0 0 1-14 0v-2" }),
+              /* @__PURE__ */ jsx("line", { x1: "12", y1: "19", x2: "12", y2: "23" }),
+              /* @__PURE__ */ jsx("line", { x1: "8", y1: "23", x2: "16", y2: "23" })
+            ] })
+          }
+        ),
+        isExecuting ? /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "navsi-chatbot-stop-button",
+            onClick: stopExecution,
+            "aria-label": "Stop",
+            title: "Stop current action",
+            children: /* @__PURE__ */ jsx("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "12", height: "12", rx: "1" }) })
+          }
+        ) : /* @__PURE__ */ jsx(
+          "button",
+          {
+            className: "navsi-chatbot-send-button",
+            onClick: handleSend,
+            disabled: !isConnected,
+            children: /* @__PURE__ */ jsx("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { d: "M2.01 21L23 12 2.01 3 2 10l15 2-15 2z" }) })
+          }
+        )
+      ] }),
+      voiceTranscript && /* @__PURE__ */ jsx("div", { className: "navsi-chatbot-voice-transcript", "aria-live": "polite", children: voiceTranscript })
+    ] }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        className: `navsi-chatbot-toggle ${buttonClassName || ""}`,
+        onClick: () => setWidgetOpen(!isWidgetOpen),
+        "aria-label": isWidgetOpen ? "Close chat" : "Open chat",
+        children: isWidgetOpen ? /* @__PURE__ */ jsx("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { d: "M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z" }) }) : /* @__PURE__ */ jsx("svg", { width: "28", height: "28", viewBox: "0 0 24 24", fill: "currentColor", children: /* @__PURE__ */ jsx("path", { d: "M20 2H4c-1.1 0-2 .9-2 2v18l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 14H6l-2 2V4h16v12z" }) })
+      }
+    )
+  ] });
+}
+
+export { ChatbotProvider, ChatbotWidget, DEFAULT_ROUTE_TIMEOUT, NavigationController, WebSocketClient, createMemoryAdapter, createNavigationController, createWebSocketClient };
+//# sourceMappingURL=chunk-EHZXIZIP.js.map
+//# sourceMappingURL=chunk-EHZXIZIP.js.map