@burdenoff/website-sdk 2026.1104.3 → 2026.1105.1

package/dist/avatar-mic/index.mjs

@@ -0,0 +1,736 @@
+import { __publicField } from '../chunk-VNS5WDWO.mjs';
+
+// src/avatar-mic/capture-worklet.ts
+var CAPTURE_FRAME_SAMPLES = 320;
+var CAPTURE_SAMPLE_RATE = 16e3;
+var CAPTURE_PROCESSOR_NAME = "boff-handsfree-capture";
+var CAPTURE_WORKLET_SOURCE = `
+"use strict";
+const FRAME = ${CAPTURE_FRAME_SAMPLES};
+class BoffHandsfreeCapture extends AudioWorkletProcessor {
+  constructor() {
+    super();
+    this.step = sampleRate / ${CAPTURE_SAMPLE_RATE};
+    this.half = 6 * this.step;
+    this.fc = 7200 / sampleRate;
+    this.buf = new Float32Array(Math.ceil(this.half * 2) + 4096);
+    this.len = 0;
+    this.pos = 0;
+    this.frame = new Float32Array(FRAME);
+    this.n = 0;
+    this.seq = 0;
+    this.refEnergy = 0;
+    this.refCount = 0;
+    this.stopped = false;
+    this.port.onmessage = (e) => { if (e.data && e.data.type === "stop") this.stopped = true; };
+  }
+  tap(d) {
+    const x = 2 * this.fc * d;
+    const s = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+    return 2 * this.fc * s * 0.5 * (1 + Math.cos(Math.PI * d / this.half));
+  }
+  emit() {
+    const pcm = new Int16Array(FRAME);
+    let energy = 0;
+    let crossings = 0;
+    for (let i = 0; i < FRAME; i++) {
+      const v = Math.max(-1, Math.min(1, this.frame[i]));
+      pcm[i] = Math.round(v * 32767);
+      energy += v * v;
+      if (i > 0 && (v >= 0) !== (this.frame[i - 1] >= 0)) crossings++;
+    }
+    const refMean = this.refCount > 0 ? this.refEnergy / this.refCount : 0;
+    this.port.postMessage({
+      pcm: pcm.buffer,
+      rmsDb: 10 * Math.log10(energy / FRAME + 1e-9),
+      refDb: 10 * Math.log10(refMean + 1e-9),
+      zcr: crossings / FRAME,
+      ctxTime: currentTime,
+      seq: this.seq++,
+    }, [pcm.buffer]);
+    this.n = 0;
+    this.refEnergy = 0;
+    this.refCount = 0;
+  }
+  process(inputs) {
+    if (this.stopped) return false;
+    const mic = inputs[0] && inputs[0][0];
+    if (!mic) return true;
+    const ref = inputs[1] && inputs[1][0];
+    if (ref) { for (let i = 0; i < ref.length; i++) this.refEnergy += ref[i] * ref[i]; }
+    this.refCount += mic.length;
+    if (this.len + mic.length > this.buf.length) {
+      const grown = new Float32Array((this.len + mic.length) * 2);
+      grown.set(this.buf.subarray(0, this.len));
+      this.buf = grown;
+    }
+    this.buf.set(mic, this.len);
+    this.len += mic.length;
+    while (this.pos + this.half < this.len) {
+      const from = Math.max(0, Math.ceil(this.pos - this.half));
+      const to = Math.floor(this.pos + this.half);
+      let acc = 0;
+      for (let i = from; i <= to; i++) acc += this.buf[i] * this.tap(i - this.pos);
+      this.frame[this.n++] = acc;
+      this.pos += this.step;
+      if (this.n === FRAME) this.emit();
+    }
+    const drop = Math.max(0, Math.floor(this.pos - this.half));
+    if (drop > 0) {
+      this.buf.copyWithin(0, drop, this.len);
+      this.len -= drop;
+      this.pos -= drop;
+    }
+    return true;
+  }
+}
+registerProcessor("${CAPTURE_PROCESSOR_NAME}", BoffHandsfreeCapture);
+`;
+
+// src/avatar-mic/mic-capture.ts
+var MicCaptureError = class extends Error {
+  constructor(reason) {
+    super(`mic capture failed: ${reason}`);
+    __publicField(this, "reason", reason);
+    this.name = "MicCaptureError";
+  }
+};
+var CAPTURE_CONSTRAINTS = {
+  audio: {
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true,
+    channelCount: 1
+  }
+};
+function isMicCaptureSupported() {
+  return typeof navigator !== "undefined" && typeof navigator.mediaDevices?.getUserMedia === "function" && typeof AudioContext !== "undefined" && typeof AudioWorkletNode !== "undefined";
+}
+async function startMicCapture(onFrame) {
+  if (!isMicCaptureSupported()) throw new MicCaptureError("unsupported");
+  let stream;
+  try {
+    stream = await navigator.mediaDevices.getUserMedia(CAPTURE_CONSTRAINTS);
+  } catch (cause) {
+    const name = cause instanceof DOMException ? cause.name : "";
+    throw new MicCaptureError(
+      name === "NotAllowedError" || name === "SecurityError" ? "not-allowed" : "unavailable"
+    );
+  }
+  const track = stream.getAudioTracks()[0];
+  if (!track) {
+    stream.getTracks().forEach((t) => t.stop());
+    throw new MicCaptureError("unavailable");
+  }
+  const context = new AudioContext({ latencyHint: "interactive" });
+  const release = () => {
+    stream.getTracks().forEach((t) => t.stop());
+  };
+  try {
+    await context.resume();
+    const url = URL.createObjectURL(
+      new Blob([CAPTURE_WORKLET_SOURCE], { type: "text/javascript" })
+    );
+    try {
+      await context.audioWorklet.addModule(url);
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+    const node = new AudioWorkletNode(context, CAPTURE_PROCESSOR_NAME, {
+      numberOfInputs: 1,
+      numberOfOutputs: 0
+    });
+    node.port.onmessage = (event) => onFrame(event.data);
+    const micSource = context.createMediaStreamSource(stream);
+    micSource.connect(node, 0, 0);
+    let stopped = false;
+    const onPageHide = () => handle.stop();
+    const handle = {
+      context,
+      micSource,
+      track,
+      settings: track.getSettings(),
+      stop() {
+        if (stopped) return;
+        stopped = true;
+        window.removeEventListener("pagehide", onPageHide);
+        node.port.onmessage = null;
+        try {
+          node.port.postMessage({ type: "stop" });
+          micSource.disconnect();
+        } catch {
+        }
+        release();
+        void context.close().catch(() => void 0);
+      }
+    };
+    window.addEventListener("pagehide", onPageHide);
+    return handle;
+  } catch (cause) {
+    release();
+    void context.close().catch(() => void 0);
+    throw cause instanceof MicCaptureError ? cause : new MicCaptureError("unavailable");
+  }
+}
+
+// src/avatar-mic/stt-stream.ts
+var WEB_STT_SUBPROTOCOL = "boff.web-stt.v1";
+var OFFER_PREFIX = "offer.";
+var STREAM_PATH = "/stt/stream";
+var WEB_STT_LANGUAGES = ["en-IN"];
+var TOKEN_CHARS = /^[A-Za-z0-9._~-]{1,4096}$/;
+var UTTERANCE_ID = /^[A-Za-z0-9._-]{1,64}$/;
+var NOTICE_VERSION = /^[A-Za-z0-9._-]{1,32}$/;
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "[::1]"]);
+var MAX_SEND_BYTES = 6400;
+var SOCKET_OPEN = 1;
+var CLOSE_CODE_ERRORS = {
+  4400: { code: "upstream", retryable: false },
+  4401: { code: "auth", retryable: false },
+  4403: { code: "auth", retryable: false },
+  4408: { code: "closed", retryable: true },
+  4413: { code: "upstream", retryable: false },
+  4429: { code: "quota", retryable: false },
+  4500: { code: "upstream", retryable: true },
+  4503: { code: "upstream", retryable: true }
+};
+var CLOSE_AUTH = 4401;
+function webSttUrl(base) {
+  let url;
+  try {
+    url = new URL(`${base}${STREAM_PATH}`);
+  } catch {
+    return null;
+  }
+  if (url.protocol === "https:") url.protocol = "wss:";
+  else if (url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname.toLowerCase())) {
+    url.protocol = "ws:";
+  } else {
+    return null;
+  }
+  url.search = "";
+  url.hash = "";
+  return url.toString();
+}
+function isOfferToken(token) {
+  return TOKEN_CHARS.test(token);
+}
+function webSttSubprotocols(token) {
+  return [WEB_STT_SUBPROTOCOL, `${OFFER_PREFIX}${token}`];
+}
+function isUtteranceId(value) {
+  return UTTERANCE_ID.test(value);
+}
+function isNoticeVersion(value) {
+  return NOTICE_VERSION.test(value);
+}
+function configFrame(press) {
+  return JSON.stringify({
+    t: "config",
+    v: 1,
+    utteranceId: press.utteranceId,
+    epoch: press.epoch,
+    langs: [...WEB_STT_LANGUAGES],
+    sampleRate: 16e3,
+    encoding: "s16le",
+    notice: press.notice
+  });
+}
+function endFrame(utteranceId) {
+  return JSON.stringify({ t: "end", utteranceId });
+}
+function cancelFrame(utteranceId) {
+  return JSON.stringify({ t: "cancel", utteranceId });
+}
+function chunkFrames(frames) {
+  const perChunk = Math.floor(MAX_SEND_BYTES / 2);
+  const out = [];
+  let current = [];
+  const flush = () => {
+    if (current.length > 0) out.push(Int16Array.from(current));
+    current = [];
+  };
+  for (const frame of frames) {
+    for (const sample of frame) {
+      current.push(sample);
+      if (current.length === perChunk) flush();
+    }
+  }
+  flush();
+  return out;
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readServerMessage(data) {
+  if (typeof data !== "string") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!isRecord(parsed)) return null;
+  const { t, utteranceId, epoch, text } = parsed;
+  if (t === "ready") return { t };
+  if (t === "partial" || t === "final") {
+    if (typeof text !== "string" || typeof utteranceId !== "string" || typeof epoch !== "number") {
+      return null;
+    }
+    return { t, utteranceId, epoch, text };
+  }
+  if (t === "done") {
+    if (typeof utteranceId !== "string" || typeof epoch !== "number") {
+      return null;
+    }
+    return { t, utteranceId, epoch };
+  }
+  if (t === "error") {
+    return {
+      t,
+      code: typeof parsed.code === "string" ? parsed.code : "upstream",
+      retryable: parsed.retryable === true,
+      utteranceId: typeof utteranceId === "string" ? utteranceId : null,
+      detail: typeof parsed.detail === "string" ? parsed.detail : null
+    };
+  }
+  return null;
+}
+function openBrowserSocket(url, protocols) {
+  const socket = new WebSocket(url, protocols);
+  socket.binaryType = "arraybuffer";
+  return {
+    get readyState() {
+      return socket.readyState;
+    },
+    send: (data) => socket.send(data),
+    close: (code) => socket.close(code),
+    listen(handlers) {
+      socket.onopen = () => handlers.open();
+      socket.onmessage = (event) => handlers.message(event.data);
+      socket.onclose = (event) => handlers.close(event.code);
+      socket.onerror = () => handlers.error();
+    }
+  };
+}
+
+// src/avatar-mic/press.ts
+var MAX_PRESS_MS = 3e4;
+var PRE_ROLL_MS = 1e3;
+var READY_TIMEOUT_MS = 1e4;
+var FINAL_WAIT_MS = 12e3;
+var OFFER_TTL_MS = 12e4;
+var OFFER_MARGIN_MS = 5e3;
+var CLOCK_TOLERANCE_MS = 5e3;
+var IDLE = { 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;
+  return offer.receivedAt + life - OFFER_MARGIN_MS;
+}
+function failureOf(code, retryable, detail) {
+  if (detail === "notice-version") return "unavailable";
+  switch (code) {
+    case "quota":
+      return "limit";
+    case "auth":
+      return "unavailable";
+    case "busy":
+      return retryable ? "busy" : "unavailable";
+    default:
+      return "failed";
+  }
+}
+function failureOfClose(code) {
+  const known = CLOSE_CODE_ERRORS[code];
+  if (known === void 0) return "failed";
+  return failureOf(known.code, known.retryable, null);
+}
+function randomUtteranceId() {
+  const crypto = globalThis.crypto;
+  if (typeof crypto?.randomUUID === "function") {
+    return `web-${crypto.randomUUID()}`;
+  }
+  if (typeof crypto?.getRandomValues !== "function") return null;
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  return `web-${Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+var BROWSER = {
+  createSocket: openBrowserSocket,
+  startCapture: startMicCapture,
+  newUtteranceId: randomUtteranceId
+};
+function createAvatarMic(options, seams = {}) {
+  const { createSocket, startCapture, newUtteranceId } = {
+    ...BROWSER,
+    ...seams
+  };
+  let press = null;
+  let connection = null;
+  let epoch = 0;
+  let state = IDLE;
+  const report = (next) => {
+    state = next;
+    options.onState(next);
+  };
+  const heard = (p) => [...p.finals, p.partial].filter((part) => part !== "").join(" ");
+  const finalText = (p) => p.finals.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 send = (data) => {
+    const socket = connection?.socket;
+    if (socket && socket.readyState === SOCKET_OPEN) socket.send(data);
+  };
+  const closeConnection = () => {
+    const closing = connection;
+    connection = null;
+    try {
+      closing?.socket.close(1e3);
+    } catch {
+    }
+  };
+  const clearTimers = (p) => {
+    for (const timer of [p.readyTimer, p.limitTimer, p.finalTimer]) {
+      if (timer !== null) clearTimeout(timer);
+    }
+    p.readyTimer = null;
+    p.limitTimer = null;
+    p.finalTimer = null;
+  };
+  const release = (p) => {
+    const capture = p.capture;
+    p.capture = null;
+    p.preRoll = [];
+    p.preRollMs = 0;
+    try {
+      capture?.stop();
+    } catch {
+    }
+  };
+  const settle = (p, next) => {
+    if (p.stage === "ended") return;
+    p.stage = "ended";
+    release(p);
+    clearTimers(p);
+    if (press === p) press = null;
+    closeConnection();
+    report(next);
+  };
+  const fail = (p, reason) => settle(p, { name: "failed", epoch: p.epoch, reason, text: finalText(p) });
+  const complete = (p) => settle(p, {
+    name: "done",
+    epoch: p.epoch,
+    text: finalText(p),
+    limit: p.limit
+  });
+  const stopRecording = (p, limit, withEnd) => {
+    if (p.stage !== "listening") return;
+    release(p);
+    if (p.limitTimer !== null) clearTimeout(p.limitTimer);
+    p.limitTimer = null;
+    p.stage = "finishing";
+    p.limit = limit;
+    if (withEnd) send(endFrame(p.utteranceId));
+    p.finalTimer = setTimeout(() => {
+      p.finalTimer = null;
+      if (press !== p || p.stage !== "finishing") return;
+      if (p.finals.length > 0) complete(p);
+      else fail(p, "failed");
+    }, FINAL_WAIT_MS);
+    show(p);
+  };
+  const begin = (p) => {
+    if (p.stage !== "starting" || p.capture === null) return;
+    if (p.readyTimer !== null) clearTimeout(p.readyTimer);
+    p.readyTimer = null;
+    send(
+      configFrame({
+        utteranceId: p.utteranceId,
+        epoch: p.epoch,
+        notice: options.notice
+      })
+    );
+    for (const chunk of chunkFrames(p.preRoll)) send(chunk);
+    p.sentMs += p.preRollMs;
+    p.preRoll = [];
+    p.preRollMs = 0;
+    p.stage = "listening";
+    p.startedAt = Date.now();
+    p.limitTimer = setTimeout(() => {
+      p.limitTimer = null;
+      if (press === p) stopRecording(p, true, true);
+    }, MAX_PRESS_MS);
+    show(p);
+  };
+  const onFrame = (p, frame) => {
+    if (press !== p) return;
+    const pcm = new Int16Array(frame.pcm);
+    const ms = pcm.length * 1e3 / CAPTURE_SAMPLE_RATE;
+    if (p.stage === "starting") {
+      p.preRoll.push(pcm);
+      p.preRollMs += ms;
+      while (p.preRollMs > PRE_ROLL_MS) {
+        const oldest = p.preRoll.shift();
+        if (oldest === void 0) break;
+        p.preRollMs -= oldest.length * 1e3 / CAPTURE_SAMPLE_RATE;
+      }
+      return;
+    }
+    if (p.stage !== "listening") return;
+    if (p.sentMs + ms > MAX_PRESS_MS) {
+      stopRecording(p, true, true);
+      return;
+    }
+    send(pcm);
+    p.sentMs += ms;
+  };
+  const onPressError = (p, error) => {
+    if (error.code === "bad-frame" && error.detail === "utterance-too-long") {
+      stopRecording(p, true, false);
+      return;
+    }
+    if (error.code === "timeout") {
+      if (p.finals.length > 0) complete(p);
+      else fail(p, "failed");
+      return;
+    }
+    fail(p, failureOf(error.code, error.retryable, error.detail));
+  };
+  const onMessage = (data) => {
+    const message = readServerMessage(data);
+    if (message === null || connection === null) return;
+    const p = press;
+    if (message.t === "ready") {
+      connection.ready = true;
+      if (p !== null) begin(p);
+      return;
+    }
+    if (message.t === "error" && message.utteranceId === null) {
+      connection.refusal = {
+        code: message.code,
+        retryable: message.retryable,
+        detail: message.detail
+      };
+      return;
+    }
+    if (p === null || p.stage === "ended") return;
+    if (message.utteranceId !== p.utteranceId) return;
+    switch (message.t) {
+      case "partial":
+        if (message.epoch !== p.epoch) return;
+        p.partial = message.text.trim();
+        show(p);
+        return;
+      case "final": {
+        if (message.epoch !== p.epoch) return;
+        const text = message.text.trim();
+        if (text !== "") p.finals.push(text);
+        p.partial = "";
+        show(p);
+        return;
+      }
+      case "done":
+        if (message.epoch !== p.epoch) return;
+        complete(p);
+        return;
+      case "error":
+        onPressError(p, message);
+        return;
+    }
+  };
+  const onClose = (closed, code) => {
+    connection = null;
+    const p = press;
+    if (p === null || p.stage === "ended") return;
+    if (p.stage === "starting") {
+      if (closed.ready && !p.ownConnection) {
+        if (p.capture !== null) connect(p);
+        return;
+      }
+      if (!closed.ready && !p.retried && code === CLOSE_AUTH) {
+        p.retried = true;
+        connect(p);
+        return;
+      }
+    }
+    if (p.stage === "finishing" && p.finals.length > 0) {
+      complete(p);
+      return;
+    }
+    const refusal = closed.refusal;
+    fail(
+      p,
+      refusal === null ? failureOfClose(code) : failureOf(refusal.code, refusal.retryable, refusal.detail)
+    );
+  };
+  const offerFor = async (p) => {
+    const held = options.offer();
+    if (!p.retried && held !== null && Date.now() < offerFreshUntil(held)) {
+      return held;
+    }
+    return await options.refreshOffer();
+  };
+  const open = (p, token) => {
+    const url = webSttUrl(options.base);
+    if (url === null || !isOfferToken(token)) {
+      fail(p, "unavailable");
+      return;
+    }
+    let socket;
+    try {
+      socket = createSocket(url, webSttSubprotocols(token));
+    } catch {
+      fail(p, "failed");
+      return;
+    }
+    const opened = { socket, ready: false, refusal: null };
+    connection = opened;
+    p.ownConnection = true;
+    socket.listen({
+      // The server's `ready` is what begins the press; a close always follows an error.
+      open: () => void 0,
+      error: () => void 0,
+      message: (data) => {
+        if (connection === opened) onMessage(data);
+      },
+      close: (code) => {
+        if (connection === opened) onClose(opened, code);
+      }
+    });
+  };
+  function connect(p) {
+    if (connection !== null) {
+      if (connection.ready) begin(p);
+      return;
+    }
+    if (p.readyTimer !== null) clearTimeout(p.readyTimer);
+    p.readyTimer = setTimeout(() => {
+      p.readyTimer = null;
+      if (press === p && p.stage === "starting") fail(p, "failed");
+    }, READY_TIMEOUT_MS);
+    const waiting = () => press === p && p.stage === "starting" && connection === null;
+    void offerFor(p).then(
+      (offer) => {
+        if (!waiting()) return;
+        if (offer === null) {
+          fail(p, "unavailable");
+          return;
+        }
+        open(p, offer.token);
+      },
+      () => {
+        if (waiting()) fail(p, "failed");
+      }
+    );
+  }
+  const cancel = () => {
+    const p = press;
+    press = null;
+    if (p !== null && p.stage !== "ended") {
+      if (p.stage === "listening" || p.stage === "finishing") {
+        send(cancelFrame(p.utteranceId));
+      }
+      p.stage = "ended";
+      release(p);
+      clearTimers(p);
+    }
+    closeConnection();
+    if (state.name !== "idle") report(IDLE);
+  };
+  const start = () => {
+    const current = press;
+    if (current !== null && (current.stage === "starting" || current.stage === "listening")) {
+      return;
+    }
+    if (current !== null && current.stage === "finishing") {
+      send(cancelFrame(current.utteranceId));
+      current.stage = "ended";
+      release(current);
+      clearTimers(current);
+      press = null;
+    }
+    epoch += 1;
+    const utteranceId = newUtteranceId();
+    if (utteranceId === null || !isUtteranceId(utteranceId) || !isNoticeVersion(options.notice)) {
+      closeConnection();
+      report({ name: "failed", epoch, reason: "unsupported", text: "" });
+      return;
+    }
+    const p = {
+      epoch,
+      utteranceId,
+      stage: "starting",
+      capture: null,
+      preRoll: [],
+      preRollMs: 0,
+      sentMs: 0,
+      startedAt: 0,
+      finals: [],
+      partial: "",
+      limit: false,
+      ownConnection: false,
+      retried: false,
+      readyTimer: null,
+      limitTimer: null,
+      finalTimer: null
+    };
+    press = p;
+    report({ name: "starting", epoch });
+    let capturing;
+    try {
+      capturing = startCapture((frame) => onFrame(p, frame));
+    } catch (error) {
+      capturing = Promise.reject(error);
+    }
+    capturing.then(
+      (capture) => {
+        if (press !== p || p.stage !== "starting") {
+          try {
+            capture.stop();
+          } catch {
+          }
+          return;
+        }
+        p.capture = capture;
+        connect(p);
+      },
+      (error) => {
+        if (press !== p || p.stage !== "starting") return;
+        fail(
+          p,
+          error instanceof MicCaptureError && error.reason === "not-allowed" ? "denied" : "unsupported"
+        );
+      }
+    );
+  };
+  return {
+    start,
+    stop() {
+      const p = press;
+      if (p === null) return;
+      if (p.stage === "starting") cancel();
+      else stopRecording(p, false, true);
+    },
+    cancel,
+    state: () => state
+  };
+}
+
+export { createAvatarMic };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map