@burdenoff/website-sdk 2026.828.6 → 2026.829.1

package/dist/hooks/index.mjs

@@ -1276,23 +1276,37 @@ function getRecognitionCtor() {
   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 };
+  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 };
-    if (status?.state === "denied")
-      return { ok: false, message: MIC_DENIED_MESSAGE };
+    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 };
+    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") {
@@ -1335,19 +1349,18 @@ function useSpeechInput({
   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 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;
@@ -1356,82 +1369,111 @@ function useSpeechInput({
       recognition.stop();
     } catch {
     }
-    setListening(false);
-    setInterim("");
   }, []);
-  const start = useCallback(() => {
+  const openSession = useCallback((token) => {
     const Ctor = getRecognitionCtor();
-    if (!Ctor) return;
-    if (recognitionRef.current) stop();
-    setError(null);
-    setListening(true);
+    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;
-    void ensureMicrophoneAccess().then((access) => {
+    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;
       }
-      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 = () => {
+      micConfirmedRef.current = access.confirmed;
+      if (access.primed) {
+        await sleep(RELEASE_SETTLE_MS);
         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;
+      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;