@burdenoff/website-sdk 2026.824.2 → 2026.828.1

package/dist/hooks/index.mjs

@@ -0,0 +1,1140 @@
+import { createContext, useMemo, useState, useRef, useCallback, useEffect, useContext } from 'react';
+import 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/client/security.ts
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+var RESERVED_HEADERS = /* @__PURE__ */ new Set([
+  "authorization",
+  "cookie",
+  "x-actor-id",
+  "x-actor-type",
+  "x-consent-granted-by",
+  "x-consent-scope",
+  "x-consent-granted-at",
+  "x-consent-expires-at"
+]);
+function validateGatewayUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Gateway URL must be a valid absolute URL");
+  }
+  if (url.protocol === "https:") {
+    return url.toString();
+  }
+  if (url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname.toLowerCase())) {
+    return url.toString();
+  }
+  throw new Error("Gateway URL must use HTTPS unless it targets localhost");
+}
+function sanitizeHeaders(headers) {
+  if (!headers) return void 0;
+  return Object.fromEntries(
+    Object.entries(headers).filter(
+      ([key]) => !RESERVED_HEADERS.has(key.toLowerCase())
+    )
+  );
+}
+
+// src/client/graphql-client.ts
+var _WebSDKClient = class _WebSDKClient {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "queryCache", /* @__PURE__ */ new Map());
+    __publicField(this, "inflight", /* @__PURE__ */ new Map());
+    this.config = {
+      ...config,
+      gatewayUrl: validateGatewayUrl(config.gatewayUrl),
+      headers: sanitizeHeaders(config.headers)
+    };
+  }
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Execute a GraphQL query (with deduplication and caching).
+   *
+   * Pass `{ cache: false }` to bypass the cache entirely — required for poll
+   * loops, where every tick must reach the network.
+   */
+  async query(query, variables, options) {
+    if (options?.cache === false) {
+      return this.request(query, variables, true, options.timeoutMs);
+    }
+    const cacheKey = JSON.stringify({ query, variables });
+    const cached = this.queryCache.get(cacheKey);
+    if (cached) {
+      if (Date.now() - cached.ts < _WebSDKClient.CACHE_TTL) {
+        return cached.data;
+      }
+      this.queryCache.delete(cacheKey);
+    }
+    const existing = this.inflight.get(cacheKey);
+    if (existing) {
+      return existing;
+    }
+    const promise = this.request(query, variables, true, options?.timeoutMs).then((result) => {
+      if (result.data && !result.errors?.length) {
+        if (this.queryCache.size >= _WebSDKClient.MAX_CACHE_ENTRIES) {
+          const oldestEntry = this.queryCache.keys().next().value;
+          if (oldestEntry) {
+            this.queryCache.delete(oldestEntry);
+          }
+        }
+        this.queryCache.set(cacheKey, { data: result, ts: Date.now() });
+      }
+      return result;
+    }).finally(() => {
+      this.inflight.delete(cacheKey);
+    });
+    this.inflight.set(cacheKey, promise);
+    return promise;
+  }
+  /**
+   * Execute a GraphQL mutation
+   */
+  async mutate(mutation, variables, options) {
+    return this.request(mutation, variables, false, options?.timeoutMs);
+  }
+  /** HTTP statuses worth another attempt — transient server/edge conditions. */
+  static isRetriableStatus(status) {
+    return status === 429 || status === 408 || status >= 500 && status < 600;
+  }
+  static sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * Perform the HTTP call with a hard timeout. Every outcome resolves to a
+   * GraphQLResponse — callers never hang, so a UI's `loading` state always
+   * settles into data or a renderable error.
+   */
+  async attempt(query, variables, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(this.config.gatewayUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-product-id": this.config.productId,
+          ...this.config.headers
+        },
+        body: JSON.stringify({ query, variables }),
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        console.error(
+          "[WebSDK] GraphQL request failed",
+          response.status,
+          response.statusText
+        );
+        return {
+          res: {
+            errors: [
+              {
+                message: `HTTP ${response.status}: ${response.statusText}`,
+                extensions: { code: `HTTP_${response.status}` }
+              }
+            ]
+          },
+          retriable: _WebSDKClient.isRetriableStatus(response.status)
+        };
+      }
+      return {
+        res: await response.json(),
+        retriable: false
+      };
+    } catch (error) {
+      const aborted = error instanceof Error && (error.name === "AbortError" || controller.signal.aborted);
+      const message = aborted ? `Request timed out after ${timeoutMs}ms` : error instanceof Error ? error.message : "Network error";
+      console.error("[WebSDK] Network error", message);
+      return {
+        res: {
+          errors: [
+            {
+              message,
+              extensions: { code: aborted ? "TIMEOUT" : "NETWORK_ERROR" }
+            }
+          ]
+        },
+        // Transport-level failures are worth one more try; a genuine outage
+        // just fails twice quickly and still renders an error state.
+        retriable: true
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async request(query, variables, retry = true, timeoutOverrideMs) {
+    const timeoutMs = timeoutOverrideMs ?? this.config.timeoutMs ?? _WebSDKClient.DEFAULT_TIMEOUT_MS;
+    const maxRetries = retry ? this.config.maxRetries ?? _WebSDKClient.DEFAULT_MAX_RETRIES : 0;
+    let last;
+    for (let i = 0; i <= maxRetries; i++) {
+      const { res, retriable } = await this.attempt(
+        query,
+        variables,
+        timeoutMs
+      );
+      if (!retriable || i === maxRetries) return res;
+      last = res;
+      await _WebSDKClient.sleep(
+        _WebSDKClient.RETRY_BASE_DELAY_MS * (i + 1) + Math.random() * 200
+      );
+    }
+    return last;
+  }
+};
+__publicField(_WebSDKClient, "CACHE_TTL", 5 * 60 * 1e3);
+// 5 minutes
+__publicField(_WebSDKClient, "MAX_CACHE_ENTRIES", 100);
+__publicField(_WebSDKClient, "DEFAULT_TIMEOUT_MS", 12e3);
+__publicField(_WebSDKClient, "DEFAULT_MAX_RETRIES", 1);
+__publicField(_WebSDKClient, "RETRY_BASE_DELAY_MS", 400);
+var WebSDKContext = createContext(null);
+function useWebSDK() {
+  const client = useContext(WebSDKContext);
+  if (!client) {
+    throw new Error("useWebSDK must be used within a WebSDKProvider");
+  }
+  return client;
+}
+
+// src/components/explore-types.ts
+var EXPLORE_MESSAGE_FIELDS = (
+  /* GraphQL */
+  `
+  id
+  conversationId
+  role
+  status
+  content
+  partialContent
+  activity
+  references {
+    url
+    title
+    description
+    product
+    imageUrl
+  }
+  ctas {
+    kind
+    label
+    url
+    product
+  }
+  errorCode
+  createdAt
+  completedAt
+`
+);
+var EXPLORE_CATALOG_QUERY = (
+  /* GraphQL */
+  `
+  query ExploreCatalog($productSlug: String) {
+    exploreCatalog(productSlug: $productSlug) {
+      enabled
+      products {
+        slug
+        name
+        tagline
+        website
+      }
+      examplePrompts
+      welcomeTitle
+      welcomeBody
+      limits {
+        maxMessageLength
+        maxTurnsPerConversation
+        messagesPerDay
+        historyTurns
+      }
+      captchaRequired
+      recaptchaSiteKey
+    }
+  }
+`
+);
+var EXPLORE_MESSAGE_QUERY = (
+  /* GraphQL */
+  `
+  query ExploreMessage($conversationToken: String!, $id: ID!) {
+    exploreMessage(conversationToken: $conversationToken, id: $id) {
+      ${EXPLORE_MESSAGE_FIELDS}
+    }
+  }
+`
+);
+var SEND_EXPLORE_MESSAGE_MUTATION = (
+  /* GraphQL */
+  `
+  mutation SendExploreMessage($input: SendExploreMessageInput!) {
+    sendExploreMessage(input: $input) {
+      conversation {
+        id
+        token
+        productSlug
+        turnCount
+        createdAt
+      }
+      userMessage {
+        ${EXPLORE_MESSAGE_FIELDS}
+      }
+      assistantMessage {
+        ${EXPLORE_MESSAGE_FIELDS}
+      }
+      remainingToday
+    }
+  }
+`
+);
+
+// src/data/products.ts
+var ECOSYSTEM_PRODUCTS = [
+  {
+    slug: "workspaces",
+    name: "Workspaces",
+    websiteUrl: "https://burdenoff.com"
+  },
+  {
+    slug: "vibecontrols",
+    name: "VibeControls",
+    websiteUrl: "https://vibecontrols.com"
+  },
+  {
+    slug: "fluidgrids",
+    name: "FluidGrids",
+    websiteUrl: "https://fluidgrids.com"
+  },
+  // Botlit ships on botlit.ai — botlit.com does not resolve.
+  { slug: "botlit", name: "Botlit", websiteUrl: "https://www.botlit.ai" },
+  {
+    slug: "bigconsole",
+    name: "BigConsole",
+    websiteUrl: "https://bigconsole.com"
+  },
+  {
+    slug: "semanticfed",
+    name: "SemanticFed",
+    websiteUrl: "https://semanticfed.com"
+  },
+  {
+    slug: "intelwatchtower",
+    name: "IntelWatchtower",
+    websiteUrl: "https://intelwatchtower.com"
+  },
+  { slug: "buildmyiq", name: "BuildMyIQ", websiteUrl: "https://buildmyiq.com" },
+  {
+    slug: "assethandler",
+    name: "AssetHandler",
+    websiteUrl: "https://assethandler.com"
+  },
+  {
+    slug: "crewfoundry",
+    name: "CrewFoundry",
+    websiteUrl: "https://crewfoundry.com"
+  },
+  {
+    slug: "planmagnet",
+    name: "PlanMagnet",
+    websiteUrl: "https://planmagnet.com"
+  },
+  {
+    slug: "eventfullymanaged",
+    name: "EventfullyManaged",
+    websiteUrl: "https://eventfullymanaged.com"
+  },
+  {
+    slug: "headshotmarketing",
+    name: "HeadshotMarketing",
+    websiteUrl: "https://headshotmarketing.com"
+  },
+  {
+    slug: "technospam",
+    name: "TechnoSpam",
+    websiteUrl: "https://technospam.com"
+  },
+  { slug: "kadaikodi", name: "Kadaikodi", websiteUrl: "https://kadaikodi.com" },
+  {
+    slug: "movethewheels",
+    name: "MoveTheWheels",
+    websiteUrl: "https://movethewheels.com"
+  },
+  {
+    slug: "healthybowl",
+    name: "Healthy Bowl",
+    websiteUrl: "https://gethealthybowl.com"
+  },
+  { slug: "ggnomad", name: "GGNomad", websiteUrl: "https://ggnomad.com" },
+  {
+    slug: "timecampus",
+    name: "TimeCampus",
+    websiteUrl: "https://timecampus.com"
+  },
+  {
+    slug: "manufacturedops",
+    name: "ManufacturedOps",
+    websiteUrl: "https://manufacturedops.com"
+  },
+  {
+    slug: "theglobalfuel",
+    name: "TheGlobalFuel",
+    websiteUrl: "https://theglobalfuel.com"
+  },
+  {
+    slug: "housingvista",
+    name: "HousingVista",
+    websiteUrl: "https://housingvista.com"
+  },
+  {
+    slug: "proserviceworld",
+    name: "ProServiceWorld",
+    websiteUrl: "https://proserviceworld.com"
+  },
+  {
+    slug: "mybodyshield",
+    name: "MyBodyShield",
+    websiteUrl: "https://mybodyshield.com"
+  },
+  {
+    slug: "artistrybase",
+    name: "ArtistryBase",
+    websiteUrl: "https://artistrybase.com"
+  },
+  {
+    slug: "theculturepost",
+    name: "TheCulturePost",
+    websiteUrl: "https://theculturepost.com"
+  },
+  { slug: "collabkin", name: "CollabKin", websiteUrl: "https://collabkin.com" },
+  {
+    slug: "comradecircle",
+    name: "ComradeCircle",
+    websiteUrl: "https://comradecircle.com"
+  },
+  {
+    slug: "brainyrich",
+    name: "BrainyRich",
+    websiteUrl: "https://brainyrich.com"
+  },
+  {
+    slug: "cosmicintersection",
+    name: "CosmicIntersection",
+    websiteUrl: "https://cosmicintersection.com"
+  },
+  {
+    slug: "govcitizenhub",
+    name: "GovCitizenHub",
+    websiteUrl: "https://govcitizenhub.com"
+  },
+  {
+    slug: "adaptercloud",
+    name: "AdapterCloud",
+    websiteUrl: "https://adaptercloud.com"
+  },
+  {
+    slug: "subscriberbot",
+    name: "Subscriber Bot",
+    websiteUrl: "https://subscriberbot.com"
+  },
+  {
+    slug: "hookmovies",
+    name: "HookMovies",
+    websiteUrl: "https://hookmovies.com"
+  },
+  {
+    slug: "coolandlovely",
+    name: "CoolAndLovely",
+    websiteUrl: "https://coolandlovely.com"
+  },
+  {
+    slug: "atheletebridge",
+    name: "AthleteBridge",
+    websiteUrl: "https://atheletebridge.com"
+  },
+  {
+    slug: "labsofscience",
+    name: "LabsOfScience",
+    websiteUrl: "https://labsofscience.com"
+  },
+  {
+    slug: "ecoimpacthub",
+    name: "EcoImpactHub",
+    websiteUrl: "https://ecoimpacthub.com"
+  }
+];
+
+// src/utils/recaptcha-v3.ts
+var SCRIPT_ID = "boff-recaptcha-v3";
+var SCRIPT_SRC = "https://www.google.com/recaptcha/api.js?render=";
+var EXPLORE_RECAPTCHA_ACTION = "explore_chat";
+var loaders = /* @__PURE__ */ new Map();
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+function loadRecaptchaV3(siteKey) {
+  if (!siteKey) {
+    return Promise.reject(new Error("reCAPTCHA site key is required"));
+  }
+  if (!isBrowser()) {
+    return Promise.reject(
+      new Error("reCAPTCHA v3 can only be loaded in a browser")
+    );
+  }
+  const existing = loaders.get(siteKey);
+  if (existing) return existing;
+  const promise = new Promise((resolve, reject) => {
+    const ready = () => {
+      const api = window.grecaptcha;
+      if (!api) {
+        reject(new Error("reCAPTCHA loaded but grecaptcha is unavailable"));
+        return;
+      }
+      api.ready(() => resolve(api));
+    };
+    if (window.grecaptcha) {
+      ready();
+      return;
+    }
+    const scriptId = `${SCRIPT_ID}-${siteKey}`;
+    const found = document.getElementById(scriptId);
+    if (found) {
+      found.addEventListener("load", ready, { once: true });
+      found.addEventListener(
+        "error",
+        () => reject(new Error("Failed to load reCAPTCHA v3")),
+        { once: true }
+      );
+      return;
+    }
+    const script = document.createElement("script");
+    script.id = scriptId;
+    script.src = `${SCRIPT_SRC}${encodeURIComponent(siteKey)}`;
+    script.async = true;
+    script.defer = true;
+    script.addEventListener("load", ready, { once: true });
+    script.addEventListener(
+      "error",
+      () => {
+        loaders.delete(siteKey);
+        reject(new Error("Failed to load reCAPTCHA v3"));
+      },
+      { once: true }
+    );
+    document.head.appendChild(script);
+  });
+  loaders.set(siteKey, promise);
+  return promise;
+}
+async function getRecaptchaV3Token(siteKey, action = EXPLORE_RECAPTCHA_ACTION) {
+  const api = await loadRecaptchaV3(siteKey);
+  return api.execute(siteKey, { action });
+}
+
+// src/hooks/use-explore-chat.ts
+var DEFAULT_STORAGE_KEY = "boff.explore.v1";
+var DEFAULT_POLL_INTERVAL_MS = 1500;
+var DEFAULT_POLL_TIMEOUT_MS = 9e4;
+var POLL_REQUEST_TIMEOUT_MS = 1e4;
+var SEND_REQUEST_TIMEOUT_MS = 18e3;
+var MAX_CONSECUTIVE_POLL_FAILURES = 4;
+var MAX_PERSISTED_MESSAGES = 40;
+var FALLBACK_EXPLORE_LIMITS = {
+  maxMessageLength: 2e3,
+  maxTurnsPerConversation: 20,
+  messagesPerDay: 100,
+  historyTurns: 6
+};
+var DEFAULT_EXPLORE_EXAMPLE_PROMPTS = [
+  "What does this product actually do?",
+  "Which Burdenoff product fits my team?",
+  "How do I get started, step by step?",
+  "What does it integrate with?"
+];
+var FALLBACK_WELCOME_TITLE = "Ask anything about our products";
+var FALLBACK_WELCOME_BODY = "Get straight answers drawn from our product documentation and public pages \u2014 with links back to the exact page each answer came from.";
+function buildFallbackCatalog(examplePrompts) {
+  return {
+    enabled: true,
+    products: ECOSYSTEM_PRODUCTS.map((p) => ({
+      slug: p.slug,
+      name: p.name,
+      tagline: null,
+      website: p.websiteUrl
+    })),
+    examplePrompts: examplePrompts?.length ? examplePrompts : DEFAULT_EXPLORE_EXAMPLE_PROMPTS,
+    welcomeTitle: FALLBACK_WELCOME_TITLE,
+    welcomeBody: FALLBACK_WELCOME_BODY,
+    limits: FALLBACK_EXPLORE_LIMITS,
+    captchaRequired: false,
+    recaptchaSiteKey: null
+  };
+}
+function normalizeCatalog(raw, fallback) {
+  return {
+    enabled: raw.enabled !== false,
+    products: raw.products?.length ? raw.products : fallback.products,
+    examplePrompts: raw.examplePrompts?.length ? raw.examplePrompts : fallback.examplePrompts,
+    welcomeTitle: raw.welcomeTitle || fallback.welcomeTitle,
+    welcomeBody: raw.welcomeBody || fallback.welcomeBody,
+    limits: {
+      maxMessageLength: raw.limits?.maxMessageLength || fallback.limits.maxMessageLength,
+      maxTurnsPerConversation: raw.limits?.maxTurnsPerConversation || fallback.limits.maxTurnsPerConversation,
+      messagesPerDay: raw.limits?.messagesPerDay || fallback.limits.messagesPerDay,
+      historyTurns: raw.limits?.historyTurns || fallback.limits.historyTurns
+    },
+    captchaRequired: raw.captchaRequired === true,
+    recaptchaSiteKey: raw.recaptchaSiteKey ?? null
+  };
+}
+var RATE_LIMIT_CODES = /* @__PURE__ */ new Set([
+  "RATE_LIMITED",
+  "HTTP_429",
+  "EXPLORE_GLOBAL_LIMIT"
+]);
+var CAPTCHA_CODES = /* @__PURE__ */ new Set(["CAPTCHA_FAILED", "CAPTCHA_REQUIRED"]);
+var NETWORK_CODES = /* @__PURE__ */ new Set([
+  "NETWORK_ERROR",
+  "UPSTREAM_UNAVAILABLE",
+  "CONVERSATION_BUSY",
+  "PROVIDER_ERROR",
+  "QUEUE_FULL"
+]);
+var VALIDATION_CODES = /* @__PURE__ */ new Set([
+  "MESSAGE_TOO_LONG",
+  "MESSAGE_EMPTY",
+  "CONVERSATION_LIMIT",
+  "INVALID_INPUT"
+]);
+function classifyExploreError(code, serverMessage) {
+  const c = code ?? "UNKNOWN";
+  if (RATE_LIMIT_CODES.has(c)) {
+    return {
+      kind: "rate-limit",
+      code: c,
+      message: "You've reached the message limit for now. Please try again later.",
+      retryable: false
+    };
+  }
+  if (CAPTCHA_CODES.has(c)) {
+    return {
+      kind: "captcha",
+      code: c,
+      message: "We couldn't verify that you're human. Please try sending that again.",
+      retryable: true
+    };
+  }
+  if (c === "TIMEOUT" || c === "TOOL_BUDGET") {
+    return {
+      kind: "timeout",
+      code: c,
+      message: "That answer took too long to come back. Try asking again.",
+      retryable: true
+    };
+  }
+  if (NETWORK_CODES.has(c)) {
+    return {
+      kind: "network",
+      code: c,
+      message: "We couldn't reach the assistant just now. Check your connection and try again.",
+      retryable: true
+    };
+  }
+  if (c === "EXPLORE_DISABLED") {
+    return {
+      kind: "disabled",
+      code: c,
+      message: "Explore is unavailable at the moment. Please check back soon.",
+      retryable: false
+    };
+  }
+  if (VALIDATION_CODES.has(c)) {
+    return {
+      kind: "validation",
+      code: c,
+      message: serverMessage || "That message couldn't be sent.",
+      retryable: false
+    };
+  }
+  if (c === "EMPTY_ANSWER") {
+    return {
+      kind: "unknown",
+      code: c,
+      message: "No answer came back for that one. Try rephrasing, or ask something more specific.",
+      retryable: true
+    };
+  }
+  return {
+    kind: "unknown",
+    code: c,
+    message: serverMessage || "Something went wrong. Please try again.",
+    retryable: true
+  };
+}
+function readPersisted(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.sessionStorage.getItem(key);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    const record = parsed;
+    return {
+      conversationToken: typeof record.conversationToken === "string" ? record.conversationToken : null,
+      messages: Array.isArray(record.messages) ? record.messages.slice(-MAX_PERSISTED_MESSAGES) : [],
+      focusProduct: typeof record.focusProduct === "string" ? record.focusProduct : null
+    };
+  } catch {
+    return null;
+  }
+}
+function visibleText(message) {
+  return message.content || message.partialContent || "";
+}
+function countUserTurns(messages) {
+  return messages.filter((m) => m.role === "USER").length;
+}
+function useExploreChat(options = {}) {
+  const {
+    productSlug,
+    pageUrl,
+    locale,
+    examplePrompts,
+    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    pollTimeoutMs = DEFAULT_POLL_TIMEOUT_MS,
+    storageKey = DEFAULT_STORAGE_KEY,
+    persist = true,
+    onSend
+  } = options;
+  const client = useWebSDK();
+  const promptKey = JSON.stringify(examplePrompts ?? []);
+  const fallbackCatalog = useMemo(
+    () => buildFallbackCatalog(JSON.parse(promptKey)),
+    [promptKey]
+  );
+  const [catalog, setCatalog] = useState(fallbackCatalog);
+  const [messages, setMessages] = useState([]);
+  const [phase, setPhase] = useState("loading");
+  const [error, setError] = useState(null);
+  const [remainingToday, setRemainingToday] = useState(null);
+  const [focusProduct, setFocusProductState] = useState(null);
+  const [turnCount, setTurnCount] = useState(0);
+  const [hydrated, setHydrated] = useState(false);
+  const mountedRef = useRef(true);
+  const pollGenerationRef = useRef(0);
+  const pollTimerRef = useRef(null);
+  const conversationTokenRef = useRef(null);
+  const catalogRef = useRef(fallbackCatalog);
+  const turnCountRef = useRef(0);
+  const focusProductRef = useRef(null);
+  const lastSentTextRef = useRef(null);
+  const inFlightRef = useRef(false);
+  catalogRef.current = catalog;
+  const clearPollTimer = useCallback(() => {
+    if (pollTimerRef.current !== null) {
+      clearTimeout(pollTimerRef.current);
+      pollTimerRef.current = null;
+    }
+  }, []);
+  const cancelPolling = useCallback(() => {
+    pollGenerationRef.current += 1;
+    clearPollTimer();
+  }, [clearPollTimer]);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      pollGenerationRef.current += 1;
+      if (pollTimerRef.current !== null) {
+        clearTimeout(pollTimerRef.current);
+        pollTimerRef.current = null;
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (!persist) {
+      setHydrated(true);
+      return;
+    }
+    const stored = readPersisted(storageKey);
+    if (stored) {
+      conversationTokenRef.current = stored.conversationToken;
+      focusProductRef.current = stored.focusProduct;
+      const settled = stored.messages.flatMap((m) => {
+        if (m.role !== "ASSISTANT") return [m];
+        if (m.status !== "PENDING" && m.status !== "RUNNING") return [m];
+        const text = visibleText(m);
+        if (!text) return [];
+        return [{ ...m, status: "COMPLETED", content: text }];
+      });
+      setMessages(settled);
+      setFocusProductState(stored.focusProduct);
+      const turns = countUserTurns(settled);
+      turnCountRef.current = turns;
+      setTurnCount(turns);
+    }
+    setHydrated(true);
+  }, [persist, storageKey]);
+  useEffect(() => {
+    if (!persist || !hydrated || typeof window === "undefined") return;
+    try {
+      const payload = {
+        conversationToken: conversationTokenRef.current,
+        messages: messages.slice(-MAX_PERSISTED_MESSAGES),
+        focusProduct
+      };
+      if (!payload.conversationToken && payload.messages.length === 0 && !payload.focusProduct) {
+        window.sessionStorage.removeItem(storageKey);
+        return;
+      }
+      window.sessionStorage.setItem(storageKey, JSON.stringify(payload));
+    } catch {
+    }
+  }, [persist, hydrated, storageKey, messages, focusProduct]);
+  useEffect(() => {
+    let cancelled = false;
+    const load = async () => {
+      const res = await client.query(
+        EXPLORE_CATALOG_QUERY,
+        { productSlug: productSlug ?? null }
+      );
+      if (cancelled || !mountedRef.current) return;
+      const raw = res.data?.exploreCatalog;
+      if (res.errors?.length || !raw) {
+        console.warn(
+          "[WebSDK] exploreCatalog unavailable \u2014 using the built-in fallback catalog",
+          res.errors?.[0]?.message
+        );
+        setPhase((prev) => prev === "loading" ? "ready" : prev);
+        return;
+      }
+      const next = normalizeCatalog(raw, fallbackCatalog);
+      setCatalog(next);
+      catalogRef.current = next;
+      setPhase((prev) => {
+        if (!next.enabled) return "disabled";
+        return prev === "loading" ? "ready" : prev;
+      });
+    };
+    void load();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, productSlug, fallbackCatalog]);
+  const startPolling = useCallback(
+    (conversationToken, messageId) => {
+      pollGenerationRef.current += 1;
+      const generation = pollGenerationRef.current;
+      const startedAt = Date.now();
+      let consecutiveFailures = 0;
+      const isStale = () => !mountedRef.current || generation !== pollGenerationRef.current;
+      const finishWithError = (chatError) => {
+        inFlightRef.current = false;
+        setMessages(
+          (prev) => prev.flatMap((m) => {
+            if (m.id !== messageId) return [m];
+            const text = visibleText(m);
+            if (!text) return [];
+            return [{ ...m, status: "FAILED", content: text }];
+          })
+        );
+        setError(chatError);
+        setPhase(chatError.kind === "rate-limit" ? "limited" : "error");
+      };
+      const tick = async () => {
+        if (isStale()) return;
+        if (Date.now() - startedAt > pollTimeoutMs) {
+          finishWithError(classifyExploreError("TIMEOUT"));
+          return;
+        }
+        const res = await client.query(
+          EXPLORE_MESSAGE_QUERY,
+          { conversationToken, id: messageId },
+          { cache: false, timeoutMs: POLL_REQUEST_TIMEOUT_MS }
+        );
+        if (isStale()) return;
+        const first = res.errors?.[0];
+        if (first) {
+          const code = typeof first.extensions?.code === "string" ? first.extensions.code : void 0;
+          const classified = classifyExploreError(code, first.message);
+          if (!classified.retryable) {
+            finishWithError(classified);
+            return;
+          }
+          consecutiveFailures += 1;
+          if (consecutiveFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
+            finishWithError(classified);
+            return;
+          }
+          pollTimerRef.current = setTimeout(() => void tick(), pollIntervalMs);
+          return;
+        }
+        const message = res.data?.exploreMessage;
+        if (!message) {
+          consecutiveFailures += 1;
+          if (consecutiveFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
+            finishWithError(classifyExploreError("NOT_FOUND"));
+            return;
+          }
+          pollTimerRef.current = setTimeout(() => void tick(), pollIntervalMs);
+          return;
+        }
+        consecutiveFailures = 0;
+        setMessages(
+          (prev) => prev.map((m) => m.id === messageId ? message : m)
+        );
+        if (message.status === "COMPLETED") {
+          inFlightRef.current = false;
+          setError(null);
+          setPhase("ready");
+          return;
+        }
+        if (message.status === "FAILED") {
+          finishWithError(
+            classifyExploreError(message.errorCode ?? "UPSTREAM_UNAVAILABLE")
+          );
+          return;
+        }
+        setPhase("streaming");
+        pollTimerRef.current = setTimeout(() => void tick(), pollIntervalMs);
+      };
+      pollTimerRef.current = setTimeout(() => void tick(), pollIntervalMs);
+    },
+    [client, pollIntervalMs, pollTimeoutMs]
+  );
+  const submit = useCallback(
+    async (text, optimisticId, captchaAttempt) => {
+      const activeCatalog = catalogRef.current;
+      let recaptchaToken;
+      if (activeCatalog.captchaRequired && activeCatalog.recaptchaSiteKey) {
+        try {
+          recaptchaToken = await getRecaptchaV3Token(
+            activeCatalog.recaptchaSiteKey
+          );
+        } catch (err) {
+          console.warn("[WebSDK] reCAPTCHA v3 token could not be minted", err);
+        }
+      }
+      const input = {
+        message: text,
+        ...conversationTokenRef.current ? { conversationToken: conversationTokenRef.current } : {},
+        ...focusProductRef.current || productSlug ? { productSlug: focusProductRef.current ?? productSlug } : {},
+        ...recaptchaToken ? { recaptchaToken } : {},
+        ...locale ? { locale } : {},
+        ...pageUrl ? { pageUrl } : {}
+      };
+      const res = await client.mutate(
+        SEND_EXPLORE_MESSAGE_MUTATION,
+        { input },
+        { timeoutMs: SEND_REQUEST_TIMEOUT_MS }
+      );
+      if (!mountedRef.current) return;
+      const first = res.errors?.[0];
+      const result = res.data?.sendExploreMessage;
+      if (first || !result) {
+        const code = typeof first?.extensions?.code === "string" ? first.extensions.code : void 0;
+        const classified = classifyExploreError(code, first?.message);
+        if (classified.kind === "captcha" && captchaAttempt === 0) {
+          await submit(text, optimisticId, 1);
+          return;
+        }
+        inFlightRef.current = false;
+        setError(classified);
+        setPhase(classified.kind === "rate-limit" ? "limited" : "error");
+        return;
+      }
+      conversationTokenRef.current = result.conversation.token;
+      turnCountRef.current = result.conversation.turnCount;
+      setTurnCount(result.conversation.turnCount);
+      setRemainingToday(result.remainingToday ?? null);
+      const userMessage = result.userMessage;
+      const assistantMessage = result.assistantMessage;
+      setMessages((prev) => {
+        const replaced = prev.some((m) => m.id === optimisticId) ? prev.map((m) => m.id === optimisticId ? userMessage : m) : [...prev, userMessage];
+        return [...replaced, assistantMessage];
+      });
+      if (assistantMessage.status === "COMPLETED" || assistantMessage.status === "FAILED") {
+        inFlightRef.current = false;
+        if (assistantMessage.status === "FAILED") {
+          const classified = classifyExploreError(
+            assistantMessage.errorCode ?? "UPSTREAM_UNAVAILABLE"
+          );
+          setError(classified);
+          setPhase("error");
+        } else {
+          setPhase("ready");
+        }
+        return;
+      }
+      setPhase("streaming");
+      startPolling(result.conversation.token, assistantMessage.id);
+    },
+    [client, locale, pageUrl, productSlug, startPolling]
+  );
+  const send = useCallback(
+    async (message) => {
+      const text = message.trim();
+      if (!text) return;
+      if (inFlightRef.current) return;
+      const activeCatalog = catalogRef.current;
+      if (!activeCatalog.enabled) {
+        setError(classifyExploreError("EXPLORE_DISABLED"));
+        setPhase("disabled");
+        return;
+      }
+      if (text.length > activeCatalog.limits.maxMessageLength) {
+        setError({
+          kind: "validation",
+          code: "MESSAGE_TOO_LONG",
+          message: `That message is ${text.length} characters \u2014 the limit is ${activeCatalog.limits.maxMessageLength}.`,
+          retryable: false
+        });
+        return;
+      }
+      if (turnCountRef.current >= activeCatalog.limits.maxTurnsPerConversation) {
+        setError({
+          kind: "validation",
+          code: "CONVERSATION_LIMIT",
+          message: `This conversation has reached its ${activeCatalog.limits.maxTurnsPerConversation}-message limit. Start a new chat to keep going.`,
+          retryable: false
+        });
+        return;
+      }
+      inFlightRef.current = true;
+      lastSentTextRef.current = text;
+      setError(null);
+      setPhase("sending");
+      cancelPolling();
+      const optimistic = {
+        id: makeOptimisticId(),
+        conversationId: conversationTokenRef.current ?? "pending",
+        role: "USER",
+        status: "COMPLETED",
+        content: text,
+        partialContent: null,
+        activity: [],
+        references: [],
+        ctas: [],
+        errorCode: null,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+        completedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setMessages((prev) => [...prev, optimistic]);
+      turnCountRef.current += 1;
+      setTurnCount(turnCountRef.current);
+      onSend?.(text);
+      try {
+        await submit(text, optimistic.id, 0);
+      } catch (err) {
+        if (!mountedRef.current) return;
+        console.error("[WebSDK] Explore send failed", err);
+        inFlightRef.current = false;
+        setError(classifyExploreError("NETWORK_ERROR"));
+        setPhase("error");
+      }
+    },
+    [cancelPolling, onSend, submit]
+  );
+  const stop = useCallback(() => {
+    cancelPolling();
+    inFlightRef.current = false;
+    setMessages(
+      (prev) => prev.flatMap((m) => {
+        if (m.role !== "ASSISTANT") return [m];
+        if (m.status !== "PENDING" && m.status !== "RUNNING") return [m];
+        const text = visibleText(m);
+        if (!text) return [];
+        return [
+          {
+            ...m,
+            status: "COMPLETED",
+            content: text,
+            completedAt: (/* @__PURE__ */ new Date()).toISOString()
+          }
+        ];
+      })
+    );
+    setPhase(
+      (prev) => prev === "sending" || prev === "streaming" ? "ready" : prev
+    );
+  }, [cancelPolling]);
+  const retry = useCallback(() => {
+    const text = lastSentTextRef.current;
+    if (!text) return;
+    cancelPolling();
+    inFlightRef.current = false;
+    setMessages((prev) => {
+      const next = [...prev];
+      const last = next[next.length - 1];
+      if (last?.role === "ASSISTANT" && last.status === "FAILED") next.pop();
+      const prior = next[next.length - 1];
+      if (prior?.role === "USER" && prior.content === text) next.pop();
+      return next;
+    });
+    turnCountRef.current = Math.max(0, turnCountRef.current - 1);
+    setTurnCount(turnCountRef.current);
+    void send(text);
+  }, [cancelPolling, send]);
+  const reset = useCallback(() => {
+    cancelPolling();
+    inFlightRef.current = false;
+    conversationTokenRef.current = null;
+    lastSentTextRef.current = null;
+    turnCountRef.current = 0;
+    setTurnCount(0);
+    setMessages([]);
+    setError(null);
+    setRemainingToday(null);
+    setPhase(catalogRef.current.enabled ? "ready" : "disabled");
+    if (typeof window !== "undefined") {
+      try {
+        window.sessionStorage.removeItem(storageKey);
+      } catch {
+      }
+    }
+  }, [cancelPolling, storageKey]);
+  const setFocusProduct = useCallback((slug) => {
+    focusProductRef.current = slug;
+    setFocusProductState(slug);
+  }, []);
+  const activity = useMemo(() => {
+    for (let i = messages.length - 1; i >= 0; i -= 1) {
+      const m = messages[i];
+      if (!m || m.role !== "ASSISTANT") continue;
+      if (m.status !== "PENDING" && m.status !== "RUNNING") return null;
+      const lines = m.activity ?? [];
+      return lines.length ? lines[lines.length - 1] ?? null : null;
+    }
+    return null;
+  }, [messages]);
+  const canSend = (phase === "ready" || phase === "error") && catalog.enabled && turnCount < catalog.limits.maxTurnsPerConversation;
+  return {
+    phase,
+    catalog,
+    messages,
+    activity,
+    remainingToday,
+    error,
+    focusProduct,
+    setFocusProduct,
+    send,
+    stop,
+    retry,
+    reset,
+    canSend
+  };
+}
+var optimisticCounter = 0;
+function makeOptimisticId() {
+  optimisticCounter += 1;
+  return `boff-explore-local-${Date.now()}-${optimisticCounter}`;
+}
+
+export { DEFAULT_EXPLORE_EXAMPLE_PROMPTS, FALLBACK_EXPLORE_LIMITS, classifyExploreError, useExploreChat };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map