@burdenoff/website-sdk 2026.1105.2 → 2026.1106.1

package/dist/avatar-mic/index.js

@@ -2,6 +2,717 @@
 
 var chunkZSTFX7FV_js = require('../chunk-ZSTFX7FV.js');
 
+// src/avatar-mic/speech-words.ts
+var FILLERS = /* @__PURE__ */ new Set([
+  "uh",
+  "um",
+  "uhm",
+  "umm",
+  "er",
+  "erm",
+  "eh",
+  "ah",
+  "hm",
+  "hmm",
+  "hmmm",
+  "mm",
+  "mmm",
+  "mhm",
+  "huh",
+  "oh",
+  "so",
+  "well",
+  "okay",
+  "ok",
+  "and",
+  "like",
+  "hey",
+  "hi",
+  "hello",
+  "actually"
+]);
+var OPEN_ENDINGS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "of",
+  "to",
+  "for",
+  "about",
+  "and",
+  "or",
+  "but",
+  "what",
+  "how",
+  "which",
+  "is",
+  "are",
+  "can"
+]);
+var PRONOUNS = /* @__PURE__ */ new Set([
+  "i",
+  "me",
+  "you",
+  "it",
+  "we",
+  "us",
+  "they",
+  "them",
+  "he",
+  "him",
+  "she",
+  "her",
+  "this",
+  "that",
+  "these",
+  "those"
+]);
+var ECHO_MIN_WORDS = 3;
+var SELF_CONTAINED_SCRIPT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+function tidyWords(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function speechWords(text) {
+  const flat = text.toLowerCase().replace(/[^\p{L}\p{M}\p{N}]+/gu, " ").trim();
+  return flat === "" ? [] : flat.split(" ");
+}
+function startsWithWords(whole, head) {
+  return head.length <= whole.length && head.every((word, index) => whole[index] === word);
+}
+function endsWithWords(whole, tail) {
+  return tail.length <= whole.length && tail.every(
+    (word, index) => whole[whole.length - tail.length + index] === word
+  );
+}
+function startsWithWordsOf(text, head) {
+  return startsWithWords(speechWords(text), speechWords(head));
+}
+function mergeTurnPhrase(turn, phrase) {
+  const heard = speechWords(turn);
+  const incoming = speechWords(phrase);
+  if (incoming.length === 0) return turn;
+  if (heard.length === 0) return tidyWords(phrase);
+  if (startsWithWords(incoming, heard)) {
+    return incoming.length === heard.length ? turn : tidyWords(phrase);
+  }
+  if (incoming.length >= 2 && endsWithWords(heard, incoming)) return turn;
+  return tidyWords(`${turn} ${phrase}`);
+}
+function mergeInterim(turn, interim) {
+  const said = tidyWords(interim);
+  if (said === "") return turn;
+  const head = speechWords(turn);
+  if (head.length === 0) return said;
+  const tokens = said.split(" ");
+  let matched = 0;
+  for (let at = 0; at < tokens.length; at += 1) {
+    const words = speechWords(tokens[at] ?? "");
+    for (const word of words) {
+      if (word !== head[matched]) return tidyWords(`${turn} ${said}`);
+      matched += 1;
+      if (matched === head.length) {
+        return tidyWords(`${turn} ${tokens.slice(at + 1).join(" ")}`);
+      }
+    }
+  }
+  return tidyWords(`${turn} ${said}`);
+}
+function saidWords(words) {
+  return words.filter((word) => !FILLERS.has(word));
+}
+function isGenuineSpeech(text) {
+  const said = saidWords(speechWords(text));
+  if (said.length === 1 && PRONOUNS.has(said[0] ?? "")) return false;
+  const content = said.filter((word) => !OPEN_ENDINGS.has(word));
+  if (content.length === 0) return false;
+  const letters = [...content.join("")];
+  if (letters.length >= 2) return true;
+  return letters.length === 1 && SELF_CONTAINED_SCRIPT.test(letters[0] ?? "");
+}
+function waitsLonger(text) {
+  const words = speechWords(text);
+  const last = words[words.length - 1];
+  if (last === void 0) return false;
+  return saidWords(words).length <= 1 || OPEN_ENDINGS.has(last) || FILLERS.has(last);
+}
+function isEchoOf(text, spoken) {
+  if (spoken === null) return false;
+  const heard = speechWords(text);
+  if (heard.length < ECHO_MIN_WORDS) return false;
+  return ` ${speechWords(spoken).join(" ")} `.includes(` ${heard.join(" ")} `);
+}
+
+// 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 BROWSER_PAUSE_MIN_MS = 2e3;
+var BROWSER_PAUSE_MAX_MS = 2500;
+var BROWSER_PAUSE_AFTER_START_MS = 1500;
+var BROWSER_PAUSE_SHOWN_MS = 800;
+var BROWSER_ECHO_WINDOW_MS = 2500;
+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;
+    if (last !== void 0 && startsWithWordsOf(text, last)) {
+      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 };
+  const { endpoint } = options;
+  const pauseMs = endpoint === void 0 || !Number.isFinite(endpoint.pauseMs) ? BROWSER_PAUSE_MIN_MS : Math.min(
+    BROWSER_PAUSE_MAX_MS,
+    Math.max(BROWSER_PAUSE_MIN_MS, endpoint.pauseMs)
+  );
+  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 turnOf = (earlier, instance) => {
+    let turn = earlier;
+    for (const final of instance?.finals ?? []) {
+      turn = mergeTurnPhrase(turn, final);
+    }
+    return mergeInterim(turn, instance?.interim ?? "");
+  };
+  const heard = (p) => turnOf(p.earlier, p.instance);
+  const show = (p) => {
+    if (p.stage === "listening") {
+      const text = heard(p);
+      report({
+        name: "listening",
+        epoch: p.epoch,
+        startedAt: p.startedAt,
+        text,
+        ...endpoint === void 0 ? {} : { genuine: isGenuineSpeech(text), pausing: p.pausing }
+      });
+    } 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,
+      p.pauseTimer,
+      p.pausingTimer
+    ]) {
+      if (timer !== null) clearTimeout(timer);
+    }
+    p.startTimer = null;
+    p.limitTimer = null;
+    p.finalTimer = null;
+    p.launchTimer = null;
+    p.pauseTimer = null;
+    p.pausingTimer = null;
+  };
+  const clearPause = (p) => {
+    if (p.pauseTimer !== null) clearTimeout(p.pauseTimer);
+    if (p.pausingTimer !== null) clearTimeout(p.pausingTimer);
+    p.pauseTimer = null;
+    p.pausingTimer = 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;
+    if (endpoint === void 0) {
+      settle(p, { name: "done", epoch: p.epoch, text, limit: p.limit });
+      return;
+    }
+    const by = p.stage === "finishing" ? p.by ?? "tap" : p.stage === "starting" ? "silence" : "failed";
+    const echo = by === "pause" && p.speechAt !== null && p.speechAt - p.listenedAt <= BROWSER_ECHO_WINDOW_MS && isEchoOf(text, endpoint.echoOf());
+    settle(p, {
+      name: "done",
+      epoch: p.epoch,
+      text,
+      limit: p.limit,
+      by,
+      echo
+    });
+  };
+  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 armPause = (p, turn, speech) => {
+    clearPause(p);
+    if (!speech) return;
+    const at = now();
+    if (!p.pausing) {
+      p.pausingTimer = setTimeout(
+        () => {
+          p.pausingTimer = null;
+          if (press !== p || p.stage !== "listening") return;
+          p.pausing = true;
+          show(p);
+        },
+        Math.max(0, p.wordsAt + BROWSER_PAUSE_SHOWN_MS - at)
+      );
+    }
+    const instance = p.instance;
+    if (instance === null || !instance.started) return;
+    const wait = waitsLonger(turn) ? 2 * pauseMs : pauseMs;
+    const due = Math.max(
+      p.wordsAt + wait,
+      instance.startedAt + BROWSER_PAUSE_AFTER_START_MS
+    );
+    p.pauseTimer = setTimeout(
+      () => {
+        p.pauseTimer = null;
+        if (press === p && p.stage === "listening" && p.instance === instance) {
+          stopRecording(p, "pause");
+        }
+      },
+      Math.max(0, due - at)
+    );
+  };
+  const listenOn = (p) => {
+    if (endpoint === void 0 || p.stage !== "listening") return;
+    const turn = heard(p);
+    const words = speechWords(turn).join(" ");
+    const at = now();
+    if (words !== p.words) {
+      p.words = words;
+      p.wordsAt = at;
+      p.pausing = false;
+    }
+    const speech = isGenuineSpeech(turn);
+    if (speech && p.speechAt === null) {
+      p.speechAt = at;
+      if (p.limitTimer !== null) clearTimeout(p.limitTimer);
+      p.limitTimer = setTimeout(() => {
+        p.limitTimer = null;
+        if (press === p) stopRecording(p, "limit");
+      }, options.maxPressMs);
+    }
+    armPause(p, turn, speech);
+  };
+  const began = (p, instance) => {
+    instance.started = true;
+    instance.startedAt = now();
+    hadMicrophone = true;
+    if (p.stage === "starting") {
+      if (p.startTimer !== null) clearTimeout(p.startTimer);
+      p.startTimer = null;
+      p.stage = "listening";
+      p.startedAt = Date.now();
+      p.listenedAt = instance.startedAt;
+      p.limitTimer = setTimeout(() => {
+        p.limitTimer = null;
+        if (press !== p) return;
+        if (endpoint === void 0) {
+          stopRecording(p, "limit");
+        } else if (p.stage === "listening" && p.speechAt === null) {
+          settle(p, {
+            name: "done",
+            epoch: p.epoch,
+            text: "",
+            limit: false,
+            by: "silence",
+            echo: false
+          });
+        }
+      }, options.maxPressMs);
+    }
+    listenOn(p);
+  };
+  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) => {
+    p.earlier = turnOf(p.earlier, instance);
+  };
+  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": {
+        if (p.pauseTimer !== null) clearTimeout(p.pauseTimer);
+        p.pauseTimer = null;
+        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;
+      listenOn(p);
+      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, by) {
+    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;
+    clearPause(p);
+    p.stage = "finishing";
+    p.limit = by === "limit";
+    p.by = by;
+    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,
+      by: null,
+      words: "",
+      wordsAt: 0,
+      speechAt: null,
+      listenedAt: 0,
+      pausing: false,
+      pauseTimer: null,
+      pausingTimer: 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, "tap");
+    },
+    cancel,
+    state: () => state
+  };
+}
+
 // src/avatar-mic/capture-worklet.ts
 var CAPTURE_FRAME_SAMPLES = 320;
 var CAPTURE_SAMPLE_RATE = 16e3;
@@ -324,7 +1035,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 +1068,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 +1363,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 +1445,6 @@ function createAvatarMic(options, seams = {}) {
 }
 
 exports.createAvatarMic = createAvatarMic;
+exports.createBrowserAvatarMic = createBrowserAvatarMic;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map