@burdenoff/website-sdk 2026.828.4 → 2026.828.6

package/dist/hooks/index.mjs

@@ -559,6 +559,8 @@ async function getRecaptchaV3Token(siteKey, action = EXPLORE_RECAPTCHA_ACTION) {
 
 // src/hooks/use-explore-chat.ts
 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;
@@ -697,10 +699,58 @@ function classifyExploreError(code, serverMessage) {
     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.sessionStorage.getItem(key);
+    const raw = window.localStorage.getItem(key);
     if (!raw) return null;
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") return null;
@@ -745,6 +795,8 @@ function useExploreChat(options = {}) {
   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);
@@ -782,6 +834,7 @@ function useExploreChat(options = {}) {
       setHydrated(true);
       return;
     }
+    setArchive(readArchive(storageKey));
     const stored = readPersisted(storageKey);
     if (stored) {
       conversationTokenRef.current = stored.conversationToken;
@@ -810,13 +863,28 @@ function useExploreChat(options = {}) {
         focusProduct
       };
       if (!payload.conversationToken && payload.messages.length === 0 && !payload.focusProduct) {
-        window.sessionStorage.removeItem(storageKey);
+        window.localStorage.removeItem(storageKey);
         return;
       }
-      window.sessionStorage.setItem(storageKey, JSON.stringify(payload));
+      window.localStorage.setItem(storageKey, JSON.stringify(payload));
     } catch {
     }
   }, [persist, hydrated, storageKey, messages, focusProduct]);
+  useEffect(() => {
+    messagesRef.current = messages;
+    if (!persist || !hydrated) 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, storageKey]);
   useEffect(() => {
     let cancelled = false;
     const load = async () => {
@@ -1102,6 +1170,13 @@ function useExploreChat(options = {}) {
     void send(text);
   }, [cancelPolling, send]);
   const reset = useCallback(() => {
+    setArchive(
+      upsertArchive(storageKey, {
+        token: conversationTokenRef.current,
+        messages: messagesRef.current,
+        focusProduct: focusProductRef.current
+      })
+    );
     cancelPolling();
     inFlightRef.current = false;
     conversationTokenRef.current = null;
@@ -1114,11 +1189,48 @@ function useExploreChat(options = {}) {
     setPhase(catalogRef.current.enabled ? "ready" : "disabled");
     if (typeof window !== "undefined") {
       try {
-        window.sessionStorage.removeItem(storageKey);
+        window.localStorage.removeItem(storageKey);
       } catch {
       }
     }
   }, [cancelPolling, 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;
+      conversationTokenRef.current = 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, 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);
@@ -1147,7 +1259,11 @@ function useExploreChat(options = {}) {
     stop,
     retry,
     reset,
-    canSend
+    canSend,
+    history: archive,
+    openConversation,
+    deleteConversation,
+    clearHistory
   };
 }
 var optimisticCounter = 0;
@@ -1155,7 +1271,183 @@ function makeOptimisticId() {
   optimisticCounter += 1;
   return `boff-explore-local-${Date.now()}-${optimisticCounter}`;
 }
+function getRecognitionCtor() {
+  if (typeof window === "undefined") return null;
+  const w = window;
+  return w.SpeechRecognition ?? w.webkitSpeechRecognition ?? null;
+}
+var MIC_DENIED_MESSAGE = "Microphone access was blocked. Allow it in your browser's site settings to dictate.";
+async function ensureMicrophoneAccess() {
+  const media = typeof navigator === "undefined" ? void 0 : navigator.mediaDevices;
+  if (!media?.getUserMedia) return { ok: true };
+  try {
+    const status = await navigator.permissions?.query({
+      name: "microphone"
+    });
+    if (status?.state === "granted") return { ok: true };
+    if (status?.state === "denied")
+      return { ok: false, message: MIC_DENIED_MESSAGE };
+  } catch {
+  }
+  try {
+    const stream = await media.getUserMedia({ audio: true });
+    for (const track of stream.getTracks()) track.stop();
+    return { ok: 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 beginRecognitionRef = useRef(null);
+  const beginRecognition = useCallback(
+    (Ctor, token) => {
+      beginRecognitionRef.current?.(Ctor, token);
+    },
+    []
+  );
+  const finalRef = useRef(onFinalTranscript);
+  const errorRef = useRef(onError);
+  finalRef.current = onFinalTranscript;
+  errorRef.current = onError;
+  const stop = useCallback(() => {
+    startTokenRef.current += 1;
+    setListening(false);
+    setInterim("");
+    const recognition = recognitionRef.current;
+    if (!recognition) return;
+    try {
+      recognition.stop();
+    } catch {
+    }
+    setListening(false);
+    setInterim("");
+  }, []);
+  const start = useCallback(() => {
+    const Ctor = getRecognitionCtor();
+    if (!Ctor) return;
+    if (recognitionRef.current) stop();
+    setError(null);
+    setListening(true);
+    startTokenRef.current += 1;
+    const token = startTokenRef.current;
+    void ensureMicrophoneAccess().then((access) => {
+      if (token !== startTokenRef.current) return;
+      if (!access.ok) {
+        setListening(false);
+        setError(access.message);
+        errorRef.current?.(access.message);
+        return;
+      }
+      beginRecognition(Ctor, token);
+    });
+  }, [beginRecognition, stop]);
+  const beginRecognitionImpl = useCallback(
+    (Ctor, token) => {
+      const recognition = new Ctor();
+      recognition.lang = lang ?? (typeof navigator === "undefined" ? "en-US" : navigator.language || "en-US");
+      recognition.continuous = true;
+      recognition.interimResults = true;
+      recognition.maxAlternatives = 1;
+      recognition.onstart = () => {
+        if (token !== startTokenRef.current) return;
+        setError(null);
+        setListening(true);
+      };
+      recognition.onresult = (event) => {
+        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) => {
+        const message = describeError(event.error);
+        setListening(false);
+        setInterim("");
+        if (message !== "") {
+          setError(message);
+          errorRef.current?.(message);
+        }
+      };
+      recognition.onend = () => {
+        setListening(false);
+        setInterim("");
+      };
+      recognitionRef.current = recognition;
+      try {
+        recognition.start();
+      } catch {
+        setListening(false);
+      }
+    },
+    [lang]
+  );
+  beginRecognitionRef.current = beginRecognitionImpl;
+  const toggle = useCallback(() => {
+    if (listening) stop();
+    else start();
+  }, [listening, start, stop]);
+  useEffect(
+    () => () => {
+      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 };
+}
 
-export { DEFAULT_EXPLORE_EXAMPLE_PROMPTS, FALLBACK_EXPLORE_LIMITS, classifyExploreError, useExploreChat };
+export { DEFAULT_EXPLORE_EXAMPLE_PROMPTS, FALLBACK_EXPLORE_LIMITS, classifyExploreError, useExploreChat, useSpeechInput };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map