@burdenoff/website-sdk 2026.1101.1 → 2026.1101.2

package/dist/chunk-EUPFS6MZ.mjs

@@ -0,0 +1,2019 @@
+import { getRecaptchaV3Token } from './chunk-SKIYDKIS.mjs';
+import { emitProductSlug } from './chunk-KZANIV3S.mjs';
+import { useWebSDK, useWebSDKConfig } from './chunk-5JRJ57CL.mjs';
+import { useMemo, useState, useRef, useCallback, useEffect } from 'react';
+
+// src/data/products.ts
+var ECOSYSTEM_PRODUCTS = [
+  {
+    slug: "workspaces",
+    name: "Workspaces",
+    websiteUrl: "https://burdenoff.com"
+  },
+  {
+    slug: "vibecontrols",
+    name: "VibeControls",
+    websiteUrl: "https://vibecontrols.com"
+  },
+  // FluidGrids ships on www.fluidgrids.ai — fluidgrids.com only redirects there. The explore
+  // catalog and the site's own sitemap use this origin, and so must the fallback catalog
+  // built from this list, or /explore rejects FluidGrids concept images until it loads.
+  {
+    slug: "fluidgrids",
+    name: "FluidGrids",
+    websiteUrl: "https://www.fluidgrids.ai"
+  },
+  // BotManor ships on www.botmanor.com (the apex redirects there; the old botlit.ai domain
+  // still serves the same site but is no longer the name we link to).
+  // The slug follows the botlit → botmanor rename switch (utils/product-slug.ts).
+  {
+    slug: emitProductSlug("botmanor"),
+    name: "BotManor",
+    websiteUrl: "https://www.botmanor.com"
+  },
+  {
+    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/components/explore-types.ts
+var EXPLORE_FEEDBACK_REASONS = [
+  "INACCURATE",
+  "INCOMPLETE",
+  "OFF_TOPIC",
+  "HARD_TO_FOLLOW",
+  "OTHER"
+];
+var EXPLORE_MESSAGE_FIELDS = (
+  /* GraphQL */
+  `
+  id
+  conversationId
+  role
+  status
+  content
+  partialContent
+  activity
+  references {
+    url
+    title
+    description
+    product
+    imageUrl
+    index
+  }
+  ctas {
+    kind
+    label
+    url
+    product
+  }
+  followUps
+  answered
+  attachments {
+    name
+    mimeType
+    size
+    textExtracted
+  }
+  errorCode
+  createdAt
+  completedAt
+`
+);
+var EXPLORE_OWN_MESSAGE_FIELDS = (
+  /* GraphQL */
+  `
+  ${EXPLORE_MESSAGE_FIELDS}
+  feedback {
+    rating
+    reason
+    comment
+    createdAt
+  }
+`
+);
+var EXPLORE_CATALOG_ESTABLISHED_FIELDS = (
+  /* GraphQL */
+  `
+      enabled
+      products {
+        slug
+        name
+        tagline
+        website
+      }
+      examplePrompts
+      welcomeTitle
+      welcomeBody
+      limits {
+        maxMessageLength
+        maxTurnsPerConversation
+        messagesPerDay
+        historyTurns
+      }
+      captchaRequired
+      recaptchaSiteKey`
+);
+var EXPLORE_CATALOG_HIGHLIGHT_FIELD = (
+  /* GraphQL */
+  `
+      conceptHighlights {
+        product
+        productName
+        title
+        url
+        imageUrl
+        alt
+      }`
+);
+function exploreCatalogDocument(extraFields) {
+  return (
+    /* GraphQL */
+    `
+  query ExploreCatalog($productSlug: String) {
+    exploreCatalog(productSlug: $productSlug) {${EXPLORE_CATALOG_ESTABLISHED_FIELDS}${extraFields}
+    }
+  }
+`
+  );
+}
+var EXPLORE_CATALOG_QUERY = exploreCatalogDocument(
+  EXPLORE_CATALOG_HIGHLIGHT_FIELD
+);
+var EXPLORE_CATALOG_QUERY_WITHOUT_HIGHLIGHTS = exploreCatalogDocument("");
+var EXPLORE_MESSAGE_QUERY = (
+  /* GraphQL */
+  `
+  query ExploreMessage($conversationToken: String!, $id: ID!) {
+    exploreMessage(conversationToken: $conversationToken, id: $id) {
+      ${EXPLORE_OWN_MESSAGE_FIELDS}
+    }
+  }
+`
+);
+var SEND_EXPLORE_MESSAGE_MUTATION = (
+  /* GraphQL */
+  `
+  mutation SendExploreMessage($input: SendExploreMessageInput!) {
+    sendExploreMessage(input: $input) {
+      conversation {
+        id
+        token
+        productSlug
+        turnCount
+        createdAt
+      }
+      userMessage {
+        ${EXPLORE_OWN_MESSAGE_FIELDS}
+      }
+      assistantMessage {
+        ${EXPLORE_OWN_MESSAGE_FIELDS}
+      }
+      remainingToday
+    }
+  }
+`
+);
+var RECORD_EXPLORE_CLICK_MUTATION = (
+  /* GraphQL */
+  `
+  mutation RecordExploreClick($input: RecordExploreClickInput!) {
+    recordExploreClick(input: $input) {
+      recorded
+    }
+  }
+`
+);
+var SUBMIT_EXPLORE_FEEDBACK_MUTATION = (
+  /* GraphQL */
+  `
+  mutation SubmitExploreFeedback($input: SubmitExploreFeedbackInput!) {
+    submitExploreFeedback(input: $input) {
+      recorded
+      feedback {
+        rating
+        reason
+        comment
+        createdAt
+      }
+    }
+  }
+`
+);
+var EXPLORE_FEEDBACK_COMMENT_SOFT_MAX = 500;
+var ESCALATE_EXPLORE_CONVERSATION_MUTATION = (
+  /* GraphQL */
+  `
+  mutation EscalateExploreConversation(
+    $input: EscalateExploreConversationInput!
+  ) {
+    escalateExploreConversation(input: $input) {
+      created
+      escalation {
+        email
+        createdAt
+      }
+    }
+  }
+`
+);
+var EXPLORE_ESCALATION_NOTE_SOFT_MAX = 2e3;
+var DELIVERABLE_EMAIL = /^[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[A-Za-z0-9])?\.)+[A-Za-z]{2,}$/;
+function looksLikeDeliverableEmail(value) {
+  const trimmed = value.trim();
+  if (trimmed.length === 0 || trimmed.length > 254) return false;
+  return DELIVERABLE_EMAIL.test(trimmed);
+}
+var CREATE_EXPLORE_SHARE_LINK_MUTATION = (
+  /* GraphQL */
+  `
+  mutation CreateExploreShareLink($conversationToken: String!) {
+    createExploreShareLink(conversationToken: $conversationToken) {
+      shareToken
+    }
+  }
+`
+);
+var EXPLORE_SHARED_CONVERSATION_QUERY = (
+  /* GraphQL */
+  `
+  query ExploreSharedConversation($shareToken: String!) {
+    exploreSharedConversation(shareToken: $shareToken) {
+      ${EXPLORE_MESSAGE_FIELDS}
+    }
+  }
+`
+);
+var DEFAULT_STORAGE_KEY = "boff.explore.v1";
+var HISTORY_SUFFIX = ".history";
+var MAX_ARCHIVED_CONVERSATIONS = 15;
+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 = [
+  "Every course we run lives in a different spreadsheet.",
+  "We only hear a machine is down after the line has stopped.",
+  "Members quietly stop showing up and we never know why.",
+  "Which of your products fits a problem like mine?"
+];
+var FALLBACK_WELCOME_TITLE = "What problem are you trying to solve?";
+var FALLBACK_WELCOME_BODY = "Describe the problem, in your own words. You can also ask about a specific product or compare a few. Every answer comes straight from our documentation.";
+function buildFallbackCatalog(examplePrompts, welcome) {
+  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: welcome?.title ?? FALLBACK_WELCOME_TITLE,
+    welcomeBody: welcome?.body ?? FALLBACK_WELCOME_BODY,
+    limits: FALLBACK_EXPLORE_LIMITS,
+    captchaRequired: false,
+    recaptchaSiteKey: null,
+    // Empty, and deliberately not synthesised from `ECOSYSTEM_PRODUCTS`: a concept highlight
+    // needs a real published illustration URL, and this SDK has no registry of them. An
+    // invented path would render 38 broken frames on the one screen every prerender captures.
+    // The strip renders nothing at all when the list is empty, which is the honest fallback.
+    conceptHighlights: []
+  };
+}
+var BAKED_CATALOG_ELEMENT_ID = "boff-explore-catalog";
+function bakedCatalogLocale() {
+  if (typeof navigator === "undefined") return "";
+  return (navigator.language || "").toLowerCase().split("-")[0] ?? "";
+}
+function snapshotBakedElement() {
+  if (typeof document === "undefined") return null;
+  const el = document.getElementById(BAKED_CATALOG_ELEMENT_ID);
+  if (!el || el.tagName !== "SCRIPT" || el.getAttribute("type") !== "application/json")
+    return null;
+  return {
+    product: el.getAttribute("data-product") ?? "",
+    locale: el.getAttribute("data-locale") ?? "",
+    text: el.textContent ?? ""
+  };
+}
+var BAKED_AT_LOAD = snapshotBakedElement();
+function isCatalogShape(value) {
+  if (!value || typeof value !== "object") return false;
+  const c = value;
+  const listOrAbsent = (v) => v === void 0 || v === null || Array.isArray(v);
+  const textOrAbsent = (v) => v === void 0 || v === null || typeof v === "string";
+  return (c["enabled"] === void 0 || typeof c["enabled"] === "boolean") && listOrAbsent(c["products"]) && listOrAbsent(c["examplePrompts"]) && listOrAbsent(c["conceptHighlights"]) && textOrAbsent(c["welcomeTitle"]) && textOrAbsent(c["welcomeBody"]);
+}
+function readBakedCatalog(productSlug) {
+  const baked = snapshotBakedElement() ?? BAKED_AT_LOAD;
+  if (!baked) return null;
+  if (baked.product !== (productSlug ?? "")) return null;
+  if (baked.locale && baked.locale !== bakedCatalogLocale()) return null;
+  try {
+    const parsed = JSON.parse(baked.text);
+    return isCatalogShape(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function serializeBakedCatalog(raw) {
+  return JSON.stringify(raw).replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+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,
+    // `[ExploreConceptHighlight!]!` on the wire, so a gateway that KNOWS the field always
+    // sends an array. The one response that arrives without it is the retry against an older
+    // supergraph (`EXPLORE_CATALOG_QUERY_WITHOUT_HIGHLIGHTS`) — that gateway does not answer
+    // the full document at all, it refuses it. Either way
+    // `catalog.conceptHighlights.filter(...)` on `undefined` would throw inside render,
+    // blanking the welcome screen over a decorative strip.
+    conceptHighlights: raw.conceptHighlights?.length ? raw.conceptHighlights : fallback.conceptHighlights
+  };
+}
+var CATALOG_DOCUMENT_REJECTED_CODES = /* @__PURE__ */ new Set([
+  "GRAPHQL_VALIDATION_FAILED",
+  "HTTP_400"
+]);
+function catalogRejectedTheHighlightField(res) {
+  if (res.data?.exploreCatalog) return false;
+  return (res.errors ?? []).some((error) => {
+    const code = error.extensions?.code;
+    return typeof code === "string" && CATALOG_DOCUMENT_REJECTED_CODES.has(code) || error.message.includes("conceptHighlights");
+  });
+}
+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 escalateOutcomeForCode(code) {
+  switch (code) {
+    case "INVALID_EMAIL":
+      return "invalid-email";
+    case "RATE_LIMITED":
+    case "HTTP_429":
+      return "rate-limited";
+    case "CAPTCHA_REQUIRED":
+    case "CAPTCHA_FAILED":
+      return "captcha";
+    // The token owns nothing, or owns a different conversation. The server answers NOT_FOUND
+    // rather than FORBIDDEN so the endpoint is not an oracle for whether a thread exists;
+    // either way there is nothing this visitor can do about it, so it reads as a failure.
+    case "NOT_FOUND":
+      return "failed";
+    default:
+      return "failed";
+  }
+}
+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 === "TOOL_BUDGET") {
+    return {
+      kind: "scope",
+      code: c,
+      message: "That question spans more of our products than I can look through in one go. Try asking about two or three specific products.",
+      retryable: false
+    };
+  }
+  if (c === "TIMEOUT") {
+    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 historyKey(key) {
+  return `${key}${HISTORY_SUFFIX}`;
+}
+function readArchive(key) {
+  if (typeof window === "undefined") return [];
+  try {
+    const raw = window.localStorage.getItem(historyKey(key));
+    if (!raw) return [];
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+    return parsed.filter(
+      (entry) => typeof entry === "object" && entry !== null && typeof entry.token === "string" && Array.isArray(entry.messages)
+    );
+  } catch {
+    return [];
+  }
+}
+function writeArchive(key, entries) {
+  if (typeof window === "undefined") return;
+  try {
+    if (entries.length === 0) {
+      window.localStorage.removeItem(historyKey(key));
+      return;
+    }
+    window.localStorage.setItem(historyKey(key), JSON.stringify(entries));
+  } catch {
+  }
+}
+function upsertArchive(key, thread) {
+  if (!thread.token) return readArchive(key);
+  const real = thread.messages.filter(
+    (m) => m.content.trim() !== "" || m.role === "USER"
+  );
+  if (real.length === 0) return readArchive(key);
+  const firstUser = real.find((m) => m.role === "USER");
+  const entry = {
+    token: thread.token,
+    title: (firstUser?.content ?? "Conversation").trim().slice(0, 80),
+    updatedAt: real[real.length - 1]?.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    messageCount: real.length,
+    focusProduct: thread.focusProduct,
+    messages: real.slice(-20)
+  };
+  const rest = readArchive(key).filter((e) => e.token !== entry.token);
+  const next = [entry, ...rest].slice(0, MAX_ARCHIVED_CONVERSATIONS);
+  writeArchive(key, next);
+  return next;
+}
+function readPersisted(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    const raw = window.localStorage.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 readShareToken() {
+  if (typeof window === "undefined") return null;
+  try {
+    return new URL(window.location.href).searchParams.get("c");
+  } 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,
+    fallbackWelcome,
+    pollIntervalMs = DEFAULT_POLL_INTERVAL_MS,
+    pollTimeoutMs = DEFAULT_POLL_TIMEOUT_MS,
+    storageKey = DEFAULT_STORAGE_KEY,
+    persist = true,
+    onSend,
+    enabled = true,
+    shareToken: shareTokenOption
+  } = options;
+  const client = useWebSDK();
+  const { productId } = useWebSDKConfig();
+  const promptKey = JSON.stringify(examplePrompts ?? []);
+  const welcomeKey = JSON.stringify(fallbackWelcome ?? null);
+  const fallbackCatalog = useMemo(
+    () => buildFallbackCatalog(
+      JSON.parse(promptKey),
+      JSON.parse(welcomeKey) ?? void 0
+    ),
+    [promptKey, welcomeKey]
+  );
+  const [bakedRaw] = useState(
+    () => readBakedCatalog(productSlug)
+  );
+  const [catalog, setCatalog] = useState(
+    () => bakedRaw ? normalizeCatalog(bakedRaw, fallbackCatalog) : fallbackCatalog
+  );
+  const [serverCatalogRaw, setServerCatalogRaw] = useState(bakedRaw);
+  const [messages, setMessages] = useState([]);
+  const [phase, setPhase] = useState(
+    () => bakedRaw ? bakedRaw.enabled === false ? "disabled" : "ready" : "loading"
+  );
+  const [error, setError] = useState(null);
+  const [remainingToday, setRemainingToday] = useState(null);
+  const [focusProduct, setFocusProductState] = useState(null);
+  const [turnCount, setTurnCount] = useState(0);
+  const messagesRef = useRef([]);
+  const [archive, setArchive] = useState([]);
+  const [hydrated, setHydrated] = useState(false);
+  const mountedRef = useRef(true);
+  const pollGenerationRef = useRef(0);
+  const pollTimerRef = useRef(null);
+  const conversationTokenRef = useRef(null);
+  const [hasConversation, setHasConversation] = useState(false);
+  const shareTokenRef = useRef(void 0);
+  if (shareTokenRef.current === void 0) {
+    shareTokenRef.current = shareTokenOption === void 0 ? readShareToken() : shareTokenOption;
+  }
+  const isSharedView = shareTokenRef.current !== null;
+  const catalogRef = useRef(catalog);
+  const turnCountRef = useRef(0);
+  const focusProductRef = useRef(null);
+  const lastSentTextRef = useRef(null);
+  const lastSentAttachmentsRef = useRef(
+    []
+  );
+  const inFlightRef = useRef(false);
+  catalogRef.current = catalog;
+  const rememberConversationToken = useCallback((token) => {
+    conversationTokenRef.current = token;
+    setHasConversation(token !== null);
+  }, []);
+  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 (!enabled) return;
+    const shareToken = shareTokenRef.current;
+    if (!shareToken) return;
+    let cancelled = false;
+    setHydrated(true);
+    void client.query(
+      EXPLORE_SHARED_CONVERSATION_QUERY,
+      { shareToken },
+      { cache: false }
+    ).then((res) => {
+      if (cancelled || !mountedRef.current) return;
+      const shared = res?.data?.exploreSharedConversation;
+      if (shared && shared.length > 0) {
+        setMessages(shared);
+        return;
+      }
+      setError({
+        kind: "unknown",
+        code: "SHARE_NOT_FOUND",
+        message: "That shared conversation could not be found. The link may have expired.",
+        // Nothing to retry: a bad token will stay bad.
+        retryable: false
+      });
+    }).catch(() => {
+      if (cancelled || !mountedRef.current) return;
+      setError({
+        kind: "unknown",
+        code: "SHARE_NOT_FOUND",
+        message: "That shared conversation could not be loaded.",
+        retryable: true
+      });
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, enabled]);
+  useEffect(() => {
+    if (!enabled) return;
+    if (shareTokenRef.current !== null) return;
+    if (!persist) {
+      setHydrated(true);
+      return;
+    }
+    setArchive(readArchive(storageKey));
+    const stored = readPersisted(storageKey);
+    if (stored) {
+      rememberConversationToken(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, rememberConversationToken, storageKey, enabled]);
+  useEffect(() => {
+    if (!persist || !hydrated || isSharedView || 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.localStorage.removeItem(storageKey);
+        return;
+      }
+      window.localStorage.setItem(storageKey, JSON.stringify(payload));
+    } catch {
+    }
+  }, [persist, hydrated, isSharedView, storageKey, messages, focusProduct]);
+  useEffect(() => {
+    messagesRef.current = messages;
+    if (!persist || !hydrated || isSharedView) return;
+    const settled = messages.some(
+      (m) => m.role === "ASSISTANT" && (m.status === "COMPLETED" || m.status === "FAILED")
+    );
+    if (!settled) return;
+    setArchive(
+      upsertArchive(storageKey, {
+        token: conversationTokenRef.current,
+        messages,
+        focusProduct: focusProductRef.current
+      })
+    );
+  }, [messages, persist, hydrated, isSharedView, storageKey]);
+  useEffect(() => {
+    if (!enabled) return;
+    let cancelled = false;
+    const load = async () => {
+      const variables = { productSlug: productSlug ?? null };
+      let res = await client.query(
+        EXPLORE_CATALOG_QUERY,
+        variables
+      );
+      if (cancelled || !mountedRef.current) return;
+      if (catalogRejectedTheHighlightField(res)) {
+        res = await client.query(
+          EXPLORE_CATALOG_QUERY_WITHOUT_HIGHLIGHTS,
+          variables
+        );
+        if (cancelled || !mountedRef.current) return;
+      }
+      const raw = res.data?.exploreCatalog;
+      if (res.errors?.length || !raw) {
+        console.warn(
+          "[WebSDK] exploreCatalog unavailable \u2014 keeping the catalog the page started with",
+          res.errors?.[0]?.message
+        );
+        setPhase((prev) => prev === "loading" ? "ready" : prev);
+        return;
+      }
+      const next = normalizeCatalog(
+        raw,
+        bakedRaw ? normalizeCatalog(bakedRaw, fallbackCatalog) : fallbackCatalog
+      );
+      setCatalog(next);
+      setServerCatalogRaw(raw);
+      catalogRef.current = next;
+      setPhase((prev) => {
+        if (!next.enabled) return "disabled";
+        return prev === "loading" || prev === "disabled" ? "ready" : prev;
+      });
+    };
+    void load();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, productSlug, fallbackCatalog, bakedRaw, enabled]);
+  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, attachments) => {
+      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 } : {},
+        ...attachments.length > 0 ? { attachments: [...attachments] } : {}
+      };
+      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, attachments);
+          return;
+        }
+        inFlightRef.current = false;
+        setError(classified);
+        setPhase(classified.kind === "rate-limit" ? "limited" : "error");
+        return;
+      }
+      rememberConversationToken(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,
+      rememberConversationToken,
+      startPolling
+    ]
+  );
+  const send = useCallback(
+    async (message, attachments = []) => {
+      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;
+      lastSentAttachmentsRef.current = attachments;
+      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, attachments);
+      } 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, lastSentAttachmentsRef.current);
+  }, [cancelPolling, send]);
+  const reset = useCallback(() => {
+    setArchive(
+      upsertArchive(storageKey, {
+        token: conversationTokenRef.current,
+        messages: messagesRef.current,
+        focusProduct: focusProductRef.current
+      })
+    );
+    cancelPolling();
+    inFlightRef.current = false;
+    rememberConversationToken(null);
+    lastSentTextRef.current = null;
+    lastSentAttachmentsRef.current = [];
+    turnCountRef.current = 0;
+    setTurnCount(0);
+    setMessages([]);
+    setError(null);
+    setRemainingToday(null);
+    setPhase(catalogRef.current.enabled ? "ready" : "disabled");
+    if (typeof window !== "undefined") {
+      try {
+        window.localStorage.removeItem(storageKey);
+      } catch {
+      }
+    }
+  }, [cancelPolling, rememberConversationToken, storageKey]);
+  const openConversation = useCallback(
+    (token) => {
+      const entry = readArchive(storageKey).find((e) => e.token === token);
+      if (!entry) return;
+      upsertArchive(storageKey, {
+        token: conversationTokenRef.current,
+        messages: messagesRef.current,
+        focusProduct: focusProductRef.current
+      });
+      cancelPolling();
+      inFlightRef.current = false;
+      rememberConversationToken(entry.token);
+      turnCountRef.current = entry.messages.filter(
+        (m) => m.role === "USER"
+      ).length;
+      setTurnCount(turnCountRef.current);
+      setMessages(entry.messages);
+      focusProductRef.current = entry.focusProduct;
+      setFocusProductState(entry.focusProduct);
+      setError(null);
+      setPhase(catalogRef.current.enabled ? "ready" : "disabled");
+      setArchive(readArchive(storageKey));
+    },
+    [cancelPolling, rememberConversationToken, storageKey]
+  );
+  const deleteConversation = useCallback(
+    (token) => {
+      const next = readArchive(storageKey).filter((e) => e.token !== token);
+      writeArchive(storageKey, next);
+      setArchive(next);
+    },
+    [storageKey]
+  );
+  const clearHistory = useCallback(() => {
+    writeArchive(storageKey, []);
+    setArchive([]);
+  }, [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;
+  const createShareLink = useCallback(async () => {
+    const token = conversationTokenRef.current;
+    if (!token) return null;
+    try {
+      const result = await client.mutate(CREATE_EXPLORE_SHARE_LINK_MUTATION, { conversationToken: token });
+      return result?.data?.createExploreShareLink?.shareToken ?? null;
+    } catch {
+      return null;
+    }
+  }, [client]);
+  const recordClick = useCallback(
+    (messageId, kind, url) => {
+      const token = conversationTokenRef.current;
+      if (!token) return;
+      try {
+        void client.mutate(RECORD_EXPLORE_CLICK_MUTATION, {
+          input: { conversationToken: token, messageId, kind, url }
+        }).catch(() => {
+        });
+      } catch {
+      }
+    },
+    [client]
+  );
+  const submitFeedback = useCallback(
+    async (messageId, rating, detail) => {
+      const token = conversationTokenRef.current;
+      if (!token) return false;
+      const comment = detail?.comment?.trim();
+      const input = {
+        conversationToken: token,
+        messageId,
+        rating,
+        // Only meaningful with NOT_HELPFUL. The server stores null for HELPFUL either
+        // way; sending it would just be noise the backend has to defend against.
+        reason: rating === "NOT_HELPFUL" ? detail?.reason ?? null : null,
+        comment: comment ? comment : null
+      };
+      try {
+        const res = await client.mutate(
+          SUBMIT_EXPLORE_FEEDBACK_MUTATION,
+          { input }
+        );
+        const result = res?.data?.submitExploreFeedback;
+        if (!result?.recorded) return false;
+        const recorded = result.feedback;
+        if (recorded && mountedRef.current) {
+          setMessages(
+            (current) => current.map(
+              (message) => message.id === messageId ? { ...message, feedback: recorded } : message
+            )
+          );
+        }
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    [client]
+  );
+  const escalate = useCallback(
+    async (email, note) => {
+      const token = conversationTokenRef.current;
+      if (!token) {
+        return { outcome: "no-conversation", email: null, createdAt: null };
+      }
+      const attempt = async (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 = {
+          conversationToken: token,
+          email: email.trim(),
+          note: note?.trim() ? note.trim() : null,
+          ...recaptchaToken ? { recaptchaToken } : {},
+          ...productId ? { productId } : {}
+        };
+        try {
+          const res = await client.mutate(
+            ESCALATE_EXPLORE_CONVERSATION_MUTATION,
+            { input }
+          );
+          const first = res?.errors?.[0];
+          const result = res?.data?.escalateExploreConversation;
+          if (first || !result) {
+            const code = typeof first?.extensions?.code === "string" ? first.extensions.code : "ESCALATION_FAILED";
+            if (code === "CAPTCHA_FAILED" && captchaAttempt === 0) {
+              return attempt(1);
+            }
+            return {
+              outcome: escalateOutcomeForCode(code),
+              email: null,
+              createdAt: null
+            };
+          }
+          return {
+            // `created: false` is the double-click, the retry, the reload. The handover
+            // exists, so this is a success — and the address comes from the SERVER, because
+            // on a repeat submit the reply goes to whatever the FIRST handover used.
+            outcome: result.created ? "sent" : "already-handed-over",
+            email: result.escalation?.email ?? null,
+            createdAt: result.escalation?.createdAt ?? null
+          };
+        } catch {
+          return { outcome: "failed", email: null, createdAt: null };
+        }
+      };
+      return attempt(0);
+    },
+    [client, productId]
+  );
+  const canEscalate = hasConversation && !isSharedView;
+  const getConversationToken = useCallback(
+    () => conversationTokenRef.current,
+    []
+  );
+  return {
+    phase,
+    catalog,
+    serverCatalogRaw,
+    messages,
+    activity,
+    remainingToday,
+    error,
+    focusProduct,
+    setFocusProduct,
+    send,
+    stop,
+    retry,
+    reset,
+    canSend,
+    history: archive,
+    openConversation,
+    deleteConversation,
+    clearHistory,
+    recordClick,
+    submitFeedback,
+    escalate,
+    canEscalate,
+    createShareLink,
+    isSharedView,
+    getConversationToken
+  };
+}
+var optimisticCounter = 0;
+function makeOptimisticId() {
+  optimisticCounter += 1;
+  return `boff-explore-local-${Date.now()}-${optimisticCounter}`;
+}
+var DRAIN_TARGET_MS = 1200;
+var MIN_CHARS_PER_SECOND = 90;
+var MAX_CHARS_PER_SECOND = 2200;
+var MAX_STEP_MS = 250;
+var COMMIT_INTERVAL_MS = 45;
+var FALLBACK_STEP_MS = 50;
+var FENCE = /^ {0,3}(?:```|~~~)/;
+var TABLE_ROW = /^ {0,3}\|/;
+var EMPTY_BLOCK_MARKER = /^ {0,3}(?:[-+>]|#{1,6}|\d{1,9}[.)])\s*$/;
+function isWordCharacter(char) {
+  return char !== void 0 && /[\p{L}\p{N}]/u.test(char);
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function now() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function isHighSurrogate(code) {
+  return code >= 55296 && code <= 56319;
+}
+function safeInlineEnd(line) {
+  let codeSpan = null;
+  const links = [];
+  const emphasis = [];
+  let at = 0;
+  while (at < line.length) {
+    const char = line[at] ?? "";
+    if (char === "\\") {
+      at += 2;
+      continue;
+    }
+    const innermost = links[links.length - 1];
+    if (innermost !== void 0 && innermost.kind !== "label") {
+      if (char === "(") links.push({ kind: "paren", start: innermost.start });
+      else if (char === ")") links.pop();
+      at += 1;
+      continue;
+    }
+    if (char === "`") {
+      let run = 1;
+      while (line[at + run] === "`") run += 1;
+      codeSpan = codeSpan === null ? at : null;
+      at += run;
+      continue;
+    }
+    if (codeSpan !== null) {
+      at += 1;
+      continue;
+    }
+    if (char === "[") {
+      links.push({ kind: "label", start: line[at - 1] === "!" ? at - 1 : at });
+      at += 1;
+      continue;
+    }
+    if (char === "]" && innermost !== void 0) {
+      links.pop();
+      if (line[at + 1] === "(") {
+        links.push({ kind: "destination", start: innermost.start });
+        at += 2;
+        continue;
+      }
+      at += 1;
+      continue;
+    }
+    if (char === "*" || char === "_" || char === "~") {
+      let run = 1;
+      while (line[at + run] === char) run += 1;
+      const start = at;
+      at += run;
+      const before = line[start - 1];
+      const after = line[start + run];
+      if (run < 2) continue;
+      if (char === "_" && isWordCharacter(before) && isWordCharacter(after)) {
+        continue;
+      }
+      const marker = char.repeat(run);
+      const open2 = emphasis.findIndex((entry) => entry.marker === marker);
+      if (open2 !== -1) {
+        emphasis.splice(open2, 1);
+        continue;
+      }
+      if (after !== void 0 && /\s/.test(after)) continue;
+      emphasis.push({ marker, start });
+      continue;
+    }
+    at += 1;
+  }
+  const open = [
+    codeSpan,
+    links[0]?.start ?? null,
+    emphasis[0]?.start ?? null
+  ].filter((value) => value !== null);
+  return open.length === 0 ? line.length : Math.min(...open);
+}
+function revealBoundary(text, limit) {
+  if (limit <= 0) return 0;
+  const caughtUp = limit >= text.length;
+  const head = caughtUp ? text : text.slice(0, limit);
+  const lineStart = head.lastIndexOf("\n") + 1;
+  const line = head.slice(lineStart);
+  let fenceStart = null;
+  let tableStart = null;
+  let tableRows = 0;
+  let at = 0;
+  while (at < lineStart) {
+    const breakAt = head.indexOf("\n", at);
+    const end = breakAt === -1 ? lineStart : breakAt;
+    const row = head.slice(at, end);
+    if (fenceStart !== null) {
+      if (FENCE.test(row)) fenceStart = null;
+    } else if (FENCE.test(row)) {
+      fenceStart = at;
+    } else if (TABLE_ROW.test(row)) {
+      if (tableStart === null) {
+        tableStart = at;
+        tableRows = 0;
+      }
+      tableRows += 1;
+    } else if (tableStart !== null) {
+      tableStart = null;
+      tableRows = 0;
+    }
+    at = end + 1;
+  }
+  if (fenceStart === null) {
+    const lastIsRow = TABLE_ROW.test(line);
+    if (lastIsRow && tableStart === null) {
+      tableStart = lineStart;
+      tableRows = 0;
+    } else if (!lastIsRow && line !== "") {
+      tableStart = null;
+      tableRows = 0;
+    }
+    if (tableStart !== null && tableRows < 2) return tableStart;
+  }
+  if (caughtUp) return text.length;
+  if (fenceStart !== null) return fenceStart;
+  if (TABLE_ROW.test(line)) return lineStart;
+  if (EMPTY_BLOCK_MARKER.test(line)) return lineStart;
+  const cut = lineStart + safeInlineEnd(line);
+  return isHighSurrogate(text.charCodeAt(cut - 1)) ? cut - 1 : cut;
+}
+function prefersReducedMotion() {
+  if (typeof window === "undefined") return true;
+  try {
+    return window.matchMedia?.("(prefers-reduced-motion: reduce)").matches === true;
+  } catch {
+    return false;
+  }
+}
+function useProgressiveReveal(text, settled) {
+  const [, setFrame] = useState(0);
+  const [reduced] = useState(prefersReducedMotion);
+  const immediate = settled || reduced;
+  const textRef = useRef(text);
+  const cursorRef = useRef(immediate ? text.length : 0);
+  const cutRef = useRef(immediate ? text.length : 0);
+  const committedRef = useRef(0);
+  if (text !== textRef.current) {
+    const revealed = textRef.current.slice(0, Math.floor(cursorRef.current));
+    if (revealed !== "" && !text.startsWith(revealed)) {
+      cursorRef.current = text.length;
+    }
+    cursorRef.current = Math.min(cursorRef.current, text.length);
+    cutRef.current = Math.min(cutRef.current, text.length);
+    textRef.current = text;
+  }
+  if (immediate) cursorRef.current = text.length;
+  const cut = immediate ? text.length : Math.max(
+    cutRef.current,
+    revealBoundary(text, Math.floor(cursorRef.current))
+  );
+  cutRef.current = cut;
+  useEffect(() => {
+    if (immediate) return;
+    if (cursorRef.current >= text.length) return;
+    let cancelled = false;
+    let cancelStep = null;
+    let previous = now();
+    const commit = (at, force) => {
+      if (!force && at - committedRef.current < COMMIT_INTERVAL_MS) return;
+      committedRef.current = at;
+      setFrame((value) => value + 1);
+    };
+    const step = () => {
+      cancelStep = null;
+      if (cancelled) return;
+      const at = now();
+      const elapsed = clamp(at - previous, 0, MAX_STEP_MS);
+      previous = at;
+      const length = textRef.current.length;
+      const pending = length - cursorRef.current;
+      if (pending <= 0) {
+        commit(at, true);
+        return;
+      }
+      const perSecond = clamp(
+        pending / (DRAIN_TARGET_MS / 1e3),
+        MIN_CHARS_PER_SECOND,
+        MAX_CHARS_PER_SECOND
+      );
+      cursorRef.current = Math.min(
+        length,
+        cursorRef.current + perSecond * elapsed / 1e3
+      );
+      const done = cursorRef.current >= length;
+      commit(at, done);
+      if (!done) schedule();
+    };
+    const schedule = () => {
+      if (typeof window.requestAnimationFrame === "function") {
+        const id2 = window.requestAnimationFrame(step);
+        cancelStep = () => window.cancelAnimationFrame(id2);
+        return;
+      }
+      const id = setTimeout(step, FALLBACK_STEP_MS);
+      cancelStep = () => clearTimeout(id);
+    };
+    schedule();
+    return () => {
+      cancelled = true;
+      cancelStep?.();
+    };
+  }, [text, immediate]);
+  return text.slice(0, cut);
+}
+function getRecognitionCtor() {
+  if (typeof window === "undefined") return null;
+  const w = window;
+  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+}
+function isTouchDevice() {
+  if (typeof window === "undefined" || !window.matchMedia) return false;
+  try {
+    return window.matchMedia("(pointer: coarse)").matches;
+  } catch {
+    return false;
+  }
+}
+var MIC_DENIED_MESSAGE = "Microphone access was blocked. Allow it in your browser's site settings to dictate.";
+var MIC_UNAVAILABLE_MESSAGE = "Dictation isn't available in this browser. You can type instead.";
+var RELEASE_SETTLE_MS = 250;
+var RETRY_DELAY_MS = 350;
+var sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+async function ensureMicrophoneAccess() {
+  const media = typeof navigator === "undefined" ? void 0 : navigator.mediaDevices;
+  if (!media?.getUserMedia)
+    return { ok: true, confirmed: false, primed: false };
+  try {
+    const status = await navigator.permissions?.query({
+      name: "microphone"
+    });
+    if (status?.state === "granted")
+      return { ok: true, confirmed: true, primed: false };
+  } catch {
+  }
+  try {
+    const stream = await media.getUserMedia({ audio: true });
+    for (const track of stream.getTracks()) track.stop();
+    return { ok: true, confirmed: true, primed: true };
+  } catch (error) {
+    const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+    if (name === "NotAllowedError" || name === "SecurityError") {
+      return { ok: false, message: MIC_DENIED_MESSAGE };
+    }
+    if (name === "NotFoundError" || name === "DevicesNotFoundError") {
+      return { ok: false, message: "No microphone was found." };
+    }
+    return {
+      ok: false,
+      message: "Dictation could not start. You can type instead."
+    };
+  }
+}
+function describeError(code) {
+  switch (code) {
+    case "not-allowed":
+    case "service-not-allowed":
+      return MIC_DENIED_MESSAGE;
+    case "no-speech":
+      return "I didn't catch anything \u2014 try again a little closer to the mic.";
+    case "audio-capture":
+      return "No microphone was found.";
+    case "network":
+      return "Speech recognition needs a network connection.";
+    case "aborted":
+      return "";
+    default:
+      return "Dictation stopped unexpectedly. You can type instead.";
+  }
+}
+function useSpeechInput({
+  onFinalTranscript,
+  lang,
+  onError
+}) {
+  const [supported] = useState(() => getRecognitionCtor() !== null);
+  const [listening, setListening] = useState(false);
+  const [interim, setInterim] = useState("");
+  const [error, setError] = useState(null);
+  const recognitionRef = useRef(null);
+  const startTokenRef = useRef(0);
+  const micConfirmedRef = useRef(false);
+  const wantsListeningRef = useRef(false);
+  const retriedRef = useRef(false);
+  const finalRef = useRef(onFinalTranscript);
+  const errorRef = useRef(onError);
+  finalRef.current = onFinalTranscript;
+  errorRef.current = onError;
+  const langRef = useRef(lang);
+  langRef.current = lang;
+  const stop = useCallback(() => {
+    startTokenRef.current += 1;
+    wantsListeningRef.current = false;
+    setListening(false);
+    setInterim("");
+    const recognition = recognitionRef.current;
+    if (!recognition) return;
+    try {
+      recognition.stop();
+    } catch {
+    }
+  }, []);
+  const openSession = useCallback((token) => {
+    const Ctor = getRecognitionCtor();
+    if (!Ctor || token !== startTokenRef.current) return;
+    const recognition = new Ctor();
+    recognition.lang = langRef.current ?? (typeof navigator === "undefined" ? "en-US" : navigator.language || "en-US");
+    recognition.continuous = !isTouchDevice();
+    recognition.interimResults = true;
+    recognition.maxAlternatives = 1;
+    recognition.onstart = () => {
+      if (token !== startTokenRef.current) return;
+      setError(null);
+      setListening(true);
+    };
+    recognition.onresult = (event) => {
+      if (token !== startTokenRef.current) return;
+      let settled = "";
+      let pending = "";
+      for (let i = event.resultIndex; i < event.results.length; i += 1) {
+        const result = event.results[i];
+        if (!result) continue;
+        const text = result[0]?.transcript ?? "";
+        if (result.isFinal) settled += text;
+        else pending += text;
+      }
+      setInterim(pending);
+      if (settled.trim() !== "") finalRef.current(settled);
+    };
+    recognition.onerror = (event) => {
+      if (token !== startTokenRef.current) return;
+      if ((event.error === "not-allowed" || event.error === "service-not-allowed") && micConfirmedRef.current && !retriedRef.current) {
+        retriedRef.current = true;
+        void sleep(RETRY_DELAY_MS).then(() => {
+          if (token !== startTokenRef.current || !wantsListeningRef.current)
+            return;
+          openSessionRef.current?.(token);
+        });
+        return;
+      }
+      const message = micConfirmedRef.current && (event.error === "not-allowed" || event.error === "service-not-allowed") ? MIC_UNAVAILABLE_MESSAGE : describeError(event.error);
+      wantsListeningRef.current = false;
+      setListening(false);
+      setInterim("");
+      if (message !== "") {
+        setError(message);
+        errorRef.current?.(message);
+      }
+    };
+    recognition.onend = () => {
+      if (token !== startTokenRef.current) return;
+      setInterim("");
+      if (wantsListeningRef.current && isTouchDevice()) {
+        void sleep(120).then(() => {
+          if (token !== startTokenRef.current || !wantsListeningRef.current)
+            return;
+          openSessionRef.current?.(token);
+        });
+        return;
+      }
+      setListening(false);
+    };
+    recognitionRef.current = recognition;
+    try {
+      recognition.start();
+    } catch {
+      wantsListeningRef.current = false;
+      setListening(false);
+    }
+  }, []);
+  const openSessionRef = useRef(null);
+  openSessionRef.current = openSession;
+  const start = useCallback(() => {
+    if (!getRecognitionCtor()) return;
+    startTokenRef.current += 1;
+    const token = startTokenRef.current;
+    wantsListeningRef.current = true;
+    retriedRef.current = false;
+    micConfirmedRef.current = false;
+    setError(null);
+    setListening(true);
+    void ensureMicrophoneAccess().then(async (access) => {
+      if (token !== startTokenRef.current) return;
+      if (!access.ok) {
+        wantsListeningRef.current = false;
+        setListening(false);
+        setError(access.message);
+        errorRef.current?.(access.message);
+        return;
+      }
+      micConfirmedRef.current = access.confirmed;
+      if (access.primed) {
+        await sleep(RELEASE_SETTLE_MS);
+        if (token !== startTokenRef.current) return;
+      }
+      openSessionRef.current?.(token);
+    });
+  }, []);
+  const toggle = useCallback(() => {
+    if (listening) stop();
+    else start();
+  }, [listening, start, stop]);
+  useEffect(
+    () => () => {
+      startTokenRef.current += 1;
+      wantsListeningRef.current = false;
+      const recognition = recognitionRef.current;
+      if (!recognition) return;
+      recognition.onresult = null;
+      recognition.onerror = null;
+      recognition.onend = null;
+      recognition.onstart = null;
+      try {
+        recognition.abort();
+      } catch {
+      }
+    },
+    []
+  );
+  return { supported, listening, interim, error, start, stop, toggle };
+}
+var SILENT_FAILURE_MS = 1500;
+function speechPlatform() {
+  if (typeof window === "undefined") return null;
+  const scope = window;
+  const synth = scope.speechSynthesis;
+  const Utterance = scope.SpeechSynthesisUtterance;
+  if (!synth || typeof synth.speak !== "function") return null;
+  if (typeof Utterance !== "function") return null;
+  return { synth, Utterance };
+}
+function normaliseTag(tag) {
+  return tag.trim().toLowerCase().replace(/_/g, "-");
+}
+function primaryOf(tag) {
+  return normaliseTag(tag).split("-")[0] ?? "";
+}
+function pickVoice(voices, lang) {
+  const wanted = normaliseTag(lang);
+  if (wanted === "") return null;
+  const primary = primaryOf(wanted);
+  const exact = voices.filter((voice) => normaliseTag(voice.lang) === wanted);
+  const related = voices.filter((voice) => primaryOf(voice.lang) === primary);
+  return exact.find((voice) => voice.default) ?? exact[0] ?? related.find((voice) => voice.default) ?? related[0] ?? null;
+}
+var activeOwner = null;
+var activeStop = null;
+function stopSpeaking() {
+  activeStop?.();
+}
+function useSpeechOutput({
+  lang
+} = {}) {
+  const [available, setAvailable] = useState(() => speechPlatform() !== null);
+  const [speaking, setSpeaking] = useState(false);
+  const utteranceRef = useRef(null);
+  const watchdogRef = useRef(null);
+  const ownerRef = useRef({});
+  const stopRef = useRef(() => void 0);
+  const langRef = useRef(lang);
+  langRef.current = lang;
+  const clearWatchdog = useCallback(() => {
+    if (watchdogRef.current === null) return;
+    clearTimeout(watchdogRef.current);
+    watchdogRef.current = null;
+  }, []);
+  const settle = useCallback(() => {
+    clearWatchdog();
+    utteranceRef.current = null;
+    if (activeOwner === ownerRef.current) {
+      activeOwner = null;
+      activeStop = null;
+    }
+    setSpeaking(false);
+  }, [clearWatchdog]);
+  const stop = useCallback(() => {
+    const owned = utteranceRef.current !== null;
+    settle();
+    if (owned) speechPlatform()?.synth.cancel();
+  }, [settle]);
+  stopRef.current = stop;
+  const speak = useCallback(
+    (text) => {
+      const platform = speechPlatform();
+      if (!platform) {
+        setAvailable(false);
+        return;
+      }
+      const spoken = text.trim();
+      if (spoken === "") return;
+      if (activeStop && activeOwner !== ownerRef.current) activeStop();
+      platform.synth.cancel();
+      const utterance = new platform.Utterance(spoken);
+      const wanted = langRef.current;
+      if (wanted !== void 0 && wanted !== "") {
+        const voice = pickVoice(platform.synth.getVoices(), wanted);
+        utterance.lang = voice?.lang ?? wanted;
+        if (voice) utterance.voice = voice;
+      }
+      const mine = () => utteranceRef.current === utterance;
+      utterance.onstart = () => {
+        if (!mine()) return;
+        clearWatchdog();
+        setSpeaking(true);
+      };
+      utterance.onend = () => {
+        if (!mine()) return;
+        settle();
+      };
+      utterance.onerror = (event) => {
+        if (!mine()) return;
+        const code = typeof event?.error === "string" ? event.error : "";
+        settle();
+        if (code !== "interrupted" && code !== "canceled") setAvailable(false);
+      };
+      utteranceRef.current = utterance;
+      activeOwner = ownerRef.current;
+      activeStop = () => {
+        stopRef.current();
+      };
+      setSpeaking(true);
+      platform.synth.speak(utterance);
+      clearWatchdog();
+      watchdogRef.current = setTimeout(() => {
+        watchdogRef.current = null;
+        if (!mine()) return;
+        if (platform.synth.speaking) return;
+        settle();
+        setAvailable(false);
+      }, SILENT_FAILURE_MS);
+    },
+    [clearWatchdog, settle]
+  );
+  const toggle = useCallback(
+    (text) => {
+      if (speaking) stop();
+      else speak(text);
+    },
+    [speak, speaking, stop]
+  );
+  useEffect(() => {
+    if (!speaking || typeof window === "undefined") return;
+    const onHide = () => {
+      stopRef.current();
+    };
+    window.addEventListener("pagehide", onHide);
+    return () => window.removeEventListener("pagehide", onHide);
+  }, [speaking]);
+  useEffect(
+    () => () => {
+      stopRef.current();
+    },
+    []
+  );
+  return { supported: available, speaking, speak, stop, toggle };
+}
+
+export { BAKED_CATALOG_ELEMENT_ID, DEFAULT_EXPLORE_EXAMPLE_PROMPTS, ECOSYSTEM_PRODUCTS, ESCALATE_EXPLORE_CONVERSATION_MUTATION, EXPLORE_CATALOG_QUERY, EXPLORE_CATALOG_QUERY_WITHOUT_HIGHLIGHTS, EXPLORE_ESCALATION_NOTE_SOFT_MAX, EXPLORE_FEEDBACK_COMMENT_SOFT_MAX, EXPLORE_FEEDBACK_REASONS, EXPLORE_MESSAGE_QUERY, FALLBACK_EXPLORE_LIMITS, SEND_EXPLORE_MESSAGE_MUTATION, bakedCatalogLocale, classifyExploreError, looksLikeDeliverableEmail, serializeBakedCatalog, stopSpeaking, useExploreChat, useProgressiveReveal, useSpeechInput, useSpeechOutput };
+//# sourceMappingURL=chunk-EUPFS6MZ.mjs.map
+//# sourceMappingURL=chunk-EUPFS6MZ.mjs.map