@burdenoff/website-sdk 2026.1105.2 → 2026.1105.3

package/dist/avatar-mic/index.js

@@ -2,6 +2,457 @@
 
 var chunkZSTFX7FV_js = require('../chunk-ZSTFX7FV.js');
 
+// src/avatar-mic/browser-press.ts
+var BROWSER_START_WAIT_MS = 15e3;
+var BROWSER_FINAL_WAIT_MS = 3e3;
+var BROWSER_RESTART_COOLDOWN_MS = 2e3;
+var BROWSER_TOUCH_RESTART_MS = 120;
+var BROWSER_MAX_QUICK_ENDS = 8;
+var BROWSER_MAX_RESTARTS = 60;
+var BROWSER_PRIME_SETTLE_MS = 250;
+var BROWSER_GRANT_RETRY_MS = 350;
+var QUICK_END_MS = 1e3;
+var NETWORK_FAILURES_FOR_GOOD = 2;
+var IDLE = { name: "idle" };
+function isRecognitionConstructor(value) {
+  return typeof value === "function";
+}
+function newBrowserRecognition() {
+  const found = Reflect.get(globalThis, "SpeechRecognition") ?? Reflect.get(globalThis, "webkitSpeechRecognition");
+  return isRecognitionConstructor(found) ? new found() : null;
+}
+function primeBrowserMicrophone() {
+  const media = typeof navigator === "undefined" ? void 0 : navigator.mediaDevices;
+  if (typeof media?.getUserMedia !== "function") return null;
+  return media.getUserMedia({ audio: true }).then((stream) => {
+    for (const track of stream.getTracks()) track.stop();
+  });
+}
+function watchBrowserMicPermission(onState) {
+  const permissions = typeof navigator === "undefined" ? void 0 : navigator.permissions;
+  if (typeof permissions?.query !== "function") return;
+  try {
+    void permissions.query({ name: "microphone" }).then(
+      (status) => {
+        onState(status.state);
+        status.addEventListener("change", () => onState(status.state));
+      },
+      () => void 0
+    );
+  } catch {
+  }
+}
+function hasCoarsePointer() {
+  if (typeof window === "undefined" || typeof window.matchMedia !== "function") {
+    return false;
+  }
+  try {
+    return window.matchMedia("(pointer: coarse)").matches;
+  } catch {
+    return false;
+  }
+}
+var BROWSER = {
+  createRecognition: newBrowserRecognition,
+  now: () => typeof performance !== "undefined" ? performance.now() : Date.now(),
+  primeMicrophone: primeBrowserMicrophone,
+  watchMicPermission: watchBrowserMicPermission,
+  touch: hasCoarsePointer
+};
+function primeFailure(error) {
+  const name = typeof error === "object" && error !== null && "name" in error ? String(error.name) : "";
+  if (name === "NotAllowedError" || name === "SecurityError") return "denied";
+  if (name === "NotFoundError" || name === "DevicesNotFoundError") {
+    return "unsupported";
+  }
+  return "failed";
+}
+function tidy(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function readRecognitionResults(results) {
+  const finals = [];
+  const interim = [];
+  for (let index = 0; index < results.length; index += 1) {
+    const result = results[index];
+    const text = tidy(result?.[0]?.transcript ?? "");
+    if (result === void 0 || text === "") continue;
+    if (!result.isFinal) {
+      interim.push(text);
+      continue;
+    }
+    const last = finals.length > 0 ? finals[finals.length - 1] : void 0;
+    const lower = text.toLowerCase();
+    if (last !== void 0 && (lower === last.toLowerCase() || lower.startsWith(`${last.toLowerCase()} `))) {
+      finals[finals.length - 1] = text;
+    } else {
+      finals.push(text);
+    }
+  }
+  return { finals, interim: interim.join(" ") };
+}
+function createBrowserAvatarMic(options, seams = {}) {
+  const { createRecognition, now, primeMicrophone, watchMicPermission, touch } = { ...BROWSER, ...seams };
+  let press = null;
+  let epoch = 0;
+  let state = IDLE;
+  let networkFailures = 0;
+  let permission = null;
+  let hadMicrophone = false;
+  watchMicPermission((next) => {
+    permission = next;
+  });
+  const report = (next) => {
+    state = next;
+    options.onState(next);
+  };
+  const heard = (p) => [...p.earlier, ...p.instance?.finals ?? [], p.instance?.interim ?? ""].filter((part) => part !== "").join(" ");
+  const show = (p) => {
+    if (p.stage === "listening") {
+      report({
+        name: "listening",
+        epoch: p.epoch,
+        startedAt: p.startedAt,
+        text: heard(p)
+      });
+    } else if (p.stage === "finishing") {
+      report({
+        name: "finishing",
+        epoch: p.epoch,
+        text: heard(p),
+        limit: p.limit
+      });
+    }
+  };
+  const release = (instance) => {
+    const { recognition } = instance;
+    recognition.onstart = null;
+    recognition.onresult = null;
+    recognition.onerror = null;
+    recognition.onend = null;
+    try {
+      recognition.abort();
+    } catch {
+    }
+  };
+  const clearTimers = (p) => {
+    for (const timer of [
+      p.startTimer,
+      p.limitTimer,
+      p.finalTimer,
+      p.launchTimer
+    ]) {
+      if (timer !== null) clearTimeout(timer);
+    }
+    p.startTimer = null;
+    p.limitTimer = null;
+    p.finalTimer = null;
+    p.launchTimer = null;
+  };
+  const settle = (p, next) => {
+    if (p.stage === "ended") return;
+    p.stage = "ended";
+    clearTimers(p);
+    const instance = p.instance;
+    p.instance = null;
+    if (instance !== null) release(instance);
+    if (press === p) press = null;
+    report(next);
+  };
+  const complete = (p) => {
+    const text = heard(p);
+    if (text !== "") networkFailures = 0;
+    settle(p, { name: "done", epoch: p.epoch, text, limit: p.limit });
+  };
+  const fail = (p, reason) => settle(p, { name: "failed", epoch: p.epoch, reason, text: heard(p) });
+  const current = (p, instance) => press === p && p.stage !== "ended" && p.instance === instance;
+  const began = (p, instance) => {
+    instance.started = true;
+    instance.startedAt = now();
+    hadMicrophone = true;
+    if (p.stage !== "starting") return;
+    if (p.startTimer !== null) clearTimeout(p.startTimer);
+    p.startTimer = null;
+    p.stage = "listening";
+    p.startedAt = Date.now();
+    p.limitTimer = setTimeout(() => {
+      p.limitTimer = null;
+      if (press === p) stopRecording(p, true);
+    }, options.maxPressMs);
+  };
+  const launchIn = (p, delay) => {
+    if (delay <= 0) {
+      launch(p);
+      return;
+    }
+    const stage = p.stage;
+    p.launchTimer = setTimeout(() => {
+      p.launchTimer = null;
+      if (press === p && p.stage === stage) launch(p);
+    }, delay);
+  };
+  const restart = (p, end) => {
+    p.quickEnds = end === "listened" ? 0 : p.quickEnds + 1;
+    if (p.restarts >= BROWSER_MAX_RESTARTS || p.quickEnds >= BROWSER_MAX_QUICK_ENDS) {
+      complete(p);
+      return;
+    }
+    p.restarts += 1;
+    launchIn(
+      p,
+      end === "threw" || end === "quick" && !p.touch ? BROWSER_RESTART_COOLDOWN_MS : p.touch ? BROWSER_TOUCH_RESTART_MS : 0
+    );
+  };
+  const keep = (p, instance) => {
+    for (const text of [...instance.finals, instance.interim]) {
+      if (text !== "") p.earlier.push(text);
+    }
+  };
+  const onError = (p, instance, code) => {
+    if (code === "no-speech") {
+      instance.noSpeech = true;
+      return;
+    }
+    const going = p.stage === "starting" || p.stage === "listening";
+    if (code === "language-not-supported" && going && !p.langRetried) {
+      p.langRetried = true;
+      if (options.fallbackLang !== p.lang) {
+        p.lang = options.fallbackLang;
+        keep(p, instance);
+        p.instance = null;
+        release(instance);
+        launch(p);
+        return;
+      }
+    }
+    const refused = code === "not-allowed" || code === "service-not-allowed";
+    if (refused && going && p.confirmed && !p.grantRetried) {
+      p.grantRetried = true;
+      keep(p, instance);
+      p.instance = null;
+      release(instance);
+      launchIn(p, BROWSER_GRANT_RETRY_MS);
+      return;
+    }
+    if (refused && !p.confirmed) hadMicrophone = false;
+    if (heard(p) !== "") {
+      complete(p);
+      return;
+    }
+    switch (code) {
+      case "not-allowed":
+        fail(p, p.confirmed ? "unsupported" : "denied");
+        return;
+      case "service-not-allowed":
+      case "audio-capture":
+      case "language-not-supported":
+        fail(p, "unsupported");
+        return;
+      case "network":
+        networkFailures += 1;
+        fail(
+          p,
+          networkFailures >= NETWORK_FAILURES_FOR_GOOD ? "unsupported" : "failed"
+        );
+        return;
+      default:
+        fail(p, "failed");
+    }
+  };
+  const onEnd = (p, instance) => {
+    keep(p, instance);
+    p.instance = null;
+    instance.recognition.onstart = null;
+    instance.recognition.onresult = null;
+    instance.recognition.onerror = null;
+    instance.recognition.onend = null;
+    switch (p.stage) {
+      case "starting":
+        if (instance.noSpeech) complete(p);
+        else fail(p, "failed");
+        return;
+      case "listening": {
+        const quick = !instance.started || now() - instance.startedAt < QUICK_END_MS && instance.finals.length === 0 && instance.interim === "";
+        restart(p, quick ? "quick" : "listened");
+        return;
+      }
+      case "finishing":
+        complete(p);
+        return;
+      default:
+        return;
+    }
+  };
+  function launch(p) {
+    let recognition;
+    try {
+      recognition = createRecognition();
+    } catch {
+      recognition = null;
+    }
+    if (recognition === null) {
+      if (p.stage === "starting") fail(p, "unsupported");
+      else complete(p);
+      return;
+    }
+    const instance = {
+      recognition,
+      started: false,
+      startedAt: 0,
+      finals: [],
+      interim: "",
+      noSpeech: false
+    };
+    recognition.lang = p.lang;
+    recognition.continuous = !p.touch;
+    recognition.interimResults = true;
+    recognition.maxAlternatives = 1;
+    recognition.onstart = () => {
+      if (!current(p, instance)) return;
+      began(p, instance);
+      show(p);
+    };
+    recognition.onresult = (event) => {
+      if (!current(p, instance)) return;
+      if (!instance.started) began(p, instance);
+      const read = readRecognitionResults(event.results);
+      instance.finals = read.finals;
+      instance.interim = read.interim;
+      show(p);
+    };
+    recognition.onerror = (event) => {
+      if (current(p, instance)) onError(p, instance, event.error);
+    };
+    recognition.onend = () => {
+      if (current(p, instance)) onEnd(p, instance);
+    };
+    p.instance = instance;
+    try {
+      recognition.start();
+    } catch {
+      p.instance = null;
+      release(instance);
+      if (p.stage === "starting") fail(p, "failed");
+      else if (p.stage === "listening") restart(p, "threw");
+      else complete(p);
+    }
+  }
+  function prime(p) {
+    let opening;
+    try {
+      opening = primeMicrophone();
+    } catch (error) {
+      fail(p, primeFailure(error));
+      return;
+    }
+    if (opening === null) {
+      launch(p);
+      return;
+    }
+    void opening.then(
+      () => {
+        hadMicrophone = true;
+        if (press !== p || p.stage !== "starting") return;
+        p.confirmed = true;
+        launchIn(p, BROWSER_PRIME_SETTLE_MS);
+      },
+      (error) => {
+        if (press === p && p.stage === "starting") fail(p, primeFailure(error));
+      }
+    );
+  }
+  function stopRecording(p, limit) {
+    if (p.stage !== "listening") return;
+    if (p.limitTimer !== null) clearTimeout(p.limitTimer);
+    if (p.launchTimer !== null) clearTimeout(p.launchTimer);
+    p.limitTimer = null;
+    p.launchTimer = null;
+    p.stage = "finishing";
+    p.limit = limit;
+    const instance = p.instance;
+    if (instance === null || !instance.started) {
+      complete(p);
+      return;
+    }
+    try {
+      instance.recognition.stop();
+    } catch {
+      complete(p);
+      return;
+    }
+    p.finalTimer = setTimeout(() => {
+      p.finalTimer = null;
+      if (press === p && p.stage === "finishing") complete(p);
+    }, BROWSER_FINAL_WAIT_MS);
+    show(p);
+  }
+  const cancel = () => {
+    const p = press;
+    press = null;
+    if (p !== null && p.stage !== "ended") {
+      p.stage = "ended";
+      clearTimers(p);
+      const instance = p.instance;
+      p.instance = null;
+      if (instance !== null) release(instance);
+    }
+    if (state.name !== "idle") report(IDLE);
+  };
+  const start = () => {
+    const held = press;
+    if (held !== null && (held.stage === "starting" || held.stage === "listening")) {
+      return;
+    }
+    if (held !== null && held.stage === "finishing") {
+      held.stage = "ended";
+      clearTimers(held);
+      const instance = held.instance;
+      held.instance = null;
+      if (instance !== null) release(instance);
+      press = null;
+    }
+    epoch += 1;
+    const p = {
+      epoch,
+      stage: "starting",
+      instance: null,
+      earlier: [],
+      lang: options.lang,
+      langRetried: false,
+      restarts: 0,
+      quickEnds: 0,
+      confirmed: permission === "granted",
+      grantRetried: false,
+      touch: touch(),
+      startedAt: 0,
+      limit: false,
+      startTimer: null,
+      limitTimer: null,
+      finalTimer: null,
+      launchTimer: null
+    };
+    press = p;
+    report({ name: "starting", epoch });
+    p.startTimer = setTimeout(() => {
+      p.startTimer = null;
+      if (press === p && p.stage === "starting") fail(p, "failed");
+    }, BROWSER_START_WAIT_MS);
+    if (p.confirmed || permission === null && hadMicrophone) launch(p);
+    else prime(p);
+  };
+  return {
+    start,
+    stop() {
+      const p = press;
+      if (p === null) return;
+      if (p.stage === "starting") cancel();
+      else stopRecording(p, false);
+    },
+    cancel,
+    state: () => state
+  };
+}
+
 // src/avatar-mic/capture-worklet.ts
 var CAPTURE_FRAME_SAMPLES = 320;
 var CAPTURE_SAMPLE_RATE = 16e3;
@@ -324,7 +775,7 @@ var FINAL_WAIT_MS = 12e3;
 var OFFER_TTL_MS = 12e4;
 var OFFER_MARGIN_MS = 5e3;
 var CLOCK_TOLERANCE_MS = 5e3;
-var IDLE = { name: "idle" };
+var IDLE2 = { name: "idle" };
 function offerFreshUntil(offer) {
   const ahead = offer.expiresAt - offer.receivedAt;
   const life = ahead > 0 && ahead <= OFFER_TTL_MS + CLOCK_TOLERANCE_MS ? Math.min(ahead, OFFER_TTL_MS) : OFFER_TTL_MS;
@@ -357,20 +808,20 @@ function randomUtteranceId() {
   const bytes = crypto.getRandomValues(new Uint8Array(16));
   return `web-${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
 }
-var BROWSER = {
+var BROWSER2 = {
   createSocket: openBrowserSocket,
   startCapture: startMicCapture,
   newUtteranceId: randomUtteranceId
 };
 function createAvatarMic(options, seams = {}) {
   const { createSocket, startCapture, newUtteranceId } = {
-    ...BROWSER,
+    ...BROWSER2,
     ...seams
   };
   let press = null;
   let connection = null;
   let epoch = 0;
-  let state = IDLE;
+  let state = IDLE2;
   const report = (next) => {
     state = next;
     options.onState(next);
@@ -652,7 +1103,7 @@ function createAvatarMic(options, seams = {}) {
       clearTimers(p);
     }
     closeConnection();
-    if (state.name !== "idle") report(IDLE);
+    if (state.name !== "idle") report(IDLE2);
   };
   const start = () => {
     const current = press;
@@ -734,5 +1185,6 @@ function createAvatarMic(options, seams = {}) {
 }
 
 exports.createAvatarMic = createAvatarMic;
+exports.createBrowserAvatarMic = createBrowserAvatarMic;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map