@navieo/react 1.0.0

package/dist/index.js

@@ -0,0 +1,1356 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ChatWidget: () => ChatWidget,
+  NavieoProvider: () => NavieoProvider,
+  logger: () => logger,
+  useNavieo: () => useNavieo,
+  useTourRenderer: () => useTourRenderer
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/NavieoProvider.tsx
+var import_react4 = require("react");
+
+// src/ChatWidget.tsx
+var import_react2 = require("react");
+var import_react_dom = require("react-dom");
+
+// src/useNavieo.ts
+var import_react = require("react");
+function useNavieo() {
+  const context = (0, import_react.useContext)(NavieoContext);
+  if (!context) {
+    throw new Error("useNavieo must be used within a <NavieoProvider>");
+  }
+  return context;
+}
+
+// src/ChatWidget.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+function ChatWidget() {
+  const {
+    isChatOpen,
+    toggleChat,
+    startTour,
+    tourState,
+    chatHistory,
+    clearChatHistory,
+    suggestions,
+    endTour
+  } = useNavieo();
+  const [inputValue, setInputValue] = (0, import_react2.useState)("");
+  const messagesEndRef = (0, import_react2.useRef)(null);
+  const [mounted, setMounted] = (0, import_react2.useState)(false);
+  (0, import_react2.useEffect)(() => setMounted(true), []);
+  (0, import_react2.useEffect)(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [chatHistory]);
+  const handleSubmit = (e) => {
+    e.preventDefault();
+    if (!inputValue.trim() || tourState === "loading") return;
+    startTour(inputValue.trim());
+    setInputValue("");
+  };
+  if (!mounted) return null;
+  const isTourActive = tourState === "active";
+  const widget = /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: `fixed bottom-6 right-6 flex flex-col items-end gap-3 font-sans ${isTourActive ? "z-[1100000000]" : "z-[40]"}`, children: [
+    !isTourActive && isChatOpen && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "w-[380px] h-[520px] bg-white rounded-2xl shadow-2xl border border-gray-200 flex flex-col overflow-hidden", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "px-5 py-4 bg-gradient-to-r from-blue-600 to-blue-700 text-white flex justify-between items-center", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "font-semibold text-sm", children: "Navieo Assistant" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "text-blue-200 text-xs", children: "Ask me how to do anything" })
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex items-center gap-1", children: [
+          chatHistory.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "button",
+            {
+              onClick: clearChatHistory,
+              "aria-label": "Clear chat history",
+              title: "Clear chat history",
+              className: "hover:bg-white/10 rounded-lg p-1 transition-colors",
+              children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "svg",
+                {
+                  width: "16",
+                  height: "16",
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M3 6h18M8 6V4a2 2 0 012-2h4a2 2 0 012 2v2m3 0v14a2 2 0 01-2 2H7a2 2 0 01-2-2V6h14" })
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "button",
+            {
+              onClick: toggleChat,
+              "aria-label": "Close chat",
+              className: "hover:bg-white/10 rounded-lg p-1 transition-colors",
+              children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                "svg",
+                {
+                  width: "18",
+                  height: "18",
+                  viewBox: "0 0 24 24",
+                  fill: "none",
+                  stroke: "currentColor",
+                  strokeWidth: "2",
+                  children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M18 6L6 18M6 6l12 12" })
+                }
+              )
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex-1 overflow-y-auto p-4 space-y-3", children: [
+        chatHistory.length === 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "text-center mt-6 px-4", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "w-12 h-12 bg-blue-100 rounded-full flex items-center justify-center mx-auto mb-4", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "svg",
+            {
+              className: "w-6 h-6 text-blue-600",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2",
+              viewBox: "0 0 24 24",
+              children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M9.663 17h4.673M12 3v1m6.364 1.636l-.707.707M21 12h-1M4 12H3m3.343-5.657l-.707-.707m2.828 9.9a5 5 0 117.072 0l-.548.547A3.374 3.374 0 0014 18.469V19a2 2 0 11-4 0v-.531c0-.895-.356-1.754-.988-2.386l-.548-.547z" })
+            }
+          ) }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "text-gray-900 font-medium text-sm mb-1", children: "How can I help?" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { className: "text-gray-400 text-xs leading-relaxed mb-4", children: "Ask me how to do anything in this app and I'll guide you step by step." }),
+          suggestions && suggestions.length > 0 && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "space-y-1.5", children: suggestions.map((s) => /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+            "button",
+            {
+              disabled: tourState === "loading",
+              onClick: () => {
+                if (tourState === "loading") return;
+                setInputValue(s.label);
+                startTour(s.label);
+              },
+              className: "flex items-center gap-2 w-full text-left text-xs bg-gray-50 hover:bg-gray-100 text-gray-600 rounded-lg px-3 py-2 transition-colors disabled:opacity-50",
+              children: [
+                /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "flex-1", children: s.label }),
+                s.tag && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "shrink-0 text-[10px] font-medium px-1.5 py-0.5 rounded bg-blue-100 text-blue-600", children: s.tag })
+              ]
+            },
+            s.label
+          )) })
+        ] }),
+        chatHistory.map((msg, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "div",
+          {
+            className: `flex ${msg.role === "user" ? "justify-end" : "justify-start"}`,
+            children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "div",
+              {
+                className: `max-w-[85%] rounded-2xl px-4 py-2.5 text-sm leading-relaxed whitespace-pre-line ${msg.role === "user" ? "bg-blue-600 text-white rounded-br-md" : "bg-gray-100 text-gray-800 rounded-bl-md"}`,
+                children: msg.content
+              }
+            )
+          },
+          i
+        )),
+        tourState === "loading" && /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "flex justify-start", children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { className: "bg-gray-100 rounded-2xl rounded-bl-md px-4 py-2.5 text-sm text-gray-500", children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { className: "inline-flex gap-1", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "w-1.5 h-1.5 bg-gray-400 rounded-full animate-bounce [animation-delay:0ms]" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "w-1.5 h-1.5 bg-gray-400 rounded-full animate-bounce [animation-delay:150ms]" }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("span", { className: "w-1.5 h-1.5 bg-gray-400 rounded-full animate-bounce [animation-delay:300ms]" })
+        ] }) }) }),
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("div", { ref: messagesEndRef })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "form",
+        {
+          onSubmit: handleSubmit,
+          className: "p-3 border-t border-gray-200 bg-white",
+          children: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "flex gap-2", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "input",
+              {
+                type: "text",
+                value: inputValue,
+                onChange: (e) => setInputValue(e.target.value),
+                placeholder: "How do I...",
+                className: "flex-1 border border-gray-300 rounded-xl px-4 py-2.5 text-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-transparent",
+                disabled: tourState === "loading"
+              }
+            ),
+            /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+              "button",
+              {
+                type: "submit",
+                disabled: tourState === "loading" || !inputValue.trim(),
+                className: "bg-blue-600 text-white px-4 py-2.5 rounded-xl text-sm hover:bg-blue-700 disabled:opacity-50 transition-colors",
+                children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+                  "svg",
+                  {
+                    className: "w-4 h-4",
+                    fill: "none",
+                    stroke: "currentColor",
+                    strokeWidth: "2",
+                    viewBox: "0 0 24 24",
+                    children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M5 12h14M12 5l7 7-7 7" })
+                  }
+                )
+              }
+            )
+          ] })
+        }
+      )
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "button",
+      {
+        onClick: isTourActive ? endTour : toggleChat,
+        "aria-label": isTourActive ? "Stop tour" : "Open Navieo assistant",
+        className: `w-14 h-14 rounded-full shadow-lg flex items-center justify-center transition-all hover:scale-105 ${isTourActive ? "bg-red-500 hover:bg-red-600" : isChatOpen ? "bg-gray-700 hover:bg-gray-800" : "bg-blue-600 hover:bg-blue-700"} text-white`,
+        children: isTourActive ? (
+          /* Stop icon */
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+            "svg",
+            {
+              width: "20",
+              height: "20",
+              viewBox: "0 0 24 24",
+              fill: "currentColor",
+              children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("rect", { x: "6", y: "6", width: "12", height: "12", rx: "2" })
+            }
+          )
+        ) : isChatOpen ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "svg",
+          {
+            width: "22",
+            height: "22",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M18 6L6 18M6 6l12 12" })
+          }
+        ) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+          "svg",
+          {
+            width: "22",
+            height: "22",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("path", { d: "M21 15a2 2 0 01-2 2H7l-4 4V5a2 2 0 012-2h14a2 2 0 012 2z" })
+          }
+        )
+      }
+    )
+  ] }) });
+  return (0, import_react_dom.createPortal)(widget, document.body);
+}
+
+// src/TourRenderer.tsx
+var import_driver = require("driver.js");
+var import_driver2 = require("driver.js/dist/driver.css");
+var import_react3 = require("react");
+
+// src/routeUtils.ts
+function stripRouteGroups(route) {
+  return route.replace(/\/\([^)]+\)/g, "") || "/";
+}
+function normalizeRoute(route) {
+  let r = route.trim();
+  r = stripRouteGroups(r);
+  const qIdx = r.indexOf("?");
+  if (qIdx !== -1) r = r.slice(0, qIdx);
+  const hIdx = r.indexOf("#");
+  if (hIdx !== -1) r = r.slice(0, hIdx);
+  if (r.length > 1 && r.endsWith("/")) r = r.slice(0, -1);
+  return r;
+}
+function isDynamicRoute(route) {
+  return /\[.+?\]/.test(route);
+}
+function routeMatches(actual, pattern) {
+  const a = normalizeRoute(actual);
+  const p = normalizeRoute(pattern);
+  if (a === p) return true;
+  const actualParts = a.split("/");
+  const patternParts = p.split("/");
+  const lastPart = patternParts[patternParts.length - 1];
+  if (lastPart && lastPart.startsWith("[[...") && lastPart.endsWith("]]")) {
+    const prefixParts = patternParts.slice(0, -1);
+    if (actualParts.length < prefixParts.length) return false;
+    return prefixParts.every(
+      (part, i) => part.startsWith("[") && part.endsWith("]") || part === actualParts[i]
+    );
+  }
+  if (lastPart && lastPart.startsWith("[...") && lastPart.endsWith("]")) {
+    const prefixParts = patternParts.slice(0, -1);
+    if (actualParts.length <= prefixParts.length) return false;
+    return prefixParts.every(
+      (part, i) => part.startsWith("[") && part.endsWith("]") || part === actualParts[i]
+    );
+  }
+  if (actualParts.length !== patternParts.length) return false;
+  return patternParts.every(
+    (part, i) => part.startsWith("[") && part.endsWith("]") || part === actualParts[i]
+  );
+}
+
+// src/constants.ts
+var TOUR_ERRORS = {
+  /** Element polling timed out — page elements never appeared in the DOM. */
+  elementsNotFound: (stepLabels) => `Could not find the page elements needed for the next steps (${stepLabels}). The page may still be loading or the layout may have changed.`,
+  /** Transition between route groups timed out (60s safety). */
+  transitionTimeout: "The tour couldn't continue because the next page didn't load in time.",
+  /** Driver.js threw an unexpected exception. */
+  driverCrash: "The tour encountered an unexpected error and had to stop.",
+  /** continueAfterNavigation couldn't find a matching route group. */
+  noMatchingGroup: "The tour couldn't find steps for the page you navigated to. The tour has been stopped."
+};
+var CHAT_MESSAGES = {
+  /** Wraps a tour error for display in chat. */
+  tourError: (detail) => `The tour ran into a problem: ${detail} Please try again or ask a different question.`,
+  /** Navigation timeout — route never changed within NAV_TIMEOUT_MS. */
+  navigationTimeout: "The tour was stopped because the expected page navigation didn't complete in time. Please try again.",
+  /** API returned no steps and no answer text. */
+  noStepsFound: "I couldn't find specific steps for that. Try asking something else.",
+  /** API returned steps but none had the required fields. */
+  invalidSteps: "The response didn't contain valid steps. Try rephrasing your question.",
+  /** Generic API/network error. */
+  genericError: "Something went wrong. Please try again.",
+  /** Tour started successfully. */
+  tourStarted: (stepCount) => `I found ${stepCount} step${stepCount !== 1 ? "s" : ""} to help you. Starting the tour!`
+};
+
+// src/logger.ts
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  silent: 4
+};
+var PREFIX = "[Navieo]";
+function getDefaultLevel() {
+  if (typeof window !== "undefined") {
+    const override = window.__NAVIEO_LOG_LEVEL__;
+    if (typeof override === "string" && override in LEVEL_ORDER) {
+      return override;
+    }
+  }
+  if (typeof process !== "undefined" && process.env?.NODE_ENV === "production") {
+    return "warn";
+  }
+  return "debug";
+}
+var NavieoLogger = class {
+  constructor() {
+    this.level = getDefaultLevel();
+  }
+  /** Change the active log level at runtime. */
+  setLevel(level) {
+    this.level = level;
+  }
+  getLevel() {
+    return this.level;
+  }
+  shouldLog(level) {
+    return LEVEL_ORDER[level] >= LEVEL_ORDER[this.level];
+  }
+  /** Verbose diagnostic info — only shown at "debug" level. */
+  debug(message, ...args) {
+    if (this.shouldLog("debug")) {
+      console.log(`${PREFIX} ${message}`, ...args);
+    }
+  }
+  /** Standard operational info — shown at "info" level and above. */
+  info(message, ...args) {
+    if (this.shouldLog("info")) {
+      console.log(`${PREFIX} ${message}`, ...args);
+    }
+  }
+  /** Warnings — shown at "warn" level and above. */
+  warn(message, ...args) {
+    if (this.shouldLog("warn")) {
+      console.warn(`${PREFIX} ${message}`, ...args);
+    }
+  }
+  /** Errors — always shown unless "silent". */
+  error(message, ...args) {
+    if (this.shouldLog("error")) {
+      console.error(`${PREFIX} ${message}`, ...args);
+    }
+  }
+  /**
+   * Log a structured diagnostic table for tour steps.
+   * Only shown at "debug" level.
+   */
+  debugSteps(label, steps) {
+    if (this.shouldLog("debug")) {
+      console.log(`${PREFIX} ${label}`);
+      console.table(steps);
+    }
+  }
+};
+var logger = new NavieoLogger();
+
+// src/TourRenderer.tsx
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function groupByRoute(steps) {
+  const groups = [];
+  let currentGroup = null;
+  steps.forEach((step, i) => {
+    if (!currentGroup || currentGroup.route !== step.route) {
+      currentGroup = { route: step.route, steps: [], globalStartIndex: i };
+      groups.push(currentGroup);
+    }
+    currentGroup.steps.push(step);
+  });
+  return groups;
+}
+function useTourRenderer(options = {}) {
+  const driverRef = (0, import_react3.useRef)(null);
+  const optionsRef = (0, import_react3.useRef)(options);
+  optionsRef.current = options;
+  const allStepsRef = (0, import_react3.useRef)([]);
+  const groupsRef = (0, import_react3.useRef)([]);
+  const currentGroupIndexRef = (0, import_react3.useRef)(0);
+  const transitioningRef = (0, import_react3.useRef)(false);
+  const transitionTimeoutRef = (0, import_react3.useRef)(null);
+  const forceDestroyRef = (0, import_react3.useRef)(false);
+  const lastLocalIndexRef = (0, import_react3.useRef)(0);
+  function resolveSelector(step) {
+    const candidates = [];
+    if (step.selector?.cssSelector) candidates.push(step.selector.cssSelector);
+    if (step.elementId) candidates.push(`#${CSS.escape(step.elementId)}`);
+    if (step.selector?.testId) candidates.push(`[data-testid="${CSS.escape(step.selector.testId)}"]`);
+    if (step.selector?.ariaLabel) candidates.push(`[aria-label="${CSS.escape(step.selector.ariaLabel)}"]`);
+    const stepLabel = step.tooltipTitle || step.elementId || "unknown";
+    if (candidates.length === 0) {
+      logger.warn(`resolveSelector("${stepLabel}"): no selectors defined on step`);
+      return void 0;
+    }
+    logger.debug(`resolveSelector("${stepLabel}"): trying ${candidates.length} candidates: ${candidates.join(", ")}`);
+    for (const sel of candidates) {
+      try {
+        const el = document.querySelector(sel);
+        if (el) {
+          logger.debug(`resolveSelector("${stepLabel}"): FOUND via "${sel}" \u2192 <${el.tagName.toLowerCase()}>`);
+          return sel;
+        }
+        logger.debug(`resolveSelector("${stepLabel}"): miss "${sel}"`);
+      } catch {
+        logger.warn(`resolveSelector("${stepLabel}"): invalid selector syntax "${sel}"`);
+      }
+    }
+    logger.warn(`resolveSelector("${stepLabel}"): NO element found. Tried: ${candidates.join(", ")}`);
+    return void 0;
+  }
+  function buildDriverSteps(group, totalSteps, isLastGroup) {
+    return group.steps.map((s, i) => {
+      const globalIndex = group.globalStartIndex + i;
+      const isLastStepInGroup = i === group.steps.length - 1;
+      return {
+        element: s.selector?.cssSelector || `#${s.elementId}`,
+        popover: {
+          title: escapeHtml(s.tooltipTitle || `Step ${globalIndex + 1} of ${totalSteps}`),
+          description: escapeHtml(s.tooltipText),
+          progressText: `${globalIndex + 1} of ${totalSteps}`,
+          ...isLastStepInGroup && !isLastGroup ? { doneBtnText: "Next \u2192" } : {}
+        }
+      };
+    });
+  }
+  function destroyCurrentDriver() {
+    const d = driverRef.current;
+    if (!d) return;
+    logger.debug("destroyCurrentDriver: destroying active driver instance");
+    forceDestroyRef.current = true;
+    try {
+      d.destroy();
+    } catch {
+    }
+    forceDestroyRef.current = false;
+    driverRef.current = null;
+  }
+  const pollIntervalRef = (0, import_react3.useRef)(null);
+  function clearTransitionTimeout() {
+    if (transitionTimeoutRef.current) {
+      clearTimeout(transitionTimeoutRef.current);
+      transitionTimeoutRef.current = null;
+    }
+  }
+  function clearPollInterval() {
+    if (pollIntervalRef.current) {
+      clearInterval(pollIntervalRef.current);
+      pollIntervalRef.current = null;
+    }
+  }
+  function anyElementExists(steps) {
+    for (const step of steps) {
+      const candidates = [];
+      if (step.selector?.cssSelector) candidates.push(step.selector.cssSelector);
+      if (step.elementId) candidates.push(`#${CSS.escape(step.elementId)}`);
+      if (step.selector?.testId) candidates.push(`[data-testid="${CSS.escape(step.selector.testId)}"]`);
+      if (step.selector?.ariaLabel) candidates.push(`[aria-label="${CSS.escape(step.selector.ariaLabel)}"]`);
+      for (const sel of candidates) {
+        try {
+          if (document.querySelector(sel)) return true;
+        } catch {
+        }
+      }
+    }
+    return false;
+  }
+  function launchDriver(group, driverSteps) {
+    logger.info(`launchDriver: group="${group.route}", ${driverSteps.length} steps, globalStart=${group.globalStartIndex}`);
+    const resolvedSummary = [];
+    for (let idx = 0; idx < driverSteps.length; idx++) {
+      const resolved = resolveSelector(group.steps[idx]);
+      if (resolved) {
+        driverSteps[idx].element = resolved;
+      } else {
+        driverSteps[idx].element = void 0;
+      }
+      resolvedSummary.push({
+        step: group.steps[idx].tooltipTitle || `Step ${idx + 1}`,
+        selector: resolved || null
+      });
+    }
+    logger.debugSteps("launchDriver: resolved selectors", resolvedSummary);
+    try {
+      logger.debug("launchDriver: calling driver() constructor...");
+      driverRef.current = (0, import_driver.driver)({
+        showProgress: true,
+        animate: true,
+        overlayColor: "rgba(0, 0, 0, 0.6)",
+        stagePadding: 8,
+        stageRadius: 8,
+        steps: driverSteps,
+        onHighlightStarted: (_element, _step, opts) => {
+          const localIndex = opts.state.activeIndex ?? 0;
+          lastLocalIndexRef.current = localIndex;
+          const globalIndex = group.globalStartIndex + localIndex;
+          logger.debug(`onHighlightStarted: local=${localIndex}, global=${globalIndex}`);
+          optionsRef.current.onStepChange?.(globalIndex);
+        },
+        onDestroyStarted: () => {
+          const d = driverRef.current;
+          if (!d) {
+            logger.warn("onDestroyStarted: driverRef is null \u2014 skipping");
+            return;
+          }
+          if (forceDestroyRef.current) {
+            logger.debug("onDestroyStarted: forceDestroy=true, confirming");
+            driverRef.current = null;
+            d.destroy();
+            return;
+          }
+          const activeIndex = lastLocalIndexRef.current;
+          const isLastStep = activeIndex >= driverSteps.length - 1;
+          const isLastGroupNow = currentGroupIndexRef.current >= groupsRef.current.length - 1;
+          const hasMoreGroups = !isLastGroupNow;
+          logger.info(
+            `onDestroyStarted: step=${activeIndex}/${driverSteps.length - 1}, group=${currentGroupIndexRef.current}/${groupsRef.current.length - 1}, isLastStep=${isLastStep}, hasMoreGroups=${hasMoreGroups}`
+          );
+          if (isLastStep && hasMoreGroups) {
+            transitioningRef.current = true;
+            driverRef.current = null;
+            d.destroy();
+            const nextGroup = groupsRef.current[currentGroupIndexRef.current + 1];
+            logger.info(`onDestroyStarted: transitioning to next group, route="${nextGroup.route}"`);
+            clearTransitionTimeout();
+            transitionTimeoutRef.current = setTimeout(() => {
+              if (transitioningRef.current) {
+                logger.warn("Transition safety timeout (60s) \u2014 navigation never completed");
+                transitioningRef.current = false;
+                optionsRef.current.onClose?.();
+              }
+              transitionTimeoutRef.current = null;
+            }, 6e4);
+            optionsRef.current.onNavigationNeeded?.(nextGroup.route);
+          } else if (isLastStep && isLastGroupNow) {
+            driverRef.current = null;
+            d.destroy();
+            logger.info("onDestroyStarted: tour COMPLETE (last step of last group)");
+            optionsRef.current.onComplete?.();
+          } else {
+            driverRef.current = null;
+            d.destroy();
+            logger.info("onDestroyStarted: tour CLOSED by user (early exit)");
+            optionsRef.current.onClose?.();
+          }
+        },
+        onDestroyed: () => {
+          if (transitioningRef.current) {
+            logger.debug("onDestroyed: transitioning between groups, skipping");
+            return;
+          }
+          logger.debug("onDestroyed: driver fully destroyed");
+        }
+      });
+      logger.debug("launchDriver: driver() created, calling .drive()...");
+      driverRef.current.drive();
+      logger.info("launchDriver: .drive() called \u2014 tour should now be visible");
+    } catch (err) {
+      logger.error("launchDriver: Driver.js crashed!", err);
+      driverRef.current = null;
+      optionsRef.current.onError?.(TOUR_ERRORS.driverCrash);
+    }
+  }
+  const driveGroup = (0, import_react3.useCallback)((groupIndex) => {
+    logger.info(`driveGroup(${groupIndex}): entering`);
+    transitioningRef.current = false;
+    lastLocalIndexRef.current = 0;
+    clearTransitionTimeout();
+    clearPollInterval();
+    destroyCurrentDriver();
+    const groups = groupsRef.current;
+    const totalSteps = allStepsRef.current.length;
+    logger.debug(`driveGroup(${groupIndex}): totalGroups=${groups.length}, totalSteps=${totalSteps}`);
+    if (groupIndex >= groups.length) {
+      logger.warn(`driveGroup(${groupIndex}): index out of range (${groups.length} groups), calling onComplete`);
+      optionsRef.current.onComplete?.();
+      return;
+    }
+    currentGroupIndexRef.current = groupIndex;
+    const group = groups[groupIndex];
+    const isLastGroup = groupIndex >= groups.length - 1;
+    const driverSteps = buildDriverSteps(group, totalSteps, isLastGroup);
+    const stepDetails = group.steps.map((s, i) => ({
+      index: group.globalStartIndex + i,
+      route: s.route,
+      title: s.tooltipTitle || "(no title)",
+      cssSelector: s.selector?.cssSelector || "(none)",
+      elementId: s.elementId || "(none)",
+      testId: s.selector?.testId || "(none)"
+    }));
+    logger.info(`driveGroup(${groupIndex}): route="${group.route}", ${driverSteps.length} steps, isLastGroup=${isLastGroup}`);
+    logger.debugSteps(`driveGroup(${groupIndex}): step details`, stepDetails);
+    const POLL_INTERVAL_MS = 200;
+    const POLL_TIMEOUT_MS = 5e3;
+    const pollStartTime = Date.now();
+    if (anyElementExists(group.steps)) {
+      logger.info(`driveGroup(${groupIndex}): elements found immediately \u2014 launching`);
+      launchDriver(group, driverSteps);
+      return;
+    }
+    logger.info(`driveGroup(${groupIndex}): elements NOT found yet, starting poll (interval=${POLL_INTERVAL_MS}ms, timeout=${POLL_TIMEOUT_MS}ms)`);
+    pollIntervalRef.current = setInterval(() => {
+      const elapsed = Date.now() - pollStartTime;
+      if (anyElementExists(group.steps)) {
+        logger.info(`driveGroup(${groupIndex}): elements found after ${elapsed}ms \u2014 launching`);
+        clearPollInterval();
+        launchDriver(group, driverSteps);
+        return;
+      }
+      if (elapsed >= POLL_TIMEOUT_MS) {
+        clearPollInterval();
+        logger.warn(`driveGroup(${groupIndex}): poll timed out after ${POLL_TIMEOUT_MS}ms \u2014 launching anyway (soft fallback)`);
+        launchDriver(group, driverSteps);
+      }
+    }, POLL_INTERVAL_MS);
+  }, []);
+  const startTour = (0, import_react3.useCallback)(
+    (steps, currentRoute) => {
+      logger.info(`startTour: ${steps.length} steps, currentRoute="${currentRoute}"`);
+      const stepSummary = steps.map((s, i) => ({
+        step: i + 1,
+        route: s.route,
+        title: s.tooltipTitle || "(no title)",
+        cssSelector: s.selector?.cssSelector || "(none)",
+        elementId: s.elementId || "(none)"
+      }));
+      logger.debugSteps("startTour: received steps", stepSummary);
+      allStepsRef.current = steps;
+      groupsRef.current = groupByRoute(steps);
+      currentGroupIndexRef.current = 0;
+      transitioningRef.current = false;
+      const groups = groupsRef.current;
+      logger.info(`startTour: grouped into ${groups.length} route groups: ${groups.map((g) => `"${g.route}"(${g.steps.length})`).join(", ")}`);
+      if (groups.length === 0) {
+        logger.warn("startTour: no groups created \u2014 returning");
+        return;
+      }
+      if (!routeMatches(currentRoute, groups[0].route)) {
+        logger.info(
+          `startTour: first group route "${groups[0].route}" != currentRoute "${currentRoute}" \u2014 showing nav popover before redirect`
+        );
+        destroyCurrentDriver();
+        driverRef.current = (0, import_driver.driver)({
+          showProgress: false,
+          animate: true,
+          overlayColor: "rgba(0, 0, 0, 0.6)",
+          steps: [
+            {
+              popover: {
+                title: `Navigating to ${groups[0].route}`,
+                description: "This guide needs to take you to a different page. Click Next to continue.",
+                doneBtnText: "Next \u2192"
+              }
+            }
+          ],
+          onDestroyStarted: () => {
+            const d = driverRef.current;
+            if (!d) return;
+            driverRef.current = null;
+            d.destroy();
+            optionsRef.current.onNavigationNeeded?.(groups[0].route);
+          }
+        });
+        driverRef.current.drive();
+      } else {
+        logger.info(`startTour: first group route matches currentRoute \u2014 calling driveGroup(0)`);
+        driveGroup(0);
+      }
+    },
+    [driveGroup]
+  );
+  const continueAfterNavigation = (0, import_react3.useCallback)(
+    (arrivedRouteOrPattern) => {
+      const groups = groupsRef.current;
+      logger.info(
+        `continueAfterNavigation: arrivedAt="${arrivedRouteOrPattern}", currentGroup=${currentGroupIndexRef.current}, totalGroups=${groups.length}`
+      );
+      const nextIndex = groups.findIndex(
+        (g, i) => i > currentGroupIndexRef.current && (g.route === arrivedRouteOrPattern || routeMatches(arrivedRouteOrPattern, g.route))
+      );
+      if (nextIndex !== -1) {
+        logger.info(`continueAfterNavigation: found next group ${nextIndex}, route="${groups[nextIndex].route}"`);
+        driveGroup(nextIndex);
+      } else if (groups.length > 0 && (groups[0].route === arrivedRouteOrPattern || routeMatches(arrivedRouteOrPattern, groups[0].route)) && currentGroupIndexRef.current === 0) {
+        logger.info("continueAfterNavigation: first group matches \u2014 driving group 0");
+        driveGroup(0);
+      } else {
+        const currentGroup = groups[currentGroupIndexRef.current];
+        if (currentGroup && (currentGroup.route === arrivedRouteOrPattern || routeMatches(arrivedRouteOrPattern, currentGroup.route))) {
+          logger.debug(`continueAfterNavigation: current group already matches "${arrivedRouteOrPattern}" \u2014 duplicate, ignoring`);
+          return;
+        }
+        logger.warn(`continueAfterNavigation: no matching group for "${arrivedRouteOrPattern}" \u2014 ignoring`);
+      }
+    },
+    [driveGroup]
+  );
+  const restoreTour = (0, import_react3.useCallback)(
+    (steps, currentRoute) => {
+      logger.info(`restoreTour: ${steps.length} steps, currentRoute="${currentRoute}"`);
+      allStepsRef.current = steps;
+      groupsRef.current = groupByRoute(steps);
+      currentGroupIndexRef.current = 0;
+      transitioningRef.current = false;
+      const groups = groupsRef.current;
+      logger.info(`restoreTour: grouped into ${groups.length} route groups: ${groups.map((g) => `"${g.route}"(${g.steps.length})`).join(", ")}`);
+      if (groups.length === 0) {
+        logger.warn("restoreTour: no groups \u2014 aborting");
+        return;
+      }
+      const matchingIndex = groups.findIndex(
+        (g) => routeMatches(currentRoute, g.route)
+      );
+      if (matchingIndex !== -1) {
+        logger.info(`restoreTour: found matching group ${matchingIndex}, route="${groups[matchingIndex].route}" \u2014 driving`);
+        driveGroup(matchingIndex);
+      } else {
+        logger.warn(`restoreTour: no group matches currentRoute "${currentRoute}" \u2014 falling back to startTour logic`);
+        if (!routeMatches(currentRoute, groups[0].route)) {
+          optionsRef.current.onNavigationNeeded?.(groups[0].route);
+        } else {
+          driveGroup(0);
+        }
+      }
+    },
+    [driveGroup]
+  );
+  const stopTour = (0, import_react3.useCallback)(() => {
+    logger.info("stopTour: stopping tour and clearing all state");
+    transitioningRef.current = false;
+    clearTransitionTimeout();
+    clearPollInterval();
+    destroyCurrentDriver();
+    allStepsRef.current = [];
+    groupsRef.current = [];
+    currentGroupIndexRef.current = 0;
+  }, []);
+  const nextStep = (0, import_react3.useCallback)(() => {
+    driverRef.current?.moveNext();
+  }, []);
+  const prevStep = (0, import_react3.useCallback)(() => {
+    driverRef.current?.movePrevious();
+  }, []);
+  const goToStep = (0, import_react3.useCallback)((index) => {
+    driverRef.current?.moveTo(index);
+  }, []);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      clearTransitionTimeout();
+      clearPollInterval();
+      destroyCurrentDriver();
+    };
+  }, []);
+  return (0, import_react3.useMemo)(
+    () => ({ startTour, restoreTour, stopTour, nextStep, prevStep, goToStep, continueAfterNavigation }),
+    [startTour, restoreTour, stopTour, nextStep, prevStep, goToStep, continueAfterNavigation]
+  );
+}
+
+// src/NavieoProvider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var NavieoErrorBoundary = class extends import_react4.Component {
+  constructor(props) {
+    super(props);
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError() {
+    return { hasError: true };
+  }
+  componentDidCatch(error, info) {
+    logger.error("Navieo caught a render error:", error, info.componentStack);
+  }
+  render() {
+    if (this.state.hasError) {
+      return this.props.children;
+    }
+    return this.props.children;
+  }
+};
+var NavieoContext = (0, import_react4.createContext)(null);
+var CHAT_STORAGE_KEY = "navieo_chat_history";
+var TOUR_STORAGE_KEY = "navieo_active_tour";
+var MAX_STORED_MESSAGES = 50;
+var CONTEXT_WINDOW = 6;
+var NAV_TIMEOUT_MS = 3e4;
+var MAX_TOUR_STEPS = 50;
+var FETCH_TIMEOUT_MS = 3e4;
+var MIN_REQUEST_INTERVAL_MS = 2e3;
+function sanitizeInput(str) {
+  return str.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "");
+}
+function isValidEndpoint(endpoint) {
+  if (endpoint.startsWith("/")) return true;
+  try {
+    const url = new URL(endpoint);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+    if (typeof window !== "undefined" && url.origin === window.location.origin) return true;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function saveTourState(state) {
+  if (typeof window === "undefined") return;
+  try {
+    if (state) {
+      sessionStorage.setItem(TOUR_STORAGE_KEY, JSON.stringify(state));
+    } else {
+      sessionStorage.removeItem(TOUR_STORAGE_KEY);
+    }
+  } catch {
+  }
+}
+function loadTourState() {
+  if (typeof window === "undefined") return null;
+  try {
+    const stored = sessionStorage.getItem(TOUR_STORAGE_KEY);
+    if (!stored) return null;
+    const parsed = JSON.parse(stored);
+    if (!parsed || !Array.isArray(parsed.steps) || parsed.steps.length === 0 || !parsed.steps.every(
+      (s) => s && typeof s === "object" && typeof s.route === "string" && typeof s.tooltipText === "string"
+    )) {
+      logger.warn("loadTourState: invalid persisted data \u2014 clearing");
+      sessionStorage.removeItem(TOUR_STORAGE_KEY);
+      return null;
+    }
+    return parsed;
+  } catch {
+    try {
+      sessionStorage.removeItem(TOUR_STORAGE_KEY);
+    } catch {
+    }
+  }
+  return null;
+}
+function loadChatHistory() {
+  if (typeof window === "undefined") return [];
+  try {
+    const stored = localStorage.getItem(CHAT_STORAGE_KEY);
+    if (stored) {
+      const parsed = JSON.parse(stored);
+      if (Array.isArray(parsed)) {
+        const valid = parsed.filter(
+          (m) => !!m && typeof m === "object" && (m.role === "user" || m.role === "assistant") && typeof m.content === "string"
+        );
+        return valid.slice(-MAX_STORED_MESSAGES);
+      }
+    }
+  } catch {
+    try {
+      localStorage.removeItem(CHAT_STORAGE_KEY);
+    } catch {
+    }
+  }
+  return [];
+}
+function saveChatHistory(messages) {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.setItem(
+      CHAT_STORAGE_KEY,
+      JSON.stringify(messages.slice(-MAX_STORED_MESSAGES))
+    );
+  } catch {
+  }
+}
+function NavieoProvider({
+  children,
+  currentRoute,
+  onNavigate,
+  apiEndpoint = "/api/guide",
+  appId,
+  suggestions,
+  renderChat = true
+}) {
+  const apiKey = typeof process !== "undefined" ? process.env?.NEXT_PUBLIC_NAVIEO_PUBLISHABLE_KEY : void 0;
+  const [isChatOpen, setIsChatOpen] = (0, import_react4.useState)(false);
+  const [tourState, setTourState] = (0, import_react4.useState)("idle");
+  const [steps, setSteps] = (0, import_react4.useState)([]);
+  const [currentStepIndex, setCurrentStepIndex] = (0, import_react4.useState)(0);
+  const [chatHistory, setChatHistory] = (0, import_react4.useState)(loadChatHistory);
+  (0, import_react4.useEffect)(() => {
+    logger.info("NavieoProvider MOUNTED");
+    return () => {
+      logger.warn("NavieoProvider UNMOUNTED \u2014 cleaning up");
+      tourRef.current.stopTour();
+      if (navTimeoutRef.current) clearTimeout(navTimeoutRef.current);
+      if (startTourDelayRef.current) clearTimeout(startTourDelayRef.current);
+      if (errorRecoveryRef.current) clearTimeout(errorRecoveryRef.current);
+    };
+  }, []);
+  (0, import_react4.useEffect)(() => {
+    saveChatHistory(chatHistory);
+  }, [chatHistory]);
+  (0, import_react4.useEffect)(() => {
+    if (tourState !== "active") return;
+    const handler = (e) => {
+      e.preventDefault();
+    };
+    window.addEventListener("beforeunload", handler);
+    return () => window.removeEventListener("beforeunload", handler);
+  }, [tourState]);
+  const stepsRef = (0, import_react4.useRef)([]);
+  stepsRef.current = steps;
+  const chatHistoryRef = (0, import_react4.useRef)(chatHistory);
+  chatHistoryRef.current = chatHistory;
+  const pendingRouteRef = (0, import_react4.useRef)(null);
+  const resetTour = (0, import_react4.useCallback)(() => {
+    logger.info("resetTour: resetting tour state to idle");
+    setTourState("idle");
+    setSteps([]);
+    setCurrentStepIndex(0);
+    saveTourState(null);
+  }, []);
+  const navTimeoutRef = (0, import_react4.useRef)(null);
+  const startTourDelayRef = (0, import_react4.useRef)(null);
+  const errorRecoveryRef = (0, import_react4.useRef)(null);
+  const clearNavTimeout = (0, import_react4.useCallback)(() => {
+    if (navTimeoutRef.current) {
+      clearTimeout(navTimeoutRef.current);
+      navTimeoutRef.current = null;
+    }
+  }, []);
+  const tour = useTourRenderer({
+    onStepChange: (index) => {
+      logger.debug(`Provider.onStepChange: index=${index}`);
+      setCurrentStepIndex(index);
+    },
+    onComplete: () => {
+      logger.info("Provider.onComplete: tour finished, resetting");
+      clearNavTimeout();
+      pendingRouteRef.current = null;
+      resetTour();
+    },
+    onClose: () => {
+      logger.info("Provider.onClose: tour closed, resetting");
+      clearNavTimeout();
+      pendingRouteRef.current = null;
+      resetTour();
+    },
+    onError: (message) => {
+      logger.error(`Provider.onError: ${message}`);
+      pendingRouteRef.current = null;
+      clearNavTimeout();
+      resetTour();
+      setChatHistory((prev) => [
+        ...prev,
+        {
+          role: "assistant",
+          content: CHAT_MESSAGES.tourError(message)
+        }
+      ]);
+      setIsChatOpen(true);
+    },
+    onNavigationNeeded: (route) => {
+      logger.info(`Provider.onNavigationNeeded: route="${route}", currentRoute="${currentRoute}"`);
+      if (routeMatches(currentRoute, route)) {
+        logger.info(`Provider.onNavigationNeeded: ALREADY on target route \u2014 continuing in 500ms`);
+        saveTourState(null);
+        const timer = setTimeout(() => {
+          logger.debug(`Provider.onNavigationNeeded: delayed continueAfterNavigation("${route}")`);
+          tourRef.current.continueAfterNavigation(route);
+        }, 500);
+        navTimeoutRef.current = timer;
+        return;
+      }
+      pendingRouteRef.current = route;
+      saveTourState({ steps: stepsRef.current, pendingRoute: route });
+      clearNavTimeout();
+      navTimeoutRef.current = setTimeout(() => {
+        if (pendingRouteRef.current) {
+          logger.warn(`Provider: navigation timeout \u2014 route "${route}" not reached after ${NAV_TIMEOUT_MS / 1e3}s, resetting`);
+          pendingRouteRef.current = null;
+          saveTourState(null);
+          tourRef.current.stopTour();
+          resetTour();
+          setChatHistory((prev) => [
+            ...prev,
+            { role: "assistant", content: CHAT_MESSAGES.navigationTimeout }
+          ]);
+          setIsChatOpen(true);
+        }
+      }, NAV_TIMEOUT_MS);
+      if (!route.startsWith("/") || route.startsWith("//")) {
+        logger.error(`Provider.onNavigationNeeded: rejected invalid route "${route}"`);
+        return;
+      }
+      if (isDynamicRoute(route)) {
+        logger.info(`Provider.onNavigationNeeded: dynamic route "${route}" \u2014 waiting for user navigation`);
+      } else {
+        logger.info(`Provider.onNavigationNeeded: static route \u2014 calling onNavigate("${route}")`);
+        onNavigate(route);
+      }
+    }
+  });
+  const tourRef = (0, import_react4.useRef)(tour);
+  tourRef.current = tour;
+  (0, import_react4.useEffect)(() => {
+    const persisted = loadTourState();
+    if (persisted && persisted.steps.length > 0) {
+      logger.info(`Provider: restoring persisted tour: ${persisted.steps.length} steps, pendingRoute="${persisted.pendingRoute}"`);
+      setSteps(persisted.steps);
+      setTourState("active");
+      const timer = setTimeout(() => {
+        saveTourState(null);
+        logger.info("Provider: calling restoreTour from persisted state");
+        tourRef.current.restoreTour(persisted.steps, currentRoute);
+      }, 500);
+      return () => clearTimeout(timer);
+    }
+  }, []);
+  (0, import_react4.useEffect)(() => {
+    logger.debug(
+      `Route watcher fired: currentRoute="${currentRoute}", tourState="${tourState}", stepIndex=${currentStepIndex}, stepsCount=${stepsRef.current.length}, pendingRoute=${pendingRouteRef.current || "null"}`
+    );
+    if (pendingRouteRef.current) {
+      const matches = routeMatches(currentRoute, pendingRouteRef.current);
+      logger.info(`Provider route watcher: currentRoute="${currentRoute}", pending="${pendingRouteRef.current}", matches=${matches}`);
+      if (matches) {
+        const pendingPattern = pendingRouteRef.current;
+        pendingRouteRef.current = null;
+        clearNavTimeout();
+        saveTourState(null);
+        const timer = setTimeout(() => {
+          logger.info(`Provider route watcher: DOM ready, continuing tour for "${pendingPattern}"`);
+          tourRef.current.continueAfterNavigation(pendingPattern);
+        }, 500);
+        return () => clearTimeout(timer);
+      }
+      return;
+    }
+    if (tourState === "active" && stepsRef.current.length > 0) {
+      const currentStepRoute = stepsRef.current[currentStepIndex]?.route;
+      if (currentStepRoute && !routeMatches(currentRoute, currentStepRoute)) {
+        const futureStep = stepsRef.current.find(
+          (s, i) => i > currentStepIndex && routeMatches(currentRoute, s.route)
+        );
+        if (futureStep) {
+          logger.info(`Provider route watcher (Case 2): auto-detected navigation to future step route "${futureStep.route}"`);
+          saveTourState(null);
+          const timer = setTimeout(() => {
+            tourRef.current.continueAfterNavigation(futureStep.route);
+          }, 500);
+          return () => clearTimeout(timer);
+        }
+      }
+    }
+  }, [currentRoute, clearNavTimeout, tourState, currentStepIndex]);
+  const openChat = (0, import_react4.useCallback)(() => setIsChatOpen(true), []);
+  const closeChat = (0, import_react4.useCallback)(() => setIsChatOpen(false), []);
+  const toggleChat = (0, import_react4.useCallback)(() => setIsChatOpen((v) => !v), []);
+  const clearChatHistory = (0, import_react4.useCallback)(() => {
+    setChatHistory([]);
+    saveChatHistory([]);
+  }, []);
+  const abortControllerRef = (0, import_react4.useRef)(null);
+  const lastRequestTimeRef = (0, import_react4.useRef)(0);
+  const startTour = (0, import_react4.useCallback)(
+    async (query) => {
+      const trimmedQuery = sanitizeInput(query.slice(0, 500));
+      logger.info(`Provider.startTour: query="${trimmedQuery}", currentRoute="${currentRoute}"`);
+      const now = Date.now();
+      if (now - lastRequestTimeRef.current < MIN_REQUEST_INTERVAL_MS) {
+        logger.warn("Provider.startTour: request throttled (too fast)");
+        return;
+      }
+      lastRequestTimeRef.current = now;
+      if (!isValidEndpoint(apiEndpoint)) {
+        logger.error(`Provider.startTour: invalid API endpoint "${apiEndpoint}"`);
+        setChatHistory((prev) => [
+          ...prev,
+          { role: "user", content: trimmedQuery },
+          { role: "assistant", content: CHAT_MESSAGES.genericError }
+        ]);
+        setTourState("error");
+        return;
+      }
+      if (abortControllerRef.current) {
+        logger.info("Provider.startTour: aborting previous in-flight request");
+        abortControllerRef.current.abort();
+      }
+      if (startTourDelayRef.current) {
+        clearTimeout(startTourDelayRef.current);
+        startTourDelayRef.current = null;
+      }
+      if (errorRecoveryRef.current) {
+        clearTimeout(errorRecoveryRef.current);
+        errorRecoveryRef.current = null;
+      }
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      const timeoutId = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      setTourState("loading");
+      setChatHistory((prev) => [...prev, { role: "user", content: trimmedQuery }]);
+      try {
+        const headers = { "Content-Type": "application/json" };
+        if (apiKey) headers["x-api-key"] = apiKey;
+        const recentContext = chatHistoryRef.current.slice(-CONTEXT_WINDOW).map((m) => ({ role: m.role, content: m.content }));
+        logger.debug(`Provider.startTour: fetching ${apiEndpoint} with ${recentContext.length} context messages`);
+        const response = await fetch(apiEndpoint, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            query: trimmedQuery,
+            currentRoute,
+            appId,
+            chatContext: recentContext
+          }),
+          signal: controller.signal
+        });
+        logger.debug(`Provider.startTour: API response status=${response.status}`);
+        if (!response.ok) {
+          const errorText = await response.text().catch(() => "");
+          logger.error(`Provider.startTour: API error ${response.status}: ${errorText.slice(0, 200)}`);
+          throw new Error("The guide service returned an error. Please try again.");
+        }
+        let data;
+        try {
+          data = await response.json();
+        } catch {
+          throw new Error("Invalid JSON response from API");
+        }
+        const parsed = data;
+        const steps2 = Array.isArray(parsed?.steps) ? parsed.steps : [];
+        const answer = typeof parsed?.answer === "string" ? parsed.answer : void 0;
+        const error = typeof parsed?.error === "string" ? parsed.error : void 0;
+        logger.info(`Provider.startTour: API returned ${steps2.length} steps, answer=${!!answer}, error=${error || "none"}`);
+        if (error) {
+          logger.warn(`Provider.startTour: API returned error: ${error}`);
+          setTourState("error");
+          setChatHistory((prev) => [
+            ...prev,
+            { role: "assistant", content: CHAT_MESSAGES.genericError }
+          ]);
+          return;
+        }
+        if (steps2.length === 0) {
+          logger.info("Provider.startTour: 0 steps returned \u2014 showing answer text");
+          setTourState("idle");
+          setChatHistory((prev) => [
+            ...prev,
+            {
+              role: "assistant",
+              content: answer || CHAT_MESSAGES.noStepsFound
+            }
+          ]);
+          return;
+        }
+        logger.debugSteps("Provider.startTour: raw steps from API", steps2.map((s, i) => ({
+          step: i + 1,
+          route: s.route,
+          title: s.tooltipTitle || "(no title)",
+          text: (s.tooltipText || "").slice(0, 60) + "...",
+          cssSelector: s.selector?.cssSelector || "(none)",
+          elementId: s.elementId || "(none)"
+        })));
+        const validSteps = steps2.filter(
+          (s) => s && typeof s.route === "string" && typeof s.tooltipText === "string"
+        ).slice(0, MAX_TOUR_STEPS);
+        if (steps2.length > MAX_TOUR_STEPS) {
+          logger.warn(`Provider.startTour: truncated ${steps2.length} steps to ${MAX_TOUR_STEPS}`);
+        }
+        for (const s of validSteps) {
+          s.route = s.route.trim();
+          if (s.elementId) s.elementId = s.elementId.trim();
+          if (s.selector) {
+            if (s.selector.cssSelector) s.selector.cssSelector = s.selector.cssSelector.trim();
+            if (s.selector.testId) s.selector.testId = s.selector.testId.trim();
+            if (s.selector.ariaLabel) s.selector.ariaLabel = s.selector.ariaLabel.trim();
+          }
+        }
+        logger.info(`Provider.startTour: ${validSteps.length}/${steps2.length} steps passed validation`);
+        if (validSteps.length === 0) {
+          logger.warn("Provider.startTour: no valid steps after filtering");
+          setTourState("idle");
+          setChatHistory((prev) => [
+            ...prev,
+            { role: "assistant", content: answer || CHAT_MESSAGES.invalidSteps }
+          ]);
+          return;
+        }
+        setSteps(validSteps);
+        setCurrentStepIndex(0);
+        setTourState("active");
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            role: "assistant",
+            content: answer || CHAT_MESSAGES.tourStarted(validSteps.length)
+          }
+        ]);
+        logger.info("Provider.startTour: closing chat, scheduling tourRenderer.startTour in 300ms");
+        setIsChatOpen(false);
+        if (startTourDelayRef.current) clearTimeout(startTourDelayRef.current);
+        startTourDelayRef.current = setTimeout(() => {
+          startTourDelayRef.current = null;
+          logger.info(`Provider.startTour: 300ms elapsed, calling tourRef.current.startTour(${validSteps.length} steps, "${currentRoute}")`);
+          tourRef.current.startTour(validSteps, currentRoute);
+        }, 300);
+      } catch (err) {
+        if (err instanceof DOMException && err.name === "AbortError") {
+          logger.debug("Provider.startTour: request aborted (superseded by newer request)");
+          return;
+        }
+        logger.error("Provider.startTour: caught exception", err);
+        setTourState("error");
+        setChatHistory((prev) => [
+          ...prev,
+          {
+            role: "assistant",
+            content: CHAT_MESSAGES.genericError
+          }
+        ]);
+        if (errorRecoveryRef.current) clearTimeout(errorRecoveryRef.current);
+        errorRecoveryRef.current = setTimeout(() => {
+          errorRecoveryRef.current = null;
+          setTourState("idle");
+        }, 2e3);
+      } finally {
+        clearTimeout(timeoutId);
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+        }
+      }
+    },
+    [apiEndpoint, currentRoute, appId, apiKey]
+  );
+  const nextStep = (0, import_react4.useCallback)(() => tourRef.current.nextStep(), []);
+  const prevStep = (0, import_react4.useCallback)(() => tourRef.current.prevStep(), []);
+  const endTour = (0, import_react4.useCallback)(() => {
+    logger.info("Provider.endTour: user explicitly stopped tour");
+    pendingRouteRef.current = null;
+    clearNavTimeout();
+    saveTourState(null);
+    tourRef.current.stopTour();
+    resetTour();
+  }, [resetTour, clearNavTimeout]);
+  const goToStep = (0, import_react4.useCallback)(
+    (index) => {
+      if (index >= 0 && index < steps.length) tourRef.current.goToStep(index);
+    },
+    [steps.length]
+  );
+  const currentStep = steps[currentStepIndex] ?? null;
+  const value = (0, import_react4.useMemo)(
+    () => ({
+      isChatOpen,
+      openChat,
+      closeChat,
+      toggleChat,
+      tourState,
+      steps,
+      currentStepIndex,
+      currentStep,
+      startTour,
+      nextStep,
+      prevStep,
+      endTour,
+      goToStep,
+      chatHistory,
+      clearChatHistory,
+      currentRoute,
+      suggestions
+    }),
+    [
+      isChatOpen,
+      openChat,
+      closeChat,
+      toggleChat,
+      tourState,
+      steps,
+      currentStepIndex,
+      currentStep,
+      startTour,
+      nextStep,
+      prevStep,
+      endTour,
+      goToStep,
+      chatHistory,
+      clearChatHistory,
+      currentRoute,
+      suggestions
+    ]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(NavieoContext.Provider, { value, children: [
+    children,
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(NavieoErrorBoundary, { children: renderChat && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(ChatWidget, {}) })
+  ] });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ChatWidget,
+  NavieoProvider,
+  logger,
+  useNavieo,
+  useTourRenderer
+});
+//# sourceMappingURL=index.js.map